[Markdown] Update to ~=3.11.2

stubs/Markdown/@tests/stubtest_allowlist.txt

@@ -1,4 +1,11 @@
-# Deprecated types are infered as functions:
+# Implementation detail
+markdown.htmlparser.spec
+
+# *args/**kwargs in implementation properly typed in stubs
+markdown.extensions.md_in_html.HTMLExtractorExtra.__init__
+markdown.htmlparser.HTMLExtractor.__init__
+
+# Deprecated types are infered as functions
 markdown.extensions.abbr.AbbrPreprocessor
 markdown.extensions.abbr.AbbrInlineProcessor
 markdown.postprocessors.UnescapePostprocessor

stubs/Markdown/METADATA.toml

@@ -1,2 +1,2 @@
-version = "~=3.10.2"
+version = "~=3.11.2"
 upstream-repository = "https://github.com/Python-Markdown/markdown"

stubs/Markdown/markdown/core.pyi

@@ -13,28 +13,39 @@ from . import (
     treeprocessors as _treeprocessors,
 )
 from .extensions import Extension
+from .inlinepatterns import DelimiterProcessor
 from .util import HtmlStash, Registry
 
 __all__ = ["Markdown", "markdown", "markdownFromFile"]
 
 logger: Logger
 
 class Markdown:
+    doc_tag: ClassVar[str]
+    output_formats: ClassVar[dict[Literal["xhtml", "html"], Callable[[Element], str]]]
+
+    last_run: float
+    tab_length: int
+    ESCAPED_CHARS: list[str]
+    block_level_elements: list[str]
+    registeredExtensions: list[Extension]
+    stripTopLevelTags: bool
+    delimiters: DelimiterProcessor | None
+
+    # Set by build_parser().
     preprocessors: Registry[_preprocessors.Preprocessor]
+    parser: blockparser.BlockParser
     inlinePatterns: Registry[inlinepatterns.Pattern]
     treeprocessors: Registry[_treeprocessors.Treeprocessor]
     postprocessors: Registry[_postprocessors.Postprocessor]
-    parser: blockparser.BlockParser
+
+    references: dict[str, tuple[str, str]]
     htmlStash: HtmlStash
-    output_formats: ClassVar[dict[Literal["xhtml", "html"], Callable[[Element], str]]]
+
+    # Set by set_output_format().
     output_format: Literal["xhtml", "html"]
     serializer: Callable[[Element], str]
-    tab_length: int
-    block_level_elements: list[str]
-    registeredExtensions: list[Extension]
-    ESCAPED_CHARS: list[str]
-    doc_tag: ClassVar[str]
-    stripTopLevelTags: bool
+
     def __init__(
         self,
         *,

stubs/Markdown/markdown/extensions/__init__.pyi

@@ -3,6 +3,7 @@ from typing import Any
 
 from markdown.core import Markdown
 
+# The allowed value types depend on the respective keys.
 class Extension:
     config: Mapping[str, list[Any]]
     def __init__(self, **kwargs: Any) -> None: ...

stubs/Markdown/markdown/extensions/attr_list.pyi

@@ -1,4 +1,5 @@
 from re import Pattern
+from typing import Final
 from xml.etree.ElementTree import Element
 
 from markdown.extensions import Extension
@@ -8,12 +9,17 @@ def get_attrs_and_remainder(attrs_string: str) -> tuple[list[tuple[str, str]], s
 def get_attrs(str: str) -> list[tuple[str, str]]: ...
 def isheader(elem: Element) -> bool: ...
 
+NAME_RE: Final[Pattern[str]]
+
+def sanitize_name(name: str) -> str: ...
+
 class AttrListTreeprocessor(Treeprocessor):
-    BASE_RE: str
-    HEADER_RE: Pattern[str]
-    BLOCK_RE: Pattern[str]
-    INLINE_RE: Pattern[str]
-    NAME_RE: Pattern[str]
+    BASE_RE: Final[str]
+    HEADER_RE: Final[Pattern[str]]
+    BLOCK_RE: Final[Pattern[str]]
+    INLINE_RE: Final[Pattern[str]]
+    NAME_RE: Final[Pattern[str]]
+
     def run(self, doc: Element) -> None: ...
     def assign_attrs(self, elem: Element, attrs_string: str, *, strict: bool = False) -> str: ...
     def sanitize_name(self, name: str) -> str: ...

stubs/Markdown/markdown/extensions/legacy_em.pyi

@@ -1,11 +1,8 @@
-from markdown.extensions import Extension
-from markdown.inlinepatterns import UnderscoreProcessor
+from typing import Any
 
-EMPHASIS_RE: str
-STRONG_RE: str
-STRONG_EM_RE: str
+from markdown.extensions import Extension
 
-class LegacyUnderscoreProcessor(UnderscoreProcessor): ...
 class LegacyEmExtension(Extension): ...
 
-def makeExtension(**kwargs) -> LegacyEmExtension: ...
+# kwargs are config key/value pairs, where the value type depends on the key.
+def makeExtension(**kwargs: Any) -> LegacyEmExtension: ...

stubs/Markdown/markdown/extensions/md_in_html.pyi

@@ -1,6 +1,6 @@
 from collections.abc import Iterable, Mapping
 from typing import Literal
-from xml.etree.ElementTree import Element, TreeBuilder
+from xml.etree.ElementTree import Element
 
 from markdown.blockprocessors import BlockProcessor
 from markdown.extensions import Extension
@@ -9,15 +9,15 @@ from markdown.postprocessors import RawHtmlPostprocessor
 from markdown.preprocessors import Preprocessor
 
 class HTMLExtractorExtra(HTMLExtractor):
-    block_level_tags: set[str]
     span_tags: set[str]
     raw_tags: set[str]
-    block_tags: set[str]
-    span_and_blocks_tags: set[str]
-    mdstack: list[str]
-    treebuilder: TreeBuilder
-    mdstate: list[Literal["block", "span", "off"] | None]
-    mdstarted: list[bool]
+
+    @property
+    def block_level_tags(self) -> set[str]: ...
+    @property
+    def block_tags(self) -> set[str]: ...
+    @property
+    def span_and_blocks_tags(self) -> set[str]: ...
     def get_element(self) -> Element: ...
     def get_state(self, tag: str, attrs: Mapping[str, str]) -> Literal["block", "span", "off"] | None: ...
     def handle_starttag(self, tag: str, attrs: Iterable[tuple[str, str | None]]) -> None: ...

stubs/Markdown/markdown/htmlparser.pyi

@@ -1,29 +1,38 @@
 import html.parser as htmlparser
 import re
-from _frozen_importlib import ModuleSpec
 from collections.abc import Sequence
+from typing import Final
 
 from markdown import Markdown
 
-spec: ModuleSpec
-commentclose: re.Pattern[str]
-blank_line_re: re.Pattern[str]
+commentclose: Final[re.Pattern[str]]
+blank_line_re: Final[re.Pattern[str]]
+inner_blank_line_re: Final[re.Pattern[str]]
+void_tags: Final[frozenset[str]]
 
 class HTMLExtractor(htmlparser.HTMLParser):
     empty_tags: set[str]
     lineno_start_cache: list[int]
     md: Markdown
-    def __init__(self, md: Markdown, *args, **kwargs): ...
+
+    # Set by reset().
     inraw: bool
     intail: bool
     stack: list[str]
+    inline_stack: list[str]
     cleandoc: list[str]
+
+    def __init__(self, md: Markdown, *, convert_charrefs=False, scripting=False) -> None: ...
     @property
     def line_offset(self) -> int: ...
     def at_line_start(self) -> bool: ...
     def get_endtag_text(self, tag: str) -> str: ...
     def handle_starttag(self, tag: str, attrs: Sequence[tuple[str, str]]) -> None: ...  # type: ignore[override]
+    def open_inline_tag(self, tag: str) -> None: ...
+    def close_inline_tag(self, tag: str) -> None: ...
+    def inline_close_follows(self, text: str) -> bool: ...
     def handle_empty_tag(self, data: str, is_block: bool) -> None: ...
     def handle_decl(self, data: str) -> None: ...
+    def unknown_decl(self, data: str) -> None: ...
     def parse_bogus_comment(self, i: int, report: int = 0) -> int: ...
     def get_starttag_text(self) -> str: ...

stubs/Markdown/markdown/inlinepatterns.pyi

@@ -1,36 +1,27 @@
 import re
+from _typeshed import Unused
+from collections import deque
 from collections.abc import Collection
-from typing import ClassVar, NamedTuple
+from typing import ClassVar, Final, NamedTuple
 from xml.etree.ElementTree import Element
 
 from markdown import util
 from markdown.core import Markdown
 
-def build_inlinepatterns(md: Markdown, **kwargs) -> util.Registry[Pattern]: ...
-
-NOIMG: str
-BACKTICK_RE: str
-ESCAPE_RE: str
-EMPHASIS_RE: str
-STRONG_RE: str
-SMART_STRONG_RE: str
-SMART_EMPHASIS_RE: str
-SMART_STRONG_EM_RE: str
-EM_STRONG_RE: str
-EM_STRONG2_RE: str
-STRONG_EM_RE: str
-STRONG_EM2_RE: str
-STRONG_EM3_RE: str
-LINK_RE: str
-IMAGE_LINK_RE: str
-REFERENCE_RE: str
-IMAGE_REFERENCE_RE: str
-NOT_STRONG_RE: str
-AUTOLINK_RE: str
-AUTOMAIL_RE: str
-HTML_RE: str
-ENTITY_RE: str
-LINE_BREAK_RE: str
+def build_inlinepatterns(md: Markdown, **kwargs: Unused) -> util.Registry[Pattern]: ...
+
+NOIMG: Final[str]
+BACKTICK_RE: Final[str]
+ESCAPE_RE: Final[str]
+LINK_RE: Final[str]
+IMAGE_LINK_RE: Final[str]
+REFERENCE_RE: Final[str]
+IMAGE_REFERENCE_RE: Final[str]
+AUTOLINK_RE: Final[str]
+AUTOMAIL_RE: Final[str]
+HTML_RE: Final[str]
+ENTITY_RE: Final[str]
+LINE_BREAK_RE: Final[str]
 
 def dequote(string: str) -> str: ...
 
@@ -74,6 +65,8 @@ class BacktickInlineProcessor(InlineProcessor):
     ESCAPED_BSLASH: str
     tag: str
     def __init__(self, pattern: str) -> None: ...
+    def find_code_spans(self, start: int, text: str) -> tuple[int, int] | None: ...
+    def handleMatch(self, m: re.Match[str], data: str) -> tuple[Element | str | None, int | None, int | None]: ...  # type: ignore[override]
 
 class DoubleTagPattern(SimpleTagPattern): ...
 class DoubleTagInlineProcessor(SimpleTagInlineProcessor): ...
@@ -82,15 +75,48 @@ class HtmlInlineProcessor(InlineProcessor):
     def unescape(self, text: str) -> str: ...
     def backslash_unescape(self, text: str) -> str: ...
 
-class AsteriskProcessor(InlineProcessor):
-    PATTERNS: ClassVar[list[EmStrongItem]]
-    def build_single(self, m: re.Match[str], tag: str, idx: int) -> Element: ...
-    def build_double(self, m: re.Match[str], tags: str, idx: int) -> Element: ...
-    def build_double2(self, m: re.Match[str], tags: str, idx: int) -> Element: ...
-    def parse_sub_patterns(self, data: str, parent: Element, last: Element | None, idx: int) -> None: ...
-    def build_element(self, m: re.Match[str], builder: str, tags: str, index: int) -> Element: ...
+class Delimiter:
+    stack: deque[tuple[int, int, bool, int]]
+    tag_count: int
+    tags: tuple[str, str]
+    double: bool
+    single: bool
+    smart: bool
+
+    token: str
+    max_size: int
+    boundary: re.Pattern[str]
+    bad: re.Pattern[str]
+
+    def __init__(self, token: str, tags: str, smart: bool, double: bool): ...
+    def reset(self) -> None: ...
+
+class DelimiterProcessor(InlineProcessor):
+    SPACE: Final[re.Pattern[str]]
+
+    regions: list[tuple[int, int, int, int, tuple[str, str], int]]
+    stack: list[tuple[int, int, bool, int]]
+    tokens: list[str]
+    delimiters: dict[str, Delimiter]
+    cache_index: int
+    cache_pos: int
+    md: Markdown
+    safe_mode: bool
+    pattern: str
+    compiled_re: re.Pattern[str]
 
-class UnderscoreProcessor(AsteriskProcessor): ...
+    def __init__(self, token: str, tags: str, md: Markdown, smart: bool = False, double: bool = False) -> None: ...
+    def add(self, token: str, tags: str, smart: bool = False, double: bool = False) -> None: ...
+    def remove(self, token: str) -> None: ...
+    def reset(self) -> None: ...
+    def increment_next_position(self, start: int, count: int) -> None: ...
+    def get_cached_result(self, pos: int, data: str) -> tuple[Element, int, int]: ...
+    def get_match(self, data: str, start: int) -> re.Match[str] | None: ...
+    def search(self, data: str, start: int) -> re.Match[str] | None: ...
+    def add_region(self, delim: Delimiter, a: int, b: int, c: int, d: int, size: int) -> None: ...
+    def handleMatch(  # type: ignore[override]
+        self, m: re.Match[str], data: str
+    ) -> tuple[Element | None, int | None, int | None]: ...
 
 class LinkInlineProcessor(InlineProcessor):
     RE_LINK: ClassVar[re.Pattern[str]]