From 994a38e945dda0e98ccbad3a2499e3a8d191e47f Mon Sep 17 00:00:00 2001
From: firedotguy <nta16022013@gmail.com>
Date: Sun, 1 Mar 2026 00:06:16 +0300
Subject: [PATCH] fix: add unescape for spans

---
 '                  |  0
 README.md          |  9 +++++
 itd/models/post.py |  1 +
 itd/utils.py       | 95 ++++++++++++++++++++++++++++++++++++++++++----
 4 files changed, 97 insertions(+), 8 deletions(-)
 create mode 100644 '

diff --git a/' b/'
new file mode 100644
index 0000000..e69de29
diff --git a/README.md b/README.md
index a7bcfda..4a29b31 100644
--- a/README.md
+++ b/README.md
@@ -92,6 +92,15 @@ from itd.utils import parse_html
 
 print(с.create_post(*parse_html('значит, я это щас отправил со своего клиента, <b>воот</b>. И еще тут спаны написаны через html, по типу < i > <i>11</i>')))
 ```
+Поддерживаемые теги:
+ - `<b>`: жирный
+ - `<i>`: курсивный
+ - `<s>`: зачеркнутый
+ - `<u>`: подчеркнутый
+ - `<code>`: код
+ - `<spoiler>`: спойлер
+ - `<a href="https://google.com">`: ссылка
+ - `<q>`: цитата
 
 <!-- ### SSE - прослушивание уведомлений в реальном времени
 
diff --git a/itd/models/post.py b/itd/models/post.py
index affc289..1d68deb 100644
--- a/itd/models/post.py
+++ b/itd/models/post.py
@@ -59,6 +59,7 @@ class Span(BaseModel):
     length: int
     offset: int
     type: SpanType
+    url: str | None = None
 
 
 class _PostCounts(TextObject):
diff --git a/itd/utils.py b/itd/utils.py
index 786540f..3f682b1 100644
--- a/itd/utils.py
+++ b/itd/utils.py
@@ -5,46 +5,123 @@ from itd.enums import SpanType
 
 
 class Tag:
-    def __init__(self, open: str, close: str, type: SpanType, url: str | None = None):
+    def __init__(self, open: str, close: str, type: SpanType):
         self.open = open
         self.close = close
         self.type = type
-        self.url = url
 
 
 def _parse_spans(text: str, tags: list[Tag]) -> tuple[str, list[Span]]:
     spans: list[Span] = []
-    stack: list[tuple[int, SpanType, int, int]] = []
+    stack: list[tuple[int, SpanType, int, int, str | None]] = []
     clean_chars: list[str] = []
     i = 0
 
     while i < len(text):
+        # Проверка на экранирование
+        escaped = text[i] == '\\'
+
+        # Сначала проверяем закрывающие теги (с проверкой на экранирование)
         closed = False
         for idx, tag in enumerate(tags):
             if text.startswith(tag.close, i) and stack and stack[-1][0] == idx:
-                _, span_type, offset, _ = stack.pop()
-                spans.append(Span(length=len(clean_chars) - offset, offset=offset, type=span_type))
+                if escaped:
+                    # Экранированный закрывающий тег — выводим как текст (без слэша)
+                    clean_chars.append(tag.close)
+                    i += len(tag.close)
+                    closed = True
+                    break
+                _, span_type, offset, _, url = stack.pop()
+                spans.append(Span(length=len(clean_chars) - offset, offset=offset, type=span_type, url=url))
                 i += len(tag.close)
                 closed = True
                 break
         if closed:
             continue
 
+        # Затем проверяем открывающие теги
         opened = False
         for idx, tag in enumerate(tags):
-            if text.startswith(tag.open, i):
-                stack.append((idx, tag.type, len(clean_chars), i))
+            if tag.type == SpanType.LINK:
+                if escaped:
+                    match = re.match(tag.open, text[i+1:])
+                    if match:
+                        # Экранированный открывающий тег — выводим как текст (без слэша)
+                        clean_chars.append(match.group(0))
+                        i += 1 + match.end()
+                        opened = True
+                        break
+                else:
+                    match = re.match(tag.open, text[i:])
+                    if match:
+                        url = match.group(1) if match.groups() else None
+                        stack.append((idx, tag.type, len(clean_chars), i, url))
+                        i += match.end()
+                        opened = True
+                        break
+            elif text.startswith(tag.open, i):
+                if escaped:
+                    # Экранированный обычный тег — пропускаем, будет обработан в блоке is_escape
+                    break
+                stack.append((idx, tag.type, len(clean_chars), i, None))
                 i += len(tag.open)
                 opened = True
                 break
         if opened:
             continue
 
+        # Если это слэш, проверяем, не экранирует ли он следующий тег
+        if escaped:
+            # Проверяем, следует ли за слэшем тег
+            is_escape = False
+            for tag in tags:
+                if tag.type == SpanType.LINK:
+                    if re.match(tag.open, text[i+1:]):
+                        is_escape = True
+                        break
+                elif text.startswith(tag.open, i+1):
+                    is_escape = True
+                    break
+            # Проверяем закрывающие теги
+            if not is_escape:
+                for tag in tags:
+                    if text.startswith(tag.close, i+1):
+                        is_escape = True
+                        break
+
+            if is_escape:
+                # Пропускаем слэш и выводим следующий тег как текст
+                i += 1
+                # Находим и выводим экранированный тег
+                skip = False
+                for tag in tags:
+                    if tag.type == SpanType.LINK:
+                        match = re.match(tag.open, text[i:])
+                        if match:
+                            clean_chars.append(match.group(0))
+                            i += match.end()
+                            skip = True
+                            break
+                    elif text.startswith(tag.open, i):
+                        clean_chars.append(tag.open)
+                        i += len(tag.open)
+                        skip = True
+                        break
+                if not skip:
+                    # Проверяем закрывающие теги
+                    for tag in tags:
+                        if text.startswith(tag.close, i):
+                            clean_chars.append(tag.close)
+                            i += len(tag.close)
+                            skip = True
+                            break
+                continue
+
         clean_chars.append(text[i])
         i += 1
 
     if stack:
-        _, last_type, _, raw_pos = stack[-1]
+        _, last_type, _, raw_pos, _ = stack[-1]
         raise ValueError(f'No closing tag for {last_type.value} at pos {raw_pos}')
 
     spans.sort(key=lambda span: span.offset)
@@ -61,6 +138,8 @@ def parse_html(text: str) -> tuple[str, list[Span]]:
             Tag('<u>', '</u>', SpanType.UNDERLINE),
             Tag('<code>', '</code>', SpanType.MONOSPACE),
             Tag('<spoiler>', '</spoiler>', SpanType.SPOILER),
+            Tag(r'<a href="([^"]+)">', '</a>', SpanType.LINK),
+            Tag(r'<q>', '</q>', SpanType.QUOTE),
         ],
     )