@hawkeyexl/manni 4.4.1 → 4.6.0

package/dist/chunk-73TC4DYH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lint/parsers/markdown.ts","../src/lint/parsers/mdast.ts","../src/lint/parsers/sectionize.ts","../src/lint/parsers/metadata.ts","../src/lint/parsers/html.ts","../src/lint/parsers/rst.ts","../src/lint/parsers/xml.ts","../src/lint/parsers/asciidoc.ts","../src/lint/parsers/index.ts"],"sourcesContent":["/**\n * Markdown and MDX parsers.\n *\n * They share everything but the unified processor. MDX needs its own, selected\n * by extension rather than by a flag: `remark-mdx` reads `{` as an expression\n * delimiter, so ordinary Markdown prose containing a brace is a syntax error\n * under it. Running one processor for both formats would break either MDX\n * (without the plugin) or plain Markdown (with it).\n */\nimport { unified } from \"unified\";\nimport remarkParse from \"remark-parse\";\nimport remarkGfm from \"remark-gfm\";\nimport remarkFrontmatter from \"remark-frontmatter\";\nimport remarkMdx from \"remark-mdx\";\nimport { extractFrontmatter } from \"../../meta/index.js\";\nimport type { ContentKind, DocumentParser, DocumentTree } from \"../types.js\";\nimport { LintError } from \"../types.js\";\nimport { errorMessage } from \"../../shared/errors.js\";\nimport { documentEnd, toFragments } from \"./mdast.js\";\nimport { sectionize } from \"./sectionize.js\";\nimport { fencedPosition as frontmatterPosition, withMetadataTitle as withFrontmatterTitle } from \"./metadata.js\";\n\nconst markdownProcessor = unified()\n  .use(remarkParse)\n  .use(remarkGfm)\n  .use(remarkFrontmatter, [\"yaml\", \"toml\"]);\n\nconst mdxProcessor = unified()\n  .use(remarkParse)\n  .use(remarkGfm)\n  .use(remarkFrontmatter, [\"yaml\", \"toml\"])\n  .use(remarkMdx);\n\n/**\n * Only `parse` is used, and unified's `Processor` generics differ between the\n * plain and MDX pipelines (their tree types are not the same), so the narrow\n * structural type is both sufficient and the one that lets both pass.\n */\ninterface Parseable {\n  parse(content: string): unknown;\n}\n\nfunction parseWith(\n  processor: Parseable,\n  format: string,\n  content: string,\n  filePath: string,\n): DocumentTree {\n  let root: unknown;\n  try {\n    root = processor.parse(content);\n  } catch (err) {\n    // MDX raises on malformed expressions; a parse failure is the file's\n    // problem, not a crash, so it surfaces as an operational error naming it.\n    throw new LintError(\n      `${filePath}: could not parse as ${format}: ${errorMessage(err)}`,\n    );\n  }\n\n  const meta = extractFrontmatter(content, format);\n  const tree = root as Parameters<typeof toFragments>[0];\n\n  const frontmatter = meta.present ? meta.data : null;\n  const metaPosition = frontmatterPosition(content);\n\n  return {\n    format,\n    filePath,\n    frontmatter,\n    frontmatterPosition: metaPosition,\n    sections: sectionize(\n      withFrontmatterTitle(toFragments(tree), frontmatter, metaPosition),\n      documentEnd(tree),\n    ),\n    // Markdown's links are read from mdast by `manni graph` itself.\n    links: [],\n  };\n}\n\n/**\n * What both formats emit. `element` is MDX's alone: plain Markdown has no JSX,\n * so `<Steps>` is raw HTML to it and no tree it produces carries an element.\n * Declaring one here would report a rule about elements as checked on every\n * `.md` file it silently could not see.\n */\nconst SHARED_KINDS: ContentKind[] = [\n  \"paragraph\",\n  \"codeBlock\",\n  \"list\",\n  \"listItem\",\n  \"table\",\n  \"tableRow\",\n  \"tableCell\",\n  \"admonition\",\n  \"image\",\n  \"blockquote\",\n];\n\nexport const markdownParser: DocumentParser = {\n  name: \"markdown\",\n  label: \"Markdown\",\n  kinds: SHARED_KINDS,\n  extensions: [\".md\", \".markdown\"],\n  parse: (content, filePath) =>\n    parseWith(markdownProcessor, \"markdown\", content, filePath),\n};\n\nexport const mdxParser: DocumentParser = {\n  name: \"mdx\",\n  label: \"MDX\",\n  kinds: [...SHARED_KINDS, \"element\"],\n  extensions: [\".mdx\"],\n  parse: (content, filePath) => parseWith(mdxProcessor, \"mdx\", content, filePath),\n};\n","/**\n * mdast -> generic fragments. Shared by the Markdown and MDX parsers, which\n * differ only in which unified processor produced the tree.\n *\n * The mapping is onto the family content model (proposal 0065), never onto a\n * nearest neighbour: a blockquote is a `blockquote` and a table is a `table`,\n * because counting either as a paragraph would make `paragraphs: {max: 3}`\n * fail documents a reader would say satisfy it. A node type the model has no\n * kind for is still skipped with its subtree rather than approximated.\n *\n * MDX-only node types (`mdxJsxFlowElement`, and the expressions and comments\n * this file deliberately drops) appear only in trees the MDX processor\n * produced. The plain Markdown processor has no `remark-mdx`, so its trees\n * cannot carry them and `markdownParser` neither emits `element` nor declares\n * it. That is why one mapping serves both formats without a mode flag.\n */\nimport { toString as mdastToString } from \"mdast-util-to-string\";\nimport type { Position } from \"../types.js\";\nimport type {\n  AdmonitionNode,\n  ContentNode,\n  ElementNode,\n  ImageNode,\n  ListItemNode,\n  TableCellNode,\n  TableRowNode,\n} from \"../types.js\";\nimport type { Fragment } from \"./sectionize.js\";\n\n/** An MDX JSX attribute, as `mdast-util-mdx-jsx` shapes it. */\ninterface MdAttribute {\n  type: string;\n  name?: string | null;\n  /** A string for `a=\"b\"`, null for a bare `a`, an expression node for `a={b}`. */\n  value?: string | { type?: string; value?: string } | null;\n}\n\n/** Minimal structural view of an mdast node; avoids depending on @types/mdast shapes. */\ninterface MdNode {\n  type: string;\n  position?: {\n    start: { line: number; column: number; offset?: number };\n    end: { line: number; column: number; offset?: number };\n  };\n  children?: MdNode[];\n  depth?: number;\n  lang?: string | null;\n  ordered?: boolean | null;\n  value?: string;\n  url?: string;\n  alt?: string | null;\n  title?: string | null;\n  /** MDX JSX only; null on a fragment (`<>`). */\n  name?: string | null;\n  attributes?: MdAttribute[];\n}\n\nconst ZERO: Position = {\n  start: { line: 1, column: 1, offset: 0 },\n  end: { line: 1, column: 1, offset: 0 },\n};\n\n/**\n * unist positions carry `offset` as optional. It is always present on a tree\n * remark parsed from a string, but the type does not say so, and a missing\n * offset would otherwise become `NaN` in a reporter.\n */\nexport function positionOf(node: MdNode): Position {\n  const p = node.position;\n  if (!p) return { start: { ...ZERO.start }, end: { ...ZERO.end } };\n  return {\n    start: { line: p.start.line, column: p.start.column, offset: p.start.offset ?? 0 },\n    end: { line: p.end.line, column: p.end.column, offset: p.end.offset ?? 0 },\n  };\n}\n\nfunction isContentNode(node: ContentNode | null): node is ContentNode {\n  return node !== null;\n}\n\nfunction childContent(node: MdNode): ContentNode[] {\n  return (node.children ?? []).map(toContentNode).filter(isContentNode);\n}\n\n/**\n * `AdmonitionNode.variant` is optional, for the formats that name a flavor\n * this vocabulary does not carry. A GitHub alert always names one of five, so\n * every admonition this file produces has one, and saying so here is what\n * keeps a missing lookup from being mistaken for a format that named nothing.\n */\ntype AlertVariant = NonNullable<AdmonitionNode[\"variant\"]>;\n\n/**\n * The five alert types GitHub defines. `danger` is in the model's `variant`\n * set but is not one of them, so `> [!DANGER]` renders as an ordinary\n * blockquote and is read as one here: a word outside the source's own set is\n * not an equivalence to invent.\n */\nconst ALERT_VARIANTS = new Map<string, AlertVariant>([\n  [\"note\", \"note\"],\n  [\"tip\", \"tip\"],\n  [\"important\", \"important\"],\n  [\"warning\", \"warning\"],\n  [\"caution\", \"caution\"],\n]);\n\n/** The marker line, which must be the whole first line of the first paragraph. */\nconst ALERT_MARKER = /^\\[!([A-Za-z]+)\\][^\\S\\n]*$/;\n\n/**\n * The same marker where it sits at the head of a flattened string, with the\n * newline that followed it. `mdast-util-to-string` concatenates block children\n * without a separator, so the marker's paragraph may run straight into the\n * next one and there is no newline to consume.\n */\nconst ALERT_PREFIX = /^\\[!\\w+\\][^\\S\\n]*\\n?/;\n\n/**\n * A GitHub alert, which is a blockquote whose first paragraph opens with a\n * marker line. It is a check on that paragraph's text rather than a plugin,\n * because the marker is ordinary text to every Markdown parser.\n */\nfunction alertVariant(node: MdNode): AlertVariant | null {\n  const first = node.children?.[0];\n  if (!first || first.type !== \"paragraph\") return null;\n  const text = mdastToString(first);\n  const newline = text.indexOf(\"\\n\");\n  const firstLine = newline === -1 ? text : text.slice(0, newline);\n  const match = ALERT_MARKER.exec(firstLine);\n  const word = match?.[1];\n  // Case-insensitively, as GitHub matches it.\n  return word ? (ALERT_VARIANTS.get(word.toLowerCase()) ?? null) : null;\n}\n\nfunction toAdmonition(node: MdNode, variant: AlertVariant): AdmonitionNode {\n  const children = childContent(node);\n  const first = children[0];\n  // The marker is markup, not content, so it is stripped from the admonition's\n  // own text and from the paragraph that carried it. A paragraph left holding\n  // nothing but the marker is dropped rather than kept as an empty one.\n  if (first && first.kind === \"paragraph\") {\n    const stripped = first.text.replace(ALERT_PREFIX, \"\");\n    if (stripped.length === 0) children.shift();\n    else children[0] = { ...first, text: stripped };\n  }\n  return {\n    kind: \"admonition\",\n    position: positionOf(node),\n    text: mdastToString(node).replace(ALERT_PREFIX, \"\"),\n    variant,\n    children,\n  };\n}\n\n/**\n * The image a paragraph holds, when that is all it holds. An image inside\n * richer prose is part of what the paragraph says: promoting it would take the\n * sentence around it out of the paragraph count.\n */\nfunction soleImage(node: MdNode): MdNode | null {\n  const meaningful = (node.children ?? []).filter(\n    (child) => !(child.type === \"text\" && (child.value ?? \"\").trim().length === 0),\n  );\n  const only = meaningful.length === 1 ? meaningful[0] : undefined;\n  return only && only.type === \"image\" ? only : null;\n}\n\nfunction toImage(node: MdNode): ImageNode {\n  const alt = node.alt ?? \"\";\n  return {\n    kind: \"image\",\n    position: positionOf(node),\n    text: alt,\n    url: node.url ?? \"\",\n    alt,\n    ...(node.title ? { title: node.title } : {}),\n  };\n}\n\n/**\n * An MDX element's attributes, by their literal values: the string for\n * `a=\"b\"`, `true` for a bare `a`, and the braced source for `a={b}`, so a rule\n * can say \"its value is an expression\" rather than silently not matching a\n * value it cannot know. A spread (`{...rest}`) names no attribute and is\n * dropped, having no key to record it under.\n */\nfunction attributesOf(node: MdNode): Record<string, string | true> | undefined {\n  const attributes: Record<string, string | true> = {};\n  let any = false;\n  for (const attribute of node.attributes ?? []) {\n    if (attribute.type !== \"mdxJsxAttribute\") continue;\n    const name = attribute.name;\n    if (typeof name !== \"string\" || name.length === 0) continue;\n    const value = attribute.value;\n    if (value === null || value === undefined) attributes[name] = true;\n    else if (typeof value === \"string\") attributes[name] = value;\n    else attributes[name] = `{${value.value ?? \"\"}}`;\n    any = true;\n  }\n  return any ? attributes : undefined;\n}\n\nfunction toElement(node: MdNode): ElementNode {\n  const attributes = attributesOf(node);\n  return {\n    kind: \"element\",\n    position: positionOf(node),\n    text: mdastToString(node),\n    // A fragment (`<>`) has no tag to name.\n    name: node.name ?? \"\",\n    ...(attributes ? { attributes } : {}),\n    // The element's own children, never the enclosing section's: a section\n    // holding one `<Steps>` holds one block, not the four paragraphs inside\n    // it (proposal 0065, stress test 4). A heading inside one is dropped with\n    // everything else the model has no kind for, which stress test 5 records.\n    children: childContent(node),\n  };\n}\n\nfunction toTableRow(row: MdNode, header: boolean): TableRowNode {\n  return {\n    kind: \"tableRow\",\n    position: positionOf(row),\n    text: mdastToString(row),\n    header,\n    children: (row.children ?? [])\n      .filter((cell) => cell.type === \"tableCell\")\n      .map(\n        (cell): TableCellNode => ({\n          kind: \"tableCell\",\n          position: positionOf(cell),\n          text: mdastToString(cell),\n          // A GFM cell holds inline content only, so this is empty today. It\n          // is mapped rather than assumed empty because the model's cell is\n          // the one reStructuredText and DITA fill with blocks.\n          children: childContent(cell),\n        }),\n      ),\n  };\n}\n\nfunction toContentNode(node: MdNode): ContentNode | null {\n  switch (node.type) {\n    case \"paragraph\": {\n      const image = soleImage(node);\n      if (image) return toImage(image);\n      return {\n        kind: \"paragraph\",\n        position: positionOf(node),\n        text: mdastToString(node),\n      };\n    }\n    case \"code\":\n      return {\n        kind: \"codeBlock\",\n        position: positionOf(node),\n        text: node.value ?? \"\",\n        ...(node.lang ? { language: node.lang } : {}),\n      };\n    case \"list\":\n      return {\n        kind: \"list\",\n        position: positionOf(node),\n        text: mdastToString(node),\n        ordered: Boolean(node.ordered),\n        items: (node.children ?? [])\n          .filter((child) => child.type === \"listItem\")\n          .map(\n            (item): ListItemNode => ({\n              kind: \"listItem\",\n              position: positionOf(item),\n              text: mdastToString(item),\n              children: childContent(item),\n            }),\n          ),\n      };\n    case \"table\":\n      return {\n        kind: \"table\",\n        position: positionOf(node),\n        text: mdastToString(node),\n        // GFM guarantees the first row is the header, which is the one format\n        // of six where reading it positionally is safe. Everywhere else the\n        // format carries a real `thead` and this flag comes from it.\n        children: (node.children ?? [])\n          .filter((row) => row.type === \"tableRow\")\n          .map((row, index) => toTableRow(row, index === 0)),\n      };\n    case \"blockquote\": {\n      const variant = alertVariant(node);\n      if (variant) return toAdmonition(node, variant);\n      return {\n        kind: \"blockquote\",\n        position: positionOf(node),\n        text: mdastToString(node),\n        children: childContent(node),\n      };\n    }\n    case \"mdxJsxFlowElement\":\n      return toElement(node);\n    default:\n      return null;\n  }\n}\n\n/**\n * The `{#anchor}` suffix Hugo and Docusaurus write on a heading. It names the\n * rendered id, and a reader never sees it, so a template matches the heading\n * without it.\n */\nconst HEADING_ANCHOR = /\\s*\\{#[^}\\s]*\\}\\s*$/;\n\nfunction headingTitle(node: MdNode): string {\n  return mdastToString(node).replace(HEADING_ANCHOR, \"\").trim();\n}\n\n/** Flatten an mdast root's direct children into ordered fragments. */\nexport function toFragments(root: MdNode): Fragment[] {\n  const fragments: Fragment[] = [];\n  for (const node of root.children ?? []) {\n    // Frontmatter is metadata, not body content; the caller reads it separately.\n    if (node.type === \"yaml\" || node.type === \"toml\") continue;\n\n    if (node.type === \"heading\") {\n      fragments.push({\n        type: \"heading\",\n        level: node.depth ?? 1,\n        title: headingTitle(node),\n        position: positionOf(node),\n      });\n      continue;\n    }\n\n    const content = toContentNode(node);\n    if (content) fragments.push({ type: \"content\", node: content });\n  }\n  return fragments;\n}\n\n/** End of the document, for closing the final sections. */\nexport function documentEnd(root: MdNode): Position[\"end\"] {\n  return positionOf(root).end;\n}\n","/**\n * Fold a flat list of fragments into a nested section tree.\n *\n * Every format arrives here as an ordered list of `Fragment`s - a heading, or\n * a piece of content - and leaves as `SectionNode[]`. Keeping the fold in one\n * place is what makes a new format one `toFragments` function rather than a\n * second copy of the nesting, position, and slug logic.\n *\n * Named `Fragment` rather than `Block`, deliberately: \"block\" is the\n * block-level content vocabulary (`ContentKind`'s `table`, `blockquote`, and\n * so on), and this internal pipeline type never leaves `src/lint/parsers/`.\n *\n * Two position rules are deliberate:\n *\n *  - A section ends where the *next section at its level or shallower* begins,\n *    not at its own last child. A finding about a section therefore spans the\n *    trailing blank lines a reader would consider part of it, and adjacent\n *    sections tile the document with no gaps.\n *  - Content appearing before any heading becomes an implicit lead section at\n *    `level: 0`, so a headless document (frontmatter, prose, then `## ...`)\n *    still has somewhere to hang its content and its later headings nest under\n *    it rather than being dropped.\n */\nimport GithubSlugger from \"github-slugger\";\nimport type { ContentNode, Position, SectionNode } from \"../types.js\";\n\nexport interface HeadingFragment {\n  type: \"heading\";\n  /** 1-6. */\n  level: number;\n  title: string;\n  position: Position;\n  /** The source's own anchor for this heading; copied to `SectionNode.id`. */\n  id?: string;\n  /** Made by `withMetadataTitle`, not written; copied to `SectionNode.synthetic`. */\n  synthetic?: true;\n}\n\nexport interface ContentFragment {\n  type: \"content\";\n  node: ContentNode;\n}\n\nexport type Fragment = HeadingFragment | ContentFragment;\n\n/** Mutable while open; frozen into a `SectionNode` on close. */\ninterface OpenSection {\n  node: SectionNode;\n  /** End of the last block seen, the fallback when nothing follows. */\n  lastEnd: Position[\"end\"];\n}\n\n/**\n * @param fragments Document fragments in source order, frontmatter excluded.\n * @param docEnd    End of the document, used to close the final sections.\n */\nexport function sectionize(fragments: Fragment[], docEnd: Position[\"end\"]): SectionNode[] {\n  const slugger = new GithubSlugger();\n  const roots: SectionNode[] = [];\n  const stack: OpenSection[] = [];\n\n  /** Close every open section at `level` or deeper, ending it at `end`. */\n  const closeTo = (level: number, end: Position[\"end\"]): void => {\n    let top = stack.at(-1);\n    while (top !== undefined && top.node.level >= level) {\n      stack.pop();\n      top.node.position.end = { ...end };\n      top = stack.at(-1);\n    }\n  };\n\n  /** Pushes `node` onto the stack and hands back the section it opened. */\n  const push = (node: SectionNode): OpenSection => {\n    const parent = stack[stack.length - 1];\n    if (parent) {\n      node.parentSlug = parent.node.slug;\n      node.order = parent.node.sections.length + 1;\n      parent.node.sections.push(node);\n    } else {\n      node.parentSlug = null;\n      node.order = roots.length + 1;\n      roots.push(node);\n    }\n    const open: OpenSection = { node, lastEnd: node.position.end };\n    stack.push(open);\n    return open;\n  };\n\n  /**\n   * The implicit lead section. `level: 0` is below every real heading, so the\n   * headings that follow nest inside it instead of closing it.\n   */\n  const openLead = (start: Position[\"start\"]): OpenSection =>\n    push({\n      slug: slugger.slug(\"(lead)\"),\n      title: \"\",\n      level: 0,\n      order: 0,\n      parentSlug: null,\n      titlePosition: null,\n      position: { start: { ...start }, end: { ...start } },\n      children: [],\n      sections: [],\n    });\n\n  for (const fragment of fragments) {\n    if (fragment.type === \"heading\") {\n      closeTo(fragment.level, fragment.position.start);\n      push({\n        slug: slugger.slug(fragment.title),\n        title: fragment.title,\n        level: fragment.level,\n        order: 0,\n        parentSlug: null,\n        titlePosition: { ...fragment.position },\n        ...(fragment.id !== undefined ? { id: fragment.id } : {}),\n        ...(fragment.synthetic ? { synthetic: true as const } : {}),\n        position: { start: { ...fragment.position.start }, end: { ...fragment.position.end } },\n        children: [],\n        sections: [],\n      });\n      continue;\n    }\n\n    const current = stack.at(-1) ?? openLead(fragment.node.position.start);\n    current.node.children.push(fragment.node);\n    current.lastEnd = fragment.node.position.end;\n    // Every enclosing section grows with its descendants, so a parent's span\n    // always covers its children even before it is closed.\n    for (const open of stack) open.node.position.end = { ...fragment.node.position.end };\n  }\n\n  closeTo(0, docEnd);\n  return roots;\n}\n","/**\n * Metadata helpers shared by every format that has both metadata and headings.\n *\n * Both functions here were independently written four times, once per parser,\n * and were character-identical each time. They are rules about a `DocumentTree`\n * rather than about any one syntax, so they belong in one place: a subtlety\n * duplicated four ways is a subtlety that will be fixed one way.\n */\nimport { locateFrontmatter } from \"../../meta/index.js\";\nimport type { Position } from \"../types.js\";\nimport type { Fragment } from \"./sectionize.js\";\n\n/**\n * Span of a leading fenced metadata block (`--- … ---`, `+++ … +++`,\n * `;;; … ;;;`), or null when the content carries none.\n *\n * docmeta's locator reports character offsets against the original content, so\n * line numbers are recovered by counting newlines rather than by a second\n * parse - exact, because those offsets are byte-for-byte.\n */\nexport function fencedPosition(content: string): Position | null {\n  const loc = locateFrontmatter(content);\n  if (!loc) return null;\n  const before = content.slice(0, loc.openStart);\n  const startLine = before.split(\"\\n\").length;\n  const lines = content.slice(loc.openStart, loc.closeEnd).split(\"\\n\");\n  return {\n    start: { line: startLine, column: 1, offset: loc.openStart },\n    end: {\n      line: startLine + lines.length - 1,\n      // Taken from the last line's own length rather than fixed at 1. When the\n      // block ends with a newline that line is empty and the column is 1\n      // anyway; when the closing fence ends at EOF without one, the half-open\n      // end is just past the delimiter - which `offset` already said, so a\n      // fixed column contradicted it and pointed a reader's caret at the start\n      // of the fence line instead of its end.\n      // `split` always yields at least one entry, so the fallback is\n      // unreachable; an empty last line is column 1 either way.\n      column: (lines.at(-1) ?? \"\").length + 1,\n      offset: loc.closeEnd,\n    },\n  };\n}\n\n/**\n * Treat a metadata `title` as the document's H1 when the body has none.\n *\n * Docusaurus, Hugo, and Starlight all render the page title from frontmatter,\n * so their pages legitimately start at `##`. Read literally, such a page has no\n * top-level section, and every doctype template - which models the title as its\n * outermost rule, because that is how the published templates are written -\n * misaligns against it and reports a cascade. The page is not malformed; the\n * title simply is not written where a naive reading looks for it.\n *\n * So a synthetic heading is prepended, positioned on the metadata that actually\n * carries the title. Everything downstream then sees the document the way a\n * reader sees it rendered.\n *\n * Only when the body has no level-1 heading of its own: prepending one where a\n * real title exists would nest it inside a synthetic parent, which is a\n * different document.\n *\n * See ADR 01006. Formats where the title is always a body element - XML, whose\n * \"metadata\" is the root element's own attributes - do not call this, and\n * should not.\n */\nexport function withMetadataTitle(\n  fragments: Fragment[],\n  metadata: Record<string, unknown> | null,\n  position: Position | null,\n): Fragment[] {\n  const declared = metadata?.[\"title\"];\n  const title = typeof declared === \"string\" ? declared.trim() : null;\n  // Trimmed, not merely non-empty: `title: \"   \"` is as absent as no title at\n  // all, and admitting it would give the document a synthetic H1 with a blank\n  // heading - which every template then reports as the wrong title, naming\n  // nothing the author could search for.\n  if (title === null || title.length === 0) return fragments;\n  if (position === null) return fragments;\n  if (fragments.some((b) => b.type === \"heading\" && b.level === 1)) return fragments;\n\n  return [{ type: \"heading\", level: 1, title, position, synthetic: true }, ...fragments];\n}\n\n/**\n * The content with a leading fenced metadata block removed.\n *\n * docmeta's AsciiDoc and reStructuredText extractors short-circuit: when a\n * fence is present they return it and never look at the format's own metadata.\n * So a page carrying both a `---` fence and a native `:type: how-to` header\n * lost the `type` entirely and was skipped as untyped - while the same page in\n * HTML, whose extractor has no such branch, routed correctly. Running the\n * native extractor over the fence-free remainder is what lets both be read.\n *\n * Only the values are taken from that second read; positions would be shifted\n * by the removal and are not used.\n */\nexport function withoutFence(content: string): string {\n  const loc = locateFrontmatter(content);\n  return loc ? content.slice(loc.closeEnd) : content;\n}\n","/**\n * HTML parser: parse5's DOM -> generic blocks -> the shared `sectionize` fold.\n *\n * The job is the same one `mdast.ts` does for Markdown - flatten a format's own\n * tree into ordered `Fragment`s - and the same skipping discipline applies\n * where the content model has no kind at all. A `<div>` is not content and a\n * `<figure>` with no image inside it is dropped whole, because counting\n * either would make `paragraphs: {max: 3}` fail a page a reader would say\n * satisfies it. Proposal 0065 widened the model, so `blockquote`, `table`,\n * `figure`, and `dl` are no longer in that group: they map onto real nodes\n * now, alongside `admonition` from `<aside>`/`role=\"note\"` and `image` from\n * `<img>`.\n *\n * `parse` rather than `parseFragment`. Real documentation HTML is a document:\n * `<!DOCTYPE html><html><head>…</head><body>…`, and an HTML page's metadata\n * lives in `<head>`, which `parseFragment` (which parses in a `<body>` context)\n * drops on the floor - `<head>` is an ignored start tag in the \"in body\"\n * insertion mode. `parse` also handles a bare fragment, because HTML5 tree\n * construction synthesizes the missing `<html>`/`<head>`/`<body>` around it; the\n * only cost is that those synthesized elements carry no `sourceCodeLocation`,\n * which `positionOf` already has to tolerate.\n *\n * parse5 never throws on malformed input - HTML5 defines recovery for every\n * error - so unlike the MDX path there is no parse-failure branch here. A\n * document with unclosed tags parses into whatever a browser would build from\n * it, and lints against that.\n */\nimport { defaultTreeAdapter, parse } from \"parse5\";\nimport type { DefaultTreeAdapterTypes } from \"parse5\";\nimport { extractFrontmatter, extractorForExtension } from \"../../meta/index.js\";\nimport type {\n  AdmonitionNode,\n  BlockquoteNode,\n  CodeNode,\n  ContentNode,\n  DefinitionItemNode,\n  DefinitionListNode,\n  DocumentParser,\n  DocumentTree,\n  ImageNode,\n  ListItemNode,\n  Position,\n  TableCellNode,\n  TableNode,\n  TableRowNode,\n} from \"../types.js\";\nimport type { Fragment } from \"./sectionize.js\";\nimport { sectionize } from \"./sectionize.js\";\nimport { fencedPosition, withMetadataTitle } from \"./metadata.js\";\n\ntype Node = DefaultTreeAdapterTypes.Node;\ntype Element = DefaultTreeAdapterTypes.Element;\ntype ParentNode = DefaultTreeAdapterTypes.ParentNode;\n\n/**\n * What a walk does when it meets an element.\n *\n *  - `heading`/`content`: the element *is* a block. It is emitted and never\n *    descended into, because its whole subtree has already been folded into the\n *    emitted node's text (or, for a container kind, its own `children`).\n *    Descending would emit the same prose twice.\n *  - `container`: the element is not content but its children may be. Descend\n *    without emitting. This is the case that matters: real HTML wraps\n *    everything in `<html><body><main><article><div>`, and a heading inside a\n *    `<div>` is still a heading.\n *  - `opaque`: neither content nor a container. Skip the subtree entirely.\n *\n * `container` is the default, so an unknown element - a web component, a\n * `<my-callout>` - still yields the headings and paragraphs inside it. `opaque`\n * is a short, explicit list, and every entry earns its place the same way: it\n * is metadata/machinery rather than prose, so the generic content model has no\n * kind for it at all.\n */\ntype Role = \"heading\" | \"content\" | \"container\" | \"opaque\";\n\nconst HEADING_LEVELS = new Map<string, number>([\n  [\"h1\", 1],\n  [\"h2\", 2],\n  [\"h3\", 3],\n  [\"h4\", 4],\n  [\"h5\", 5],\n  [\"h6\", 6],\n]);\n\n/**\n * Elements that are a block on their own: emitted as one content node, never\n * descended into. `table`, `blockquote`, `dl`, `img` and `figure` used to sit\n * in `OPAQUE_TAGS` and be dropped whole; proposal 0065 gave each a node shape,\n * so they move here instead. `aside` joins them because it is one of the two\n * HTML sources of `admonition` - the other, `role=\"note\"`, is not a tag and is\n * checked separately in `roleOf`.\n */\nconst CONTENT_TAGS = new Set([\"p\", \"pre\", \"ul\", \"ol\", \"table\", \"blockquote\", \"dl\", \"img\", \"figure\", \"aside\"]);\n\nconst OPAQUE_TAGS = new Set([\n  // Metadata and machinery, not prose.\n  \"head\",\n  \"script\",\n  \"style\",\n  \"template\",\n  \"noscript\",\n  \"svg\",\n  \"math\",\n]);\n\n/** Elements whose text is not document text, for the flattening helpers. */\nconst NON_TEXT_TAGS = new Set([\"script\", \"style\", \"template\"]);\n\nconst ADMONITION_VARIANTS = new Set([\n  \"note\",\n  \"tip\",\n  \"important\",\n  \"caution\",\n  \"warning\",\n  \"danger\",\n]);\n\nconst ZERO: Position = {\n  start: { line: 1, column: 1, offset: 0 },\n  end: { line: 1, column: 1, offset: 0 },\n};\n\nfunction tagOf(el: Element): string {\n  return el.tagName.toLowerCase();\n}\n\n/** An element's attribute value, or `undefined` when it does not carry one. */\nfunction attrOf(el: Element, name: string): string | undefined {\n  return el.attrs.find((a) => a.name === name)?.value;\n}\n\n/**\n * `admonition`'s two HTML sources: the `<aside>` tag, and `role=\"note\"` on any\n * element. Neither one is enough on its own - `aside` is a tag and `role` is\n * an attribute any element can carry - so this is checked ahead of the\n * tag-keyed `CONTENT_TAGS`/`OPAQUE_TAGS` lookup rather than folded into it.\n */\nfunction isAdmonitionSource(el: Element, tag: string): boolean {\n  return tag === \"aside\" || attrOf(el, \"role\") === \"note\";\n}\n\nfunction roleOf(el: Element, tag: string): Role {\n  if (HEADING_LEVELS.has(tag)) return \"heading\";\n  if (isAdmonitionSource(el, tag)) return \"content\";\n  if (CONTENT_TAGS.has(tag)) return \"content\";\n  if (OPAQUE_TAGS.has(tag)) return \"opaque\";\n  return \"container\";\n}\n\n/**\n * parse5's `sourceCodeLocation` maps onto `Position` one field at a time: its\n * lines and columns are 1-based, its offsets 0-based, and its `end*` is one\n * past the last character - the same half-open span `Position` documents. A\n * `<p>foo</p>` starting at column 1 reports `endCol` 12 for an 11-character\n * element, and `endOffset - startOffset` is its length.\n *\n * A node can carry no location at all: parse5 synthesizes `<html>`, `<head>`,\n * and `<body>` around a fragment, and those have none. Nothing synthesized is\n * ever emitted as a block, but the fallback keeps a missing location from\n * becoming `NaN` in a reporter.\n */\ninterface Located {\n  sourceCodeLocation?: {\n    startLine: number;\n    startCol: number;\n    startOffset: number;\n    endLine: number;\n    endCol: number;\n    endOffset: number;\n  } | null;\n}\n\nfunction positionOf(node: Located): Position {\n  const loc = node.sourceCodeLocation;\n  if (!loc) return { start: { ...ZERO.start }, end: { ...ZERO.end } };\n  return {\n    start: { line: loc.startLine, column: loc.startCol, offset: loc.startOffset },\n    end: { line: loc.endLine, column: loc.endCol, offset: loc.endOffset },\n  };\n}\n\n/**\n * Concatenated text of a subtree, markup and all, verbatim. `skipHref` drops\n * an `<a>` linking exactly there, which is how a heading leaves out its own\n * permalink glyph.\n */\nfunction rawText(node: Node, skipHref?: string): string {\n  if (defaultTreeAdapter.isTextNode(node)) return node.value;\n  if (!defaultTreeAdapter.isElementNode(node)) return \"\";\n  const tag = tagOf(node);\n  if (NON_TEXT_TAGS.has(tag)) return \"\";\n  if (skipHref !== undefined && tag === \"a\" && attrOf(node, \"href\") === skipHref) return \"\";\n  let out = \"\";\n  for (const child of node.childNodes) out += rawText(child, skipHref);\n  return out;\n}\n\n/**\n * Text as a browser renders it: nested `<code>`, `<em>`, and `<a>` contribute\n * their text, and HTML's insignificant whitespace collapses, so a heading\n * written across three indented lines still equals `\"Overview\"` - which is what\n * a template's `heading: {const: Overview}` compares against.\n *\n * This is the HTML side of the bug the Markdown parser had before the rewrite,\n * where a title was built from `children.map(c => c.value)` and every inline\n * element vanished.\n */\nfunction flatText(node: Node, skipHref?: string): string {\n  return rawText(node, skipHref).replace(/\\s+/g, \" \").trim();\n}\n\n/** `language-x` from a `class`, per the HTML5 convention for code blocks. */\nfunction langOf(el: Element): string | undefined {\n  const className = attrOf(el, \"class\");\n  if (!className) return undefined;\n  for (const token of className.split(/\\s+/)) {\n    if (token.startsWith(\"language-\") && token.length > \"language-\".length) {\n      return token.slice(\"language-\".length);\n    }\n  }\n  return undefined;\n}\n\n/** `variant`, from `role=\"note\"` or a class naming one of the six - never invented. */\nfunction variantOf(el: Element): AdmonitionNode[\"variant\"] | undefined {\n  const className = attrOf(el, \"class\");\n  if (className) {\n    for (const token of className.split(/\\s+/)) {\n      if (ADMONITION_VARIANTS.has(token)) return token as AdmonitionNode[\"variant\"];\n    }\n  }\n  if (attrOf(el, \"role\") === \"note\") return \"note\";\n  return undefined;\n}\n\nfunction firstElementChild(el: Element, tag: string): Element | undefined {\n  for (const child of el.childNodes) {\n    if (defaultTreeAdapter.isElementNode(child) && tagOf(child) === tag) return child;\n  }\n  return undefined;\n}\n\n/** An element's direct element children, text and comment nodes excluded. */\nfunction elementChildren(el: Element): Element[] {\n  const out: Element[] = [];\n  for (const child of el.childNodes) {\n    if (defaultTreeAdapter.isElementNode(child)) out.push(child);\n  }\n  return out;\n}\n\n/** The first `<img>` anywhere under `el`, depth-first - for a `<figure>`. */\nfunction findImage(el: Element): Element | undefined {\n  for (const child of el.childNodes) {\n    if (!defaultTreeAdapter.isElementNode(child)) continue;\n    if (tagOf(child) === \"img\") return child;\n    const nested = findImage(child);\n    if (nested) return nested;\n  }\n  return undefined;\n}\n\n/**\n * `<pre>` (usually `<pre><code>`) as a code node.\n *\n * Whitespace is significant here, so this is the one place `rawText` is used\n * unnormalized. Two trims are deliberate: a newline directly after `<code>` is\n * an artifact of writing the block over several lines (the HTML parser already\n * drops one directly after `<pre>`, but not one after a nested `<code>`), and\n * dropping trailing whitespace matches mdast's `code.value`, which carries no\n * closing newline.\n */\nfunction codeNode(pre: Element): CodeNode {\n  const inner = firstElementChild(pre, \"code\");\n  const lang = langOf(pre) ?? (inner ? langOf(inner) : undefined);\n  const text = rawText(pre).replace(/^\\r?\\n/, \"\").replace(/\\s+$/, \"\");\n  return {\n    kind: \"codeBlock\",\n    position: positionOf(pre),\n    text,\n    ...(lang ? { language: lang } : {}),\n  };\n}\n\n/**\n * `<img>` as an image node. A bare `<img>` carries no caption of its own; a\n * `<figure>` wrapping one supplies both the position (the whole figure, since\n * that construct - image and caption together - is what the one node stands\n * for) and, when present, its `<figcaption>` as `text`.\n */\nfunction imageNode(img: Element, position: Position, caption: string | null): ImageNode {\n  const title = attrOf(img, \"title\");\n  return {\n    kind: \"image\",\n    position,\n    text: caption ?? \"\",\n    url: attrOf(img, \"src\") ?? \"\",\n    alt: attrOf(img, \"alt\") ?? \"\",\n    ...(title ? { title } : {}),\n  };\n}\n\n/**\n * `<figure>` as a single image node. A figure with no `<img>` anywhere inside\n * it maps to nothing - the same as before 0065, when the whole subtree was\n * opaque - because the content model has no other kind to give it.\n */\nfunction figureNode(figure: Element): ImageNode | null {\n  const img = findImage(figure);\n  if (!img) return null;\n  const caption = firstElementChild(figure, \"figcaption\");\n  return imageNode(img, positionOf(figure), caption ? flatText(caption) : null);\n}\n\n/** `<blockquote>` as a blockquote node, its own content mapped recursively. */\nfunction blockquoteNode(el: Element): BlockquoteNode {\n  return {\n    kind: \"blockquote\",\n    position: positionOf(el),\n    text: flatText(el),\n    children: childContent(el),\n  };\n}\n\n/**\n * `<aside>` or `role=\"note\"` as an admonition node. HTML names no admonition\n * type natively, so `variantOf` only ever returns one of the six when the\n * source itself said which - see its own comment. A bare `<aside>` that names\n * neither carries no `variant` at all, per `AdmonitionNode.variant`'s own\n * comment in `src/lint/types.ts`: defaulting it to `note` would make\n * `variant: note` pass on a page that never said note.\n */\nfunction admonitionNode(el: Element): AdmonitionNode {\n  const variant = variantOf(el);\n  return {\n    kind: \"admonition\",\n    position: positionOf(el),\n    text: flatText(el),\n    ...(variant ? { variant } : {}),\n    children: childContent(el),\n  };\n}\n\n/** One `<td>`/`<th>` as a table cell, its own content mapped recursively. */\nfunction cellNode(cell: Element): TableCellNode {\n  return {\n    kind: \"tableCell\",\n    position: positionOf(cell),\n    text: flatText(cell),\n    children: childContent(cell),\n  };\n}\n\n/**\n * Which grouping a row was found in. `none` is a bare `<tr>` under the table.\n *\n * A footer has to be told apart from a body, rather than both being \"not the\n * head\". `<tfoot><tr><th>Total</th></tr></tfoot>` is an ordinary way to label\n * a totals row, and the every-cell-is-a-`<th>` rule below would otherwise read\n * it as a header.\n */\ntype RowGroup = \"head\" | \"body\" | \"foot\" | \"none\";\n\n/** One `<tr>`. `header` is set from `<thead>` membership, or - failing that - from every cell being a `<th>`. Never inferred from position, and never in a footer. */\nfunction rowNode(tr: Element, group: RowGroup): TableRowNode {\n  const cells: TableCellNode[] = [];\n  let allHeaderCells = true;\n  for (const child of elementChildren(tr)) {\n    const tag = tagOf(child);\n    if (tag !== \"td\" && tag !== \"th\") continue;\n    if (tag !== \"th\") allHeaderCells = false;\n    cells.push(cellNode(child));\n  }\n  return {\n    kind: \"tableRow\",\n    position: positionOf(tr),\n    text: flatText(tr),\n    header:\n      group === \"head\" || (group !== \"foot\" && cells.length > 0 && allHeaderCells),\n    children: cells,\n  };\n}\n\n/** Rows from `<thead>`/`<tbody>`/`<tfoot>` or bare `<tr>` children, in document order. */\nfunction collectRows(parent: Element, out: TableRowNode[], group: RowGroup): void {\n  for (const child of elementChildren(parent)) {\n    const tag = tagOf(child);\n    if (tag === \"thead\") {\n      collectRows(child, out, \"head\");\n    } else if (tag === \"tbody\") {\n      collectRows(child, out, \"body\");\n    } else if (tag === \"tfoot\") {\n      collectRows(child, out, \"foot\");\n    } else if (tag === \"tr\") {\n      out.push(rowNode(child, group));\n    }\n    // `<caption>`/`<colgroup>` carry no rows and are not content of their own.\n  }\n}\n\n/** `<table>` as a table node. */\nfunction tableNode(table: Element): TableNode {\n  const rows: TableRowNode[] = [];\n  collectRows(table, rows, \"none\");\n  return {\n    kind: \"table\",\n    position: positionOf(table),\n    text: flatText(table),\n    children: rows,\n  };\n}\n\n/**\n * `<dl>` as a definition list. Each `<dt>` pairs with the `<dd>` elements that\n * immediately follow it - up to the next `<dt>` or the end of the list - and\n * the `<dt>`'s own text becomes the item's `term`. An item's position spans\n * from its `<dt>` through its last `<dd>`, or the `<dt>` alone when it has\n * none.\n */\nfunction definitionListNode(dl: Element): DefinitionListNode {\n  const children = elementChildren(dl);\n  const items: DefinitionItemNode[] = [];\n\n  for (let i = 0; i < children.length; i++) {\n    const dt = children[i];\n    if (!dt || tagOf(dt) !== \"dt\") continue;\n\n    const dds: Element[] = [];\n    let j = i + 1;\n    while (j < children.length) {\n      const next = children[j];\n      if (!next || tagOf(next) !== \"dd\") break;\n      dds.push(next);\n      j++;\n    }\n\n    const term = flatText(dt);\n    const definition = dds.flatMap((dd) => childContent(dd));\n    const lastDd = dds.at(-1);\n    const end = lastDd ? positionOf(lastDd).end : positionOf(dt).end;\n    const text = [term, ...dds.map((dd) => flatText(dd))].filter((t) => t.length > 0).join(\" \");\n\n    items.push({\n      kind: \"definitionItem\",\n      position: { start: positionOf(dt).start, end },\n      text,\n      term,\n      definition,\n    });\n  }\n\n  return {\n    kind: \"definitionList\",\n    position: positionOf(dl),\n    text: flatText(dl),\n    children: items,\n  };\n}\n\n/**\n * `<li>` children of a list, with their own content mapped recursively.\n */\nfunction listItems(list: Element): ListItemNode[] {\n  const items: ListItemNode[] = [];\n  for (const child of list.childNodes) {\n    if (!defaultTreeAdapter.isElementNode(child)) continue;\n    if (tagOf(child) !== \"li\") continue;\n    items.push({\n      kind: \"listItem\",\n      position: positionOf(child),\n      text: flatText(child),\n      children: childContent(child),\n    });\n  }\n  return items;\n}\n\n/**\n * One container element's content, with its own loose prose kept as a\n * paragraph. Shared by every construct that holds generic content recursively\n * - `<li>`, `<blockquote>`, `<aside>`/`role=\"note\"`, `<td>`/`<th>`, `<dd>` -\n * so the same reconciliation applies everywhere rather than once per kind.\n *\n * An item's text is rarely wrapped in a block element, but mdast puts a list\n * item's principal text in a `paragraph` child regardless, and\n * `lists: {items: {paragraphs: {min: 1}}}` has to count the same thing in\n * every format. So the loose text is gathered into one, in the position it\n * occupies among the container's blocks.\n *\n * Gathering it rather than checking whether the container has any children is\n * what makes the two cases agree. `<li>text</li>` and `<li><p>text</p></li>`\n * were already reconciled; `<li>Parent<ul>…</ul></li>` was not, because the\n * nested list is a child, so the item looked accounted for and `Parent` became\n * a paragraph nothing counted - while its Markdown, AsciiDoc, and reST twins\n * all counted one.\n *\n * A container element that yields no blocks of its own is inline in practice -\n * `<strong>`, `<a>`, `<code>` - so its text joins the prose around it instead\n * of being dropped, which is again what mdast does with the same markup.\n */\nfunction childContent(parent: Element): ContentNode[] {\n  const out: ContentNode[] = [];\n  let text = \"\";\n  let span: Position | null = null;\n\n  const extend = (node: Located): void => {\n    const at = positionOf(node);\n    span = span === null ? at : { start: span.start, end: at.end };\n  };\n\n  const flush = (): void => {\n    const value = text.trim();\n    const at = span;\n    text = \"\";\n    span = null;\n    if (value.length === 0) return;\n    out.push({ kind: \"paragraph\", position: at ?? positionOf(parent), text: value });\n  };\n\n  for (const child of parent.childNodes) {\n    if (defaultTreeAdapter.isTextNode(child)) {\n      text += child.value;\n      if (child.value.trim().length > 0) extend(child);\n      continue;\n    }\n    if (!defaultTreeAdapter.isElementNode(child)) continue;\n\n    const tag = tagOf(child);\n    const role = roleOf(child, tag);\n    if (role === \"heading\" || role === \"opaque\") continue;\n\n    if (role === \"content\") {\n      flush();\n      const node = toContentNode(child, tag);\n      if (node) out.push(node);\n      continue;\n    }\n\n    const nested = contentIn(child);\n    if (nested.length > 0) {\n      flush();\n      out.push(...nested);\n      continue;\n    }\n\n    const inline = flatText(child);\n    text += inline;\n    if (inline.trim().length > 0) extend(child);\n  }\n\n  flush();\n  return out;\n}\n\nfunction toContentNode(el: Element, tag: string): ContentNode | null {\n  if (isAdmonitionSource(el, tag)) return admonitionNode(el);\n  switch (tag) {\n    case \"p\":\n      return { kind: \"paragraph\", position: positionOf(el), text: flatText(el) };\n    case \"pre\":\n      return codeNode(el);\n    case \"ul\":\n    case \"ol\":\n      return {\n        kind: \"list\",\n        position: positionOf(el),\n        text: flatText(el),\n        ordered: tag === \"ol\",\n        items: listItems(el),\n      };\n    case \"table\":\n      return tableNode(el);\n    case \"blockquote\":\n      return blockquoteNode(el);\n    case \"dl\":\n      return definitionListNode(el);\n    case \"img\":\n      return imageNode(el, positionOf(el), null);\n    case \"figure\":\n      return figureNode(el);\n    default:\n      return null;\n  }\n}\n\n/**\n * Content nodes inside a container that is not itself a block - a wrapper\n * within one, reached from `childContent`. Same descend/skip rule as the\n * document walk, minus headings: a heading inside a list item does not open a\n * section, and mdast drops it the same way.\n */\nfunction contentIn(parent: ParentNode): ContentNode[] {\n  const out: ContentNode[] = [];\n  for (const child of parent.childNodes) {\n    if (!defaultTreeAdapter.isElementNode(child)) continue;\n    const tag = tagOf(child);\n    const role = roleOf(child, tag);\n    if (role === \"heading\" || role === \"opaque\") continue;\n    if (role === \"content\") {\n      const node = toContentNode(child, tag);\n      if (node) out.push(node);\n      continue;\n    }\n    out.push(...contentIn(child));\n  }\n  return out;\n}\n\n/**\n * Walk the document into ordered blocks.\n *\n * Structure comes from heading *levels* only. Explicit `<section>` nesting is\n * deliberately ignored, and `<section>` is just another container:\n *\n *  - `sectionize` already derives nesting from heading level for every format.\n *    Honoring `<section>` would mean a second nesting mechanism living in this\n *    file, plus a rule for reconciling the two whenever a page's element\n *    nesting and its heading levels disagree - which they routinely do, because\n *    `<section>` is optional and is as often a layout wrapper\n *    (`<section class=\"hero\">`) as a semantic one.\n *  - The cross-format promise is that one template produces the same findings\n *    on a page and its Markdown, AsciiDoc, or reST twin. Those formats have\n *    nothing but heading level, so deriving HTML's structure from anything else\n *    would let identical headings nest differently per format.\n *  - Where `<section>` nesting agrees with the headings - which is the whole\n *    point of writing it - honoring it changes nothing. It could only ever\n *    matter when it disagrees, and there the headings are what the reader sees.\n */\nfunction walk(parent: ParentNode, out: Fragment[], ids: HeadingIds): void {\n  for (const child of parent.childNodes) {\n    if (!defaultTreeAdapter.isElementNode(child)) continue;\n    const tag = tagOf(child);\n    const role = roleOf(child, tag);\n\n    if (role === \"heading\") {\n      const id = ids.claim(child);\n      out.push({\n        type: \"heading\",\n        level: HEADING_LEVELS.get(tag) ?? 1,\n        // The self-permalink is dropped from the title as it is from the links:\n        // Sphinx's `¶` is a widget, and \"Install the SDK¶\" is no reader's title.\n        title: flatText(child, id !== undefined ? `#${id}` : undefined),\n        position: positionOf(child),\n        ...(id !== undefined ? { id } : {}),\n      });\n      continue;\n    }\n\n    if (role === \"content\") {\n      const node = toContentNode(child, tag);\n      if (node) out.push({ type: \"content\", node });\n      continue;\n    }\n\n    if (role === \"opaque\") continue;\n\n    if (ID_CARRIERS.has(tag)) {\n      ids.enter(child);\n      walk(child, out, ids);\n      ids.leave();\n      continue;\n    }\n    walk(child, out, ids);\n  }\n}\n\n/** Elements whose `id` the first heading inside them inherits. */\nconst ID_CARRIERS = new Set([\"section\", \"article\"]);\n\n/**\n * Which id each heading answers to.\n *\n * A heading's own `id` first. Failing that, the `id` of the nearest enclosing\n * `<section>`/`<article>` - the shape Sphinx and a hand-written page both\n * produce, `<section id=\"install\"><h2>Install</h2>` - but only for the first\n * heading inside it, since the id names the section and a later sibling\n * heading is not that section's title. Every enclosing carrier is spent by\n * that first heading, nested or not, so an outer one cannot pass its id to a\n * heading that follows an inner one.\n */\nclass HeadingIds {\n  private readonly open: { id: string | undefined; spent: boolean }[] = [];\n  readonly byHeading = new Map<Element, string>();\n\n  enter(el: Element): void {\n    this.open.push({ id: attrOf(el, \"id\"), spent: false });\n  }\n\n  leave(): void {\n    this.open.pop();\n  }\n\n  claim(heading: Element): string | undefined {\n    const nearest = this.open.at(-1);\n    const inherited = nearest && !nearest.spent ? nearest.id : undefined;\n    for (const carrier of this.open) carrier.spent = true;\n    const id = attrOf(heading, \"id\") ?? inherited;\n    if (id !== undefined) this.byHeading.set(heading, id);\n    return id;\n  }\n}\n\n/**\n * Every `<a href>` and `<area href>`, in document order - and nothing else\n * that carries an `href`. `<link rel=\"stylesheet\">` and `<base>` name\n * resources and a URL base, not places a reader can go.\n *\n * A heading's self-permalink is left out: Sphinx, MkDocs and Docusaurus append\n * `<a href=\"#install\">¶</a>` to every heading, and a graph that kept them would\n * give each section an edge to itself. Only an exact `#<that heading's id>` is\n * dropped; a heading linking anywhere else keeps the link. Only an `<a>`\n * inside the heading is checked: a permalink placed beside the heading, as a\n * sibling, is kept as a link to its own section.\n */\nfunction collectLinks(\n  parent: ParentNode,\n  ids: Map<Element, string>,\n  heading: string | undefined,\n  out: DocumentTree[\"links\"],\n): void {\n  for (const child of parent.childNodes) {\n    if (!defaultTreeAdapter.isElementNode(child)) continue;\n    const tag = tagOf(child);\n    if (tag === \"a\" || tag === \"area\") {\n      const href = attrOf(child, \"href\");\n      const permalink = heading !== undefined && href === `#${heading}`;\n      if (href !== undefined && !permalink) out.push({ target: href, position: positionOf(child) });\n    }\n    collectLinks(child, ids, HEADING_LEVELS.has(tag) ? ids.get(child) : heading, out);\n  }\n}\n\n/** End of the document, for closing the final sections. */\nfunction documentEnd(content: string): Position[\"end\"] {\n  const lines = content.split(\"\\n\");\n  const last = lines[lines.length - 1] ?? \"\";\n  return { line: lines.length, column: last.length + 1, offset: content.length };\n}\n\n/**\n * An HTML page's metadata, from both places it can be.\n *\n * `extractFrontmatter(content, \"html\")` - the call the Markdown parser makes -\n * turns out to read *only* a fenced `---`/`+++`/`;;;` block; the `format`\n * argument is a label on the result, not a dispatch key. On an ordinary HTML\n * page it returns `{present: false, data: {}}`, which would leave\n * `type: how-to` in a `<meta>` tag invisible and every `.html` file unrouted.\n *\n * The `<meta>` reading lives in docmeta's *extractor* registry instead, reached\n * by extension. So both are asked, and the results merged. That keeps docmeta\n * the single source of truth for metadata - including its `<title>` lift and\n * its YAML-scalar coercion of attribute values, so `content=\"[a, b]\"` is a list\n * here exactly as it would be in frontmatter - rather than growing a second\n * `<meta>` convention in this repository.\n *\n * A fenced block wins on a key collision: it is authored at the top of the\n * source file, and it is what every sibling format reads. The two coexist\n * rarely enough that the tie-break is a formality.\n *\n * The cost is that docmeta parses the document a second time. Re-reading\n * `<meta>` off the tree already in hand would avoid it and duplicate the\n * convention; the ADR's \"docmeta is the single source of truth for frontmatter\"\n * is worth one extra parse of a file we are already reading from disk.\n */\nfunction metadataOf(\n  content: string,\n  filePath: string,\n  doc: DefaultTreeAdapterTypes.Document,\n): { frontmatter: Record<string, unknown> | null; position: Position | null } {\n  const fenced = extractFrontmatter(content, \"html\");\n  const extractor = extractorForExtension(\".html\");\n  const headMeta = extractor\n    ? extractor.extract(content, filePath)\n    : { present: false, data: {} as Record<string, unknown> };\n\n  if (!fenced.present && !headMeta.present) return { frontmatter: null, position: null };\n\n  const frontmatter = { ...headMeta.data, ...fenced.data };\n\n  // Anchor on whichever block the values actually came from. `<head>` is an\n  // HTML document's frontmatter: it is where `<title>` and every `<meta>` sit,\n  // and a finding about the page's metadata belongs there.\n  if (fenced.present) return { frontmatter, position: fencedPosition(content) };\n\n  // A `<head>` parse5 synthesized carries no source location. That happens\n  // whenever anything precedes `<html>` - a BOM is the common case - and it\n  // used to yield a null position, which silently switched off the synthetic\n  // frontmatter title: `withMetadataTitle` bails when the position is null, so\n  // the document lost its top-level section and every doctype template\n  // misaligned against it. The metadata is real either way, so fall back to the\n  // top of the file rather than disowning it.\n  const head = findHead(doc);\n  return {\n    frontmatter,\n    position: head?.sourceCodeLocation ? positionOf(head) : origin(),\n  };\n}\n\n/** Zero-width span at the top of the file, for metadata with no located block. */\nfunction origin(): Position {\n  return {\n    start: { line: 1, column: 1, offset: 0 },\n    end: { line: 1, column: 1, offset: 0 },\n  };\n}\n\n/** The document's `<head>`, when the source actually wrote one. */\nfunction findHead(doc: DefaultTreeAdapterTypes.Document): Element | undefined {\n  for (const child of doc.childNodes) {\n    if (!defaultTreeAdapter.isElementNode(child)) continue;\n    if (tagOf(child) === \"html\") return firstElementChild(child, \"head\");\n  }\n  return undefined;\n}\n\nfunction parseHtml(content: string, filePath: string): DocumentTree {\n  const doc = parse(content, { sourceCodeLocationInfo: true });\n  const fragments: Fragment[] = [];\n  const ids = new HeadingIds();\n  walk(doc, fragments, ids);\n  const links: DocumentTree[\"links\"] = [];\n  collectLinks(doc, ids.byHeading, undefined, links);\n\n  const { frontmatter, position } = metadataOf(content, filePath, doc);\n\n  return {\n    format: \"html\",\n    filePath,\n    frontmatter,\n    frontmatterPosition: position,\n    sections: sectionize(\n      withMetadataTitle(fragments, frontmatter, position),\n      documentEnd(content),\n    ),\n    links,\n  };\n}\n\nexport const htmlParser: DocumentParser = {\n  name: \"html\",\n  label: \"HTML\",\n  kinds: [\n    \"paragraph\",\n    \"codeBlock\",\n    \"list\",\n    \"listItem\",\n    \"table\",\n    \"tableRow\",\n    \"tableCell\",\n    \"admonition\",\n    \"image\",\n    \"blockquote\",\n    \"definitionList\",\n    \"definitionItem\",\n  ],\n  extensions: [\".html\", \".htm\"],\n  parse: parseHtml,\n};\n","/**\n * reStructuredText -> generic blocks.\n *\n * Unlike its siblings this parser has no AST library under it. There is no\n * usable reStructuredText parser for JavaScript, so this reads the source\n * directly: a line scanner that answers one question - what sections does this\n * document have, and what content is in each - and then hands `sectionize` the\n * same `Fragment[]` every other format produces.\n *\n * ## Section levels\n *\n * RST has no fixed heading hierarchy. A title is a line underlined, and\n * optionally also overlined, by a run of punctuation at least as long as the\n * title. Which *level* an adornment style means is discovered, not fixed:\n *\n *   \"Rather than imposing a fixed number and order of section title adornment\n *    styles, the order enforced will be the order as encountered.\"\n *   - the reStructuredText spec, \"Sections\"\n *\n * So the first style seen is level 1, the next new style level 2, and so on -\n * `===` then `+++` then `---` is a perfectly ordinary document, and a\n * hardcoded character-to-level table would get it wrong. The spec also makes\n * over-and-underlined styles distinct from underline-only ones using the same\n * character, so the style key carries both facts (`over:=` vs `under:=`).\n *\n * Levels are clamped to 6, because `SectionNode.level` is documented 1-6; a\n * document with seven adornment styles is beyond what the templates model.\n *\n * ## What this deliberately does not handle\n *\n * This is a structural scanner, not docutils. It does not implement, and\n * silently ignores:\n *\n *  - **Substitutions** (`|name|` definitions and references) - a reference is\n *    flattened to its bare name, a definition is skipped with other directives.\n *  - **Includes** (`.. include::`) - the referenced file is never read, so\n *    sections it would contribute are invisible.\n *  - **Transitions** (a lone adornment run between paragraphs) - skipped, like\n *    Markdown thematic breaks.\n *  - **Option lists** and **line blocks** (`|`) - skipped, not mapped onto\n *    anything. **Definition lists** are mapped: a term line followed by an\n *    indented definition becomes a `definitionList`/`definitionItem` pair,\n *    and consecutive pairs group into one list the way blank-separated bullet\n *    items do.\n *  - **Doctest blocks** (`>>>`) - recognised so they are not mis-read as prose,\n *    but skipped rather than emitted as `codeBlock`.\n *  - **Tables** - grid (`+---+`), simple (`===  ===`), `list-table`, and\n *    `csv-table` all become `table` nodes. Grid and simple tables take their\n *    columns from the border itself, so a spanning cell (a row border that\n *    omits one `+`, or a simple-table row that straddles a column gap) is read\n *    as if it were not spanned - the rectangular case, not the general grid\n *    grammar. A simple table's body is one row per physical line; only its\n *    header, if it has one, merges multiple lines into one row.  `list-table`\n *    and `csv-table` carry a header row only when `:header-rows:` (both) or\n *    `:header:` (`csv-table`) says so - without one, the table has real rows\n *    and no header, which is the honest answer. A `csv-table`'s external\n *    `:file:`/`:url:` source is never read, the same call `include` gets.\n *  - **Block quotes** (an indented block with no `::` ahead of it) - mapped to\n *    `blockquote`, its own content parsed the same way a list item's is.\n *  - **Quoted literal blocks** (an unindented literal block quoted with\n *    punctuation) - not recognised; read as prose.\n *  - **Enumerator styles beyond `1.`/`1)`/`#.`/`#)`** - alphabetic and Roman\n *    enumerators (`a.`, `iv.`) and the parenthesised `(1)` form are read as\n *    prose. They are ambiguous without docutils' second-item confirmation:\n *    `A. Smith wrote this` is a sentence, not a list.\n *  - **Roles and inline markup** beyond a regex flattening - `flattenInline`\n *    strips the common constructs; it does not implement inline parsing, does\n *    not process `\\` escapes, and leaves trailing reference underscores alone\n *    (stripping them would eat `snake_case`).\n *  - **Tab expansion** in indentation - a tab counts as one column, where\n *    docutils expands to the next multiple of eight.\n *  - **East Asian width** - adornment length is compared against the title's\n *    code-point count, where the spec compares display columns.\n *  - **Document title promotion** - docutils promotes a lone top-level section\n *    to the document title. Here it stays a level-1 section, which is what the\n *    doctype templates model (a title with its subsections hanging under it).\n *  - **Directive options and content semantics beyond what is listed above** -\n *    `code-block`/`code`/`sourcecode` become `codeBlock`; `note`, `tip`,\n *    `important`, `caution`, `warning`, and `danger` become `admonition` with\n *    that word as `variant`; `image` and `figure` become `image`; `list-table`\n *    and `csv-table` become `table`. `attention`, `hint`, `error`, and the\n *    generic `admonition` directive also become `admonition`, but with no\n *    `variant` at all - `AdmonitionNode.variant` has no six-value member for\n *    them, and inventing an equivalence (`hint` as `tip`, `error` as `danger`)\n *    is exactly what this parser does not do. A plain count rule still counts\n *    them; a `variant:` rule reports them as a mismatch instead of a false\n *    match. Every other directive is skipped whole.\n *  - **Anything an unterminated fenced block would need** - a *complete* fenced\n *    front matter block is cut from the body before scanning, because `---`\n *    reads as a transition and the YAML under it as prose. An unterminated one\n *    is not front matter, and is scanned as the RST it literally is.\n *\n * One judgement call is worth stating plainly. The spec requires an adornment\n * run to extend \"at least as far as the right edge of the title text\", and\n * that is what is enforced here: a shorter run is not a section title, and the\n * line becomes a paragraph. docutils the implementation is more forgiving - it\n * reports \"Title underline too short\" and recovers - but taking the strict\n * reading is what keeps this parser agreeing with `docmeta`'s RST extractor,\n * which applies the same rule to the document title.\n */\nimport { extractFrontmatter, extractorForExtension, locateFrontmatter } from \"../../meta/index.js\";\nimport type {\n  AdmonitionNode,\n  ContentNode,\n  DefinitionItemNode,\n  DocumentParser,\n  DocumentTree,\n  ListItemNode,\n  ListNode,\n  Point,\n  Position,\n  TableCellNode,\n  TableNode,\n  TableRowNode,\n} from \"../types.js\";\nimport type { Fragment } from \"./sectionize.js\";\nimport { sectionize } from \"./sectionize.js\";\nimport {\n  fencedPosition,\n  withMetadataTitle as withFrontmatterTitle,\n  withoutFence,\n} from \"./metadata.js\";\n\n/** Every character the spec allows as title adornment. */\nconst ADORNMENT_CHARS = new Set(\n  \"!\\\"#$%&'()*+,-./:;<=>?@[\\\\]^_`{|}~\".split(\"\"),\n);\n\n/** Explicit markup: a directive, comment, target, or substitution definition. */\nconst EXPLICIT = /^[ \\t]*\\.\\.(?:[ \\t]|$)/;\n/** A directive with a parseable name, e.g. `.. code-block:: python`. */\nconst DIRECTIVE = /^([ \\t]*)\\.\\.[ \\t]+([\\w.+:-]+)::[ \\t]*(.*)$/;\n/** Directives that carry a literal block, with the language as the argument. */\nconst CODE_DIRECTIVES = new Set([\"code\", \"code-block\", \"sourcecode\"]);\n/** Admonition directives that name one of the six variants directly. */\nconst ADMONITION_VARIANTS = new Map<string, AdmonitionNode[\"variant\"]>([\n  [\"note\", \"note\"],\n  [\"tip\", \"tip\"],\n  [\"important\", \"important\"],\n  [\"caution\", \"caution\"],\n  [\"warning\", \"warning\"],\n  [\"danger\", \"danger\"],\n]);\n/**\n * Every admonition directive this parser reads, variant-naming or not.\n * `attention`, `hint`, `error`, and the generic `admonition` directive still\n * become an `admonition` node - just with no `variant`, since none of the six\n * is honestly theirs. See the file header.\n */\nconst ADMONITION_DIRECTIVES = new Set([\n  ...ADMONITION_VARIANTS.keys(),\n  \"attention\",\n  \"hint\",\n  \"error\",\n  \"admonition\",\n]);\n/** A field-list entry: `:name:` or `:name: value`. */\nconst FIELD = /^[ \\t]*:[^:\\s][^:]*:(?:[ \\t]|$)/;\n/** A directive option inside a directive body, e.g. `:linenos:`. */\nconst OPTION = /^[ \\t]*:[\\w-]+:(?:[ \\t].*)?$/;\n/** A directive option, capturing its key and value: `:header-rows: 1`. */\nconst OPTION_KV = /^[ \\t]*:([\\w-]+):(?:[ \\t]+(.*))?$/;\n/** A bullet-list item. The marker must be followed by whitespace or nothing. */\nconst BULLET = /^([ \\t]*)([*+-])(?:([ \\t]+)(.*))?$/;\n/** An enumerated-list item, arabic or auto (`#`), with a `.` or `)` suffix. */\nconst ENUM = /^([ \\t]*)(\\d+|#)([.)])(?:([ \\t]+)(.*))?$/;\n/** A doctest block. */\nconst DOCTEST = /^[ \\t]*>>>[ \\t]/;\n/** A grid-table border. */\nconst GRID_TABLE = /^[ \\t]*\\+[-=+]+\\+[ \\t]*$/;\n/** A simple-table border: runs of `=` (or `-`, for column spans) with gaps. */\nconst SIMPLE_TABLE = /^[ \\t]*[-=]+(?:[ \\t]+[-=]+)+[ \\t]*$/;\n\n/**\n * The source, indexed by line.\n *\n * `text` is the array the scanner reads, and it is mutable on purpose: list\n * item markers are blanked out of it *in place, space for space*, so an item's\n * body can be scanned by the same code that scans the document body without\n * re-slicing anything. Every column and offset in `starts` stays exact by\n * construction rather than by bookkeeping.\n *\n * Line terminators are stripped, and CRLF is handled here so nothing below has\n * to know about it.\n */\ninterface Source {\n  text: string[];\n  /** Offset of the first character of each line. */\n  starts: number[];\n  /** End of the document, for closing the final sections. */\n  end: Point;\n}\n\nfunction indexLines(content: string): Source {\n  const text: string[] = [];\n  const starts: number[] = [];\n  let cursor = 0;\n  for (;;) {\n    starts.push(cursor);\n    const nl = content.indexOf(\"\\n\", cursor);\n    if (nl === -1) {\n      text.push(content.slice(cursor));\n      break;\n    }\n    const hadCr = nl > cursor && content.charCodeAt(nl - 1) === 13;\n    text.push(content.slice(cursor, hadCr ? nl - 1 : nl));\n    cursor = nl + 1;\n  }\n  return {\n    text,\n    starts,\n    end: {\n      line: text.length,\n      column: (text[text.length - 1] ?? \"\").length + 1,\n      offset: content.length,\n    },\n  };\n}\n\n/** Leading whitespace width. Tabs count as one column; see the header. */\nfunction indentOf(line: string): number {\n  let i = 0;\n  while (i < line.length && (line[i] === \" \" || line[i] === \"\\t\")) i++;\n  return i;\n}\n\nfunction isBlank(line: string | undefined): boolean {\n  return (line ?? \"\").trim() === \"\";\n}\n\n/**\n * A run of one repeated adornment character starting at column 1, or null.\n *\n * One character counts. docutils only rejects a run for being short when it is\n * also shorter than the title, so `A` over `=` is a section - and a lone\n * punctuation line that underlines nothing is a too-short transition marker,\n * which docutils drops. Skipping it, which is what the caller does with any\n * adornment that started no title, is the same outcome.\n */\nfunction adornmentOf(line: string | undefined): { char: string; length: number } | null {\n  const trimmed = (line ?? \"\").replace(/[ \\t]+$/, \"\");\n  const char = trimmed[0];\n  if (char === undefined || !ADORNMENT_CHARS.has(char)) return null;\n  for (let i = 1; i < trimmed.length; i++) {\n    if (trimmed[i] !== char) return null;\n  }\n  return { char, length: trimmed.length };\n}\n\n/**\n * Strip the inline markup a heading or paragraph is likely to carry, so a title\n * matches a template's `heading.const` and a slug reads like the rendered page.\n * A regex pass, not an inline parser - see the header for what it misses.\n */\nfunction flattenInline(text: string): string {\n  return text\n    .replace(/``([^`]*)``/g, \"$1\")\n    .replace(/:[\\w.+:-]+:`([^`]*)`/g, \"$1\")\n    .replace(/`([^`]*?)[ \\t]*<[^<>]*>`__?/g, \"$1\")\n    .replace(/`([^`]*)`__?/g, \"$1\")\n    .replace(/`([^`]*)`/g, \"$1\")\n    .replace(/\\*\\*([^*]+)\\*\\*/g, \"$1\")\n    .replace(/\\*([^*]+)\\*/g, \"$1\")\n    .replace(/\\|([^|\\s][^|]*)\\|/g, \"$1\")\n    .trim();\n}\n\n/** Point at the start of `line`'s column `column` (1-based). */\nfunction pointAt(src: Source, line: number, column: number): Point {\n  return {\n    line: line + 1,\n    column,\n    offset: (src.starts[line] ?? 0) + column - 1,\n  };\n}\n\n/**\n * Span of the source lines `first..last` inclusive, ending just past the last\n * non-whitespace character - the convention mdast uses, so a block's end never\n * runs into the heading that follows it.\n */\nfunction spanOf(src: Source, first: number, last: number, startColumn?: number): Position {\n  const firstLine = src.text[first] ?? \"\";\n  const lastLine = (src.text[last] ?? \"\").replace(/[ \\t]+$/, \"\");\n  return {\n    start: pointAt(src, first, startColumn ?? indentOf(firstLine) + 1),\n    end: pointAt(src, last, lastLine.length + 1),\n  };\n}\n\n/** A section title found at a line, with the adornment style that marked it. */\ninterface TitleHit {\n  title: string;\n  /** Style key; over-and-underlined is distinct from underline-only. */\n  style: string;\n  /** First line of the construct (the overline, or the title text). */\n  first: number;\n  /** Last line of the construct (always the underline). */\n  last: number;\n}\n\n/**\n * A section title starting at `line`, or null.\n *\n * Both forms are checked: overline / text / matching underline, and text /\n * underline. The adornment must be at least as long as the title text, and an\n * overline must match its underline in both character and length - what the\n * spec requires, and what `docmeta`'s RST extractor enforces for the doctitle.\n */\nfunction titleAt(src: Source, line: number, limit: number): TitleHit | null {\n  const over = adornmentOf(src.text[line]);\n  if (over) {\n    if (line + 2 >= limit) return null;\n    const text = src.text[line + 1] ?? \"\";\n    const under = adornmentOf(src.text[line + 2]);\n    const title = flattenInline(text);\n    if (\n      title !== \"\" &&\n      adornmentOf(text) === null &&\n      under !== null &&\n      under.char === over.char &&\n      under.length === over.length &&\n      over.length >= text.trim().length\n    ) {\n      return { title, style: `over:${over.char}`, first: line, last: line + 2 };\n    }\n    // A lone run is a transition, and a mismatched pair is not a title.\n    return null;\n  }\n\n  if (line + 1 >= limit) return null;\n  const text = src.text[line] ?? \"\";\n  if (text.trim() === \"\" || indentOf(text) > 0) return null;\n  const under = adornmentOf(src.text[line + 1]);\n  if (under === null || under.length < text.trim().length) return null;\n  const title = flattenInline(text);\n  if (title === \"\") return null;\n  return { title, style: `under:${under.char}`, first: line, last: line + 1 };\n}\n\n/**\n * End of an indented block opened at `from`: the first line at or after `from`\n * whose indent is at or below `base` and which is not blank. Returns the\n * exclusive end, trimmed of trailing blank lines.\n */\nfunction indentedBlockEnd(src: Source, from: number, to: number, base: number): number {\n  let i = from;\n  let last = from - 1;\n  while (i < to) {\n    const line = src.text[i] ?? \"\";\n    if (isBlank(line)) {\n      i++;\n      continue;\n    }\n    if (indentOf(line) <= base) break;\n    last = i;\n    i++;\n  }\n  return last + 1;\n}\n\n/** The lines `from..to` with their common indent removed, joined by newlines. */\nfunction dedent(src: Source, from: number, to: number): string {\n  let common = Infinity;\n  for (let i = from; i < to; i++) {\n    const line = src.text[i] ?? \"\";\n    if (!isBlank(line)) common = Math.min(common, indentOf(line));\n  }\n  if (!Number.isFinite(common)) common = 0;\n  const out: string[] = [];\n  for (let i = from; i < to; i++) {\n    const line = src.text[i] ?? \"\";\n    out.push(isBlank(line) ? \"\" : line.slice(common).replace(/[ \\t]+$/, \"\"));\n  }\n  return out.join(\"\\n\").replace(/\\n+$/, \"\");\n}\n\n/** Last non-blank line in `from..to`, or `from - 1` when there is none. */\nfunction lastContentLine(src: Source, from: number, to: number): number {\n  for (let i = to - 1; i >= from; i--) {\n    if (!isBlank(src.text[i])) return i;\n  }\n  return from - 1;\n}\n\n/** Scanner state that outlives one range: the adornment styles seen so far. */\ninterface Levels {\n  styles: string[];\n}\n\nfunction levelFor(levels: Levels, style: string): number {\n  let index = levels.styles.indexOf(style);\n  if (index === -1) {\n    levels.styles.push(style);\n    index = levels.styles.length - 1;\n  }\n  return Math.min(index + 1, 6);\n}\n\n/** A directive's `:key: value` option block, read up to the first non-option line. */\nfunction readOptions(\n  src: Source,\n  from: number,\n  to: number,\n): { options: Record<string, string>; next: number } {\n  const options: Record<string, string> = {};\n  let i = from;\n  while (i < to) {\n    const match = OPTION_KV.exec(src.text[i] ?? \"\");\n    if (!match) break;\n    const key = (match[1] ?? \"\").toLowerCase();\n    options[key] = (match[2] ?? \"\").trim();\n    i++;\n  }\n  return { options, next: i };\n}\n\n/** First content line of a directive body, after its options and any blank lines. */\nfunction directiveContentStart(src: Source, from: number, to: number): number {\n  const { next } = readOptions(src, from, to);\n  let start = next;\n  while (start < to && isBlank(src.text[start])) start++;\n  return start;\n}\n\n/** Index of every `+` in a grid-table border line - the table's column edges. */\nfunction gridColumns(border: string): number[] {\n  const cols: number[] = [];\n  for (let i = 0; i < border.length; i++) {\n    if (border[i] === \"+\") cols.push(i);\n  }\n  return cols;\n}\n\n/** The substrings a grid-table content line holds between `cols`' column edges. */\nfunction gridCells(line: string, cols: number[]): string[] {\n  const cells: string[] = [];\n  for (let k = 0; k < cols.length - 1; k++) {\n    const start = (cols[k] ?? 0) + 1;\n    const end = cols[k + 1] ?? line.length;\n    cells.push(line.slice(start, end));\n  }\n  return cells;\n}\n\n/**\n * A grid table (`+---+---+` borders), read from its top border at `from`.\n *\n * Column edges come from the top border alone, so a row whose own border omits\n * a `+` (a spanning cell) is read as if it were not spanned - see the file\n * header. A row is `header: true` when the border that closes it carries `=`.\n */\nfunction parseGridTable(src: Source, from: number, to: number): { node: TableNode; next: number } {\n  let end = from;\n  while (end < to && !isBlank(src.text[end])) end++;\n\n  const cols = gridColumns(src.text[from] ?? \"\");\n  const rows: TableRowNode[] = [];\n  let current: number[] = [];\n\n  const flush = (header: boolean): void => {\n    if (current.length === 0) return;\n    const first = current[0] ?? from;\n    const last = current[current.length - 1] ?? first;\n    const perColumn: string[][] = cols.slice(0, -1).map(() => []);\n    for (const lineIdx of current) {\n      const cells = gridCells(src.text[lineIdx] ?? \"\", cols);\n      cells.forEach((text, idx) => perColumn[idx]?.push(text));\n    }\n    const cellNodes: TableCellNode[] = perColumn.map((lines) => {\n      const text = flattenInline(lines.join(\" \").trim());\n      return {\n        kind: \"tableCell\",\n        position: spanOf(src, first, last),\n        text,\n        children: text === \"\" ? [] : [{ kind: \"paragraph\", position: spanOf(src, first, last), text }],\n      };\n    });\n    rows.push({\n      kind: \"tableRow\",\n      header,\n      position: spanOf(src, first, last),\n      text: cellNodes.map((c) => c.text).join(\" | \"),\n      children: cellNodes,\n    });\n    current = [];\n  };\n\n  for (let i = from + 1; i < end; i++) {\n    const line = src.text[i] ?? \"\";\n    if (GRID_TABLE.test(line)) {\n      flush(/=/.test(line));\n      continue;\n    }\n    current.push(i);\n  }\n  flush(false);\n\n  const last = lastContentLine(src, from, end);\n  return {\n    node: {\n      kind: \"table\",\n      position: spanOf(src, from, Math.max(last, from)),\n      text: rows.map((r) => r.text).join(\"\\n\"),\n      children: rows,\n    },\n    next: end,\n  };\n}\n\n/** Column spans (`[start, end)`) from a simple-table border's `=`/`-` runs. */\nfunction simpleColumns(border: string): [number, number][] {\n  const spans: [number, number][] = [];\n  const re = /[-=]+/g;\n  let match: RegExpExecArray | null;\n  while ((match = re.exec(border)) !== null) {\n    spans.push([match.index, match.index + match[0].length]);\n  }\n  return spans;\n}\n\n/** One simple-table row, built from one or more physical lines over `spans`. */\nfunction simpleRow(\n  src: Source,\n  lines: number[],\n  spans: [number, number][],\n  header: boolean,\n): TableRowNode {\n  const first = lines[0] ?? 0;\n  const last = lines[lines.length - 1] ?? first;\n  const perColumn: string[][] = spans.map(() => []);\n  for (const lineIdx of lines) {\n    const raw = src.text[lineIdx] ?? \"\";\n    spans.forEach(([start, endCol], idx) => {\n      const isLast = idx === spans.length - 1;\n      perColumn[idx]?.push(raw.slice(start, isLast ? raw.length : endCol));\n    });\n  }\n  const cells: TableCellNode[] = perColumn.map((columnLines) => {\n    const text = flattenInline(columnLines.join(\" \").trim());\n    return {\n      kind: \"tableCell\",\n      position: spanOf(src, first, last),\n      text,\n      children: text === \"\" ? [] : [{ kind: \"paragraph\", position: spanOf(src, first, last), text }],\n    };\n  });\n  return {\n    kind: \"tableRow\",\n    header,\n    position: spanOf(src, first, last),\n    text: cells.map((c) => c.text).join(\" | \"),\n    children: cells,\n  };\n}\n\n/**\n * A simple table (`===  ===` rules), read from its top border at `from`.\n *\n * One physical line is one row, with one exception: every line between the\n * top border and the header separator, if there is one, merges into a single\n * multi-line header row. Without a header separator, the table has no header.\n */\nfunction parseSimpleTable(src: Source, from: number, to: number): { node: TableNode; next: number } {\n  let end = from;\n  while (end < to && !isBlank(src.text[end])) end++;\n\n  const spans = simpleColumns(src.text[from] ?? \"\");\n  const borders: number[] = [];\n  for (let i = from; i < end; i++) {\n    if (SIMPLE_TABLE.test(src.text[i] ?? \"\")) borders.push(i);\n  }\n  const top = borders[0] ?? from;\n  const bottom = borders[borders.length - 1] ?? end - 1;\n  const interior = borders.filter((idx) => idx !== top && idx !== bottom);\n  const headerSep = interior[0];\n\n  const headerLines: number[] = [];\n  const bodyLines: number[] = [];\n  for (let i = top + 1; i < bottom; i++) {\n    if (interior.includes(i)) continue;\n    if (headerSep !== undefined && i < headerSep) headerLines.push(i);\n    else bodyLines.push(i);\n  }\n\n  const rows: TableRowNode[] = [];\n  if (headerLines.length > 0) rows.push(simpleRow(src, headerLines, spans, true));\n  for (const lineIdx of bodyLines) rows.push(simpleRow(src, [lineIdx], spans, false));\n\n  const last = lastContentLine(src, from, end);\n  return {\n    node: {\n      kind: \"table\",\n      position: spanOf(src, from, Math.max(last, from)),\n      text: rows.map((r) => r.text).join(\"\\n\"),\n      children: rows,\n    },\n    next: end,\n  };\n}\n\n/**\n * A `csv-table`'s own naive split: comma-delimited, `\"`-quoted fields with\n * `\"\"` as an escaped quote. Not the general CSV grammar, just enough for the\n * directive's inline rows.\n */\nfunction splitCsvLine(line: string): string[] {\n  const fields: string[] = [];\n  let field = \"\";\n  let quoted = false;\n  let i = 0;\n  while (i < line.length) {\n    const ch = line[i];\n    // `i < line.length` already guarantees this, but `noUncheckedIndexedAccess`\n    // cannot see it, and a `?? \"\"` fallback would silently swallow a real\n    // bounds bug instead of ending the scan.\n    if (ch === undefined) break;\n    if (quoted) {\n      if (ch === '\"') {\n        if (line[i + 1] === '\"') {\n          field += '\"';\n          i += 2;\n          continue;\n        }\n        quoted = false;\n        i++;\n        continue;\n      }\n      field += ch;\n      i++;\n      continue;\n    }\n    if (ch === '\"' && field.trim() === \"\") {\n      quoted = true;\n      i++;\n      continue;\n    }\n    if (ch === \",\") {\n      fields.push(field.trim());\n      field = \"\";\n      i++;\n      continue;\n    }\n    field += ch;\n    i++;\n  }\n  fields.push(field.trim());\n  return fields;\n}\n\n/** One `csv-table` row, from already-split fields. */\nfunction csvRow(src: Source, lineIdx: number, fields: string[], header: boolean): TableRowNode {\n  const cells: TableCellNode[] = fields.map((field) => {\n    const text = flattenInline(field);\n    return {\n      kind: \"tableCell\",\n      position: spanOf(src, lineIdx, lineIdx),\n      text,\n      children: text === \"\" ? [] : [{ kind: \"paragraph\", position: spanOf(src, lineIdx, lineIdx), text }],\n    };\n  });\n  return {\n    kind: \"tableRow\",\n    header,\n    position: spanOf(src, lineIdx, lineIdx),\n    text: cells.map((c) => c.text).join(\" | \"),\n    children: cells,\n  };\n}\n\n/**\n * Scan `from..to` at indent `base` into ordered blocks.\n *\n * `headings` is false inside a list item: RST section titles only occur at the\n * document's own indent, and a heading emitted from inside an item would break\n * the fold.\n */\nfunction scanRange(\n  src: Source,\n  levels: Levels,\n  from: number,\n  to: number,\n  base: number,\n  headings: boolean,\n): Fragment[] {\n  const fragments: Fragment[] = [];\n  const content = (node: ContentNode): void => {\n    fragments.push({ type: \"content\", node });\n  };\n  let i = from;\n\n  while (i < to) {\n    const line = src.text[i] ?? \"\";\n\n    if (isBlank(line)) {\n      i++;\n      continue;\n    }\n\n    if (headings) {\n      const hit = titleAt(src, i, to);\n      if (hit) {\n        const id = labelAbove(src, hit.first);\n        fragments.push({\n          type: \"heading\",\n          level: levelFor(levels, hit.style),\n          title: hit.title,\n          position: spanOf(src, hit.first, hit.last),\n          ...(id !== undefined ? { id } : {}),\n        });\n        i = hit.last + 1;\n        continue;\n      }\n    }\n\n    // `::` alone is the expanded form of the literal-block marker, and it also\n    // reads as a two-character run of `:`. The marker wins: an adornment of\n    // colons could only ever underline a title one or two characters wide.\n    if (line.trim() === \"::\") {\n      i = readParagraph(src, levels, fragments, i, to, base, headings);\n      continue;\n    }\n\n    // A run of adornment that did not start a title is a transition, or the\n    // stray underline of something that was not one. Either way, not content.\n    if (adornmentOf(line) !== null) {\n      i++;\n      continue;\n    }\n\n    const lineIndent = indentOf(line);\n\n    // Explicit markup: a directive, a comment, a target, or a substitution\n    // definition. Some directives become a node of their own; every other\n    // directive, comment, target, and substitution definition is skipped\n    // whole - see the file header for exactly which.\n    if (EXPLICIT.test(line)) {\n      const bodyEnd = indentedBlockEnd(src, i + 1, to, lineIndent);\n      const directive = DIRECTIVE.exec(line);\n      const name = directive?.[2]?.toLowerCase();\n\n      if (name && CODE_DIRECTIVES.has(name)) {\n        const lang = (directive?.[3] ?? \"\").trim();\n        // Drop the directive's own options (`:linenos:` and friends) before the\n        // body; they are configuration, not code.\n        let codeStart = i + 1;\n        while (codeStart < bodyEnd && OPTION.test(src.text[codeStart] ?? \"\")) codeStart++;\n        while (codeStart < bodyEnd && isBlank(src.text[codeStart])) codeStart++;\n        const codeEnd = lastContentLine(src, codeStart, bodyEnd) + 1;\n        content({\n          kind: \"codeBlock\",\n          position: spanOf(src, i, Math.max(codeEnd - 1, i)),\n          text: codeStart < codeEnd ? dedent(src, codeStart, codeEnd) : \"\",\n          ...(lang ? { language: lang } : {}),\n        });\n      } else if (name && ADMONITION_DIRECTIVES.has(name)) {\n        const variant = ADMONITION_VARIANTS.get(name);\n        const start = directiveContentStart(src, i + 1, bodyEnd);\n        const children =\n          start < bodyEnd\n            ? scanRange(src, levels, start, bodyEnd, indentOf(src.text[start] ?? \"\"), false)\n                .filter((f): f is Extract<Fragment, { type: \"content\" }> => f.type === \"content\")\n                .map((f) => f.node)\n            : [];\n        const last = lastContentLine(src, i, bodyEnd);\n        content({\n          kind: \"admonition\",\n          position: spanOf(src, i, Math.max(last, i)),\n          text: children.map((c) => c.text).join(\"\\n\"),\n          ...(variant ? { variant } : {}),\n          children,\n        });\n      } else if (name === \"image\" || name === \"figure\") {\n        const url = (directive?.[3] ?? \"\").trim();\n        if (url) {\n          const { options } = readOptions(src, i + 1, bodyEnd);\n          const alt = options[\"alt\"] ?? \"\";\n          const last = lastContentLine(src, i, bodyEnd);\n          content({\n            kind: \"image\",\n            position: spanOf(src, i, Math.max(last, i)),\n            text: alt,\n            url,\n            alt,\n          });\n        }\n      } else if (name === \"list-table\") {\n        const start = directiveContentStart(src, i + 1, bodyEnd);\n        if (start < bodyEnd) {\n          const { options } = readOptions(src, i + 1, bodyEnd);\n          const headerRows = Number.parseInt(options[\"header-rows\"] ?? \"\", 10) || 0;\n          const rowsFragment = scanRange(\n            src,\n            levels,\n            start,\n            bodyEnd,\n            indentOf(src.text[start] ?? \"\"),\n            false,\n          ).find(\n            (f): f is Extract<Fragment, { type: \"content\" }> =>\n              f.type === \"content\" && f.node.kind === \"list\",\n          );\n          if (rowsFragment && rowsFragment.node.kind === \"list\") {\n            const rows: TableRowNode[] = rowsFragment.node.items.map((item, index) => {\n              const cellsList = item.children.find((c): c is ListNode => c.kind === \"list\");\n              const cells: TableCellNode[] = (cellsList?.items ?? []).map((cellItem) => ({\n                kind: \"tableCell\",\n                position: cellItem.position,\n                text: cellItem.text,\n                children: cellItem.children,\n              }));\n              return {\n                kind: \"tableRow\",\n                header: index < headerRows,\n                position: item.position,\n                text: cells.map((c) => c.text).join(\" | \"),\n                children: cells,\n              };\n            });\n            const last = lastContentLine(src, i, bodyEnd);\n            content({\n              kind: \"table\",\n              position: spanOf(src, i, Math.max(last, i)),\n              text: rows.map((r) => r.text).join(\"\\n\"),\n              children: rows,\n            });\n          }\n        }\n      } else if (name === \"csv-table\") {\n        const { options } = readOptions(src, i + 1, bodyEnd);\n        const bodyStart = directiveContentStart(src, i + 1, bodyEnd);\n        const rowLines: number[] = [];\n        for (let li = bodyStart; li < bodyEnd; li++) {\n          if (!isBlank(src.text[li])) rowLines.push(li);\n        }\n        const headerOption = options[\"header\"];\n        if (rowLines.length > 0 || headerOption !== undefined) {\n          const headerRows = Number.parseInt(options[\"header-rows\"] ?? \"\", 10) || 0;\n          const rows: TableRowNode[] = [];\n          if (headerOption !== undefined) {\n            rows.push(csvRow(src, i, splitCsvLine(headerOption), true));\n          }\n          rowLines.forEach((lineIdx, index) => {\n            rows.push(csvRow(src, lineIdx, splitCsvLine(src.text[lineIdx] ?? \"\"), index < headerRows));\n          });\n          const last = lastContentLine(src, i, bodyEnd);\n          content({\n            kind: \"table\",\n            position: spanOf(src, i, Math.max(last, i)),\n            text: rows.map((r) => r.text).join(\"\\n\"),\n            children: rows,\n          });\n        }\n      }\n      i = Math.max(bodyEnd, i + 1);\n      continue;\n    }\n\n    // Field lists (docinfo, and bibliographic fields) are metadata, read\n    // separately by `readMetadata`. Never body content.\n    if (FIELD.test(line) && lineIndent === base) {\n      i = Math.max(indentedBlockEnd(src, i + 1, to, lineIndent), i + 1);\n      while (i < to && FIELD.test(src.text[i] ?? \"\") && indentOf(src.text[i] ?? \"\") === base) {\n        i = Math.max(indentedBlockEnd(src, i + 1, to, lineIndent), i + 1);\n      }\n      continue;\n    }\n\n    if (DOCTEST.test(line)) {\n      // Consume the run of non-blank lines the construct occupies.\n      let end = i;\n      while (end < to && !isBlank(src.text[end])) end++;\n      i = end;\n      continue;\n    }\n\n    if (GRID_TABLE.test(line)) {\n      const table = parseGridTable(src, i, to);\n      content(table.node);\n      i = table.next;\n      continue;\n    }\n\n    if (SIMPLE_TABLE.test(line)) {\n      const table = parseSimpleTable(src, i, to);\n      content(table.node);\n      i = table.next;\n      continue;\n    }\n\n    // An indented block with no `::` ahead of it is a block quote. Its own\n    // content is parsed the same way a list item's body is.\n    if (lineIndent > base) {\n      const bqEnd = indentedBlockEnd(src, i, to, base);\n      const children = scanRange(src, levels, i, bqEnd, lineIndent, false)\n        .filter((f): f is Extract<Fragment, { type: \"content\" }> => f.type === \"content\")\n        .map((f) => f.node);\n      const last = lastContentLine(src, i, bqEnd);\n      content({\n        kind: \"blockquote\",\n        position: spanOf(src, i, Math.max(last, i)),\n        text: children.map((c) => c.text).join(\"\\n\"),\n        children,\n      });\n      i = Math.max(bqEnd, i + 1);\n      continue;\n    }\n\n    const bullet = BULLET.exec(line);\n    if (bullet && indentOf(line) === base && bulletHasBody(bullet, src, i, to, base)) {\n      const list = parseList(src, levels, i, to, base, false);\n      content(list.node);\n      i = list.next;\n      continue;\n    }\n\n    const enumerated = ENUM.exec(line);\n    if (enumerated && indentOf(line) === base && bulletHasBody(enumerated, src, i, to, base)) {\n      const list = parseList(src, levels, i, to, base, true);\n      content(list.node);\n      i = list.next;\n      continue;\n    }\n\n    // A term whose next line is indented is a definition list, not a paragraph\n    // followed by a block quote.\n    const next = src.text[i + 1];\n    if (i + 1 < to && !isBlank(next) && indentOf(next ?? \"\") > base) {\n      const dl = parseDefinitionList(src, levels, i, to, base);\n      content(dl.node);\n      i = dl.next;\n      continue;\n    }\n\n    i = readParagraph(src, levels, fragments, i, to, base, headings);\n  }\n\n  return fragments;\n}\n\n/**\n * Does a matched list marker actually open an item?\n *\n * A marker with text after it always does. A bare marker opens one only when an\n * indented block follows, which is what separates an empty list item from a\n * line that merely starts with a hyphen.\n */\nfunction bulletHasBody(\n  match: RegExpExecArray,\n  src: Source,\n  line: number,\n  to: number,\n  base: number,\n): boolean {\n  // The content group is 4 for `BULLET` and 5 for `ENUM`, which has the extra\n  // suffix group. Checking both is cheaper than threading the pattern's shape\n  // through: only one of the two is ever a content group, and the other is\n  // whitespace or undefined.\n  if ((match[4] ?? \"\").trim() !== \"\" || (match[5] ?? \"\").trim() !== \"\") return true;\n  for (let i = line + 1; i < to; i++) {\n    const next = src.text[i] ?? \"\";\n    if (isBlank(next)) continue;\n    return indentOf(next) > base;\n  }\n  return false;\n}\n\n/** The marker text and the column its content starts at, for one item line. */\ninterface Marker {\n  /** Width of the marker plus the whitespace after it. */\n  width: number;\n  /** Indent the item's body sits at. */\n  contentIndent: number;\n}\n\nfunction markerOf(match: RegExpExecArray, ordered: boolean): Marker {\n  const indent = (match[1] ?? \"\").length;\n  const marker = ordered ? `${match[2] ?? \"\"}${match[3] ?? \"\"}` : (match[2] ?? \"\");\n  const gap = (ordered ? match[4] : match[3]) ?? \" \";\n  return { width: marker.length + gap.length, contentIndent: indent + marker.length + gap.length };\n}\n\n/**\n * Parse the run of list items starting at `from`.\n *\n * Each item's marker is blanked out of `src.text` - replaced by exactly as many\n * spaces - so the item body is an ordinary indented block that `scanRange` can\n * read with no special case. Offsets and columns are untouched by construction.\n */\nfunction parseList(\n  src: Source,\n  levels: Levels,\n  from: number,\n  to: number,\n  base: number,\n  ordered: boolean,\n): { node: ContentNode; next: number } {\n  const pattern = ordered ? ENUM : BULLET;\n  // `parseList` is only entered on a line that already matched, so the miss\n  // falls through to the same defaults a matched line with no marker group\n  // would have taken.\n  const firstMatch = pattern.exec(src.text[from] ?? \"\");\n  const markerChar = ordered ? (firstMatch?.[3] ?? \".\") : (firstMatch?.[2] ?? \"*\");\n  const items: ListItemNode[] = [];\n  // Where the list ends, excluding the blank lines between items - those belong\n  // to whatever follows, so a list before a heading does not swallow the gap.\n  let end = from;\n  let i = from;\n\n  while (i < to) {\n    // Items may be separated by blank lines; the list ends at the first\n    // non-blank line that is not another item at this indent.\n    let start = i;\n    while (start < to && isBlank(src.text[start])) start++;\n    if (start >= to) break;\n\n    const line = src.text[start] ?? \"\";\n    if (indentOf(line) !== base) break;\n    const match = pattern.exec(line);\n    if (!match) break;\n    // docutils ends a list when the marker style changes; so do we. The\n    // defaults match `markerChar`'s above: a different fallback here would end\n    // the list after its first item rather than read the style as unchanged.\n    const thisChar = ordered ? (match[3] ?? \".\") : (match[2] ?? \"*\");\n    if (thisChar !== markerChar) break;\n    if (!bulletHasBody(match, src, start, to, base)) break;\n\n    const marker = markerOf(match, ordered);\n    // Blank the marker in place. Same length, so `starts` stays exact.\n    src.text[start] = \" \".repeat(marker.contentIndent) + line.slice(marker.contentIndent);\n\n    const bodyEnd = Math.max(indentedBlockEnd(src, start + 1, to, base), start + 1);\n    const last = lastContentLine(src, start, bodyEnd);\n    const children = scanRange(src, levels, start, bodyEnd, marker.contentIndent, false)\n      .filter((b): b is Extract<Fragment, { type: \"content\" }> => b.type === \"content\")\n      .map((b) => b.node);\n\n    items.push({\n      kind: \"listItem\",\n      position: spanOf(src, start, Math.max(last, start), base + 1),\n      text: children.map((c) => c.text).join(\"\\n\"),\n      children,\n    });\n    i = bodyEnd;\n    end = bodyEnd;\n  }\n\n  const last = lastContentLine(src, from, end);\n  return {\n    node: {\n      kind: \"list\",\n      position: spanOf(src, from, Math.max(last, from), base + 1),\n      text: items.map((item) => item.text).join(\"\\n\"),\n      ordered,\n      items,\n    },\n    next: Math.max(i, from + 1),\n  };\n}\n\n/**\n * A run of term/definition pairs starting at `from`: an unindented term line\n * immediately followed by an indented definition. Items may be separated by\n * blank lines, the same tolerance `parseList` gives bulleted items.\n */\nfunction parseDefinitionList(\n  src: Source,\n  levels: Levels,\n  from: number,\n  to: number,\n  base: number,\n): { node: ContentNode; next: number } {\n  const items: DefinitionItemNode[] = [];\n  let i = from;\n  let end = from;\n\n  while (i < to) {\n    let start = i;\n    while (start < to && isBlank(src.text[start])) start++;\n    if (start >= to) break;\n\n    const line = src.text[start] ?? \"\";\n    if (indentOf(line) !== base) break;\n    const next = src.text[start + 1];\n    if (start + 1 >= to || isBlank(next) || indentOf(next ?? \"\") <= base) break;\n\n    const term = flattenInline(line.trim());\n    const defStart = start + 1;\n    const defIndent = indentOf(next ?? \"\");\n    const defEnd = Math.max(indentedBlockEnd(src, defStart, to, base), defStart);\n    const last = lastContentLine(src, start, defEnd);\n    const definition = scanRange(src, levels, defStart, defEnd, defIndent, false)\n      .filter((f): f is Extract<Fragment, { type: \"content\" }> => f.type === \"content\")\n      .map((f) => f.node);\n\n    items.push({\n      kind: \"definitionItem\",\n      position: spanOf(src, start, Math.max(last, start)),\n      text: [term, ...definition.map((d) => d.text)].join(\"\\n\"),\n      term,\n      definition,\n    });\n    i = defEnd;\n    end = defEnd;\n  }\n\n  const last = lastContentLine(src, from, end);\n  return {\n    node: {\n      kind: \"definitionList\",\n      position: spanOf(src, from, Math.max(last, from)),\n      text: items.map((item) => item.text).join(\"\\n\"),\n      children: items,\n    },\n    next: Math.max(i, from + 1),\n  };\n}\n\n/**\n * Read one paragraph, and the literal block it may introduce.\n *\n * A paragraph ending in `::` opens a literal block: the indented block after\n * it becomes `code`, and the `::` is stripped from the paragraph's own text the\n * way docutils strips it - removed entirely when the paragraph is only `::` or\n * when whitespace precedes it, and collapsed to one colon otherwise.\n */\nfunction readParagraph(\n  src: Source,\n  levels: Levels,\n  fragments: Fragment[],\n  from: number,\n  to: number,\n  base: number,\n  headings: boolean,\n): number {\n  let end = from;\n  while (end < to) {\n    const line = src.text[end] ?? \"\";\n    if (isBlank(line)) break;\n    if (end > from) {\n      // A line whose successor underlines it ends the paragraph and starts a\n      // section, and a construct of any other kind ends it too.\n      if (headings && titleAt(src, end, to)) break;\n      if (adornmentOf(line) !== null) break;\n      if (EXPLICIT.test(line)) break;\n      if (indentOf(line) !== base) break;\n      if (GRID_TABLE.test(line) || SIMPLE_TABLE.test(line) || DOCTEST.test(line)) break;\n    }\n    end++;\n  }\n\n  const rawText = flattenInline(\n    src.text\n      .slice(from, end)\n      .map((l) => l.trim())\n      .join(\"\\n\"),\n  );\n  const literal = /::$/.test(rawText);\n  const text = !literal\n    ? rawText\n    : rawText === \"::\"\n      ? \"\" // A paragraph that is only `::` is the marker, and nothing else.\n      : rawText.replace(/(\\s*)::$/, (_m, space: string) => (space === \"\" ? \":\" : \"\"));\n\n  if (text.trim() !== \"\") {\n    fragments.push({\n      type: \"content\",\n      node: { kind: \"paragraph\", position: spanOf(src, from, end - 1), text },\n    });\n  }\n\n  if (!literal) return end;\n\n  // The literal block is the next indented block, after any blank lines.\n  let start = end;\n  while (start < to && isBlank(src.text[start])) start++;\n  if (start >= to || indentOf(src.text[start] ?? \"\") <= base) return end;\n\n  const blockEnd = indentedBlockEnd(src, start, to, base);\n  const last = lastContentLine(src, start, blockEnd);\n  fragments.push({\n    type: \"content\",\n    node: {\n      kind: \"codeBlock\",\n      position: spanOf(src, start, Math.max(last, start)),\n      text: dedent(src, start, blockEnd),\n    },\n  });\n  return Math.max(blockEnd, end);\n}\n\n// ---------------------------------------------------------------------------\n// Links and section labels\n// ---------------------------------------------------------------------------\n\n/** A hyperlink target: `.. _name: uri`, `.. _name:`, or a backquoted phrase name. */\nconst TARGET = /^[ \\t]*\\.\\.[ \\t]+_(?:`([^`]+)`|([^:`]+)):(?:[ \\t]+(.*?))?[ \\t]*$/;\n\n/**\n * The hyperlink target defined at `line`, or null. `uri` is empty for an\n * internal target - a label for whatever follows it - and otherwise joins the\n * indented lines a long URI may continue onto, whitespace removed, as docutils\n * does. An anonymous target (`.. __: uri`) names nothing and is not one.\n */\nfunction targetAt(src: Source, line: number): { name: string; uri: string } | null {\n  const match = TARGET.exec(src.text[line] ?? \"\");\n  const name = (match?.[1] ?? match?.[2] ?? \"\").trim();\n  if (!match || name === \"\" || name === \"_\") return null;\n  let uri = match[3] ?? \"\";\n  const base = indentOf(src.text[line] ?? \"\");\n  for (let next = line + 1; next < src.text.length; next++) {\n    const text = src.text[next] ?? \"\";\n    if (isBlank(text) || indentOf(text) <= base) break;\n    uri += text;\n  }\n  return { name, uri: uri.replace(/\\s+/g, \"\") };\n}\n\n/** Reference names match case-insensitively, with whitespace collapsed. */\nconst refName = (name: string): string => name.replace(/\\s+/g, \" \").trim().toLowerCase();\n\n/**\n * The label of an internal target directly above a section title - blank lines\n * between allowed, anything else not - which is how reST gives a section the\n * anchor `:ref:` and `label_` resolve to.\n */\nfunction labelAbove(src: Source, first: number): string | undefined {\n  let line = first - 1;\n  while (line >= 0 && isBlank(src.text[line])) line--;\n  const target = line >= 0 ? targetAt(src, line) : null;\n  return target && target.uri === \"\" ? target.name : undefined;\n}\n\n/** Every source line a code block covers, 1-based, nested blocks included. */\nfunction codeLines(\n  nodes: readonly (ContentNode | ListItemNode | TableRowNode | TableCellNode | DefinitionItemNode)[],\n  out: Set<number>,\n): Set<number> {\n  for (const node of nodes) {\n    if (node.kind === \"codeBlock\") {\n      for (let l = node.position.start.line; l <= node.position.end.line; l++) out.add(l);\n    } else if (node.kind === \"list\") {\n      codeLines(node.items, out);\n    } else if (node.kind === \"definitionItem\") {\n      codeLines(node.definition, out);\n    } else if (\"children\" in node) {\n      codeLines(node.children, out);\n    }\n  }\n  return out;\n}\n\n/** Replace a match with spaces, so later patterns cannot see it and columns hold. */\nconst blank = (text: string, index: number, length: number): string =>\n  text.slice(0, index) + \" \".repeat(length) + text.slice(index + length);\n\nconst INLINE_LITERAL = /``.+?``/g;\nconst DOC_ROLE = /:doc:`([^`]*)`/g;\nconst ROLE = /:[\\w.+:-]+:`[^`]*`/g;\nconst EMBEDDED = /`([^`<]*?)\\s*<([^<>`]+)>`(__?)/g;\nconst PHRASE_REF = /`([^`]+)`_(?!_)/g;\n/** A simple reference name: alphanumerics joined by single `-_.:+`. */\nconst SIMPLE_REF = /(?<![\\w\\\\])([A-Za-z0-9]+(?:[-_.:+][A-Za-z0-9]+)*)_(?!\\w)/g;\n\n/**\n * The document's link targets, in document order.\n *\n * Three constructs are links: an embedded URI (`` `text <uri>`_ ``, or `__`\n * for an anonymous one), a named reference (`name_`, `` `two words`_ ``)\n * resolved against this document's own `.. _name: uri` targets, and a Sphinx\n * `:doc:` role. A reference to a name the document never defines yields\n * nothing - it may be a section label, or a typo, and neither has a target to\n * report. `:ref:` yields nothing either: its label resolves across a whole\n * Sphinx project, which one file cannot see.\n *\n * A line scan of its own, over every line but a code block's, rather than\n * part of `scanRange`: a link counts wherever it is, inside a directive this\n * parser skips (`seealso`) as much as in a paragraph. Like the rest of this\n * file it is not docutils. A reference split across two lines is missed, and\n * standalone URLs are not collected.\n */\nfunction collectLinks(src: Source, from: number, code: Set<number>): DocumentTree[\"links\"] {\n  const targets = new Map<string, string>();\n  for (let line = from; line < src.text.length; line++) {\n    const target = targetAt(src, line);\n    if (target && target.uri !== \"\") targets.set(refName(target.name), target.uri);\n  }\n  // An embedded URI with a single `_` also defines its text as a name.\n  for (let line = from; line < src.text.length; line++) {\n    for (const m of (src.text[line] ?? \"\").matchAll(EMBEDDED)) {\n      const name = refName(m[1] ?? \"\");\n      if (m[3] === \"_\" && name !== \"\" && !targets.has(name)) {\n        targets.set(name, (m[2] ?? \"\").replace(/\\s+/g, \"\"));\n      }\n    }\n  }\n  // A value ending in `_` (`<Python_>`, `.. _home: Python_`) names another\n  // target rather than being a URI, so the chain is followed to a URI. One\n  // that never reaches one, a cycle included, resolves to nothing.\n  const resolve = (name: string): string | undefined => {\n    let uri = targets.get(refName(name));\n    for (let hops = 0; uri?.endsWith(\"_\") && hops < targets.size; hops++) {\n      uri = targets.get(refName(uri.slice(0, -1)));\n    }\n    return uri?.endsWith(\"_\") ? undefined : uri;\n  };\n\n  const links: DocumentTree[\"links\"] = [];\n  for (let line = from; line < src.text.length; line++) {\n    let text = src.text[line] ?? \"\";\n    if (code.has(line + 1) || TARGET.test(text)) continue;\n    const hits: { column: number; length: number; target: string }[] = [];\n    // Each construct is blanked once read, so a later, looser pattern cannot\n    // read it again: `:ref:` text never becomes a phrase reference.\n    const take = (pattern: RegExp, toTarget: (m: RegExpExecArray) => string | undefined): void => {\n      for (const m of text.matchAll(pattern)) {\n        const target = toTarget(m);\n        if (target) hits.push({ column: m.index + 1, length: m[0].length, target });\n        text = blank(text, m.index, m[0].length);\n      }\n    };\n    take(INLINE_LITERAL, () => undefined);\n    take(DOC_ROLE, (m) => {\n      const inner = (m[1] ?? \"\").trim();\n      return /<([^<>]+)>$/.exec(inner)?.[1]?.trim() ?? inner;\n    });\n    take(ROLE, () => undefined);\n    take(EMBEDDED, (m) => {\n      const uri = (m[2] ?? \"\").replace(/\\s+/g, \"\");\n      // `<name_>` embeds a reference to another target, not a URI.\n      return uri.endsWith(\"_\") ? resolve(uri.slice(0, -1)) : uri;\n    });\n    take(PHRASE_REF, (m) => resolve(m[1] ?? \"\"));\n    take(SIMPLE_REF, (m) => resolve(m[1] ?? \"\"));\n    hits.sort((a, b) => a.column - b.column);\n    for (const hit of hits) {\n      links.push({\n        target: hit.target,\n        position: {\n          start: pointAt(src, line, hit.column),\n          end: pointAt(src, line, hit.column + hit.length),\n        },\n      });\n    }\n  }\n  return links;\n}\n\n/**\n * Span of the native docinfo block: the leading field list, or - when a page\n * carries only a title - the title line docmeta read it from.\n *\n * docmeta reports the block's start line but not its extent, and we are already\n * holding a line index, so the span is cheaper to recover here than to ask for.\n */\nfunction docinfoPosition(src: Source): Position | null {\n  const limit = src.text.length;\n  let i = 0;\n  while (i < limit && isBlank(src.text[i])) i++;\n\n  const hit = titleAt(src, i, limit);\n  if (hit) i = hit.last + 1;\n  while (i < limit && isBlank(src.text[i])) i++;\n\n  const fieldStart = i;\n  while (i < limit && FIELD.test(src.text[i] ?? \"\") && indentOf(src.text[i] ?? \"\") === 0) {\n    i = Math.max(indentedBlockEnd(src, i + 1, limit, 0), i + 1);\n  }\n  if (i > fieldStart) return spanOf(src, fieldStart, i - 1);\n  if (hit) return spanOf(src, hit.first, hit.last);\n  return null;\n}\n\ninterface Metadata {\n  frontmatter: Record<string, unknown> | null;\n  position: Position | null;\n  /**\n   * First body line, 0-based. Non-zero only for a fenced block, whose lines\n   * would otherwise be scanned as prose - `---` as a transition and the YAML\n   * under it as a paragraph, which opens an implicit lead section and hands the\n   * template's top-level slot the wrong thing. A docinfo field list needs no\n   * such cut: it is inside the body, and the scanner skips field lists.\n   */\n  bodyStart: number;\n}\n\n/**\n * Read the page's metadata, from both places an RST page can put it.\n *\n * `extractFrontmatter(content, \"rst\")` - the call `markdown.ts` makes - reads\n * only a *fenced* block; its format argument is a label copied onto the result,\n * not a dispatch. On its own it would leave every page using the native docinfo\n * field list unrouted, and that field list is how RST authors actually declare\n * `:type: how-to`. The RST-aware reading lives in docmeta's extractor registry,\n * so both are read and merged.\n *\n * A fenced block wins a key collision: it is the author being deliberate about\n * metadata, where a docinfo `title` is often just the document's own heading\n * read a second time. `present` is the OR of the two - the same shape the HTML\n * parser landed on, so the formats stay consistent.\n *\n * That docinfo `title` is worth knowing about. In RST the page title genuinely\n * *is* the first section title, so a page with a title and no fields comes back\n * with non-null `frontmatter` holding just that. Nothing downstream is misled -\n * routing reads `type` and `$template` - and taking docmeta's answer verbatim\n * keeps one source of truth for what a format's metadata is.\n */\nfunction readMetadata(content: string, filePath: string, src: Source): Metadata {\n  const fenced = extractFrontmatter(content, \"rst\");\n  // Read the docinfo field list from the fence-free remainder: docmeta's reST\n  // extractor returns the fence and stops when one is present, so asking it\n  // about the whole file would discard `:type:` on any page that has both.\n  const native = extractorForExtension(\".rst\")?.extract(\n    fenced.present ? withoutFence(content) : content,\n    filePath,\n  );\n\n  if (!fenced.present && !native?.present) {\n    return { frontmatter: null, position: null, bodyStart: 0 };\n  }\n\n  const loc = fenced.present ? locateFrontmatter(content) : null;\n  return {\n    frontmatter: {\n      ...(native?.present ? native.data : {}),\n      ...(fenced.present ? fenced.data : {}),\n    },\n    position: fenced.present ? fencedPosition(content) : docinfoPosition(src),\n    // `findIndex` returns -1 when no line starts at or after the closing fence,\n    // i.e. the fence is the last thing in the file. `Math.max(-1, 0)` used to\n    // launder that into line 0, restarting the scan inside the frontmatter and\n    // reading the YAML as body prose - the exact thing `bodyStart` exists to\n    // prevent. There is no body in that case, so start past the last line.\n    bodyStart: loc\n      ? (() => {\n          const i = src.starts.findIndex((start) => start >= loc.closeEnd);\n          return i === -1 ? src.starts.length : i;\n        })()\n      : 0,\n  };\n}\n\nexport const rstParser: DocumentParser = {\n  name: \"rst\",\n  label: \"reStructuredText\",\n  kinds: [\n    \"paragraph\",\n    \"codeBlock\",\n    \"list\",\n    \"listItem\",\n    \"table\",\n    \"tableRow\",\n    \"tableCell\",\n    \"admonition\",\n    \"image\",\n    \"blockquote\",\n    \"definitionList\",\n    \"definitionItem\",\n  ],\n  extensions: [\".rst\"],\n  parse(content, filePath): DocumentTree {\n    const src = indexLines(content);\n    // Order is load-bearing: `readMetadata` must run before `scanRange`.\n    // `scanRange` blanks consumed list lines in `src.text` in place so a later\n    // pass cannot re-read them, and `docinfoPosition` inside `readMetadata`\n    // reads those same lines to place the metadata span. Swapped, the docinfo\n    // field list is already blank and every metadata position collapses.\n    const { frontmatter, position, bodyStart } = readMetadata(content, filePath, src);\n    const fragments = scanRange(\n      src,\n      { styles: [] },\n      Math.max(bodyStart, 0),\n      src.text.length,\n      0,\n      true,\n    );\n\n    return {\n      format: \"rst\",\n      filePath,\n      frontmatter,\n      frontmatterPosition: position,\n      sections: sectionize(\n        withFrontmatterTitle(fragments, frontmatter, position),\n        src.end,\n      ),\n      links: collectLinks(\n        src,\n        Math.max(bodyStart, 0),\n        codeLines(\n          fragments.flatMap((f) => (f.type === \"content\" ? [f.node] : [])),\n          new Set(),\n        ),\n      ),\n    };\n  },\n};\n","/**\n * XML -> generic blocks, through a declarative vocabulary mapping.\n *\n * ADR 01001 puts XML last \"because structure comes from the document's own\n * element nesting and needs a small per-vocabulary mapping\". This is that\n * mapping, and the reason it exists: XML has no headings. Markdown says `##`,\n * AsciiDoc says `==`, HTML says `<h2>` - one universal rule each. XML says\n * whatever its schema says. DITA nests `<topic>`/`<section>` and titles them\n * with `<title>`; DocBook nests `<chapter>`/`<section>`/`<sect1>` and titles\n * them with `<title>` too, but calls a paragraph `<para>` where DITA calls it\n * `<p>`; a house schema calls them something else again. Hardcoding DITA would\n * make \"the XML parser\" a lie.\n *\n * ## The mapping\n *\n * An `XmlVocabulary` sorts element names into four buckets and says nothing\n * about anything else:\n *\n *  - `sections`   open a section, titled by the first `titles` element among\n *                 their children (or inside a `titleWrappers` child, which is\n *                 how DocBook 5 hides `<title>` in `<info>`).\n *  - `transparent` are structural wrappers with no meaning of their own -\n *                 DITA's `<body>`, `<taskbody>`, `<context>`. The walk passes\n *                 straight through them at the same level.\n *  - `paragraphs` / `code` / `unorderedLists` / `orderedLists` / `listItems` /\n *                 `tables` / `admonitions` / `images` / `blockquotes` /\n *                 `definitionLists` are the format-neutral content kinds of\n *                 `types.ts`. The last five are optional buckets: a vocabulary\n *                 that leaves one out never emits that kind, same as leaving\n *                 an entry out of `kinds`.\n *  - everything else is **skipped, with its subtree**, exactly as the Markdown\n *    parser skips a blockquote. A DITA `<related-links>` is not a paragraph,\n *    and its contents must not be counted as one, or `paragraphs: {max: 3}`\n *    fails documents a reader would say satisfy it.\n *\n * That last rule is why `transparent` has to exist as its own bucket: without\n * it, skipping the unmapped `<body>` would skip the whole topic.\n *\n * ## Titles that are not elements, and sections that carry none\n *\n * Two more fields, both earned by a DITA map:\n *\n *  - `titleAttributes` names attributes that title a section, for the schemas\n *    that spell a title as one (`<topicref navtitle=\"Install\"/>`). An attribute\n *    has no position of its own, so the heading ends where the start tag does.\n *  - `untitledSections` says a `sections` element opens a section even with no\n *    title at all. Off by default, because an untitled DITA `<section>` is\n *    prose belonging to the topic around it. On for a map, where an entry names\n *    its target by `@keyref` or `@href` and lets the referenced topic supply\n *    the title, so untitled is the normal case and dropping those entries would\n *    flatten the whole table of contents.\n *\n * ## Extending it for a bespoke schema\n *\n * Add one entry to `XML_VOCABULARIES` (or pass your own array to `parseXml`):\n *\n *     { name: \"acme\", label: \"Acme Docs\",\n *       namespaces: [\"https://acme.example/docs\"], roots: [\"manual\"],\n *       sections: [\"manual\", \"chapter\"], titles: [\"heading\"],\n *       titleWrappers: [], transparent: [\"content\"],\n *       paragraphs: [\"text\"], code: [\"sample\"], codeLangAttributes: [\"lang\"],\n *       unorderedLists: [\"bullets\"], orderedLists: [\"steps\"],\n *       listItems: [\"item\"] }\n *\n * Tables, admonitions, images, blockquotes and definition lists are five more\n * buckets, all optional - a schema that never names one simply never emits\n * that kind. See each field's own doc comment below for the shape it expects.\n *\n * Nothing else changes: the walk, the levels, the positions, and the fold are\n * vocabulary-independent. This is deliberately not wired to `manni.config.yaml`\n * yet - the shape is the commitment, the config surface is a later decision.\n *\n * ## Which vocabulary a document is in\n *\n * Scored, not guessed: a declared namespace is decisive, then elements only\n * one candidate claims, then the root element name, then the elements they\n * share. That ordering is what settles the ambiguous cases - `<section>`,\n * `<title>` and `<reference>` belong to both built-ins, so a `<section>`-rooted\n * file is decided by whether its prose is in `<p>` or `<para>`. Nothing\n * recognized at all is an error, not an empty tree: see `chooseVocabulary`.\n *\n * ## Levels\n *\n * `sectionize` folds by heading *level*, so nesting is expressed as one: the\n * level is the number of enclosing elements that actually opened a section,\n * plus one. Transparent wrappers do not count, and neither does a section\n * element with no title - an untitled DITA `<section>` is legal, and the honest\n * reading is that it adds no heading and so no level, its content belonging to\n * the section that encloses it. Levels clamp at 6, the range `SectionNode`\n * declares.\n *\n * ## Positions\n *\n * `@xmldom/xmldom` records `lineNumber` (1-based, despite its `index.d.ts`\n * saying \"zero based\") and `columnNumber` (1-based) on every node, pointing at\n * the `<` of an element's start tag and at the first character of a text node.\n * There is no end position. But *every* node carries a start, including the\n * whitespace text nodes between elements, so the exclusive end of an element is\n * the start of the next node in document order - for indented XML that is the\n * character right after `</tag>`, exactly. Only when a node is last all the way\n * up to the root does that fall back to the end of the document, per the\n * house rule for formats whose parser reports no end.\n */\nimport { DOMParser } from \"@xmldom/xmldom\";\nimport type { Element as XmlElement, Node as XmlNode } from \"@xmldom/xmldom\";\nimport { extractorForExtension } from \"../../meta/index.js\";\nimport type {\n  AdmonitionNode,\n  ContentNode,\n  DefinitionItemNode,\n  DefinitionListNode,\n  DocumentParser,\n  DocumentTree,\n  ImageNode,\n  ListItemNode,\n  Point,\n  Position,\n  TableCellNode,\n  TableNode,\n  TableRowNode,\n} from \"../types.js\";\nimport { LintError } from \"../types.js\";\nimport { errorMessage } from \"../../shared/errors.js\";\nimport type { Fragment } from \"./sectionize.js\";\nimport { sectionize } from \"./sectionize.js\";\n\n/**\n * One schema's answer to \"what is a section, and what is content?\".\n *\n * Every list is of lowercased local names - the prefix and namespace of an\n * element are not part of the match, so a document that binds DocBook to `db:`\n * maps the same as one that uses the default namespace.\n */\nexport interface XmlVocabulary {\n  /** Stable id, used in error messages. */\n  name: string;\n  /** Human-readable label. */\n  label: string;\n  /** Namespace URIs that identify this vocabulary outright. */\n  namespaces: readonly string[];\n  /** Root element names that identify it. */\n  roots: readonly string[];\n  /** Elements that open a section when they carry a title. */\n  sections: readonly string[];\n  /** Elements that carry a section's title. */\n  titles: readonly string[];\n  /**\n   * Attributes that carry a section's title when no `titles` element does,\n   * first one present wins. A DITA map spells one `<topicref navtitle=\"...\">`.\n   */\n  titleAttributes?: readonly string[];\n  /**\n   * Whether a `sections` element with no title of any kind still opens a\n   * section. Default false: an untitled container adds no heading, and its\n   * content belongs to the section that encloses it.\n   */\n  untitledSections?: boolean;\n  /** Children to look inside for a title (DocBook's `<info>`). */\n  titleWrappers: readonly string[];\n  /** Structural wrappers: no section, no content, walk through. */\n  transparent: readonly string[];\n  /** Elements that are one paragraph. */\n  paragraphs: readonly string[];\n  /** Elements that are one code block. */\n  code: readonly string[];\n  /** Attributes carrying a code block's language, first one present wins. */\n  codeLangAttributes: readonly string[];\n  /** Elements that are an unordered list. */\n  unorderedLists: readonly string[];\n  /** Elements that are an ordered list. */\n  orderedLists: readonly string[];\n  /** Elements that are one item of a list. */\n  listItems: readonly string[];\n\n  /** Elements that are a table, CALS-shaped or simple. */\n  tables?: readonly string[];\n  /** Elements whose direct children are cells: a header row or a body row. */\n  tableRows?: readonly string[];\n  /** Elements that are one cell of a row. */\n  tableCells?: readonly string[];\n  /** Wrapper elements whose descendant rows are all header rows (CALS `<thead>`). */\n  tableHeaderWrappers?: readonly string[];\n  /** Row elements that are inherently a header row on their own (DITA `<sthead>`). */\n  tableHeaderRows?: readonly string[];\n\n  /** Elements that may be an admonition. */\n  admonitions?: readonly string[];\n  /**\n   * Attribute naming the admonition's variant (DITA's `<note>` `@type`). When\n   * absent, an admonition element's own lowercased name is its variant -\n   * DocBook's five admonition elements are themselves named `note`, `tip`,\n   * `important`, `caution` and `warning`. Either way, a name outside the six\n   * `AdmonitionNode` knows produces an admonition with no `variant` set,\n   * rather than an invented equivalence - DITA's `restriction` and `fastpath`\n   * are real `@type` values this model does not have a word for.\n   */\n  admonitionVariantAttribute?: string;\n\n  /** Elements that are an image, standing alone or wrapping one. */\n  images?: readonly string[];\n  /**\n   * Element carrying the image's own url attribute - itself, for a\n   * self-contained image (DITA's `<image href>`), or a descendant found by\n   * name (DocBook's `<imagedata fileref>` inside a `<mediaobject>`).\n   */\n  imageDataElements?: readonly string[];\n  /** Attribute on an `imageDataElements` match that carries the url. */\n  imageUrlAttribute?: string;\n  /** Direct child of an `imageDataElements` match carrying the alt text. */\n  imageAltElements?: readonly string[];\n\n  /** Elements that are a block quote. */\n  blockquotes?: readonly string[];\n\n  /** Elements that are a definition list. */\n  definitionLists?: readonly string[];\n  /** Elements that are one entry, pairing a term with a definition. */\n  definitionItems?: readonly string[];\n  /** Elements that carry an entry's term(s); more than one join with \", \". */\n  definitionTerms?: readonly string[];\n  /** Elements that carry an entry's definition body. */\n  definitionBodies?: readonly string[];\n\n  /**\n   * Where a link target is written: an attribute, matched by local name (so\n   * `href` also finds DocBook's `xlink:href`), on any of `elements`. `idref`\n   * marks an attribute holding a bare id rather than a URL - DocBook's\n   * `linkend` - which is emitted as `#<id>`. Read from the whole document,\n   * skipped subtrees included, because a DITA `<related-links>` is where a\n   * topic keeps most of its links. Not counted when choosing a vocabulary.\n   */\n  links?: readonly { elements: readonly string[]; attribute: string; idref?: boolean }[];\n  /**\n   * DITA addressing. A same-scheme href names an element as\n   * `file.dita#topicid/elementid`, where the rest of the web would write\n   * `file.dita#elementid`, so the fragment is cut to its last segment. Never\n   * applied to an href with a scheme, whose fragment means what its site says.\n   */\n  ditaHrefs?: boolean;\n}\n\n/**\n * DITA. No default namespace to detect on (DITA is conventionally\n * namespace-free, with only `ditaarch:` bound on the root), so recognition\n * leans on the topic types and on `<p>`/`<codeblock>`/`<body>`.\n *\n * `<prereq>`, `<context>`, `<result>` and friends are transparent rather than\n * sections: they are untitled parts of a task body that render as continuous\n * prose, so their paragraphs belong to the task. `<related-links>` and\n * `<prolog>` are in no bucket at all, so they and their contents are skipped -\n * the blockquote rule.\n *\n * A CALS `<table>` and an OASIS `<simpletable>` share one row/cell reading:\n * `<row>`/`<entry>` for the former, `<strow>`/`<stentry>` for the latter. A row\n * inside `<thead>` is a header row (the CALS shape); `<sthead>` is a header row\n * on its own, holding `<stentry>` cells directly rather than wrapping a row.\n */\nconst DITA: XmlVocabulary = {\n  name: \"dita\",\n  label: \"DITA\",\n  namespaces: [],\n  roots: [\"dita\", \"topic\", \"concept\", \"task\", \"reference\", \"glossentry\"],\n  sections: [\n    \"topic\",\n    \"concept\",\n    \"task\",\n    \"reference\",\n    \"glossentry\",\n    \"section\",\n    \"example\",\n  ],\n  // `<glossterm>` is how a `<glossentry>` titles itself. It never carries a\n  // `<title>`, so a vocabulary listing `title` alone reads every real glossary\n  // topic as untitled and refuses the whole file. DITA-OT's own docset has\n  // thirteen of them. `src/term/core/readers/dita.ts` has always read\n  // `<glossterm>` as the term, so the two halves of this package disagreed\n  // until the vendored corpus made it visible.\n  titles: [\"title\", \"glossterm\"],\n  titleWrappers: [],\n  transparent: [\n    \"dita\",\n    \"body\",\n    \"conbody\",\n    \"taskbody\",\n    \"refbody\",\n    \"glossbody\",\n    \"abstract\",\n    \"prereq\",\n    \"context\",\n    \"result\",\n    \"postreq\",\n    \"div\",\n    \"bodydiv\",\n    \"sectiondiv\",\n  ],\n  // `<cmd>` is the imperative line of a `<step>`; treating it as a paragraph is\n  // what makes a DITA `<steps>` item shaped like a Markdown list item.\n  //\n  // `<glossdef>` is the definition, and it holds prose either directly or in\n  // `<p>`s. A paragraph rather than a wrapper, because a wrapper would drop the\n  // direct-text spelling, which is the common one.\n  paragraphs: [\"p\", \"shortdesc\", \"cmd\", \"info\", \"glossdef\"],\n  code: [\"codeblock\", \"pre\"],\n  codeLangAttributes: [\"outputclass\"],\n  unorderedLists: [\"ul\", \"sl\", \"steps-unordered\"],\n  orderedLists: [\"ol\", \"steps\", \"substeps\"],\n  listItems: [\"li\", \"sli\", \"step\", \"substep\"],\n\n  tables: [\"table\", \"simpletable\"],\n  tableRows: [\"row\", \"strow\", \"sthead\"],\n  tableCells: [\"entry\", \"stentry\"],\n  tableHeaderWrappers: [\"thead\"],\n  tableHeaderRows: [\"sthead\"],\n\n  admonitions: [\"note\"],\n  admonitionVariantAttribute: \"type\",\n\n  images: [\"image\", \"fig\"],\n  imageDataElements: [\"image\"],\n  imageUrlAttribute: \"href\",\n  imageAltElements: [\"alt\"],\n\n  blockquotes: [\"lq\"],\n\n  definitionLists: [\"dl\"],\n  definitionItems: [\"dlentry\"],\n  definitionTerms: [\"dt\"],\n  definitionBodies: [\"dd\"],\n\n  // `keyref`, `conkeyref` and `conref` are not here: a key resolves only\n  // against a map at build time, and a conref pulls content in rather than\n  // pointing a reader anywhere.\n  links: [{ elements: [\"xref\", \"link\"], attribute: \"href\" }],\n  ditaHrefs: true,\n};\n\n/**\n * DocBook 5 (and the DocBook 4 `<sectN>`/`<*info>` spellings, which cost two\n * entries and save a whole second vocabulary).\n */\nconst DOCBOOK: XmlVocabulary = {\n  name: \"docbook\",\n  label: \"DocBook\",\n  namespaces: [\"http://docbook.org/ns/docbook\"],\n  roots: [\n    \"book\",\n    \"article\",\n    \"chapter\",\n    \"section\",\n    \"sect1\",\n    \"part\",\n    \"appendix\",\n    \"preface\",\n    \"reference\",\n  ],\n  sections: [\n    \"book\",\n    \"article\",\n    \"part\",\n    \"chapter\",\n    \"appendix\",\n    \"preface\",\n    \"section\",\n    \"simplesect\",\n    \"sect1\",\n    \"sect2\",\n    \"sect3\",\n    \"sect4\",\n    \"sect5\",\n  ],\n  titles: [\"title\"],\n  titleWrappers: [\n    \"info\",\n    \"bookinfo\",\n    \"articleinfo\",\n    \"chapterinfo\",\n    \"sectioninfo\",\n  ],\n  transparent: [\"formalpara\"],\n  paragraphs: [\"para\", \"simpara\"],\n  code: [\"programlisting\", \"screen\", \"literallayout\", \"synopsis\"],\n  codeLangAttributes: [\"language\"],\n  unorderedLists: [\"itemizedlist\", \"simplelist\"],\n  orderedLists: [\"orderedlist\", \"procedure\"],\n  listItems: [\"listitem\", \"member\", \"step\"],\n\n  tables: [\"table\", \"informaltable\"],\n  tableRows: [\"row\"],\n  tableCells: [\"entry\"],\n  tableHeaderWrappers: [\"thead\"],\n  tableHeaderRows: [],\n\n  // No `admonitionVariantAttribute`: DocBook's five admonition elements are\n  // themselves named `note`/`warning`/`caution`/`tip`/`important`.\n  admonitions: [\"note\", \"warning\", \"caution\", \"tip\", \"important\"],\n\n  images: [\"mediaobject\", \"figure\"],\n  imageDataElements: [\"imagedata\"],\n  imageUrlAttribute: \"fileref\",\n  imageAltElements: [],\n\n  blockquotes: [\"blockquote\"],\n\n  definitionLists: [\"variablelist\"],\n  definitionItems: [\"varlistentry\"],\n  definitionTerms: [\"term\"],\n  // DocBook reuses `<listitem>` for a variable list's own body, distinct from\n  // the `listItems` bucket above which reads it inside `<itemizedlist>`.\n  definitionBodies: [\"listitem\"],\n\n  links: [\n    { elements: [\"link\"], attribute: \"href\" },\n    { elements: [\"ulink\"], attribute: \"url\" },\n    { elements: [\"xref\", \"link\"], attribute: \"linkend\", idref: true },\n  ],\n};\n\n/** A map's navigation entries: each is a section, and each one's `href` a link. */\nconst MAP_ENTRIES = [\n  \"map\",\n  \"bookmap\",\n  \"topicref\",\n  \"topichead\",\n  \"mapref\",\n  \"glossref\",\n  \"anchorref\",\n  \"navref\",\n  \"topicset\",\n  \"topicsetref\",\n  \"chapter\",\n  \"part\",\n  \"appendix\",\n  \"appendices\",\n  \"preface\",\n  \"notices\",\n  \"dedication\",\n  \"colophon\",\n  \"amendments\",\n];\n\n/**\n * DITA maps, `<map>` and `<bookmap>`. No namespace to detect on, as with DITA\n * itself, so recognition leans on `<topicref>` and the rest of the navigation\n * vocabulary.\n *\n * A map is a table of contents, which is a tree of titled nodes - and a tree of\n * titled nodes is what a section tree is. `<topicref>` nesting is section\n * nesting. The one thing a map does that a topic never does is leave its nodes\n * untitled: a real entry points by `@keyref` or `@href` and lets the referenced\n * topic supply the title, so `untitledSections` is on and an untitled entry is\n * an untitled section rather than a failure. A titled entry may be titled\n * either way, as `<topicmeta><navtitle>` or as `@navtitle`, so `titles` and\n * `titleAttributes` both name it.\n *\n * `sections` is wide because navigation is. `<glossref>`, `<mapref>`,\n * `<navref>`, `<topicset>` and a bookmap's `<chapter>`/`<part>`/`<appendix>`\n * are all `<topicref>` specializations, and a map that nests its entries in one\n * of them - DITA-OT's own glossary map nests thirteen `<glossref>`s - would\n * otherwise parse to a tree with nothing in it.\n *\n * `<reltable>` and `<keydef>` are in no bucket at all, so they and their\n * contents are skipped, the blockquote rule. A relationship table states which\n * topics relate to each other, and a key definition binds a key to a resource.\n * Neither is navigation, and counting their `<topicref>`s as sections would\n * make every map's shape a lie. A `<glossref>` carrying `@keys` is the case\n * that looks like both, and it is a section: `<keydef>` defaults to\n * `processing-role=\"resource-only\"` and so never appears in a table of\n * contents, while `<glossref>` processes normally and does. That is a fact\n * about DITA, not a preference.\n *\n * `<topicmeta>` is both a title wrapper and transparent. Wrapping is how\n * `<navtitle>` is found; transparency is how the `<shortdesc>` and `<linktext>`\n * beside it are read, since a map has no other prose and they live nowhere\n * else. `<booktitle>` is a wrapper only: a bookmap titles itself\n * `<booktitle><mainbooktitle>`, and the optional `<booklibrary>` beside it\n * names the series rather than the book, so only `<mainbooktitle>` is a title.\n */\nconst DITAMAP: XmlVocabulary = {\n  name: \"ditamap\",\n  label: \"DITA map\",\n  namespaces: [],\n  roots: [\"map\", \"bookmap\"],\n  sections: MAP_ENTRIES,\n  // `navtitle` sits in both buckets on purpose, because DITA spells it either\n  // way. The element form wins: `headingOf` asks `titleOf` first, so\n  // `@navtitle` is read only when the entry has no `<topicmeta><navtitle>`.\n  titles: [\"title\", \"navtitle\", \"mainbooktitle\"],\n  titleAttributes: [\"navtitle\"],\n  titleWrappers: [\"topicmeta\", \"booktitle\"],\n  untitledSections: true,\n  transparent: [\n    \"topicgroup\",\n    \"topicmeta\",\n    \"frontmatter\",\n    \"backmatter\",\n    \"booklists\",\n  ],\n  paragraphs: [\"shortdesc\", \"linktext\"],\n  code: [],\n  codeLangAttributes: [],\n  unorderedLists: [],\n  orderedLists: [],\n  listItems: [],\n\n  // Every navigation entry's `href`. `<keydef>` is not an entry - it binds a\n  // key to a resource and never appears in a table of contents - so its\n  // `href` is not a link, for the reason it is not a section.\n  links: [{ elements: MAP_ENTRIES, attribute: \"href\" }],\n  ditaHrefs: true,\n};\n\n/**\n * The vocabularies tried, in declaration order (which breaks scoring ties).\n * Exported so a bespoke schema is an array entry rather than a fork.\n */\nexport const XML_VOCABULARIES: readonly XmlVocabulary[] = [\n  DITA,\n  DOCBOOK,\n  DITAMAP,\n];\n\n/** Precomputed lookups for one vocabulary. */\ninterface Compiled {\n  vocab: XmlVocabulary;\n  sections: Set<string>;\n  titles: Set<string>;\n  titleWrappers: Set<string>;\n  transparent: Set<string>;\n  paragraphs: Set<string>;\n  code: Set<string>;\n  unordered: Set<string>;\n  ordered: Set<string>;\n  items: Set<string>;\n  tables: Set<string>;\n  tableRows: Set<string>;\n  tableCells: Set<string>;\n  tableHeaderWrappers: Set<string>;\n  tableHeaderRows: Set<string>;\n  admonitions: Set<string>;\n  images: Set<string>;\n  imageDataElements: Set<string>;\n  imageAltElements: Set<string>;\n  blockquotes: Set<string>;\n  definitionLists: Set<string>;\n  definitionItems: Set<string>;\n  definitionTerms: Set<string>;\n  definitionBodies: Set<string>;\n  links: { elements: Set<string>; attribute: string; idref: boolean }[];\n  /** Every name the vocabulary claims, for scoring. */\n  known: Set<string>;\n}\n\nconst lower = (names: readonly string[] = []): Set<string> =>\n  new Set(names.map((n) => n.toLowerCase()));\n\nfunction compile(vocab: XmlVocabulary): Compiled {\n  const c: Compiled = {\n    vocab,\n    sections: lower(vocab.sections),\n    titles: lower(vocab.titles),\n    titleWrappers: lower(vocab.titleWrappers),\n    transparent: lower(vocab.transparent),\n    paragraphs: lower(vocab.paragraphs),\n    code: lower(vocab.code),\n    unordered: lower(vocab.unorderedLists),\n    ordered: lower(vocab.orderedLists),\n    items: lower(vocab.listItems),\n    tables: lower(vocab.tables),\n    tableRows: lower(vocab.tableRows),\n    tableCells: lower(vocab.tableCells),\n    tableHeaderWrappers: lower(vocab.tableHeaderWrappers),\n    tableHeaderRows: lower(vocab.tableHeaderRows),\n    admonitions: lower(vocab.admonitions),\n    images: lower(vocab.images),\n    imageDataElements: lower(vocab.imageDataElements),\n    imageAltElements: lower(vocab.imageAltElements),\n    blockquotes: lower(vocab.blockquotes),\n    definitionLists: lower(vocab.definitionLists),\n    definitionItems: lower(vocab.definitionItems),\n    definitionTerms: lower(vocab.definitionTerms),\n    definitionBodies: lower(vocab.definitionBodies),\n    links: (vocab.links ?? []).map((l) => ({\n      elements: lower(l.elements),\n      attribute: l.attribute.toLowerCase(),\n      idref: l.idref ?? false,\n    })),\n    known: new Set(),\n  };\n  for (const set of [\n    c.sections,\n    c.titles,\n    c.titleWrappers,\n    c.transparent,\n    c.paragraphs,\n    c.code,\n    c.unordered,\n    c.ordered,\n    c.items,\n    c.tables,\n    c.tableRows,\n    c.tableCells,\n    c.tableHeaderWrappers,\n    c.tableHeaderRows,\n    c.admonitions,\n    c.images,\n    c.imageDataElements,\n    c.imageAltElements,\n    c.blockquotes,\n    c.definitionLists,\n    c.definitionItems,\n    c.definitionTerms,\n    c.definitionBodies,\n  ]) {\n    for (const name of set) c.known.add(name);\n  }\n  return c;\n}\n\nconst ELEMENT_NODE = 1;\n\n/** Lowercased local name, prefix and namespace discarded. */\nfunction localName(node: XmlNode): string {\n  const el = node as XmlElement;\n  const name = el.localName ?? node.nodeName.split(\":\").pop() ?? node.nodeName;\n  return name.toLowerCase();\n}\n\nfunction* elementChildren(el: XmlNode): Generator<XmlElement> {\n  for (let child = el.firstChild; child; child = child.nextSibling) {\n    if (child.nodeType === ELEMENT_NODE) yield child as XmlElement;\n  }\n}\n\n/** An attribute's value by lowercased local name, any prefix: `id` finds `xml:id`. */\nfunction attributeByLocalName(el: XmlElement, name: string): string | null {\n  for (let i = 0; i < el.attributes.length; i++) {\n    const attr = el.attributes.item(i);\n    if (attr && localName(attr) === name) return attr.value;\n  }\n  return null;\n}\n\n/** `file.dita#topic/element` -> `file.dita#element`; see `XmlVocabulary.ditaHrefs`. */\nfunction ditaTarget(href: string): string {\n  if (/^[a-z][a-z0-9+.-]*:/i.test(href)) return href;\n  const hash = href.indexOf(\"#\");\n  const slash = href.lastIndexOf(\"/\");\n  return hash === -1 || slash < hash ? href : href.slice(0, hash + 1) + href.slice(slash + 1);\n}\n\n/** First direct child matching one of `names`, or null. */\nfunction findDirectChild(el: XmlElement, names: Set<string>): XmlElement | null {\n  for (const child of elementChildren(el)) {\n    if (names.has(localName(child))) return child;\n  }\n  return null;\n}\n\n/** First descendant matching one of `names`, in document order, or null. */\nfunction findDescendant(el: XmlElement, names: Set<string>): XmlElement | null {\n  for (const child of elementChildren(el)) {\n    if (names.has(localName(child))) return child;\n    const nested = findDescendant(child, names);\n    if (nested) return nested;\n  }\n  return null;\n}\n\n/** Collapse XML's indentation whitespace into the single spaces a reader sees. */\nfunction flatten(text: string | null): string {\n  return (text ?? \"\").replace(/\\s+/g, \" \").trim();\n}\n\n/**\n * A code block's text, minus the layout the source added around it: the newline\n * that follows the start tag when the code is on its own line, and the\n * indentation before the end tag. Everything between is significant and is left\n * exactly as written, which is what mdast does with a fenced block's value.\n */\nfunction codeText(text: string | null): string {\n  return (text ?? \"\").replace(/^[^\\S\\n]*\\n/, \"\").replace(/\\n[^\\S\\n]*$/, \"\");\n}\n\n/** The six variants `AdmonitionNode` knows. A name outside this set names no variant. */\ntype Variant = Exclude<AdmonitionNode[\"variant\"], undefined>;\nconst ADMONITION_VARIANTS = new Set<Variant>([\n  \"note\",\n  \"tip\",\n  \"important\",\n  \"caution\",\n  \"warning\",\n  \"danger\",\n]);\n\nfunction isAdmonitionVariant(name: string): name is Variant {\n  return (ADMONITION_VARIANTS as ReadonlySet<string>).has(name);\n}\n\n/** Weights for `chooseVocabulary`, in the order they are meant to dominate. */\nconst NAMESPACE_MATCH = 1000;\nconst EXCLUSIVE_ELEMENT = 10;\nconst ROOT_NAME = 5;\nconst SHARED_ELEMENT = 1;\n\n/**\n * Score every vocabulary against the document and take the best.\n *\n * A namespace match on the root is decisive: a document that declares its\n * namespace has already said what it is. Failing that, what counts is elements\n * only one candidate claims - `<para>` and `<programlisting>` are DocBook's\n * alone, `<p>` and `<taskbody>` DITA's - because those are the ones whose\n * presence is an argument. Elements the candidates share (`<section>`,\n * `<title>`) are worth a point as a tiebreak and no more, since they are\n * evidence for everyone and therefore for no one.\n *\n * The root element name is weaker still, and deliberately weaker than a single\n * exclusive element. `<section>` is a DocBook root, so a bare `<section>` whose\n * prose is in `<p>` would otherwise be read as DocBook - and every `<p>` in it\n * would then be an unmapped element, silently skipped, leaving a titled section\n * with no content and no complaint. One `<p>` is better evidence about what a\n * file is than the name of its outermost tag.\n */\nfunction chooseVocabulary(\n  root: XmlElement,\n  compiled: Compiled[],\n): { best: Compiled; score: number } {\n  const counts = new Map<string, number>();\n  const tally = (node: XmlNode): void => {\n    for (const child of elementChildren(node)) {\n      const name = localName(child);\n      counts.set(name, (counts.get(name) ?? 0) + 1);\n      tally(child);\n    }\n  };\n  counts.set(localName(root), 1);\n  tally(root);\n\n  /** How many candidates claim each name; 1 means the name is decisive. */\n  const claims = new Map<string, number>();\n  for (const c of compiled) {\n    for (const name of c.known) claims.set(name, (claims.get(name) ?? 0) + 1);\n  }\n\n  const ns = (root.namespaceURI ?? \"\").toLowerCase();\n  const rootName = localName(root);\n\n  let best: Compiled | undefined;\n  let bestScore = -1;\n  for (const c of compiled) {\n    let score = 0;\n    if (ns && c.vocab.namespaces.some((u) => u.toLowerCase() === ns)) {\n      score += NAMESPACE_MATCH;\n    }\n    if (lower(c.vocab.roots).has(rootName)) score += ROOT_NAME;\n    for (const [name, n] of counts) {\n      if (!c.known.has(name)) continue;\n      score += n * (claims.get(name) === 1 ? EXCLUSIVE_ELEMENT : SHARED_ELEMENT);\n    }\n    if (score > bestScore) {\n      best = c;\n      bestScore = score;\n    }\n  }\n  if (!best) {\n    // The vocabulary list is the registry's own and is never empty; the loop\n    // assigns on its first pass, because every score beats the -1 it starts\n    // from. Saying so out loud beats returning a vocabulary nobody chose.\n    throw new LintError(\"No XML vocabularies are registered.\");\n  }\n  return { best, score: bestScore };\n}\n\n/**\n * Line/column -> offset, over the content as it was read.\n *\n * xmldom normalizes line endings before parsing, so its line and column are\n * against a LF-only copy. Line *numbers* survive that normalization unchanged\n * and CRLF only ever differs at a line terminator, so indexing the original\n * content's line starts with xmldom's (line, column) lands on the same\n * character - which is what keeps `offset` an index into the file the reporter\n * will quote, not into a normalized copy of it.\n */\nclass SourceMap {\n  private readonly lineStarts: number[] = [0];\n  /** Byte-order mark length, added back to every offset. */\n  private readonly bom: number;\n  private readonly body: string;\n  readonly docEnd: Point;\n\n  constructor(content: string) {\n    this.bom = content.charCodeAt(0) === 0xfeff ? 1 : 0;\n    this.body = content.slice(this.bom);\n    for (let i = 0; i < this.body.length; i++) {\n      const ch = this.body[i];\n      if (ch === \"\\n\") this.lineStarts.push(i + 1);\n      else if (ch === \"\\r\") {\n        if (this.body[i + 1] === \"\\n\") i++;\n        this.lineStarts.push(i + 1);\n      }\n    }\n    // `lineStarts` opens with 0 and is only ever appended to, so the fallback\n    // is unreachable - and it is the start of the one and only line anyway.\n    const lastStart = this.lineStarts.at(-1) ?? 0;\n    this.docEnd = {\n      line: this.lineStarts.length,\n      column: this.body.length - lastStart + 1,\n      offset: content.length,\n    };\n  }\n\n  /** The source text, for the parser to hand to xmldom without the BOM. */\n  get text(): string {\n    return this.body;\n  }\n\n  /** Start point of a node, or null when the locator recorded none. */\n  point(node: XmlNode | null | undefined): Point | null {\n    if (!node) return null;\n    const line = node.lineNumber;\n    const column = node.columnNumber;\n    if (typeof line !== \"number\" || typeof column !== \"number\") return null;\n    const start = this.lineStarts[line - 1];\n    if (start === undefined) return null;\n    const offset = Math.min(start + column - 1, this.body.length) + this.bom;\n    return { line, column, offset };\n  }\n\n  /** End of the line a point sits on, exclusive of its terminator. */\n  endOfLine(line: number): Point {\n    const start = this.lineStarts[line - 1];\n    if (start === undefined) return { ...this.docEnd };\n    const next = this.lineStarts[line];\n    const end = next === undefined ? this.body.length : next - 1;\n    return { line, column: end - start + 1, offset: end + this.bom };\n  }\n}\n\n/**\n * The exclusive end of an element: where the next node in document order\n * starts. Whitespace text nodes carry positions too, so for indented XML that\n * is the character immediately after `</tag>`.\n */\nfunction nextInDocumentOrder(el: XmlNode): XmlNode | null {\n  let node: XmlNode = el;\n  for (;;) {\n    if (node.nextSibling) return node.nextSibling;\n    const parent: XmlNode | null = node.parentNode;\n    if (!parent || parent.nodeType !== ELEMENT_NODE) return null;\n    node = parent;\n  }\n}\n\n/** Flattens one document into ordered fragments under one vocabulary. */\nclass Flattener {\n  readonly fragments: Fragment[] = [];\n\n  constructor(\n    private readonly c: Compiled,\n    private readonly map: SourceMap,\n  ) {}\n\n  private span(el: XmlNode): Position {\n    const start = this.map.point(el) ?? { ...this.map.docEnd };\n    const end =\n      this.map.point(nextInDocumentOrder(el)) ?? { ...this.map.docEnd };\n    // A malformed locator (or an element that ends the document) must never\n    // produce a backwards span; rules sort findings by offset.\n    return end.offset < start.offset ? { start, end: { ...start } } : { start, end };\n  }\n\n  /** The title element of a section container, direct or inside a wrapper. */\n  private titleOf(el: XmlElement): XmlElement | null {\n    for (const child of elementChildren(el)) {\n      if (this.c.titles.has(localName(child))) return child;\n    }\n    for (const child of elementChildren(el)) {\n      if (!this.c.titleWrappers.has(localName(child))) continue;\n      for (const inner of elementChildren(child)) {\n        if (this.c.titles.has(localName(inner))) return inner;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * The exclusive end of an element's start tag: where its first child begins,\n   * which for indented XML is the character right after `>`. A childless\n   * element has no such node and falls back to the end of the element, which\n   * for `<topicref keyref=\"a\"/>` is the same character anyway.\n   */\n  private startTagEnd(el: XmlElement): Point {\n    return this.map.point(el.firstChild) ?? this.span(el).end;\n  }\n\n  /**\n   * The heading a section container carries: its text, and where the heading\n   * ends. A `titles` element ends it at its own end. An attribute title and an\n   * absent one both end it at the end of the start tag, since neither has a\n   * position and anything further would swallow a nested section's heading.\n   * Null when the vocabulary says an untitled container is not a section.\n   */\n  private headingOf(el: XmlElement): { title: string; end: Point } | null {\n    const title = this.titleOf(el);\n    if (title) {\n      return { title: flatten(title.textContent), end: this.span(title).end };\n    }\n    for (const attr of this.c.vocab.titleAttributes ?? []) {\n      const value = el.getAttribute(attr);\n      if (value) return { title: flatten(value), end: this.startTagEnd(el) };\n    }\n    if (this.c.vocab.untitledSections) {\n      return { title: \"\", end: this.startTagEnd(el) };\n    }\n    return null;\n  }\n\n  /** Walk one element: section, wrapper, content, or skipped subtree. */\n  visit(el: XmlElement, level: number): void {\n    const name = localName(el);\n\n    if (this.c.sections.has(name)) {\n      const heading = this.headingOf(el);\n      if (!heading) {\n        // An untitled section container adds no heading, so it adds no level\n        // either; its content belongs to the section that encloses it.\n        this.walkChildren(el, level);\n        return;\n      }\n      const next = Math.min(level + 1, 6);\n      const id = attributeByLocalName(el, \"id\");\n      this.fragments.push({\n        type: \"heading\",\n        level: next,\n        title: heading.title,\n        ...(id ? { id } : {}),\n        // From the container's start tag through the end of its title: the\n        // container is the section, so a section that began at its `<title>`\n        // would leave its own opening tag outside itself and stop adjacent\n        // sections from tiling the document.\n        position: { start: this.span(el).start, end: heading.end },\n      });\n      this.walkChildren(el, next);\n      return;\n    }\n\n    if (this.c.transparent.has(name)) {\n      this.walkChildren(el, level);\n      return;\n    }\n\n    const node = this.content(el);\n    if (node) this.fragments.push({ type: \"content\", node });\n    // Unmapped: skipped with its subtree, like a Markdown blockquote.\n  }\n\n  /**\n   * Every link target under `el`, in document order. A walk of its own rather\n   * than part of `visit`, because `visit` skips unmapped subtrees and\n   * `<related-links>` is one of them.\n   */\n  links(el: XmlElement, out: DocumentTree[\"links\"] = []): DocumentTree[\"links\"] {\n    const name = localName(el);\n    for (const source of this.c.links) {\n      if (!source.elements.has(name)) continue;\n      const value = attributeByLocalName(el, source.attribute);\n      if (!value) continue;\n      const target = source.idref\n        ? `#${value}`\n        : this.c.vocab.ditaHrefs\n          ? ditaTarget(value)\n          : value;\n      out.push({ target, position: this.span(el) });\n    }\n    for (const child of elementChildren(el)) this.links(child, out);\n    return out;\n  }\n\n  private walkChildren(el: XmlElement, level: number): void {\n    for (const child of elementChildren(el)) this.visit(child, level);\n  }\n\n  /** One element as a content node, or null when it is not one. */\n  private content(el: XmlElement): ContentNode | null {\n    const name = localName(el);\n    const position = this.span(el);\n\n    if (this.c.paragraphs.has(name)) {\n      return { kind: \"paragraph\", position, text: flatten(el.textContent) };\n    }\n\n    if (this.c.code.has(name)) {\n      const lang = this.langOf(el);\n      return {\n        kind: \"codeBlock\",\n        position,\n        text: codeText(el.textContent),\n        ...(lang ? { language: lang } : {}),\n      };\n    }\n\n    const ordered = this.c.ordered.has(name);\n    if (ordered || this.c.unordered.has(name)) {\n      return {\n        kind: \"list\",\n        position,\n        text: flatten(el.textContent),\n        ordered,\n        items: [...elementChildren(el)]\n          .filter((item) => this.c.items.has(localName(item)))\n          .map((item): ListItemNode => ({\n            kind: \"listItem\",\n            position: this.span(item),\n            text: flatten(item.textContent),\n            children: this.blockContent(item),\n          })),\n      };\n    }\n\n    if (this.c.tables.has(name)) return this.tableNode(el, position);\n\n    if (this.c.admonitions.has(name)) {\n      const variant = this.admonitionVariantOf(el, name);\n      return {\n        kind: \"admonition\",\n        position,\n        text: flatten(el.textContent),\n        // A `@type`/name outside the six variants `AdmonitionNode` knows\n        // leaves `variant` unset, rather than inventing an equivalence.\n        ...(variant ? { variant } : {}),\n        children: this.blockContent(el),\n      };\n    }\n\n    if (this.c.images.has(name)) return this.imageNode(el, position);\n\n    if (this.c.blockquotes.has(name)) {\n      return {\n        kind: \"blockquote\",\n        position,\n        text: flatten(el.textContent),\n        children: this.blockContent(el),\n      };\n    }\n\n    if (this.c.definitionLists.has(name)) return this.definitionListNode(el, position);\n\n    return null;\n  }\n\n  /** A table's rows, from any of its CALS wrappers (`tgroup`, `tbody`, `thead`). */\n  private tableNode(el: XmlElement, position: Position): TableNode {\n    return {\n      kind: \"table\",\n      position,\n      text: flatten(el.textContent),\n      children: this.tableRowsOf(el, false),\n    };\n  }\n\n  /**\n   * Rows found anywhere under `el`, recursing through every wrapper - `tgroup`,\n   * `tbody`, `thead` and the like - regardless of whether it is known\n   * elsewhere. A table's internal grouping elements carry no content of their\n   * own; only the rows and cells inside them do.\n   *\n   * `inheritedHeader` tracks whether an enclosing `tableHeaderWrappers` element\n   * (CALS's `<thead>`) has been entered; `tableHeaderRows` (DITA's `<sthead>`)\n   * marks a row as a header on its own, without a wrapper.\n   */\n  private tableRowsOf(el: XmlElement, inheritedHeader: boolean): TableRowNode[] {\n    const rows: TableRowNode[] = [];\n    for (const child of elementChildren(el)) {\n      const name = localName(child);\n      if (this.c.tableRows.has(name)) {\n        rows.push(this.tableRow(child, inheritedHeader || this.c.tableHeaderRows.has(name)));\n        continue;\n      }\n      rows.push(\n        ...this.tableRowsOf(child, inheritedHeader || this.c.tableHeaderWrappers.has(name)),\n      );\n    }\n    return rows;\n  }\n\n  private tableRow(el: XmlElement, header: boolean): TableRowNode {\n    const cells: TableCellNode[] = [];\n    for (const child of elementChildren(el)) {\n      if (!this.c.tableCells.has(localName(child))) continue;\n      cells.push({\n        kind: \"tableCell\",\n        position: this.span(child),\n        text: flatten(child.textContent),\n        children: this.blockContent(child),\n      });\n    }\n    return {\n      kind: \"tableRow\",\n      position: this.span(el),\n      text: flatten(el.textContent),\n      header,\n      children: cells,\n    };\n  }\n\n  /**\n   * An admonition's variant: the value of `admonitionVariantAttribute` when the\n   * vocabulary names one (DITA's `<note type>`, defaulting to `note` when the\n   * attribute is absent - DITA's own default), or the element's own lowercased\n   * name otherwise (DocBook's `<warning>`, `<tip>`, and so on). Undefined when\n   * neither names one of the six variants `AdmonitionNode` knows.\n   */\n  private admonitionVariantOf(el: XmlElement, name: string): Variant | undefined {\n    const attr = this.c.vocab.admonitionVariantAttribute;\n    const raw = (attr ? el.getAttribute(attr) : \"\") || name;\n    const variant = raw.toLowerCase();\n    return isAdmonitionVariant(variant) ? variant : undefined;\n  }\n\n  /**\n   * An image, standing alone or wrapping one. `imageDataElements` names the\n   * element carrying the url - `el` itself for a self-contained image (DITA's\n   * `<image href>`), or a descendant found by name otherwise (DocBook's\n   * `<imagedata fileref>` inside a `<mediaobject>`/`<figure>`). The caption\n   * reuses `titleOf`, the same lookup a section uses for its heading - DITA's\n   * `<fig><title>` and DocBook's `<figure><title>` are both a direct `<title>`\n   * child.\n   */\n  private imageNode(el: XmlElement, position: Position): ImageNode {\n    const name = localName(el);\n    const dataEl = this.c.imageDataElements.has(name)\n      ? el\n      : findDescendant(el, this.c.imageDataElements);\n    const attr = this.c.vocab.imageUrlAttribute;\n    const url = (dataEl && attr ? dataEl.getAttribute(attr) : \"\") || \"\";\n    const altEl = dataEl ? findDirectChild(dataEl, this.c.imageAltElements) : null;\n    const title = this.titleOf(el);\n    return {\n      kind: \"image\",\n      position,\n      text: flatten(el.textContent),\n      url,\n      alt: altEl ? flatten(altEl.textContent) : \"\",\n      ...(title ? { title: flatten(title.textContent) } : {}),\n    };\n  }\n\n  private definitionListNode(el: XmlElement, position: Position): DefinitionListNode {\n    const children: DefinitionItemNode[] = [];\n    for (const child of elementChildren(el)) {\n      if (this.c.definitionItems.has(localName(child))) {\n        children.push(this.definitionItem(child));\n      }\n    }\n    return {\n      kind: \"definitionList\",\n      position,\n      text: flatten(el.textContent),\n      children,\n    };\n  }\n\n  /** One entry, pairing its term(s) - joined with \", \" when more than one - with its definition body. */\n  private definitionItem(el: XmlElement): DefinitionItemNode {\n    const terms: string[] = [];\n    let body: XmlElement | null = null;\n    for (const child of elementChildren(el)) {\n      const name = localName(child);\n      if (this.c.definitionTerms.has(name)) {\n        terms.push(flatten(child.textContent));\n      } else if (body === null && this.c.definitionBodies.has(name)) {\n        body = child;\n      }\n    }\n    return {\n      kind: \"definitionItem\",\n      position: this.span(el),\n      text: flatten(el.textContent),\n      term: terms.join(\", \"),\n      definition: body ? this.blockContent(body) : [],\n    };\n  }\n\n  /**\n   * One container's content, with its own loose prose kept as a paragraph.\n   * Shared by list items, table cells, admonitions, block quotes, and a\n   * definition's body - anywhere the content model asks for a container's\n   * `children` rather than a single block.\n   *\n   * mdast puts a list item's principal text in a `paragraph` child regardless\n   * of markup, and `lists: {items: {paragraphs: {min: 1}}}` has to count the\n   * same thing in every format. So the loose text is gathered into one, in the\n   * position it occupies among the container's blocks.\n   *\n   * Gathering it rather than checking whether the container has any children is\n   * what makes the two cases agree. `<li>bare text</li>` was already\n   * reconciled; `<li>Parent<ul>…</ul></li>` was not, because the nested list is\n   * a child, so the item looked accounted for and `Parent` became prose\n   * nothing counted - while its Markdown, HTML, AsciiDoc, and reST twins all\n   * counted one. This is the same fix `html.ts` carries, and the two should\n   * stay in step.\n   *\n   * Unmapped elements contribute their text rather than being skipped, which is\n   * what the old whole-item `textContent` did: inside a container they are\n   * inline markup - DITA's `<b>`, `<xref>` - not structure worth dropping.\n   */\n  private blockContent(container: XmlElement): ContentNode[] {\n    const out: ContentNode[] = [];\n    let text = \"\";\n\n    const flush = (): void => {\n      const value = flatten(text);\n      text = \"\";\n      if (value.length === 0) return;\n      out.push({ kind: \"paragraph\", position: this.span(container), text: value });\n    };\n\n    for (let child = container.firstChild; child; child = child.nextSibling) {\n      if (child.nodeType !== ELEMENT_NODE) {\n        text += child.nodeValue ?? \"\";\n        continue;\n      }\n\n      const el = child as XmlElement;\n      const nested = this.c.transparent.has(localName(el))\n        ? this.contentChildren(el)\n        : [this.content(el)].filter((n): n is ContentNode => n !== null);\n\n      if (nested.length > 0) {\n        flush();\n        out.push(...nested);\n        continue;\n      }\n      text += el.textContent ?? \"\";\n    }\n\n    flush();\n    return out;\n  }\n\n  private contentChildren(el: XmlElement): ContentNode[] {\n    const out: ContentNode[] = [];\n    for (const child of elementChildren(el)) {\n      if (this.c.transparent.has(localName(child))) {\n        out.push(...this.contentChildren(child));\n        continue;\n      }\n      const node = this.content(child);\n      if (node) out.push(node);\n    }\n    return out;\n  }\n\n  /** A code block's language, with a `language-` prefix stripped. */\n  private langOf(el: XmlElement): string | undefined {\n    for (const attr of this.c.vocab.codeLangAttributes) {\n      const value = el.getAttribute(attr);\n      if (value) return value.replace(/^language-/, \"\");\n    }\n    return undefined;\n  }\n}\n\n/**\n * Parse, refusing anything xmldom had to guess at.\n *\n * xmldom is lenient: it throws only on a `fatalError`, and reports `error` and\n * `warning` through the handler while carrying on with a repaired tree. The\n * line between them is drawn at `error` because in XML the element tree *is*\n * the structure - there is no second signal like a `##` to fall back on - so\n * linting a tree xmldom guessed at reports on a document nobody wrote. A\n * mismatched end tag or a stray `<` puts every following element at the wrong\n * depth, and the findings would be confident nonsense. `warning` is left alone:\n * xmldom recovers from an unquoted attribute value without changing the element\n * tree at all, and attributes here are metadata, not structure.\n *\n * This is also the line docmeta's XML extractor draws, so a file manni lint\n * lints is exactly a file docmeta will read metadata from.\n */\nfunction parseDocument(source: string, filePath: string): XmlElement {\n  const problems: string[] = [];\n  let doc;\n  try {\n    doc = new DOMParser({\n      onError: (level, message) => {\n        if (level === \"error\" || level === \"fatalError\") problems.push(message);\n      },\n    }).parseFromString(source, \"text/xml\");\n  } catch (err) {\n    const detail = problems[0] ?? errorMessage(err);\n    throw new LintError(\n      `${filePath}: could not parse as XML: ${firstLine(detail)}`,\n    );\n  }\n\n  const [firstProblem] = problems;\n  if (firstProblem !== undefined) {\n    throw new LintError(\n      `${filePath}: could not parse as XML: ${firstLine(firstProblem)}`,\n    );\n  }\n\n  const root = doc.documentElement;\n  if (!root) {\n    throw new LintError(`${filePath}: could not parse as XML: no root element`);\n  }\n  return root;\n}\n\n/** xmldom appends the offending source to some messages; one line is enough. */\nfunction firstLine(message: string): string {\n  const [first] = message.split(\"\\n\");\n  return (first ?? message).trim();\n}\n\n/**\n * Metadata for routing, from docmeta.\n *\n * **Not `extractFrontmatter`.** `src/parsers/markdown.ts` calls it because for\n * Markdown it is the whole story, but in docmeta that function is specifically\n * the *fenced* `---` block reader (\"core front matter extraction shared by the\n * markdown, mdx, adoc, rst formats\"). An XML file has no fenced block, so\n * `extractFrontmatter(content, \"xml\")` returns `{ data: {}, present: false }`\n * for every XML document ever written, and `type:` routing for `.xml` would\n * silently never fire. docmeta's *registry* is the right door: its XML\n * extractor reads the root element's attributes (`<task type=\"how-to\">` ->\n * `{ type: \"how-to\" }`, minus `xmlns*`, with values parsed as YAML scalars)\n * plus the text of simple direct children as dotted keys (`task.title`). That\n * is a real `type`, so an `.xml` page does route.\n *\n * The HTML parser merges a fenced block with its native reading, fenced\n * winning a collision. This one does not, because an `.xml` file cannot carry a\n * fenced block and still be XML: a leading `---` is character data outside the\n * root element, which xmldom reports as an error and `parseDocument` refuses\n * before metadata is ever read. (HTML has no such rule - a comment or stray\n * text before `<html>` parses fine - which is why the merge is right there and\n * would be unreachable code here.)\n *\n * It throws on malformed XML, the same line `parseDocument` draws, but it is\n * called after the parse so in practice it cannot be the one to complain.\n */\nfunction readMetadata(\n  content: string,\n  filePath: string,\n): Record<string, unknown> | null {\n  const extractor = extractorForExtension(\".xml\");\n  if (!extractor) return null;\n  try {\n    const meta = extractor.extract(content, filePath);\n    return meta.present ? meta.data : null;\n  } catch (err) {\n    throw new LintError(\n      `${filePath}: could not read XML metadata: ${firstLine(errorMessage(err))}`,\n    );\n  }\n}\n\n/**\n * Note on the frontmatter-title rule.\n *\n * `withFrontmatterTitle` in the Markdown parser synthesizes an H1 from\n * `title:` when the body has none, because Docusaurus and Hugo render the page\n * title from frontmatter and their pages legitimately start at `##`. That\n * reasoning does not carry to XML and the rule is deliberately not applied\n * here. An XML document's title is an element - `<title>` - in the body, in\n * document order, exactly where the section fold already looks for it; there is\n * no publishing convention that moves it out. And what docmeta calls this\n * document's \"frontmatter\" is the *root element's own attributes*, so a `title`\n * attribute would be a second title on the very element that already carries\n * the real one: synthesizing a section from it would nest the document's actual\n * title underneath a duplicate of itself. A document with no title element at\n * all is not a page missing its H1, it is a document with no structure to lint,\n * and `parseXml` says so.\n */\n\n/**\n * Parse XML into the generic tree.\n *\n * @param vocabularies Overrides the built-ins; the extension point for a\n *                     bespoke schema until there is a config surface for it.\n */\nexport function parseXml(\n  content: string,\n  filePath: string,\n  vocabularies: readonly XmlVocabulary[] = XML_VOCABULARIES,\n): DocumentTree {\n  const map = new SourceMap(content);\n  const root = parseDocument(map.text, filePath);\n\n  const compiled = vocabularies.map(compile);\n  if (compiled.length === 0) {\n    throw new LintError(`${filePath}: no XML vocabularies are configured.`);\n  }\n\n  const { best, score } = chooseVocabulary(root, compiled);\n  const names = compiled.map((c) => c.vocab.label).join(\", \");\n\n  // Nothing recognized is an error rather than an empty tree. An empty tree\n  // would lint as a document that is missing every section its template asks\n  // for - a cascade of findings that says nothing about the page and points\n  // nowhere useful. The gap is in the mapping, and this is where to say so.\n  if (score <= 0) {\n    throw new LintError(\n      `${filePath}: no known XML vocabulary matched <${localName(root)}>. ` +\n        `manni lint understands ${names}; add an entry to XML_VOCABULARIES ` +\n        `in src/parsers/xml.ts to describe another schema.`,\n    );\n  }\n\n  const flattener = new Flattener(best, map);\n  flattener.visit(root, 0);\n  const fragments = flattener.fragments;\n\n  if (!fragments.some((b) => b.type === \"heading\")) {\n    throw new LintError(\n      `${filePath}: read as ${best.vocab.label}, but no titled section was found. ` +\n        `A ${best.vocab.label} section is one of <${best.vocab.sections.join(\">, <\")}> ` +\n        `carrying a <${best.vocab.titles.join(\">/<\")}>; without one the document has ` +\n        `no structure to check.`,\n    );\n  }\n\n  const frontmatter = readMetadata(content, filePath);\n\n  return {\n    format: \"xml\",\n    filePath,\n    frontmatter,\n    // The metadata block is the root element's start tag: from its `<` to the\n    // character after its `>`, which is where its first child begins.\n    frontmatterPosition: frontmatter\n      ? {\n          start: map.point(root) ?? { ...map.docEnd },\n          end:\n            map.point(root.firstChild) ??\n            map.endOfLine(map.point(root)?.line ?? 1),\n        }\n      : null,\n    sections: sectionize(fragments, map.docEnd),\n    links: flattener.links(root),\n  };\n}\n\nexport const xmlParser: DocumentParser = {\n  name: \"xml\",\n  label: \"XML\",\n  kinds: [\n    \"paragraph\",\n    \"codeBlock\",\n    \"list\",\n    \"listItem\",\n    \"table\",\n    \"tableRow\",\n    \"tableCell\",\n    \"admonition\",\n    \"image\",\n    \"blockquote\",\n    \"definitionList\",\n    \"definitionItem\",\n  ],\n  /**\n   * `.dita` and `.ditamap` as well as `.xml`, because that is what a DITA topic\n   * and a DITA map are actually called on disk and docmeta registers both — a\n   * docset whose topics this parser was written for would otherwise be walked\n   * past entirely.\n   *\n   * A map carries no prose, but it is a tree of navigation entries, and that is\n   * the same thing a section tree is: `<topicref>` nesting is section nesting.\n   * A docset of maps with no map template matches nothing and is skipped as\n   * `no-template`, exactly as an untyped Markdown page is.\n   */\n  extensions: [\".xml\", \".dita\", \".ditamap\"],\n  /**\n   * A directory walk collects `.dita` and `.ditamap` but not `.xml`. Both of\n   * those are documentation by definition; `.xml` is a container a repository\n   * uses for build files, sitemaps, and project metadata, none of which match a\n   * documentation vocabulary. Sweeping those in made one `pom.xml` fail an\n   * otherwise clean tree. Naming an `.xml` file explicitly still parses it.\n   */\n  walkExtensions: [\".dita\", \".ditamap\"],\n  parse: (content, filePath) => parseXml(content, filePath),\n};\n","/**\n * AsciiDoc parser.\n *\n * Asciidoctor already hands back a nested block tree, so the work here is the\n * same as `mdast.ts`'s: flatten it into ordered `Fragment`s and let `sectionize`\n * rebuild the nesting. `table`, `admonition`, `image`, `quote` and `dlist`\n * contexts map onto the shared content model (proposal 0065); a context that\n * still has no kind there - `sidebar`, a thematic break, `verse`, `example`,\n * and so on - is skipped whole rather than mapped to a nearest neighbour, for\n * the reason the Markdown parser skips a construct it does not model: a\n * sidebar is not a paragraph, and counting one as such would make\n * `paragraphs: {max: 3}` fail a document a reader would say satisfies it.\n *\n * Two things about Asciidoctor shape this file:\n *\n *  - **Positions come from line numbers, and only line numbers.** `load()` is\n *    given `sourcemap: true` so every block carries `getLineNumber()`; nothing\n *    reports where a block *ends*, and there are no columns or offsets at all.\n *    Those are derived from a line-start index built once over the content.\n *    The pre-rewrite `parsers/asciidoc.js` instead reconstructed a `=== Title`\n *    marker and ran `content.indexOf()` on it, which mismatches on attribute\n *    lines, duplicate titles, and any non-canonical heading syntax.\n *  - **Metadata arrives two ways.** AsciiDoc's own is the document header -\n *    `= Title` plus `:key: value` entries - and that is how a real page says\n *    `:type: how-to`. Some toolchains prepend a Markdown-style `---` fence\n *    instead, which is a thematic break to Asciidoctor, so `skip-front-matter`\n *    consumes it rather than letting it parse as body content; line numbering\n *    is unaffected, so the body still indexes the original file. Both readings\n *    run, and the results merge.\n */\nimport { createRequire } from \"node:module\";\nimport type asciidoctor from \"@asciidoctor/core\";\nimport { extractFrontmatter, extractorForExtension } from \"../../meta/index.js\";\nimport type {\n  AdmonitionNode,\n  ContentNode,\n  DefinitionItemNode,\n  DocumentParser,\n  DocumentTree,\n  ListItemNode,\n  Point,\n  Position,\n  TableCellNode,\n  TableRowNode,\n} from \"../types.js\";\nimport { LintError } from \"../types.js\";\nimport { errorMessage } from \"../../shared/errors.js\";\nimport type { Fragment } from \"./sectionize.js\";\nimport { sectionize } from \"./sectionize.js\";\nimport {\n  fencedPosition,\n  withMetadataTitle as withFrontmatterTitle,\n  withoutFence,\n} from \"./metadata.js\";\n\n/**\n * `@asciidoctor/core`, not the `asciidoctor` meta-package.\n *\n * Only the parser is wanted here. The meta-package adds `@asciidoctor/cli`\n * (and yargs) plus the ejs, nunjucks and pug template engines, none of which\n * this file can reach - 63 lockfile entries that installed with manni so that\n * one `.adoc` file could be read. The core is the same Asciidoctor at the same\n * version, published as a real ESM module, so the default import is the\n * factory with no CJS interop to undo.\n *\n * Stay on 3.x. `@asciidoctor/core@4` is a rewrite whose `load()` returns a\n * promise, and `DocumentParser.parse` is synchronous for every format. Moving\n * to it would also drop `@asciidoctor/opal-runtime` and with it the deprecated\n * `glob`/`inflight` pair, which 3.x still brings in on its own.\n *\n * Required on the first `.adoc` file rather than imported: Asciidoctor and the\n * Opal runtime cost every `manni lint` and `manni check` run a tenth of a\n * second, and most never read AsciiDoc. `parse` is synchronous, so this is\n * the package's own CommonJS build through `require`, not `await import()`.\n */\nlet processor: ReturnType<typeof asciidoctor> | undefined;\n\nfunction getProcessor(): ReturnType<typeof asciidoctor> {\n  if (processor === undefined) {\n    const factory = createRequire(import.meta.url)(\"@asciidoctor/core\") as typeof asciidoctor;\n    processor = factory();\n  }\n  return processor;\n}\n\n/**\n * Minimal structural view of an Asciidoctor node.\n *\n * `getBlocks()` is typed `any[]` upstream and is not even homogeneous - a\n * description list returns `[[terms], description]` tuples rather than nodes -\n * so everything is read back through `asNode`, which checks for the one method\n * every real block has.\n */\ninterface AdocNode {\n  getContext(): string;\n  getId?(): string | undefined;\n  getLineNumber?(): number | undefined;\n  getBlocks?(): unknown[];\n  getLevel?(): number;\n  getTitle?(): string | undefined;\n  getSource?(): string;\n  getContent?(): string;\n  getAttribute?(name: string): unknown;\n  getItems?(): unknown[];\n  getRows?(): AdocRows;\n}\n\n/** A list item. Its principal text is not among its blocks. */\ninterface AdocItem {\n  getLineNumber?(): number | undefined;\n  getText(): string;\n  getBlocks(): unknown[];\n}\n\n/** A table cell, from either a head, body or foot row. */\ninterface AdocCell {\n  getLineNumber?(): number | undefined;\n  getText(): string;\n}\n\n/** `Table#getRows()`'s own shape: the three row groups, each an array of cell rows. */\ninterface AdocRows {\n  getHead(): AdocCell[][];\n  getBody(): AdocCell[][];\n  getFoot(): AdocCell[][];\n}\n\ninterface AdocDocument extends AdocNode {\n  hasHeader(): boolean;\n  getHeader(): unknown;\n}\n\nfunction asNode(value: unknown): AdocNode | null {\n  const node = value as AdocNode | null;\n  return node && typeof node.getContext === \"function\" ? node : null;\n}\n\nfunction asItem(value: unknown): AdocItem | null {\n  const item = value as AdocItem | null;\n  return item && typeof item.getText === \"function\" ? item : null;\n}\n\n/** Blocks of a container, filtered down to the ones that really are nodes. */\nfunction childrenOf(node: AdocNode): AdocNode[] {\n  const blocks = node.getBlocks?.() ?? [];\n  return blocks.map(asNode).filter((n): n is AdocNode => n !== null);\n}\n\nfunction lineOf(node: { getLineNumber?(): number | undefined }): number {\n  return node.getLineNumber?.() ?? 1;\n}\n\n// ---------------------------------------------------------------------------\n// Positions\n// ---------------------------------------------------------------------------\n\n/**\n * Line numbers to `Point`s.\n *\n * The offsets a reporter prints, and the offsets `validateDocument` sorts\n * findings by, do not exist anywhere in Asciidoctor's output. They are all\n * recovered from one pass over the content that records where each line\n * starts, so a lookup is an array index rather than a search through the text.\n */\ninterface LineIndex {\n  /** Column 1 of `line`. */\n  start(line: number): Point;\n  /** Just past the last character of `line`, before its line break. */\n  endOfLine(line: number): Point;\n  /** End of the document, for closing the final sections. */\n  documentEnd(): Point;\n}\n\nfunction lineIndex(content: string): LineIndex {\n  const starts: number[] = [0];\n  for (let i = 0; i < content.length; i++) {\n    if (content[i] === \"\\n\") starts.push(i + 1);\n  }\n\n  /** Line numbers come from a third-party tree; keep them inside the file. */\n  const clamp = (line: number): number =>\n    Math.min(Math.max(Math.trunc(line) || 1, 1), starts.length);\n\n  /**\n   * Offset of column 1 of a clamped line. `starts` opens with 0 and `clamp`\n   * keeps the index inside it, so the fallback is unreachable - and 0 is where\n   * a line clamped to 1 starts anyway.\n   */\n  const startOf = (n: number): number => starts[n - 1] ?? 0;\n\n  return {\n    start(line) {\n      const n = clamp(line);\n      return { line: n, column: 1, offset: startOf(n) };\n    },\n    endOfLine(line) {\n      const n = clamp(line);\n      const from = startOf(n);\n      const next = starts[n];\n      let stop = next === undefined ? content.length : next - 1;\n      if (stop > from && content[stop - 1] === \"\\r\") stop -= 1;\n      return { line: n, column: stop - from + 1, offset: stop };\n    },\n    documentEnd() {\n      return {\n        line: starts.length,\n        column: content.length - startOf(starts.length) + 1,\n        offset: content.length,\n      };\n    },\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Inline text\n// ---------------------------------------------------------------------------\n\nconst NAMED_ENTITIES: Record<string, string> = {\n  amp: \"&\",\n  lt: \"<\",\n  gt: \">\",\n  quot: '\"',\n  apos: \"'\",\n  nbsp: \" \",\n};\n\n/**\n * Asciidoctor's plain-text rendering, flattened.\n *\n * `getTitle()`, `getContent()`, and `ListItem#getText()` all return inline\n * *HTML*: a heading written with backtick-quoted `lint` comes back as\n * `Use the <code>lint</code> command`. Stripping the tags and decoding the\n * entities is this format's equivalent of `mdast-util-to-string`, and it is\n * what makes `heading: {const: \"Overview\"}` mean the same thing here as it does\n * in Markdown.\n *\n * The one place it is lossy is Asciidoctor's `replacements` substitution, which\n * fires before we ever see the string: a straight apostrophe arrives as\n * `&#8217;` and flattens to a curly one, where Markdown would leave it alone.\n * That is Asciidoctor's conversion, not ours, and it exposes no way to ask for\n * a title with quotes substituted but replacements skipped.\n */\nfunction flattenInline(html: string | undefined): string {\n  if (!html) return \"\";\n  return decodeEntities(html.replace(/<[^>]*>/g, \"\"));\n}\n\nfunction decodeEntities(text: string): string {\n  return text\n    .replace(/&#(\\d+);/g, (_, dec: string) => String.fromCodePoint(Number(dec)))\n    .replace(/&#x([0-9a-f]+);/gi, (_, hex: string) =>\n      String.fromCodePoint(Number.parseInt(hex, 16)),\n    )\n    .replace(\n      /&([a-z]+);/gi,\n      (whole: string, name: string) => NAMED_ENTITIES[name.toLowerCase()] ?? whole,\n    );\n}\n\n/** A link target found in converted inline HTML, with the line of the block it came from. */\ninterface Harvested {\n  target: string;\n  line: number;\n}\n\n/**\n * Link targets harvested by `inline` during the current `parse`. Module state\n * rather than a parameter threaded through every draft function, which is\n * safe only because `parse` is synchronous and never re-entered: it resets\n * this on the way in and reads it on the way out.\n */\nlet harvested: Harvested[] = [];\n\nconst ANCHOR = /<a\\s([^>]*)>/gi;\nconst HREF = /(?:^|\\s)href=\"([^\"]*)\"/;\nconst CLASS = /(?:^|\\s)class=\"([^\"]*)\"/;\n\n/**\n * `flattenInline`, after taking the `href` of every anchor in the HTML.\n *\n * The converted HTML is the only place Asciidoctor says where a link goes, and\n * flattening is where that is lost, so the targets are taken here or nowhere.\n * Two kinds of anchor are not links: `include`, which is how secure mode\n * renders an `include::` it refused to read, and `footnote`, which points at\n * the footnote list a full HTML conversion would append, not at any section.\n */\nfunction inline(html: string | undefined, line: number): string {\n  for (const match of (html ?? \"\").matchAll(ANCHOR)) {\n    const attrs = match[1] ?? \"\";\n    const href = HREF.exec(attrs)?.[1];\n    if (href === undefined) continue;\n    const classes = (CLASS.exec(attrs)?.[1] ?? \"\").split(/\\s+/);\n    if (classes.includes(\"include\") || classes.includes(\"footnote\")) continue;\n    harvested.push({ target: decodeEntities(href), line });\n  }\n  return flattenInline(html);\n}\n\n// ---------------------------------------------------------------------------\n// Asciidoctor's tree -> drafts\n// ---------------------------------------------------------------------------\n\n/**\n * A block with a start line but no span yet.\n *\n * The walk cannot assign spans as it goes, because a block's end is the start\n * of whatever comes after it - which is only known once the whole document is\n * flat. So the walk emits drafts and `place` closes them.\n */\ntype Draft =\n  | { kind: \"heading\"; line: number; level: number; title: string; id?: string }\n  | { kind: \"paragraph\"; line: number; text: string }\n  | { kind: \"codeBlock\"; line: number; text: string; language?: string }\n  | { kind: \"list\"; line: number; ordered: boolean; items: DraftItem[] }\n  | { kind: \"table\"; line: number; rows: DraftRow[] }\n  | {\n      kind: \"admonition\";\n      line: number;\n      variant: AdmonitionNode[\"variant\"];\n      children: Draft[];\n    }\n  | { kind: \"image\"; line: number; url: string; alt: string; title?: string }\n  | { kind: \"blockquote\"; line: number; children: Draft[] }\n  | { kind: \"definitionList\"; line: number; items: DraftDefinitionItem[] };\n\n/** Every draft but a heading, which is the only kind that is not content. */\ntype ContentDraft = Exclude<Draft, { kind: \"heading\" }>;\n\ninterface DraftItem {\n  line: number;\n  text: string;\n  children: Draft[];\n}\n\ninterface DraftCell {\n  line: number;\n  text: string;\n}\n\ninterface DraftRow {\n  line: number;\n  header: boolean;\n  cells: DraftCell[];\n}\n\ninterface DraftDefinitionItem {\n  line: number;\n  term: string;\n  children: Draft[];\n}\n\nfunction stringAttribute(node: AdocNode, name: string): string | undefined {\n  const value = node.getAttribute?.(name);\n  return typeof value === \"string\" && value.length > 0 ? value : undefined;\n}\n\nfunction draftList(node: AdocNode, ordered: boolean): Draft {\n  const items: DraftItem[] = [];\n\n  for (const raw of node.getItems?.() ?? []) {\n    const item = asItem(raw);\n    if (!item) continue;\n\n    const line = lineOf(item);\n    const text = inline(item.getText(), line);\n    const children: Draft[] = [];\n\n    // An item's principal text is not one of its blocks, but mdast puts it in\n    // a paragraph child - so `lists: {items: {paragraphs: {min: 1}}}` counts\n    // the same thing in both formats only if we put it there too.\n    if (text.length > 0) children.push({ kind: \"paragraph\", line, text });\n    collect(\n      item.getBlocks().map(asNode).filter((n): n is AdocNode => n !== null),\n      children,\n    );\n\n    items.push({ line, text, children });\n  }\n\n  return { kind: \"list\", line: lineOf(node), ordered, items };\n}\n\n/**\n * A block's own children, recursively drafted - the same walk `collect` does\n * at document level, reused for a container whose content is content in its\n * own right (an admonition, a blockquote) rather than a section's directly.\n */\nfunction draftChildren(node: AdocNode): Draft[] {\n  const children: Draft[] = [];\n  collect(childrenOf(node), children);\n  return children;\n}\n\n/**\n * AsciiDoc's own admonition vocabulary is closed - `NOTE`, `TIP`, `IMPORTANT`,\n * `CAUTION`, `WARNING`, and nothing else; there is no `DANGER`. So unlike a\n * format with free-form admonition naming, every real admonition here maps\n * cleanly onto the shared vocabulary, and only a node whose `name` attribute\n * is missing or unrecognised - which real AsciiDoc input cannot produce -\n * fails to.\n */\nconst ADMONITION_VARIANTS = new Set<string>([\n  \"note\",\n  \"tip\",\n  \"important\",\n  \"caution\",\n  \"warning\",\n]);\n\nfunction admonitionVariant(node: AdocNode): AdmonitionNode[\"variant\"] | null {\n  const name = stringAttribute(node, \"name\")?.toLowerCase();\n  return name && ADMONITION_VARIANTS.has(name)\n    ? (name as AdmonitionNode[\"variant\"])\n    : null;\n}\n\n/**\n * An admonition's content, whichever of the two forms it took.\n *\n * A compound admonition (`[TIP]\\n====\\n...\\n====`) has real blocks, and\n * `getContent()` on it returns their *rendered* concatenation - using both\n * would double the content. A simple one (`NOTE: text`) has no blocks at all;\n * its only content is `getContent()`, exactly as a paragraph's is.\n */\nfunction draftAdmonition(node: AdocNode, variant: AdmonitionNode[\"variant\"]): Draft {\n  const children = draftChildren(node);\n  if (children.length === 0) {\n    const text = inline(node.getContent?.(), lineOf(node));\n    if (text.length > 0) children.push({ kind: \"paragraph\", line: lineOf(node), text });\n  }\n  return { kind: \"admonition\", line: lineOf(node), variant, children };\n}\n\n/** A quote block's content, by the same two-form rule as an admonition's. */\nfunction draftBlockquote(node: AdocNode): Draft {\n  const children = draftChildren(node);\n  if (children.length === 0) {\n    const text = inline(node.getContent?.(), lineOf(node));\n    if (text.length > 0) children.push({ kind: \"paragraph\", line: lineOf(node), text });\n  }\n  return { kind: \"blockquote\", line: lineOf(node), children };\n}\n\nfunction draftTable(node: AdocNode): Draft {\n  const rows = node.getRows?.();\n  const toRow = (header: boolean) => (cells: AdocCell[]): DraftRow => ({\n    line: cells[0]?.getLineNumber?.() ?? lineOf(node),\n    header,\n    cells: cells.map((cell) => {\n      const line = cell.getLineNumber?.() ?? lineOf(node);\n      return { line, text: inline(cell.getText(), line) };\n    }),\n  });\n  return {\n    kind: \"table\",\n    line: lineOf(node),\n    rows: [\n      ...(rows?.getHead().map(toRow(true)) ?? []),\n      ...(rows?.getBody().map(toRow(false)) ?? []),\n      ...(rows?.getFoot().map(toRow(false)) ?? []),\n    ],\n  };\n}\n\n/**\n * A description list's items.\n *\n * `getItems()` does not hand back `ListItem`s for a `dlist` the way it does\n * for a `ulist`/`olist`; each entry is a `[terms, description]` tuple, and a\n * missing description arrives as AsciiDoctor's own `nil`, which is a real\n * object in the JS bridge rather than `null` or `undefined` - `asItem` rejects\n * it the same way it rejects anything else with no `getText`.\n */\nfunction draftDefinitionList(node: AdocNode): Draft {\n  const items: DraftDefinitionItem[] = [];\n\n  for (const entry of node.getItems?.() ?? []) {\n    if (!Array.isArray(entry)) continue;\n    const [rawTerms, rawDesc] = entry as [unknown, unknown];\n    const terms = (Array.isArray(rawTerms) ? rawTerms : [])\n      .map(asItem)\n      .filter((t): t is AdocItem => t !== null);\n    const first = terms[0];\n    if (!first) continue;\n\n    const children: Draft[] = [];\n    const desc = asItem(rawDesc);\n    if (desc) {\n      const text = inline(desc.getText(), lineOf(desc));\n      if (text.length > 0) children.push({ kind: \"paragraph\", line: lineOf(desc), text });\n      collect(\n        desc.getBlocks().map(asNode).filter((n): n is AdocNode => n !== null),\n        children,\n      );\n    }\n\n    items.push({\n      line: lineOf(first),\n      term: terms.map((t) => inline(t.getText(), lineOf(t))).join(\", \"),\n      children,\n    });\n  }\n\n  return { kind: \"definitionList\", line: lineOf(node), items };\n}\n\n/** One block, or null when the content model has no kind for it. */\nfunction draftOf(node: AdocNode): Draft | null {\n  switch (node.getContext()) {\n    case \"paragraph\":\n      return {\n        kind: \"paragraph\",\n        line: lineOf(node),\n        text: inline(node.getContent?.(), lineOf(node)),\n      };\n    case \"listing\":\n    case \"literal\": {\n      const lang = stringAttribute(node, \"language\");\n      return {\n        kind: \"codeBlock\",\n        line: lineOf(node),\n        // Raw, not converted: a code block's text is its source, and\n        // `getContent()` would escape every `<` in it.\n        text: node.getSource?.() ?? \"\",\n        ...(lang ? { language: lang } : {}),\n      };\n    }\n    case \"ulist\":\n      return draftList(node, false);\n    case \"olist\":\n      return draftList(node, true);\n    case \"table\":\n      return draftTable(node);\n    case \"admonition\": {\n      const variant = admonitionVariant(node);\n      return variant ? draftAdmonition(node, variant) : null;\n    }\n    case \"image\": {\n      const url = stringAttribute(node, \"target\");\n      if (!url) return null;\n      const title = inline(node.getTitle?.(), lineOf(node));\n      return {\n        kind: \"image\",\n        line: lineOf(node),\n        url,\n        alt: stringAttribute(node, \"alt\") ?? \"\",\n        ...(title.length > 0 ? { title } : {}),\n      };\n    }\n    case \"quote\":\n      return draftBlockquote(node);\n    case \"dlist\":\n      return draftDefinitionList(node);\n    default:\n      // Sidebars, thematic breaks, verses, and the rest the content model\n      // does not name. Skipped whole: their children are not the section's\n      // content either.\n      return null;\n  }\n}\n\n/**\n * Flatten a container's children into drafts, in document order.\n *\n * `section` contributes a heading and then its own children as siblings, which\n * is what turns Asciidoctor's nesting back into the flat stream `sectionize`\n * folds.\n *\n * Two containers are transparent - recursed through, contributing nothing of\n * their own - because neither is a construct the author meant as content:\n *\n *  - `preamble`, a wrapper Asciidoctor inserts between a document title and the\n *    first section. Skipping it would swallow the lead prose.\n *  - `open` (`--`). That is how an author attaches several blocks to one list\n *    item, so skipping it would make a numbered step's whole body invisible to\n *    a template. The constructs a `--` block can be *turned into* do not arrive\n *    here at all: `[NOTE]` becomes an `admonition`, `[quote]` a `quote`,\n *    `[sidebar]` a `sidebar`, each with its own context and each skipped by the\n *    default branch, which is the line mdast draws around a blockquote. So a\n *    node still reporting `open` is the bare attach-blocks form by elimination.\n */\nfunction collect(nodes: AdocNode[], out: Draft[]): void {\n  for (const node of nodes) {\n    const context = node.getContext();\n\n    if (context === \"section\") {\n      // Explicit (`[[id]]`, `[#id]`) or the one Asciidoctor generated\n      // (`_install`): either way, the anchor an `xref` to it resolves to.\n      const id = node.getId?.();\n      out.push({\n        kind: \"heading\",\n        line: lineOf(node),\n        // Asciidoctor's `=` title is level 0, so every level is one shallower\n        // than the heading level the rest of the tool speaks in.\n        level: (node.getLevel?.() ?? 0) + 1,\n        title: inline(node.getTitle?.(), lineOf(node)),\n        ...(id ? { id } : {}),\n      });\n      collect(childrenOf(node), out);\n      continue;\n    }\n\n    if (context === \"preamble\" || context === \"open\") {\n      collect(childrenOf(node), out);\n      continue;\n    }\n\n    const draft = draftOf(node);\n    if (draft) out.push(draft);\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Drafts -> blocks\n// ---------------------------------------------------------------------------\n\n/**\n * Give every draft a span.\n *\n * A heading spans its own title line, the way an mdast heading spans its `#`\n * line. Everything else ends where the next block begins, and the last block at\n * `end` - the convention `sectionize` already uses for sections, applied one\n * level down because Asciidoctor reports where a block starts and nothing at\n * all about where it stops.\n */\nfunction place(drafts: Draft[], end: Point, index: LineIndex): Fragment[] {\n  return drafts.map((draft, i): Fragment => {\n    const next = drafts[i + 1];\n    const boundary = next ? index.start(next.line) : end;\n\n    if (draft.kind === \"heading\") {\n      return {\n        type: \"heading\",\n        level: draft.level,\n        title: draft.title,\n        ...(draft.id !== undefined ? { id: draft.id } : {}),\n        position: {\n          start: index.start(draft.line),\n          end: index.endOfLine(draft.line),\n        },\n      };\n    }\n\n    return {\n      type: \"content\",\n      node: contentNode(\n        draft,\n        { start: index.start(draft.line), end: boundary },\n        index,\n      ),\n    };\n  });\n}\n\n/** `place`, for content that cannot contain a heading. */\nfunction placeContent(drafts: Draft[], end: Point, index: LineIndex): ContentNode[] {\n  return place(drafts, end, index).flatMap((fragment) =>\n    fragment.type === \"content\" ? [fragment.node] : [],\n  );\n}\n\nfunction placeItems(items: DraftItem[], end: Point, index: LineIndex): ListItemNode[] {\n  return items.map((item, i) => {\n    const next = items[i + 1];\n    const boundary = next ? index.start(next.line) : end;\n    return {\n      kind: \"listItem\",\n      position: { start: index.start(item.line), end: boundary },\n      text: item.text,\n      children: placeContent(item.children, boundary, index),\n    };\n  });\n}\n\n/**\n * A table cell's own span: its starting line only.\n *\n * Asciidoctor reports a line per cell, but several cells on one row commonly\n * share a single source line, so there is no line-based boundary between\n * them the way there is between rows or list items. A cell spans just the\n * line it starts on, the way a heading spans its own title line.\n */\nfunction placeCells(cells: DraftCell[], index: LineIndex): TableCellNode[] {\n  return cells.map((cell) => ({\n    kind: \"tableCell\",\n    position: { start: index.start(cell.line), end: index.endOfLine(cell.line) },\n    text: cell.text,\n    children: [],\n  }));\n}\n\nfunction placeRows(rows: DraftRow[], end: Point, index: LineIndex): TableRowNode[] {\n  return rows.map((row, i) => {\n    const next = rows[i + 1];\n    const boundary = next ? index.start(next.line) : end;\n    const cells = placeCells(row.cells, index);\n    return {\n      kind: \"tableRow\",\n      position: { start: index.start(row.line), end: boundary },\n      text: cells.map((cell) => cell.text).join(\" | \"),\n      header: row.header,\n      children: cells,\n    };\n  });\n}\n\nfunction placeDefinitionItems(\n  items: DraftDefinitionItem[],\n  end: Point,\n  index: LineIndex,\n): DefinitionItemNode[] {\n  return items.map((item, i) => {\n    const next = items[i + 1];\n    const boundary = next ? index.start(next.line) : end;\n    const definition = placeContent(item.children, boundary, index);\n    const definitionText = definition.map((node) => node.text).join(\" \");\n    return {\n      kind: \"definitionItem\",\n      position: { start: index.start(item.line), end: boundary },\n      text: definitionText.length > 0 ? `${item.term}: ${definitionText}` : item.term,\n      term: item.term,\n      definition,\n    };\n  });\n}\n\nfunction contentNode(\n  draft: ContentDraft,\n  position: Position,\n  index: LineIndex,\n): ContentNode {\n  switch (draft.kind) {\n    case \"paragraph\":\n      return { kind: \"paragraph\", position, text: draft.text };\n    case \"codeBlock\":\n      return {\n        kind: \"codeBlock\",\n        position,\n        text: draft.text,\n        ...(draft.language ? { language: draft.language } : {}),\n      };\n    case \"list\":\n      return {\n        kind: \"list\",\n        position,\n        // Informational only - no rule reads a list's own text - so the items\n        // are joined one per line rather than run together the way\n        // `mdast-util-to-string` concatenates them.\n        text: draft.items.map((item) => item.text).join(\"\\n\"),\n        ordered: draft.ordered,\n        items: placeItems(draft.items, position.end, index),\n      };\n    case \"table\": {\n      const rows = placeRows(draft.rows, position.end, index);\n      return {\n        kind: \"table\",\n        position,\n        text: rows.map((row) => row.text).join(\"\\n\"),\n        children: rows,\n      };\n    }\n    case \"admonition\": {\n      const children = placeContent(draft.children, position.end, index);\n      return {\n        kind: \"admonition\",\n        position,\n        text: children.map((node) => node.text).join(\"\\n\\n\"),\n        variant: draft.variant,\n        children,\n      };\n    }\n    case \"image\":\n      return {\n        kind: \"image\",\n        position,\n        text: draft.alt,\n        url: draft.url,\n        alt: draft.alt,\n        ...(draft.title ? { title: draft.title } : {}),\n      };\n    case \"blockquote\": {\n      const children = placeContent(draft.children, position.end, index);\n      return {\n        kind: \"blockquote\",\n        position,\n        text: children.map((node) => node.text).join(\"\\n\\n\"),\n        children,\n      };\n    }\n    case \"definitionList\": {\n      const children = placeDefinitionItems(draft.items, position.end, index);\n      return {\n        kind: \"definitionList\",\n        position,\n        // `item.text`, which is `\"term: definition\"`, not `item.term`. A\n        // node's `text` is its flattened rendering, so dropping the definition\n        // bodies here would make a pattern rule find a word in every format\n        // except this one.\n        text: children.map((item) => item.text).join(\"\\n\"),\n        children,\n      };\n    }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Document metadata\n// ---------------------------------------------------------------------------\n\n/**\n * The AsciiDoc-aware reader, which the plain `extractFrontmatter` is not.\n *\n * `extractFrontmatter(content, \"asciidoc\")` reads only the fenced `--- ... ---`\n * block some toolchains prepend - its format argument is a label copied onto\n * the result, not a parser selector. AsciiDoc's own metadata is the document\n * header: the `= Title` line plus `:key: value` attribute entries, up to the\n * first blank line. That is how a real page declares `:type: how-to`, and\n * reading it is what makes type routing work for `.adoc` at all.\n */\nconst nativeExtractor = extractorForExtension(\".adoc\");\n\ninterface Metadata {\n  data: Record<string, unknown> | null;\n  position: Position | null;\n}\n\n/**\n * Span of the native header: the run of lines before the first blank one,\n * which is exactly the range docmeta's extractor reads attributes from.\n */\nfunction headerPosition(content: string, index: LineIndex): Position | null {\n  let last = 0;\n  for (const [i, line] of content.split(/\\r?\\n/).entries()) {\n    if (line.trim() === \"\") break;\n    last = i + 1;\n  }\n  if (last === 0) return null;\n  return { start: index.start(1), end: index.endOfLine(last) };\n}\n\n/**\n * Both metadata styles, merged, with the fenced block winning a key collision:\n * a file carrying a fence has chosen it as its metadata of record. `present` is\n * the OR of the two, so a page with only `:type: how-to` still reports\n * frontmatter and still routes.\n */\nfunction metadata(content: string, filePath: string, index: LineIndex): Metadata {\n  const fenced = extractFrontmatter(content, \"asciidoc\");\n  // Read the native header from the fence-free remainder: docmeta's AsciiDoc\n  // extractor returns the fence and stops when one is present, so asking it\n  // about the whole file would discard `:type:` on any page that has both.\n  const native = nativeExtractor?.extract(\n    fenced.present ? withoutFence(content) : content,\n    filePath,\n  );\n\n  if (!fenced.present && !native?.present) return { data: null, position: null };\n\n  return {\n    data: { ...(native?.data ?? {}), ...(fenced.present ? fenced.data : {}) },\n    position:\n      (fenced.present ? fencedPosition(content) : null) ??\n      headerPosition(content, index),\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Parser\n// ---------------------------------------------------------------------------\n\nfunction load(content: string, filePath: string): AdocDocument {\n  const asciidoc = getProcessor();\n  try {\n    return asciidoc.load(content, {\n      // Without this every block's `getLineNumber()` is undefined and there are\n      // no positions to derive at all.\n      sourcemap: true,\n      // Asciidoctor.js's default already, pinned because it is what keeps\n      // `include::` from reading the disk: a refused include renders as a link\n      // to its target, which `inline` then drops.\n      safe: \"secure\",\n      attributes: {\n        // A leading `---` fence is a thematic break in AsciiDoc; this consumes\n        // it as metadata instead, without disturbing line numbering.\n        \"skip-front-matter\": true,\n        // `xref:other.adoc[]` keeps its source suffix rather than becoming\n        // `other.html`, so a harvested link names the file that exists.\n        relfilesuffix: \".adoc\",\n      },\n    }) as unknown as AdocDocument;\n  } catch (err) {\n    // Asciidoctor recovers from malformed *documents* - it warns about an\n    // unterminated block and carries on - so this fires when the loader itself\n    // refuses the input. Either way it is the file's problem, not a crash.\n    throw new LintError(\n      `${filePath}: could not parse as asciidoc: ${errorMessage(err)}`,\n    );\n  }\n}\n\n/**\n * The document title, as a heading block.\n *\n * `= Title` is not a block: Asciidoctor keeps it as the document header, and\n * `getDocumentTitle()` lies about it - with no header at all it falls back to\n * the first section's title - so this goes through `hasHeader()`. A header made\n * only of attribute entries has no title to contribute, and emitting an empty\n * heading for it would both invent a section and block the frontmatter title\n * those attributes may be carrying.\n */\nfunction headerDraft(doc: AdocDocument): Draft | null {\n  if (!doc.hasHeader()) return null;\n  const header = asNode(doc.getHeader());\n  if (!header) return null;\n  const title = inline(header.getTitle?.(), lineOf(header));\n  if (title.length === 0) return null;\n  return {\n    kind: \"heading\",\n    line: lineOf(header),\n    level: (header.getLevel?.() ?? 0) + 1,\n    title,\n  };\n}\n\nfunction parse(content: string, filePath: string): DocumentTree {\n  const doc = load(content, filePath);\n  const index = lineIndex(content);\n\n  harvested = [];\n  const drafts: Draft[] = [];\n  const header = headerDraft(doc);\n  if (header) drafts.push(header);\n  collect(childrenOf(doc), drafts);\n  // Stable, so links on one line keep their order. Needed at all because a\n  // description list's terms are read after its body.\n  const links = harvested\n    .sort((a, b) => a.line - b.line)\n    .map(({ target, line }) => ({\n      target,\n      position: { start: index.start(line), end: index.endOfLine(line) },\n    }));\n\n  const meta = metadata(content, filePath, index);\n  const end = index.documentEnd();\n\n  return {\n    format: \"asciidoc\",\n    filePath,\n    frontmatter: meta.data,\n    frontmatterPosition: meta.position,\n    sections: sectionize(\n      withFrontmatterTitle(place(drafts, end, index), meta.data, meta.position),\n      end,\n    ),\n    links,\n  };\n}\n\nexport const asciidocParser: DocumentParser = {\n  name: \"asciidoc\",\n  label: \"AsciiDoc\",\n  kinds: [\n    \"paragraph\",\n    \"codeBlock\",\n    \"list\",\n    \"listItem\",\n    \"table\",\n    \"tableRow\",\n    \"tableCell\",\n    \"admonition\",\n    \"image\",\n    \"blockquote\",\n    \"definitionList\",\n    \"definitionItem\",\n  ],\n  extensions: [\".adoc\", \".asciidoc\"],\n  parse,\n};\n","/**\n * Parser registry. Maps file extensions to parsers and resolves a parser by\n * name for the `--as` override.\n *\n * Shaped after docmeta's extractor registry, and for the same reason:\n * everything downstream of `parse()` operates on the generic `DocumentTree`, so\n * adding a format is one file plus one line here - no change to matching,\n * rules, templates, or reporting.\n *\n * A format is registered here when, and only when, a parser reads it. That is\n * what `manni lint tools` lists and what `--as` accepts, so neither can name a\n * format the tool does not read. An extension no parser claims is skipped by\n * name, never parsed as Markdown the way the pre-rewrite `inferFileType` did.\n */\nimport type { ContentKind, DocumentParser } from \"../types.js\";\nimport { markdownParser, mdxParser } from \"./markdown.js\";\nimport { htmlParser } from \"./html.js\";\nimport { rstParser } from \"./rst.js\";\nimport { xmlParser } from \"./xml.js\";\nimport { asciidocParser } from \"./asciidoc.js\";\n\nexport const PARSERS: DocumentParser[] = [\n  markdownParser,\n  mdxParser,\n  htmlParser,\n  asciidocParser,\n  rstParser,\n  xmlParser,\n];\n\nconst byExtension = new Map<string, DocumentParser>();\nconst byName = new Map<string, DocumentParser>();\nfor (const parser of PARSERS) {\n  byName.set(parser.name, parser);\n  for (const ext of parser.extensions) byExtension.set(ext.toLowerCase(), parser);\n}\n\n/** Resolve a parser for a file extension (including the dot). */\nexport function parserForExtension(ext: string): DocumentParser | undefined {\n  return byExtension.get(ext.toLowerCase());\n}\n\n/** Resolve a parser by its `--as` name. */\nexport function parserByName(name: string): DocumentParser | undefined {\n  return byName.get(name.toLowerCase());\n}\n\n/** Extensions collected from a directory walk. */\nexport function supportedExtensions(): string[] {\n  return PARSERS.flatMap((p) => p.walkExtensions ?? p.extensions);\n}\n\n/**\n * Why a file no parser claims is skipped. One sentence for every command that\n * says it, so `lint` and `templates` cannot drift apart. `name` is the\n * extension, or the file itself when it has none.\n */\nexport function unsupportedFormatMessage(name: string): string {\n  return `no parser is registered for \"${name}\". Supported extensions: ${supportedExtensions().join(\", \")}. Use --as to override.`;\n}\n\n/** Every format the tool reads, for `manni lint tools`. */\nexport function listFormats(): {\n  name: string;\n  label: string;\n  extensions: string[];\n  kinds: ContentKind[];\n}[] {\n  return PARSERS.map((p) => ({\n    name: p.name,\n    label: p.label,\n    extensions: p.extensions,\n    kinds: p.kinds,\n  }));\n}\n"],"mappings":"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","names":["firstLine","metadata","processor","ZERO","positionOf","childContent","toContentNode","inline","documentEnd","ADMONITION_VARIANTS","firstLine","text","under","title","last","rawText","collectLinks","elementChildren","ADMONITION_VARIANTS","readMetadata","flattenInline","ADMONITION_VARIANTS","parse"]}