markdown-extractor 0.1.1__tar.gz → 0.2.0__tar.gz

{markdown_extractor-0.1.1/src/markdown_extractor.egg-info → markdown_extractor-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-extractor
-Version: 0.1.1
+Version: 0.2.0
 Summary: Extract structured sections from Markdown by header — bracket-style access with robust handling of code blocks, tables, math, and YAML front matter.
 Author-email: Fasil <fasilwdr@hotmail.com>
 License: Apache License
@@ -417,6 +417,122 @@ bool(s.block(99))                   # False — null sentinel
 out-of-range — strict access stays strict. Use `block()` / `.get()` only
 when you want soft fall-through.
 
+### `.filtered(**kwargs)` — narrow any collection in place
+
+Collection accessors return `BlockList` / `SectionList`, both `list`
+subclasses that add a `.filtered(**kwargs)` method for chainable,
+attribute-based narrowing. The kwargs form keeps the API usable from
+Jinja2 / Django templates (which can't define lambdas). Existing list
+operations (indexing, iteration, `len()`, `isinstance(x, list)`) keep
+working unchanged.
+
+```python
+s = e["Section 1"]
+
+# Equality (most common):
+s.blocks.filtered(kind="paragraph")
+e["Section 1"].children.filtered(level=2)
+
+# Multiple kwargs AND together:
+s.blocks.filtered(kind="code", info="python")
+
+# Operator suffixes:
+e.headers().filtered(level__gte=2)
+e.headers().filtered(level__in=[2, 3])
+e.headers().filtered(title__startswith="Sub")
+
+# Chains keep the typed return — both results are SectionList:
+e.headers() \
+    .filtered(level=2) \
+    .filtered(title__startswith="A")
+
+# No kwargs → a shallow copy of the same subclass.
+e.headers().filtered()
+```
+
+Supported operator suffixes:
+
+| Suffix | Meaning |
+|--------|---------|
+| *(none)* | `==` |
+| `__ne` | `!=` |
+| `__lt`, `__lte`, `__gt`, `__gte` | comparison |
+| `__in` | membership in iterable |
+| `__contains` | substring (`b in a`) or container-`in` |
+| `__startswith`, `__endswith` | string prefix / suffix |
+
+Items missing the requested attribute are treated as non-matches — no
+exception. Slices preserve the subclass too, so
+`section.children[1:].filtered(level=2)` works.
+
+The method is available on:
+
+| Returns `BlockList` | Returns `SectionList` |
+|---------------------|------------------------|
+| `Section.blocks` | `Section.children` |
+| `Block.children` | `Section.find(title)` |
+| `Block.walk()` | `Section.walk()` |
+| | `MDExtractor.find(title)` |
+| | `MDExtractor.walk()` |
+| | `MDExtractor.headers()` |
+
+
+### `.mapped(path)` — extract / flatten across a collection
+
+`BlockList`, `SectionList`, `Section`, and `Block` all expose a
+`.mapped(path)` method — dotted-path attribute traversal that flattens
+list-valued attributes and keeps the typed return so you can keep
+chaining `.filtered(...)`. Calling it on a single `Section` / `Block`
+behaves like a one-element collection, so the same path rules apply.
+
+```python
+s = e["Section 1"]
+
+# Pull every body block from every direct subsection (flat BlockList):
+s.children.mapped("blocks")
+
+# Dotted paths walk further — every list_item inside every top-level
+# block of Section 1, fully flattened:
+s.blocks.mapped("children")             # → 3 list_items (the bullets)
+
+# Two-level dotted path — every inline token under those bullets:
+s.blocks.mapped("children.inlines")
+# → [bold 'Lightweight', text ' — …', em 'Flexible', text ' — …',
+#    code 'Tested',     text ' — …']
+
+# Equivalent — chained calls produce the same result as the dotted path:
+s.blocks.mapped("children.inlines") == s.blocks.mapped("children").mapped("inlines")
+
+# Chain with .filtered() — still a BlockList:
+s.blocks.mapped("children").filtered(kind="list_item")
+
+# Scalar attributes return a plain list:
+s.children.mapped("title")              # ['Subsection 1.1', 'FAQ']
+e.headers().mapped("title")             # ['Section 1', 'Subsection 1.1', 'FAQ']
+
+# Works on a single Section / Block too — treated as a one-element collection:
+s.mapped("title")                       # ['Section 1']
+s.mapped("children.blocks")             # BlockList — every block under every child
+s.blocks[1].mapped("children.inlines")  # same dotted-path rules from a single Block
+```
+
+Behaviour notes:
+
+- List-valued attributes (e.g. `.blocks`, `.inlines`, `.children`)
+  are **flattened** into the result.
+- Scalar attributes (e.g. `.title`, `.kind`, `.text`) are appended;
+  the return is a plain `list` (no `.filtered()` chaining).
+- The concrete subclass is preserved when every step yields the same
+  `FilteredList` subclass, so the typed-return chain
+  `… .mapped("blocks").filtered(kind="paragraph")` keeps working.
+- Items missing the attribute are skipped silently — same convention
+  as `.filtered()`.
+- `coll.mapped("")` returns a shallow copy of the same subclass.
+- On a single `Section` / `Block`, `record.mapped(path)` is equivalent
+  to wrapping it in a one-element list and mapping — so a scalar path
+  returns a list of one (e.g. `section.mapped("title") == [section.title]`).
+
+
 ### `to_list()` — flatten body to strings
 
 One entry per top-level block. Lists expand to one entry per top-level

{markdown_extractor-0.1.1 → markdown_extractor-0.2.0}/README.md

@@ -176,6 +176,122 @@ bool(s.block(99))                   # False — null sentinel
 out-of-range — strict access stays strict. Use `block()` / `.get()` only
 when you want soft fall-through.
 
+### `.filtered(**kwargs)` — narrow any collection in place
+
+Collection accessors return `BlockList` / `SectionList`, both `list`
+subclasses that add a `.filtered(**kwargs)` method for chainable,
+attribute-based narrowing. The kwargs form keeps the API usable from
+Jinja2 / Django templates (which can't define lambdas). Existing list
+operations (indexing, iteration, `len()`, `isinstance(x, list)`) keep
+working unchanged.
+
+```python
+s = e["Section 1"]
+
+# Equality (most common):
+s.blocks.filtered(kind="paragraph")
+e["Section 1"].children.filtered(level=2)
+
+# Multiple kwargs AND together:
+s.blocks.filtered(kind="code", info="python")
+
+# Operator suffixes:
+e.headers().filtered(level__gte=2)
+e.headers().filtered(level__in=[2, 3])
+e.headers().filtered(title__startswith="Sub")
+
+# Chains keep the typed return — both results are SectionList:
+e.headers() \
+    .filtered(level=2) \
+    .filtered(title__startswith="A")
+
+# No kwargs → a shallow copy of the same subclass.
+e.headers().filtered()
+```
+
+Supported operator suffixes:
+
+| Suffix | Meaning |
+|--------|---------|
+| *(none)* | `==` |
+| `__ne` | `!=` |
+| `__lt`, `__lte`, `__gt`, `__gte` | comparison |
+| `__in` | membership in iterable |
+| `__contains` | substring (`b in a`) or container-`in` |
+| `__startswith`, `__endswith` | string prefix / suffix |
+
+Items missing the requested attribute are treated as non-matches — no
+exception. Slices preserve the subclass too, so
+`section.children[1:].filtered(level=2)` works.
+
+The method is available on:
+
+| Returns `BlockList` | Returns `SectionList` |
+|---------------------|------------------------|
+| `Section.blocks` | `Section.children` |
+| `Block.children` | `Section.find(title)` |
+| `Block.walk()` | `Section.walk()` |
+| | `MDExtractor.find(title)` |
+| | `MDExtractor.walk()` |
+| | `MDExtractor.headers()` |
+
+
+### `.mapped(path)` — extract / flatten across a collection
+
+`BlockList`, `SectionList`, `Section`, and `Block` all expose a
+`.mapped(path)` method — dotted-path attribute traversal that flattens
+list-valued attributes and keeps the typed return so you can keep
+chaining `.filtered(...)`. Calling it on a single `Section` / `Block`
+behaves like a one-element collection, so the same path rules apply.
+
+```python
+s = e["Section 1"]
+
+# Pull every body block from every direct subsection (flat BlockList):
+s.children.mapped("blocks")
+
+# Dotted paths walk further — every list_item inside every top-level
+# block of Section 1, fully flattened:
+s.blocks.mapped("children")             # → 3 list_items (the bullets)
+
+# Two-level dotted path — every inline token under those bullets:
+s.blocks.mapped("children.inlines")
+# → [bold 'Lightweight', text ' — …', em 'Flexible', text ' — …',
+#    code 'Tested',     text ' — …']
+
+# Equivalent — chained calls produce the same result as the dotted path:
+s.blocks.mapped("children.inlines") == s.blocks.mapped("children").mapped("inlines")
+
+# Chain with .filtered() — still a BlockList:
+s.blocks.mapped("children").filtered(kind="list_item")
+
+# Scalar attributes return a plain list:
+s.children.mapped("title")              # ['Subsection 1.1', 'FAQ']
+e.headers().mapped("title")             # ['Section 1', 'Subsection 1.1', 'FAQ']
+
+# Works on a single Section / Block too — treated as a one-element collection:
+s.mapped("title")                       # ['Section 1']
+s.mapped("children.blocks")             # BlockList — every block under every child
+s.blocks[1].mapped("children.inlines")  # same dotted-path rules from a single Block
+```
+
+Behaviour notes:
+
+- List-valued attributes (e.g. `.blocks`, `.inlines`, `.children`)
+  are **flattened** into the result.
+- Scalar attributes (e.g. `.title`, `.kind`, `.text`) are appended;
+  the return is a plain `list` (no `.filtered()` chaining).
+- The concrete subclass is preserved when every step yields the same
+  `FilteredList` subclass, so the typed-return chain
+  `… .mapped("blocks").filtered(kind="paragraph")` keeps working.
+- Items missing the attribute are skipped silently — same convention
+  as `.filtered()`.
+- `coll.mapped("")` returns a shallow copy of the same subclass.
+- On a single `Section` / `Block`, `record.mapped(path)` is equivalent
+  to wrapping it in a one-element list and mapping — so a scalar path
+  returns a list of one (e.g. `section.mapped("title") == [section.title]`).
+
+
 ### `to_list()` — flatten body to strings
 
 One entry per top-level block. Lists expand to one entry per top-level

markdown_extractor-0.2.0/src/markdown_extractor/__init__.py

@@ -0,0 +1,25 @@
+"""markdown-extractor — extract structured sections from Markdown.
+
+Public API:
+    MDExtractor  — entry point for parsing a Markdown document.
+    Section      — a node in the parsed header tree.
+    Block        — a node in a section's parsed body block tree.
+    SectionList  — the filterable list returned by ``.children`` / ``walk()`` / ``find()`` / ``headers()``.
+    BlockList    — the filterable list returned by ``.blocks`` and ``Block.children`` / ``walk()``.
+"""
+
+from markdown_extractor._collections import BlockList, FilteredList, SectionList
+from markdown_extractor.blocks import Block
+from markdown_extractor.extractor import MDExtractor
+from markdown_extractor.section import Section
+
+__version__ = "0.2.0"
+__all__ = [
+    "MDExtractor",
+    "Section",
+    "Block",
+    "SectionList",
+    "BlockList",
+    "FilteredList",
+    "__version__",
+]

markdown_extractor-0.2.0/src/markdown_extractor/_collections.py

@@ -0,0 +1,166 @@
+"""Collection types that add ``.filtered(**kwargs)`` on top of ``list``.
+
+:class:`FilteredList` is a thin ``list`` subclass with one extra method —
+``filtered`` — for chainable, attribute-based narrowing using keyword
+arguments (so it works inside Jinja2 / Django templates, which cannot
+define lambdas). The two named subclasses :class:`BlockList` and
+:class:`SectionList` are what the public API actually returns; they exist
+mostly to give nicer reprs and let ``isinstance(x, BlockList)`` discriminate
+without poking at generic introspection.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Generic, List, Optional, Tuple, TypeVar, Union
+
+T = TypeVar("T")
+
+
+_MISSING = object()
+
+
+# Operator table — ``attr__<op>=value`` maps to ``_OPS[op](attr_value, value)``.
+# Adding a new operator is a one-line entry here.
+_OPS = {
+    "eq":         lambda a, b: a == b,
+    "ne":         lambda a, b: a != b,
+    "lt":         lambda a, b: a < b,
+    "lte":        lambda a, b: a <= b,
+    "gt":         lambda a, b: a > b,
+    "gte":        lambda a, b: a >= b,
+    "in":         lambda a, b: a in b,
+    "contains":   lambda a, b: b in a,
+    "startswith": lambda a, b: a.startswith(b),
+    "endswith":   lambda a, b: a.endswith(b),
+}
+
+
+def _resolve_key(key: str) -> Tuple[str, str]:
+    """Split ``"level__gte"`` into ``("level", "gte")``.
+
+    Falls back to ``(key, "eq")`` if the suffix after the last ``__`` is
+    not a known operator, so an attribute literally named ``foo__bar`` is
+    still addressable via ``foo__bar=value``.
+    """
+    if "__" in key:
+        attr, _, op = key.rpartition("__")
+        if op in _OPS and attr:
+            return attr, op
+    return key, "eq"
+
+
+class FilteredList(list, Generic[T]):
+    """A ``list`` subclass with chainable, kwargs-based filtering.
+
+    Examples::
+
+        section.blocks.filtered(kind="paragraph")
+        section.blocks.filtered(kind="code", info="python")
+        e.headers().filtered(level__gte=2)
+        e.headers().filtered(level__in=[2, 3])
+        e.headers().filtered(title__startswith="Sub")
+
+    Multiple kwargs are AND-combined. Each key is ``attr`` (implicit
+    equality) or ``attr__<op>``. Supported operators: ``eq`` (default),
+    ``ne``, ``lt``, ``lte``, ``gt``, ``gte``, ``in``, ``contains``,
+    ``startswith``, ``endswith``.
+
+    Items missing the requested attribute are treated as non-matches
+    (no exception). Filtering and slicing both preserve the concrete
+    subclass, so chains stay typed end-to-end.
+    """
+
+    def filtered(self, **conditions: Any) -> "FilteredList[T]":
+        """Return a new collection of the same type containing only items
+        matching every keyword condition.
+
+        With no kwargs, returns a shallow copy.
+        """
+        if not conditions:
+            return type(self)(self)
+        checks = [(*_resolve_key(k), v) for k, v in conditions.items()]
+        out: "FilteredList[T]" = type(self)()
+        for item in self:
+            keep = True
+            for attr, op, expected in checks:
+                value = getattr(item, attr, _MISSING)
+                if value is _MISSING:
+                    keep = False
+                    break
+                try:
+                    matched = _OPS[op](value, expected)
+                except (TypeError, AttributeError):
+                    matched = False
+                if not matched:
+                    keep = False
+                    break
+            if keep:
+                out.append(item)
+        return out
+
+    def mapped(self, path: str) -> Union["FilteredList[Any]", List[Any]]:
+        """Gather values from a dotted attribute path, flattening lists.
+
+        Examples::
+
+            section.children.mapped("title")            # list[str]
+            section.children.mapped("blocks")           # BlockList
+            section.children.mapped("blocks.inlines")   # BlockList
+
+        Equivalent: ``c.mapped("x.y") == c.mapped("x").mapped("y")``.
+        List-typed attributes (e.g. ``.blocks``) flatten into the result;
+        scalar attributes append. The concrete subclass is preserved
+        when every value came from the same :class:`FilteredList`
+        subclass, so ``.mapped("blocks").filtered(kind="paragraph")``
+        keeps working. Items missing the attribute are skipped (same
+        as :meth:`filtered`). An empty path returns a shallow copy.
+        """
+        if not path:
+            return type(self)(self)
+        attr, _, rest = path.partition(".")
+
+        gathered: List[Any] = []
+        list_kind: Optional[type] = None
+        mixed = False
+        saw_scalar = False
+
+        for item in self:
+            value = getattr(item, attr, _MISSING)
+            if value is _MISSING:
+                continue
+            if isinstance(value, list):
+                if isinstance(value, FilteredList):
+                    if list_kind is None:
+                        list_kind = type(value)
+                    elif list_kind is not type(value):
+                        mixed = True
+                gathered.extend(value)
+            else:
+                saw_scalar = True
+                gathered.append(value)
+
+        result: Union[FilteredList[Any], List[Any]]
+        if list_kind is not None and not saw_scalar:
+            result = (FilteredList if mixed else list_kind)(gathered)
+        else:
+            result = gathered  # plain list (scalars, or nothing matched)
+
+        if rest:
+            if isinstance(result, FilteredList):
+                return result.mapped(rest)
+            return []  # can't descend into scalars / missing attrs
+        return result
+
+    def __getitem__(self, key):
+        result = super().__getitem__(key)
+        if isinstance(key, slice):
+            return type(self)(result)
+        return result
+
+
+class BlockList(FilteredList["Block"]):  # type: ignore[type-arg]
+    """A :class:`FilteredList` of :class:`~markdown_extractor.blocks.Block`."""
+
+
+class SectionList(FilteredList["Section"]):  # type: ignore[type-arg]
+    """A :class:`FilteredList` of :class:`~markdown_extractor.section.Section`."""

{markdown_extractor-0.1.1 → markdown_extractor-0.2.0}/src/markdown_extractor/blocks.py

@@ -17,8 +17,10 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass, field
-from typing import Iterator, List, Optional
+from typing import List, Optional
 
+from markdown_extractor._collections import BlockList
+from markdown_extractor.inline import parse_inlines
 from markdown_extractor.text_renderer import strip_inline
 
 
@@ -33,13 +35,36 @@ from markdown_extractor.text_renderer import strip_inline
 class Block:
     kind: str
     text: str = ""
-    children: List["Block"] = field(default_factory=list)
+    children: "BlockList" = field(default_factory=BlockList)
     info: str = ""  # code language, list marker style, etc.
+    inlines: "BlockList" = field(default_factory=BlockList)  # structured inline tokens (paragraph / list_item)
 
-    def walk(self) -> Iterator["Block"]:
-        yield self
+    def walk(self) -> "BlockList":
+        """Return this block and every descendant in depth-first order.
+
+        The result is a :class:`BlockList`, so you can chain
+        ``block.walk().filtered(kind="code")``.
+        """
+        out: BlockList = BlockList()
+        out.append(self)
         for child in self.children:
-            yield from child.walk()
+            out.extend(child.walk())
+        return out
+
+    def mapped(self, path: str):
+        """Dotted-path attribute traversal on a single block.
+
+        Equivalent to ``BlockList([self]).mapped(path)`` — treats this
+        block as a one-element collection so the same dotted-path /
+        flattening rules apply::
+
+            block.mapped("children")           # BlockList of children
+            block.mapped("children.inlines")   # BlockList — flat
+            block.mapped("text")               # [text]      (scalar → list)
+
+        See :meth:`FilteredList.mapped` for full semantics.
+        """
+        return BlockList([self]).mapped(path)
 
     def to_dict(self) -> dict:
         out: dict = {"kind": self.kind, "text": self.text}
@@ -47,6 +72,8 @@ class Block:
             out["info"] = self.info
         if self.children:
             out["children"] = [c.to_dict() for c in self.children]
+        if self.inlines:
+            out["inlines"] = [t.to_dict() for t in self.inlines]
         return out
 
     @property
@@ -105,12 +132,12 @@ def _expand_indent(s: str) -> int:
     return col
 
 
-def parse_blocks(text: str) -> List[Block]:
+def parse_blocks(text: str) -> BlockList:
     """Parse a section's body text into a list of top-level blocks."""
     if not text or not text.strip():
-        return []
+        return BlockList()
     lines = text.split("\n")
-    return _parse(lines, 0, len(lines), base_indent=0)
+    return BlockList(_parse(lines, 0, len(lines), base_indent=0))
 
 
 def _parse(lines: List[str], start: int, end: int, base_indent: int) -> List[Block]:
@@ -202,7 +229,7 @@ def _consume_list(lines, i, end, base_indent, ordered: bool):
     """
     list_indent = _expand_indent(lines[i])
     kind = "ordered_list" if ordered else "list"
-    items: List[Block] = []
+    items: BlockList = BlockList()
     j = i
     while j < end:
         line = lines[j]
@@ -252,8 +279,8 @@ def _consume_list(lines, i, end, base_indent, ordered: bool):
             m = m_o if ordered else m_b
             if m is None:
                 break
-            rest = m.group("rest")
-            item = Block(kind="list_item", text=rest.strip())
+            rest = m.group("rest").strip()
+            item = Block(kind="list_item", text=rest, inlines=parse_inlines(rest))
             items.append(item)
             j += 1
             continue
@@ -318,7 +345,8 @@ def _consume_paragraph(lines, i, end, base_indent):
             break
         body.append(stripped)
         j += 1
-    return Block(kind="paragraph", text=" ".join(body)), j
+    text = " ".join(body)
+    return Block(kind="paragraph", text=text, inlines=parse_inlines(text)), j
 
 
 def flatten(blocks: List[Block]) -> List[str]:
@@ -350,10 +378,10 @@ def _null_block() -> Block:
     Behaviour:
     - ``bool(b)`` is ``False``
     - ``b.text_plain`` → ``""``
-    - ``b.text`` → ``""``, ``b.children`` → ``[]``
+    - ``b.text`` → ``""``, ``b.children`` → ``[]``, ``b.inlines`` → ``[]``
     - ``b.get(*more)`` → keeps returning this sentinel
     """
     global _NULL_BLOCK
     if _NULL_BLOCK is None:
-        _NULL_BLOCK = Block(kind="", text="", children=[], info="")
+        _NULL_BLOCK = Block(kind="", text="", children=BlockList(), info="")
     return _NULL_BLOCK

{markdown_extractor-0.1.1 → markdown_extractor-0.2.0}/src/markdown_extractor/extractor.py

@@ -6,6 +6,7 @@ import json
 from pathlib import Path
 from typing import Iterator, List, Optional, Union
 
+from markdown_extractor._collections import SectionList
 from markdown_extractor.blocks import Block
 from markdown_extractor.parser import parse
 from markdown_extractor.section import Section
@@ -103,19 +104,21 @@ class MDExtractor:
         """Navigate by a sequence of titles (root → leaf)."""
         return self._root.get_section(*path)
 
-    def find(self, title: str) -> List[Section]:
+    def find(self, title: str) -> SectionList:
         """Find every section whose title equals ``title`` (any depth)."""
         return self._root.find(title)
 
-    def walk(self) -> Iterator[Section]:
-        """Iterate over every header section in the document, depth-first."""
-        for section in self._root.walk():
-            if section.level > 0:
-                yield section
+    def walk(self) -> SectionList:
+        """Every header section in the document, depth-first.
 
-    def headers(self) -> List[Section]:
-        """All header sections as a flat list (depth-first order)."""
-        return list(self.walk())
+        Returns a :class:`SectionList` (the synthetic root is excluded),
+        so the result can be chained with ``.filtered(...)``.
+        """
+        return self._root.walk().filtered(level__gt=0)
+
+    def headers(self) -> SectionList:
+        """All header sections as a flat :class:`SectionList`."""
+        return self.walk()
 
     def to_dict(self) -> dict:
         """JSON-friendly dict of the whole tree."""

{markdown_extractor-0.1.1 → markdown_extractor-0.2.0}/src/markdown_extractor/html_renderer.py

@@ -17,6 +17,14 @@ from html import escape
 from typing import Iterable, List
 
 from markdown_extractor.blocks import Block
+from markdown_extractor.inline import (
+    _BOLD_RE,
+    _EM_STAR_RE,
+    _EM_UNDER_RE,
+    _IMG_RE,
+    _INLINE_CODE_RE,
+    _LINK_RE,
+)
 
 
 def render(blocks: Iterable[Block]) -> str:
@@ -49,13 +57,9 @@ def _render_block(block: Block) -> str:
 # ---------------------------------------------------------------- inline
 
 # Order matters: replace inline code first (so its contents are not further
-# transformed), then images, links, bold, em.
-_CODE_RE = re.compile(r"`([^`]+)`")
-_IMG_RE = re.compile(r"!\[([^\]]*)\]\(([^)\s]+)\)")
-_LINK_RE = re.compile(r"\[([^\]]+)\]\(([^)\s]+)\)")
-_BOLD_RE = re.compile(r"\*\*([^*]+)\*\*")
-_EM_RE = re.compile(r"(?<![*\w])\*([^*\n]+?)\*(?!\w)")
-_EM_UNDER_RE = re.compile(r"(?<![\w_])_([^_\n]+?)_(?!\w)")
+# transformed), then images, links, bold, em. Regex patterns live in
+# :mod:`markdown_extractor.inline` so the parser and both renderers
+# share one source of truth.
 
 
 def _inline(text: str) -> str:
@@ -76,7 +80,7 @@ def _inline(text: str) -> str:
     def repl_code(m: re.Match) -> str:
         return stash(f"<code>{escape(m.group(1))}</code>")
 
-    out = _CODE_RE.sub(repl_code, text)
+    out = _INLINE_CODE_RE.sub(repl_code, text)
     out = escape(out, quote=False)
 
     def repl_img(m: re.Match) -> str:
@@ -94,7 +98,7 @@ def _inline(text: str) -> str:
     out = _IMG_RE.sub(repl_img, out)
     out = _LINK_RE.sub(repl_link, out)
     out = _BOLD_RE.sub(lambda m: f"<strong>{m.group(1)}</strong>", out)
-    out = _EM_RE.sub(lambda m: f"<em>{m.group(1)}</em>", out)
+    out = _EM_STAR_RE.sub(lambda m: f"<em>{m.group(1)}</em>", out)
     out = _EM_UNDER_RE.sub(lambda m: f"<em>{m.group(1)}</em>", out)
 
     # Restore stashed HTML.