@temelj/mdx 0.14.0 → 0.15.0

package/dist/stream-tail.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-tail.mjs","names":[],"sources":["../src/stream-tail.ts"],"sourcesContent":["import type { HtmlLoweringCache } from \"./html-lower.ts\";\nimport type { HtmlElementNode, HtmlNode, HtmlPendingNode, HtmlRootNode } from \"./html.ts\";\nimport type { JsxAttributeLike, MdxNode, PhrasingContent } from \"./model.ts\";\nimport type { BlockSyntax, PendingBlockSyntax } from \"./parser/block-syntax.ts\";\nimport type { ResolvedParserLimits } from \"./parser/config.ts\";\nimport type { CommittedJsxOpening } from \"./parser/embedded-scanner.ts\";\nimport type {\n  DefinitionLookup,\n  InlinePendingSyntax,\n  InlineSyntax,\n} from \"./parser/inline-syntax.ts\";\nimport type { PhrasingCache } from \"./parser/materialize.ts\";\nimport type { SourceRange } from \"./ranges.ts\";\nimport type { SourceFile } from \"./source.ts\";\nimport type { ResolvedSyntaxOptions } from \"./syntax-options.ts\";\n\nimport { footnoteReferences } from \"./html-lower.ts\";\nimport { parseFlowRange } from \"./parser/block-parser.ts\";\nimport { InlineInput, type InlineSegment } from \"./parser/inline-input.ts\";\nimport { InlineParser } from \"./parser/inline-parser.ts\";\nimport { isFlowJsxChildren } from \"./parser/materialize-jsx.ts\";\nimport {\n  materializeDocument,\n  materializePhrasing,\n  materializePhrasingGroups,\n} from \"./parser/materialize.ts\";\nimport { sourceText } from \"./source.ts\";\n\n/** Lowers MDX siblings in the scope of the block that contains the open leaf. */\nexport type LowerNodes = (nodes: readonly MdxNode[], previous?: MdxNode) => HtmlNode[];\n\nexport interface OpenLeafContext {\n  readonly definitions: DefinitionLookup;\n  readonly references: Set<string>;\n  readonly file: SourceFile;\n  readonly syntax: ResolvedSyntaxOptions;\n  readonly limits: ResolvedParserLimits;\n  /** Code text of the open fence, extended by later appends. */\n  readonly fence: FenceText;\n  /** Work on the open paragraph that later appends reuse. */\n  readonly paragraph: OpenParagraph;\n  readonly phrasing: PhrasingCache;\n  /** Lowering resolves references through this cache; a new one means new definitions. */\n  readonly lowering: HtmlLoweringCache;\n}\n\n/** One inline node of the open paragraph with its materialized and lowered output. */\ninterface InlineGroup {\n  readonly node: PhrasingContent | undefined;\n  /** Totals through this group, so a reused prefix needs no new pass. */\n  readonly htmlEnd: number;\n  readonly nodeEnd: number;\n}\n\n/** Children of a long open paragraph are grouped into fragments of this size. */\nconst CHUNK_SIZE = 64;\n\n/**\n * The open paragraph's input, resumable inline parse, and the output of its\n * leading inline nodes. The paragraph owns these arrays and truncates and\n * extends them in place, so an append decodes, parses, materializes, and\n * lowers only what changed.\n */\nexport class OpenParagraph {\n  #start = -1;\n  #lowering: HtmlLoweringCache | undefined;\n  #input: InlineInput | undefined;\n  #parser: InlineParser | undefined;\n  readonly #groups: InlineGroup[] = [];\n  readonly #children: HtmlNode[] = [];\n  /** Fragments of full chunks of `#children`, reused while their nodes are unchanged. */\n  readonly #chunks: HtmlRootNode[] = [];\n  /** Footnote numbers can change while the paragraph is open, so groups from here render again. */\n  #numbered = Infinity;\n\n  /** Starts tracking the paragraph at `start`, dropping work done for another. */\n  public open(start: number, lowering: HtmlLoweringCache): void {\n    if (this.#start !== start) {\n      this.#start = start;\n      this.#input = undefined;\n      this.truncate(0);\n    }\n\n    if (this.#lowering !== lowering) {\n      this.#lowering = lowering;\n      this.truncate(0);\n    }\n  }\n\n  public parse(\n    file: SourceFile,\n    segments: readonly InlineSegment[],\n    syntax: ResolvedSyntaxOptions,\n    definitions: DefinitionLookup,\n  ): ReturnType<InlineParser[\"parse\"]> {\n    this.#parser ??= new InlineParser(syntax);\n    this.#input = new InlineInput(file, segments, this.#input);\n\n    return this.#parser.parse(this.#input, definitions);\n  }\n\n  /** The last materialized node, which decides how text after a hard break renders. */\n  public get lastNode(): PhrasingContent | undefined {\n    return this.#groups.at(-1)?.node;\n  }\n\n  /** The unchanged prefix, capped where footnote numbering must be refreshed. */\n  public reusable(changedFrom: number): number {\n    const groups = this.#groups;\n    let low = Math.min(groups.length, changedFrom, this.#numbered);\n\n    // The group after a reused hard break must render again with that context.\n    while (low > 0 && groups[low - 1].node?.kind === \"hardBreak\") {\n      low--;\n    }\n\n    return low;\n  }\n\n  /** Keeps the first `length` groups and returns how many nodes they materialized. */\n  public truncate(length: number): number {\n    this.#groups.length = length;\n    const last = this.#groups.at(-1);\n    this.#children.length = last?.htmlEnd ?? 0;\n    this.#chunks.length = Math.min(\n      this.#chunks.length,\n      Math.floor(this.#children.length / CHUNK_SIZE),\n    );\n\n    if (length === 0) {\n      this.#numbered = Infinity;\n    }\n\n    return last?.nodeEnd ?? 0;\n  }\n\n  public push(\n    node: PhrasingContent | undefined,\n    html: readonly HtmlNode[],\n    nodeEnd: number,\n    numbered: boolean,\n  ): void {\n    this.#children.push(...html);\n    this.#groups.push({ node, htmlEnd: this.#children.length, nodeEnd });\n\n    if (numbered) {\n      this.#numbered = Math.min(this.#numbered, this.#groups.length - 1);\n    }\n  }\n\n  /**\n   * The rendered children for a snapshot.\n   * A long paragraph groups full chunks into fragments that keep their identity, so a snapshot copies only the\n   * chunk list and the last partial chunk.\n   */\n  public children(): HtmlNode[] {\n    const children = this.#children;\n\n    if (children.length < CHUNK_SIZE * 2) {\n      return [...children];\n    }\n\n    while ((this.#chunks.length + 1) * CHUNK_SIZE <= children.length) {\n      const start = this.#chunks.length * CHUNK_SIZE;\n      this.#chunks.push(\n        Object.freeze({ kind: \"root\", children: children.slice(start, start + CHUNK_SIZE) }),\n      );\n    }\n\n    return [...this.#chunks, ...children.slice(this.#chunks.length * CHUNK_SIZE)];\n  }\n}\n\n/** The open leaf's rendering, and the nodes it materialized for the node limit. */\nexport interface OpenLeafHtml {\n  readonly nodes: readonly HtmlNode[];\n  readonly nodeCount: number;\n}\n\n/**\n * Renders the open leaf of a stream.\n * The materializer leaves an empty placeholder with the leaf's origin, and lowering asks this function for the\n * placeholder's HTML.\n */\nexport function lowerOpenLeaf(\n  node: MdxNode,\n  pending: PendingBlockSyntax,\n  context: OpenLeafContext,\n  lower: LowerNodes,\n): OpenLeafHtml | undefined {\n  if (node.origin?.start !== pending.range.start || node.origin.end !== pending.range.end) {\n    return undefined;\n  }\n\n  switch (pending.kind) {\n    case \"paragraph\":\n      return node.kind === \"paragraph\" ? openParagraph(pending, context, lower) : undefined;\n    case \"fencedCode\":\n      return node.kind === \"codeBlock\"\n        ? {\n            nodes: [\n              pendingNode(\"fence\", context.file.slice(pending.range), pending.range, {\n                children: [\n                  text(context.fence.text(context.file, pending.range.start, pending.value)),\n                ],\n                language:\n                  pending.language === undefined\n                    ? undefined\n                    : context.file.semanticSlice(pending.language),\n                meta:\n                  pending.meta === undefined ? undefined : context.file.semanticSlice(pending.meta),\n              }),\n            ],\n            nodeCount: 0,\n          }\n        : undefined;\n    case \"math\":\n      return node.kind === \"displayMath\"\n        ? {\n            nodes: [\n              pendingNode(\"displayMath\", context.file.semanticSlice(pending.range), pending.range, {\n                children: [\n                  text(\n                    new InlineInput(context.file, pending.value)\n                      .toString()\n                      .replace(/\\r\\n?|\\n/gu, \"\\n\")\n                      .replace(/\\n$/u, \"\"),\n                  ),\n                ],\n              }),\n            ],\n            nodeCount: 0,\n          }\n        : undefined;\n    case \"jsx\":\n      return node.kind === \"rawHtmlBlock\" ? openJsx(pending, context, lower) : undefined;\n    case \"expression\":\n      return node.kind === \"rawHtmlBlock\"\n        ? {\n            nodes: [\n              pendingNode(\"expression\", context.file.semanticSlice(pending.range), pending.range, {\n                children: [text(context.file.semanticSlice(pending.range))],\n              }),\n            ],\n            nodeCount: 0,\n          }\n        : undefined;\n    case \"esm\":\n      return node.kind === \"rawHtmlBlock\"\n        ? {\n            nodes: [pendingNode(\"esm\", context.file.slice(pending.range), pending.range)],\n            nodeCount: 0,\n          }\n        : undefined;\n  }\n}\n\n/** A paragraph whose last construct is still open renders that construct as a pending node. */\nfunction openParagraph(\n  pending: Extract<PendingBlockSyntax, { kind: \"paragraph\" }>,\n  context: OpenLeafContext,\n  lower: LowerNodes,\n): OpenLeafHtml {\n  const cache = context.paragraph;\n  cache.open(pending.range.start, context.lowering);\n  const parsed = cache.parse(context.file, pending.input, context.syntax, context.definitions);\n\n  for (const identifier of parsed.references) {\n    context.references.add(identifier);\n  }\n\n  const open = parsed.pending;\n  const boundary = open?.range.start ?? Infinity;\n  const nodes = parsed.nodes;\n  const reused = cache.reusable(parsed.changedFrom);\n  let nodeCount = cache.truncate(reused);\n  const changed: InlineSyntax[] = [];\n\n  for (let index = reused; index < nodes.length; index++) {\n    const node = nodes[index];\n\n    if (node.range.start >= boundary) {\n      break;\n    }\n\n    if (node.range.end > boundary && node.kind !== \"text\") {\n      break;\n    }\n\n    // Text that runs into the open construct ends where it starts.\n    const range = { start: node.range.start, end: boundary };\n\n    const inline: InlineSyntax =\n      node.range.end <= boundary\n        ? node\n        : { kind: \"text\", value: context.file.semanticSlice(range), range };\n\n    changed.push(inline);\n  }\n\n  const groups = materializePhrasingGroups(\n    context.file,\n    changed,\n    context.syntax,\n    context.limits,\n    context.phrasing,\n  );\n\n  for (const materialized of groups) {\n    nodeCount += materialized.nodeCount;\n\n    cache.push(\n      materialized.nodes.at(-1),\n      lower(materialized.nodes, cache.lastNode),\n      nodeCount,\n      materialized.nodes.some((child) => footnoteReferences(child).length > 0),\n    );\n  }\n\n  const children = cache.children();\n\n  if (open !== undefined) {\n    const lowered = openInline(open, context, lower);\n    children.push(lowered.node);\n    nodeCount += lowered.nodeCount;\n  }\n\n  const paragraph: HtmlElementNode = {\n    kind: \"element\",\n    tagName: \"p\",\n    attributes: {},\n    children,\n    origin: pending.range,\n  };\n\n  return { nodes: [paragraph], nodeCount };\n}\n\ninterface OpenInlineHtml {\n  readonly node: HtmlPendingNode;\n  readonly nodeCount: number;\n}\n\nfunction openInline(\n  open: InlinePendingSyntax,\n  context: OpenLeafContext,\n  lower: LowerNodes,\n): OpenInlineHtml {\n  const source = context.file.slice(open.range);\n\n  switch (open.kind) {\n    case \"strong\":\n    case \"emphasis\":\n    case \"delete\":\n    case \"link\": {\n      const materialized = materializePhrasing(\n        context.file,\n        open.children,\n        context.syntax,\n        context.limits,\n      );\n\n      return {\n        node: pendingNode(open.kind, source, open.range, { children: lower(materialized.nodes) }),\n        nodeCount: materialized.nodeCount,\n      };\n    }\n\n    case \"code\":\n      return {\n        node: pendingNode(\"code\", source, open.range, { children: [text(open.value)] }),\n        nodeCount: 0,\n      };\n    case \"image\":\n      return {\n        node: pendingNode(\"image\", source, open.range, { children: [text(open.alt)] }),\n        nodeCount: 0,\n      };\n    case \"math\":\n      return {\n        node: pendingNode(\"inlineMath\", context.file.semanticSlice(open.range), open.range, {\n          children: [text(open.value)],\n        }),\n        nodeCount: 0,\n      };\n    case \"expression\":\n      return {\n        node: pendingNode(\"expression\", context.file.semanticSlice(open.range), open.range, {\n          children: [text(context.file.semanticSlice(open.range))],\n        }),\n        nodeCount: 0,\n      };\n    case \"jsx\":\n      return { node: pendingNode(\"jsx\", source, open.range), nodeCount: 0 };\n  }\n}\n\n/**\n * Open flow JSX with a committed opening tag renders as pending JSX with its\n * children so far. An opening tag with expression attributes stays inert.\n */\nfunction openJsx(\n  pending: Extract<PendingBlockSyntax, { kind: \"jsx\" }>,\n  context: OpenLeafContext,\n  lower: LowerNodes,\n): OpenLeafHtml {\n  const authored = context.file.slice(pending.range);\n  const opening = pending.opening;\n\n  if (opening === undefined || !opening.safe || opening.name === undefined) {\n    return { nodes: [pendingNode(\"jsx\", authored, pending.range)], nodeCount: 0 };\n  }\n\n  const children: HtmlNode[] = [];\n  let nodeCount = 0;\n\n  if (opening.end !== undefined && opening.end < authored.length) {\n    const range = { start: pending.range.start + opening.end, end: pending.range.end };\n    const flow = isFlowJsxChildren(context.file, range);\n\n    const drafts: readonly BlockSyntax[] = flow\n      ? parseFlowRange(sourceText(context.file).grammar(), range, context.syntax)\n      : [{ kind: \"paragraph\", range, input: [{ kind: \"source\", range }] }];\n\n    const materialized = materializeDocument(context.file, drafts, context.syntax, context.limits, {\n      keepReferences: true,\n      allowIncomplete: true,\n    });\n\n    if (materialized.kind === \"ok\") {\n      const lowered = lower(materialized.document.children);\n      const paragraph = lowered[0];\n\n      // Children on the opening line are phrasing, so they are not wrapped in a paragraph.\n      children.push(\n        ...(!flow && paragraph?.kind === \"element\" && paragraph.tagName === \"p\"\n          ? paragraph.children\n          : lowered),\n      );\n      nodeCount = materialized.blocks.reduce((count, block) => count + block.nodeCount, 0);\n    }\n  }\n\n  return {\n    nodes: [\n      {\n        kind: \"jsx\",\n        state: \"pending\",\n        element: \"flow\",\n        name: opening.name,\n        attributes: committedAttributes(opening),\n        fallback: authored,\n        children,\n        origin: pending.range,\n      },\n    ],\n    nodeCount,\n  };\n}\n\nfunction committedAttributes(opening: CommittedJsxOpening): JsxAttributeLike[] {\n  return Object.entries(opening.attributes).flatMap(([name, value]): JsxAttributeLike[] =>\n    value === false\n      ? []\n      : [{ kind: \"jsxAttribute\", name, value: value === true ? undefined : value }],\n  );\n}\n\n/**\n * The code of an open fence. Complete lines never change while the fence stays\n * open, so each append decodes only the lines that arrived since the last one.\n */\nexport class FenceText {\n  #start = -1;\n  #complete = 0;\n  #last: SourceRange | undefined;\n  #text = \"\";\n\n  public text(file: SourceFile, start: number, segments: PendingFenceSegments): string {\n    const reusable =\n      this.#start === start &&\n      this.#complete <= segments.length &&\n      (this.#complete === 0 || sameRange(segment(segments, this.#complete - 1), this.#last));\n\n    if (!reusable) {\n      this.#start = start;\n      this.#complete = 0;\n      this.#last = undefined;\n      this.#text = \"\";\n    }\n\n    // The last segment can be a partial line, so only earlier segments are kept.\n    const complete = Math.max(this.#complete, segments.length - 1);\n\n    if (complete > this.#complete) {\n      this.#text += normalizeLineEndings(\n        new InlineInput(file, segments.slice(this.#complete, complete)).toString(),\n      );\n      this.#complete = complete;\n      this.#last = segment(segments, complete - 1);\n    }\n\n    const tail = segments.slice(complete);\n\n    return tail.length === 0\n      ? this.#text\n      : this.#text + normalizeLineEndings(new InlineInput(file, tail).toString());\n  }\n}\n\ntype PendingFenceSegments = Extract<PendingBlockSyntax, { kind: \"fencedCode\" }>[\"value\"];\n\nfunction segment(segments: PendingFenceSegments, index: number): SourceRange | undefined {\n  const value = segments[index];\n\n  return value?.kind === \"source\" ? value.range : undefined;\n}\n\nfunction sameRange(left: SourceRange | undefined, right: SourceRange | undefined): boolean {\n  return left?.start === right?.start && left?.end === right?.end;\n}\n\nfunction normalizeLineEndings(value: string): string {\n  return value.replace(/\\r\\n?/gu, \"\\n\");\n}\n\nconst TRIMMABLE_TAIL_TAGS: ReadonlySet<string> = new Set([\n  \"blockquote\",\n  \"h1\",\n  \"h2\",\n  \"h3\",\n  \"h4\",\n  \"h5\",\n  \"h6\",\n  \"li\",\n  \"ol\",\n  \"ul\",\n]);\n\n/**\n * Removes empty trailing containers from the open end of a stream. A bare list\n * marker, heading marker, or quote marker can still become other syntax, so it\n * renders nothing until content arrives.\n */\nexport function trimOpenTail(nodes: readonly HtmlNode[]): readonly HtmlNode[] {\n  let index = nodes.length - 1;\n\n  while (index >= 0 && isWhitespaceText(nodes[index])) {\n    index--;\n  }\n\n  const last = nodes[index];\n\n  // Long previews group children into fragments, which are transparent here.\n  const transparent = last?.kind === \"root\";\n\n  if (!transparent && (last?.kind !== \"element\" || !TRIMMABLE_TAIL_TAGS.has(last.tagName))) {\n    return nodes;\n  }\n\n  const nested = trimOpenTail(last.children);\n\n  if (nested.every(isWhitespaceText)) {\n    return nodes.slice(0, index);\n  }\n\n  return nested === last.children\n    ? nodes\n    : [...nodes.slice(0, index), { ...last, children: nested }, ...nodes.slice(index + 1)];\n}\n\nfunction isWhitespaceText(node: HtmlNode | undefined): boolean {\n  return node?.kind === \"text\" && node.value.trim() === \"\";\n}\n\nfunction pendingNode(\n  construct: HtmlPendingNode[\"construct\"],\n  source: string,\n  origin: SourceRange,\n  fields: Partial<Pick<HtmlPendingNode, \"children\" | \"language\" | \"meta\">> = {},\n): HtmlPendingNode {\n  return {\n    kind: \"pending\",\n    construct,\n    source,\n    children: fields.children ?? [],\n    language: fields.language,\n    meta: fields.meta,\n    origin,\n  };\n}\n\nfunction text(value: string): HtmlNode {\n  return { kind: \"text\", value };\n}\n"],"mappings":"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"}

package/dist/stream-types.d.mts

@@ -0,0 +1,89 @@
+import { SourceRange } from "./ranges.mjs";
+import { SyntaxOptions } from "./syntax-options.mjs";
+import { HtmlFootnoteSectionNode, HtmlNode } from "./html.mjs";
+import { SourceFile } from "./source.mjs";
+import { Diagnostic } from "./diagnostics.mjs";
+import { ParserLimit, ParserLimits } from "./parser/config.mjs";
+import { ParseResult } from "./parser.mjs";
+//#region src/stream-types.d.ts
+declare const blockIdBrand: unique symbol;
+/** Identifies one top-level block for the lifetime of a stream, across appends and edits. */
+export type BlockId = string & {
+  readonly [blockIdBrand]: "BlockId";
+};
+export interface MdxEdit {
+  readonly start: number;
+  readonly end: number;
+  readonly text: string;
+}
+/** Identifiers of the link definitions and footnotes a block references. */
+export interface StreamDependencies {
+  readonly definitions: readonly string[];
+  readonly footnotes: readonly string[];
+}
+/** What a renderer needs from one block. It is plain data, so a server can send it. */
+export interface PreviewBlock {
+  readonly id: BlockId;
+  readonly origin: SourceRange;
+  /** Provisional HTML. Open syntax and missing references have their own node kinds. */
+  readonly nodes: readonly HtmlNode[];
+  /** An `invalid` block renders its authored source as inert text. */
+  readonly status: "invalid" | "valid";
+  /**
+   * Later input cannot change a settled block's syntax. Its rendering can still
+   * change when a definition it references changes.
+   */
+  readonly settled: boolean;
+}
+/** What a renderer needs from a stream preview. */
+export interface MdxPreview {
+  readonly blocks: readonly PreviewBlock[];
+  /** The footnote section, while any defined footnote is referenced. */
+  readonly footnotes: HtmlFootnoteSectionNode | undefined;
+}
+export interface StreamBlock extends PreviewBlock {
+  readonly diagnostics: readonly Diagnostic[];
+  readonly dependencies: StreamDependencies;
+}
+/** A provisional view of incomplete input. Errors stay local to the blocks that contain them. */
+export interface MdxStreamSnapshot extends MdxPreview {
+  readonly kind: "preview";
+  readonly file: SourceFile;
+  readonly blocks: readonly StreamBlock[];
+  readonly diagnostics: readonly Diagnostic[];
+  /** The limit the source exceeds. Blocks then keep the last preview within limits. */
+  readonly limit: ParserLimit | undefined;
+}
+export interface CompletedBlock {
+  readonly id: BlockId;
+  readonly origin: SourceRange;
+}
+export interface MdxStreamCompletion extends ParseResult {
+  readonly kind: "complete";
+  /** The stream blocks that make up the document, with the identities they streamed with. */
+  readonly blocks: readonly CompletedBlock[];
+}
+export interface MdxStreamLimits extends ParserLimits {
+  /** The longest top-level block that can contain open syntax. */
+  readonly maximumPendingBlockLength?: number;
+}
+export interface MdxStreamOptions {
+  /** Initial source. */
+  readonly source?: string;
+  /** The file name for diagnostics. */
+  readonly name?: string;
+  readonly syntax?: SyntaxOptions;
+  readonly limits?: MdxStreamLimits;
+}
+/** What changed between two consecutive snapshots. */
+export interface MdxStreamChange {
+  readonly snapshot: MdxStreamSnapshot;
+  /** Blocks before this index are the previous snapshot's block objects, except `refreshed`. */
+  readonly start: number;
+  /** Earlier blocks that rendered again because a definition they reference changed. */
+  readonly refreshed: readonly StreamBlock[];
+  readonly footnotesChanged: boolean;
+}
+//#endregion
+export {};
+//# sourceMappingURL=stream-types.d.mts.map

package/dist/stream-types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-types.d.mts","names":[],"sources":["../src/stream-types.ts"],"mappings":";;;;;;;;cAQc;;YAGF;YAA+B;;iBAE1B;WACN;WACA;WACA;;;iBAIM;WACN;WACA;;;iBAIM;WACN,IAAI;WACJ,QAAQ;;WAER,gBAAgB;;WAEhB;;;;;WAKA;;;iBAIM;WACN,iBAAiB;;WAEjB,WAAW;;iBAGL,oBAAoB;WAC1B,sBAAsB;WACtB,cAAc;;;iBAIR,0BAA0B;WAChC;WACA,MAAM;WACN,iBAAiB;WACjB,sBAAsB;;WAEtB,OAAO;;iBAGD;WACN,IAAI;WACJ,QAAQ;;iBAGF,4BAA4B;WAClC;;WAEA,iBAAiB;;iBAGX,wBAAwB;;WAE9B;;iBAGM;;WAEN;;WAEA;WACA,SAAS;WACT,SAAS;;;iBAIH;WACN,UAAU;;WAEV;;WAEA,oBAAoB;WACpB"}

package/dist/stream-types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/stream.d.mts

@@ -0,0 +1,28 @@
+import { MdxEdit, MdxStreamChange, MdxStreamCompletion, MdxStreamOptions, MdxStreamSnapshot } from "./stream-types.mjs";
+//#region src/stream.d.ts
+/**
+ * Parses a document while it arrives.
+ * Each append renders only the open tail.
+ * Settled blocks keep their identity, so renderers update only what changed.
+ */
+export declare class MdxStream {
+  #private;
+  constructor(options?: MdxStreamOptions);
+  append(text: string): MdxStreamSnapshot;
+  edit(edit: MdxEdit): MdxStreamSnapshot;
+  snapshot(): MdxStreamSnapshot | MdxStreamCompletion;
+  /**
+   * Finishes the document strictly. Success is terminal.
+   * After a failure the stream stays open, so an edit can repair it.
+   *
+   * @throws {ParseError} Invalid authored syntax.
+   * @throws {LimitError} An exceeded parser limit.
+   */
+  complete(): MdxStreamCompletion;
+  /** Calls `listener` after every change with what changed since the previous snapshot. */
+  subscribe(listener: (change: MdxStreamChange) => void): () => void;
+  private publish;
+  private assertOpen;
+}
+//#endregion
+//# sourceMappingURL=stream.d.mts.map

package/dist/stream.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.mts","names":[],"sources":["../src/stream.ts"],"mappings":";;;;;;;qBAmBa;;EAKX,YAAmB,UAAS;EAqBrB,OAAO,eAAe;EAQtB,KAAK,MAAM,UAAU;EAiBrB,YAAY,oBAAoB;;;;;;;;EAWhC,YAAY;;EAaZ,UAAU,WAAW,QAAQ;UAM5B;UAQA"}

package/dist/stream.mjs

@@ -0,0 +1,68 @@
+import { ConfigurationError, InputError } from "./errors.mjs";
+import { resolveParserLimits } from "./parser/config.mjs";
+import { StreamSession } from "./stream-session.mjs";
+//#region src/stream.ts
+const defaultMaximumPendingBlockLength = 4194304;
+/**
+* Parses a document while it arrives.
+* Each append renders only the open tail.
+* Settled blocks keep their identity, so renderers update only what changed.
+*/
+var MdxStream = class {
+	#session;
+	#listeners = /* @__PURE__ */ new Set();
+	#completion;
+	constructor(options = {}) {
+		const { maximumPendingBlockLength = defaultMaximumPendingBlockLength, ...limits } = options.limits ?? {};
+		if (!Number.isSafeInteger(maximumPendingBlockLength) || maximumPendingBlockLength < 1) throw ConfigurationError.invalidStreamLimit("maximumPendingBlockLength", maximumPendingBlockLength, 1);
+		this.#session = new StreamSession({
+			name: options.name ?? "source.mdx",
+			source: options.source ?? "",
+			syntax: options.syntax,
+			limits: resolveParserLimits(limits),
+			maximumPendingBlockLength
+		});
+	}
+	append(text) {
+		this.assertOpen();
+		return text.length === 0 ? this.#session.current.snapshot : this.publish(this.#session.append(text));
+	}
+	edit(edit) {
+		this.assertOpen();
+		const length = this.#session.current.snapshot.file.length;
+		if (!Number.isSafeInteger(edit.start) || !Number.isSafeInteger(edit.end) || edit.start < 0 || edit.end < edit.start || edit.end > length) throw InputError.replacementRangeOutsideSource(edit.start, edit.end, length);
+		return this.publish(this.#session.edit(edit));
+	}
+	snapshot() {
+		return this.#completion ?? this.#session.current.snapshot;
+	}
+	/**
+	* Finishes the document strictly. Success is terminal.
+	* After a failure the stream stays open, so an edit can repair it.
+	*
+	* @throws {ParseError} Invalid authored syntax.
+	* @throws {LimitError} An exceeded parser limit.
+	*/
+	complete() {
+		if (this.#completion !== void 0) return this.#completion;
+		const completion = this.#session.complete();
+		this.#completion = completion;
+		return completion;
+	}
+	/** Calls `listener` after every change with what changed since the previous snapshot. */
+	subscribe(listener) {
+		this.#listeners.add(listener);
+		return () => this.#listeners.delete(listener);
+	}
+	publish(change) {
+		for (const listener of this.#listeners) listener(change);
+		return change.snapshot;
+	}
+	assertOpen() {
+		if (this.#completion !== void 0) throw InputError.streamCompleted();
+	}
+};
+//#endregion
+export { MdxStream };
+
+//# sourceMappingURL=stream.mjs.map

package/dist/stream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.mjs","names":[],"sources":["../src/stream.ts"],"sourcesContent":["import type {\n  MdxEdit,\n  MdxStreamChange,\n  MdxStreamCompletion,\n  MdxStreamOptions,\n  MdxStreamSnapshot,\n} from \"./stream-types.ts\";\n\nimport { ConfigurationError, InputError } from \"./errors.ts\";\nimport { resolveParserLimits } from \"./parser/config.ts\";\nimport { StreamSession } from \"./stream-session.ts\";\n\nconst defaultMaximumPendingBlockLength = 4 * 1024 * 1024;\n\n/**\n * Parses a document while it arrives.\n * Each append renders only the open tail.\n * Settled blocks keep their identity, so renderers update only what changed.\n */\nexport class MdxStream {\n  readonly #session: StreamSession;\n  readonly #listeners = new Set<(change: MdxStreamChange) => void>();\n  #completion: MdxStreamCompletion | undefined;\n\n  public constructor(options: MdxStreamOptions = {}) {\n    const { maximumPendingBlockLength = defaultMaximumPendingBlockLength, ...limits } =\n      options.limits ?? {};\n\n    if (!Number.isSafeInteger(maximumPendingBlockLength) || maximumPendingBlockLength < 1) {\n      throw ConfigurationError.invalidStreamLimit(\n        \"maximumPendingBlockLength\",\n        maximumPendingBlockLength,\n        1,\n      );\n    }\n\n    this.#session = new StreamSession({\n      name: options.name ?? \"source.mdx\",\n      source: options.source ?? \"\",\n      syntax: options.syntax,\n      limits: resolveParserLimits(limits),\n      maximumPendingBlockLength,\n    });\n  }\n\n  public append(text: string): MdxStreamSnapshot {\n    this.assertOpen();\n\n    return text.length === 0\n      ? this.#session.current.snapshot\n      : this.publish(this.#session.append(text));\n  }\n\n  public edit(edit: MdxEdit): MdxStreamSnapshot {\n    this.assertOpen();\n    const length = this.#session.current.snapshot.file.length;\n\n    if (\n      !Number.isSafeInteger(edit.start) ||\n      !Number.isSafeInteger(edit.end) ||\n      edit.start < 0 ||\n      edit.end < edit.start ||\n      edit.end > length\n    ) {\n      throw InputError.replacementRangeOutsideSource(edit.start, edit.end, length);\n    }\n\n    return this.publish(this.#session.edit(edit));\n  }\n\n  public snapshot(): MdxStreamSnapshot | MdxStreamCompletion {\n    return this.#completion ?? this.#session.current.snapshot;\n  }\n\n  /**\n   * Finishes the document strictly. Success is terminal.\n   * After a failure the stream stays open, so an edit can repair it.\n   *\n   * @throws {ParseError} Invalid authored syntax.\n   * @throws {LimitError} An exceeded parser limit.\n   */\n  public complete(): MdxStreamCompletion {\n    if (this.#completion !== undefined) {\n      return this.#completion;\n    }\n\n    const completion = this.#session.complete();\n\n    this.#completion = completion;\n\n    return completion;\n  }\n\n  /** Calls `listener` after every change with what changed since the previous snapshot. */\n  public subscribe(listener: (change: MdxStreamChange) => void): () => void {\n    this.#listeners.add(listener);\n\n    return () => this.#listeners.delete(listener);\n  }\n\n  private publish(change: MdxStreamChange): MdxStreamSnapshot {\n    for (const listener of this.#listeners) {\n      listener(change);\n    }\n\n    return change.snapshot;\n  }\n\n  private assertOpen(): void {\n    if (this.#completion !== undefined) {\n      throw InputError.streamCompleted();\n    }\n  }\n}\n"],"mappings":";;;;AAYA,MAAM,mCAAmC;;;;;;AAOzC,IAAa,YAAb,MAAuB;CACrB;CACA,6BAAsB,IAAI,IAAuC;CACjE;CAEA,YAAmB,UAA4B,CAAC,GAAG;EACjD,MAAM,EAAE,4BAA4B,kCAAkC,GAAG,WACvE,QAAQ,UAAU,CAAC;EAErB,IAAI,CAAC,OAAO,cAAc,yBAAyB,KAAK,4BAA4B,GAClF,MAAM,mBAAmB,mBACvB,6BACA,2BACA,CACF;EAGF,KAAK,WAAW,IAAI,cAAc;GAChC,MAAM,QAAQ,QAAQ;GACtB,QAAQ,QAAQ,UAAU;GAC1B,QAAQ,QAAQ;GAChB,QAAQ,oBAAoB,MAAM;GAClC;EACF,CAAC;CACH;CAEA,OAAc,MAAiC;EAC7C,KAAK,WAAW;EAEhB,OAAO,KAAK,WAAW,IACnB,KAAK,SAAS,QAAQ,WACtB,KAAK,QAAQ,KAAK,SAAS,OAAO,IAAI,CAAC;CAC7C;CAEA,KAAY,MAAkC;EAC5C,KAAK,WAAW;EAChB,MAAM,SAAS,KAAK,SAAS,QAAQ,SAAS,KAAK;EAEnD,IACE,CAAC,OAAO,cAAc,KAAK,KAAK,KAChC,CAAC,OAAO,cAAc,KAAK,GAAG,KAC9B,KAAK,QAAQ,KACb,KAAK,MAAM,KAAK,SAChB,KAAK,MAAM,QAEX,MAAM,WAAW,8BAA8B,KAAK,OAAO,KAAK,KAAK,MAAM;EAG7E,OAAO,KAAK,QAAQ,KAAK,SAAS,KAAK,IAAI,CAAC;CAC9C;CAEA,WAA2D;EACzD,OAAO,KAAK,eAAe,KAAK,SAAS,QAAQ;CACnD;;;;;;;;CASA,WAAuC;EACrC,IAAI,KAAK,gBAAgB,KAAA,GACvB,OAAO,KAAK;EAGd,MAAM,aAAa,KAAK,SAAS,SAAS;EAE1C,KAAK,cAAc;EAEnB,OAAO;CACT;;CAGA,UAAiB,UAAyD;EACxE,KAAK,WAAW,IAAI,QAAQ;EAE5B,aAAa,KAAK,WAAW,OAAO,QAAQ;CAC9C;CAEA,QAAgB,QAA4C;EAC1D,KAAK,MAAM,YAAY,KAAK,YAC1B,SAAS,MAAM;EAGjB,OAAO,OAAO;CAChB;CAEA,aAA2B;EACzB,IAAI,KAAK,gBAAgB,KAAA,GACvB,MAAM,WAAW,gBAAgB;CAErC;AACF"}

package/dist/syntax-options.d.mts

@@ -0,0 +1,21 @@
+//#region src/syntax-options.d.ts
+export type FrontmatterFormat = "yaml" | "toml";
+export type FrontmatterMode = "auto" | FrontmatterFormat;
+export type MathFormat = "dollar" | "tex";
+export type MathMode = "auto" | MathFormat;
+export interface SyntaxOptions {
+  readonly directives?: boolean;
+  readonly frontmatter?: FrontmatterMode;
+  readonly math?: MathMode;
+  readonly strikethroughMarkerCount?: 1 | 2;
+}
+export interface ResolvedSyntaxOptions {
+  readonly directives: boolean;
+  readonly frontmatter: readonly FrontmatterFormat[];
+  readonly math: readonly MathFormat[];
+  readonly singleTilde: boolean;
+}
+export declare function resolveSyntaxOptions(options?: SyntaxOptions): ResolvedSyntaxOptions;
+export declare function frontmatterFence(format: FrontmatterFormat): "---" | "+++";
+//#endregion
+//# sourceMappingURL=syntax-options.d.mts.map

package/dist/syntax-options.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"syntax-options.d.mts","names":[],"sources":["../src/syntax-options.ts"],"mappings":";YAAY;YAEA,2BAA2B;YAE3B;YAEA,oBAAoB;iBAEf;WACN;WACA,cAAc;WACd,OAAO;WACP;;iBAGM;WACN;WACA,sBAAsB;WACtB,eAAe;WACf;;wBAGK,qBAAqB,UAAS,gBAAqB;wBAqBnD,iBAAiB,QAAQ"}

package/dist/syntax-options.mjs

@@ -0,0 +1,26 @@
+//#region src/syntax-options.ts
+function resolveSyntaxOptions(options = {}) {
+	return {
+		directives: options.directives ?? false,
+		frontmatter: resolveFrontmatter(options.frontmatter),
+		math: resolveMath(options.math),
+		singleTilde: (options.strikethroughMarkerCount ?? 1) === 1
+	};
+}
+function resolveMath(mode) {
+	if (mode === void 0) return [];
+	if (mode === "auto") return ["dollar", "tex"];
+	return [mode];
+}
+function frontmatterFence(format) {
+	return format === "yaml" ? "---" : "+++";
+}
+function resolveFrontmatter(mode) {
+	if (mode === void 0) return [];
+	if (mode === "auto") return ["yaml", "toml"];
+	return [mode];
+}
+//#endregion
+export { frontmatterFence, resolveSyntaxOptions };
+
+//# sourceMappingURL=syntax-options.mjs.map

package/dist/syntax-options.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"syntax-options.mjs","names":[],"sources":["../src/syntax-options.ts"],"sourcesContent":["export type FrontmatterFormat = \"yaml\" | \"toml\";\n\nexport type FrontmatterMode = \"auto\" | FrontmatterFormat;\n\nexport type MathFormat = \"dollar\" | \"tex\";\n\nexport type MathMode = \"auto\" | MathFormat;\n\nexport interface SyntaxOptions {\n  readonly directives?: boolean;\n  readonly frontmatter?: FrontmatterMode;\n  readonly math?: MathMode;\n  readonly strikethroughMarkerCount?: 1 | 2;\n}\n\nexport interface ResolvedSyntaxOptions {\n  readonly directives: boolean;\n  readonly frontmatter: readonly FrontmatterFormat[];\n  readonly math: readonly MathFormat[];\n  readonly singleTilde: boolean;\n}\n\nexport function resolveSyntaxOptions(options: SyntaxOptions = {}): ResolvedSyntaxOptions {\n  return {\n    directives: options.directives ?? false,\n    frontmatter: resolveFrontmatter(options.frontmatter),\n    math: resolveMath(options.math),\n    singleTilde: (options.strikethroughMarkerCount ?? 1) === 1,\n  };\n}\n\nfunction resolveMath(mode: MathMode | undefined): readonly MathFormat[] {\n  if (mode === undefined) {\n    return [];\n  }\n\n  if (mode === \"auto\") {\n    return [\"dollar\", \"tex\"];\n  }\n\n  return [mode];\n}\n\nexport function frontmatterFence(format: FrontmatterFormat): \"---\" | \"+++\" {\n  return format === \"yaml\" ? \"---\" : \"+++\";\n}\n\nfunction resolveFrontmatter(mode: FrontmatterMode | undefined): readonly FrontmatterFormat[] {\n  if (mode === undefined) {\n    return [];\n  }\n\n  if (mode === \"auto\") {\n    return [\"yaml\", \"toml\"];\n  }\n\n  return [mode];\n}\n"],"mappings":";AAsBA,SAAgB,qBAAqB,UAAyB,CAAC,GAA0B;CACvF,OAAO;EACL,YAAY,QAAQ,cAAc;EAClC,aAAa,mBAAmB,QAAQ,WAAW;EACnD,MAAM,YAAY,QAAQ,IAAI;EAC9B,cAAc,QAAQ,4BAA4B,OAAO;CAC3D;AACF;AAEA,SAAS,YAAY,MAAmD;CACtE,IAAI,SAAS,KAAA,GACX,OAAO,CAAC;CAGV,IAAI,SAAS,QACX,OAAO,CAAC,UAAU,KAAK;CAGzB,OAAO,CAAC,IAAI;AACd;AAEA,SAAgB,iBAAiB,QAA0C;CACzE,OAAO,WAAW,SAAS,QAAQ;AACrC;AAEA,SAAS,mBAAmB,MAAiE;CAC3F,IAAI,SAAS,KAAA,GACX,OAAO,CAAC;CAGV,IAAI,SAAS,QACX,OAAO,CAAC,QAAQ,MAAM;CAGxB,OAAO,CAAC,IAAI;AACd"}

package/dist/traversal.d.mts

@@ -0,0 +1,25 @@
+import { DocumentNode, FlowContent, MdxKind, MdxNode, MdxNodeForKind, PhrasingContent } from "./model.mjs";
+import { HtmlKind, HtmlNode, HtmlNodeForKind, HtmlRootNode } from "./html.mjs";
+import { TreeCursor } from "./tree.mjs";
+//#region src/traversal.d.ts
+export declare function walkMdx(root: MdxNode): Iterable<TreeCursor<MdxNode>>;
+export declare function selectMdx<TKind extends MdxKind>(root: MdxNode, kind: TKind): Iterable<TreeCursor<MdxNode, MdxNodeForKind<TKind>>>;
+export declare function walkHtml(root: HtmlNode): Iterable<TreeCursor<HtmlNode>>;
+export declare function selectHtml<TKind extends HtmlKind>(root: HtmlNode, kind: TKind): Iterable<TreeCursor<HtmlNode, HtmlNodeForKind<TKind>>>;
+/**
+ * A node that may replace `TNode`: any phrasing node for phrasing content, any
+ * flow node for flow content, and the same kind otherwise.
+ */
+export type MdxReplacement<TNode extends MdxNode> = TNode extends PhrasingContent ? PhrasingContent : TNode extends FlowContent ? FlowContent : TNode;
+/**
+ * A rewrite handler runs before the node's children are rewritten. Returning
+ * `undefined` keeps the node, a node of the same content category replaces it,
+ * and `null` removes it from its parent.
+ */
+export type MdxRewriteHandlers = { readonly [TKind in MdxKind]?: (cursor: TreeCursor<MdxNode, MdxNodeForKind<TKind>>) => MdxReplacement<MdxNodeForKind<TKind>> | null | undefined; };
+/** HTML handlers may replace a node with any node kind, because every parent accepts all kinds. */
+export type HtmlRewriteHandlers = { readonly [TKind in HtmlKind]?: (cursor: TreeCursor<HtmlNode, HtmlNodeForKind<TKind>>) => HtmlNode | null | undefined; };
+export declare function rewriteMdx(document: DocumentNode, handlers: MdxRewriteHandlers): DocumentNode;
+export declare function rewriteHtml(root: HtmlRootNode, handlers: HtmlRewriteHandlers): HtmlRootNode;
+//#endregion
+//# sourceMappingURL=traversal.d.mts.map

package/dist/traversal.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traversal.d.mts","names":[],"sources":["../src/traversal.ts"],"mappings":";;;;wBAeiB,QAAQ,MAAM,UAAU,SAAS,WAAW;wBAI5C,UAAU,cAAc,SACvC,MAAM,SACN,MAAM,QACL,SAAS,WAAW,SAAS,eAAe;wBAI9B,SAAS,MAAM,WAAW,SAAS,WAAW;wBAI9C,WAAW,cAAc,UACxC,MAAM,UACN,MAAM,QACL,SAAS,WAAW,UAAU,gBAAgB;;;;;YAQrC,eAAe,cAAc,WAAW,cAAc,kBAC9D,kBACA,cAAc,cACZ,cACA;;;;;;YAOM,iCACA,SAAS,YACjB,QAAQ,WAAW,SAAS,eAAe,YACxC,eAAe,eAAe;;YAIzB,kCACA,SAAS,aACjB,QAAQ,WAAW,UAAU,gBAAgB,YAC1C;wBAGS,WAAW,UAAU,cAAc,UAAU,qBAAqB;wBAMlE,YAAY,MAAM,cAAc,UAAU,sBAAsB"}

package/dist/traversal.mjs

@@ -0,0 +1,136 @@
+import { htmlChildren } from "./html.mjs";
+import { isFlowContent, isPhrasingContent, mdxChildren } from "./model.mjs";
+import { TreeCursor, selectTree, walkTree } from "./tree.mjs";
+//#region src/traversal.ts
+function* walkMdx(root) {
+	yield* walkTree(root, mdxChildren);
+}
+function* selectMdx(root, kind) {
+	yield* selectTree(root, kind, mdxChildren);
+}
+function* walkHtml(root) {
+	yield* walkTree(root, htmlChildren);
+}
+function* selectHtml(root, kind) {
+	yield* selectTree(root, kind, htmlChildren);
+}
+function rewriteMdx(document, handlers) {
+	const result = rewriteMdxNode(document, void 0, void 0, handlers);
+	return result?.kind === "document" ? result : {
+		...document,
+		children: []
+	};
+}
+function rewriteHtml(root, handlers) {
+	const result = rewriteHtmlNode(root, void 0, void 0, handlers);
+	if (result === null) return {
+		...root,
+		children: []
+	};
+	return result.kind === "root" ? result : {
+		...root,
+		children: [result]
+	};
+}
+function rewriteMdxNode(node, parent, index, handlers) {
+	const handler = handlers[node.kind];
+	const replacement = handler?.(new TreeCursor(node, parent, index));
+	if (replacement === null) return null;
+	if (replacement !== void 0 && !replaceable(node, replacement)) throw new TypeError(`A ${node.kind} rewrite handler returned a ${replacement.kind} node`);
+	const current = replacement ?? node;
+	const cursor = new TreeCursor(current, parent, index);
+	switch (current.kind) {
+		case "textDirective":
+		case "leafDirective": {
+			const label = rewriteLabel(current.label, cursor, handlers);
+			return label === current.label ? current : {
+				...current,
+				label
+			};
+		}
+		case "containerDirective": {
+			const body = rewriteParent(current, cursor, current.label === void 0 ? 0 : 1, handlers);
+			const label = rewriteLabel(current.label, cursor, handlers);
+			return label === body.label ? body : {
+				...body,
+				label
+			};
+		}
+		default: return "children" in current ? rewriteParent(current, cursor, 0, handlers) : current;
+	}
+}
+function rewriteParent(node, cursor, offset, handlers) {
+	const children = rewriteChildren(node.children, (child, childIndex) => rewriteMdxNode(child, cursor, childIndex + offset, handlers));
+	if (children === node.children) return node;
+	if (!fitsParent(node, children)) throw new TypeError(`A rewrite produced children that a ${node.kind} node cannot contain`);
+	return {
+		...node,
+		children
+	};
+}
+/** Rewrite handlers keep content categories, so this holds unless a handler bypassed the types. */
+function fitsParent(parent, children) {
+	return children.every((child) => acceptsChild(parent, child));
+}
+function acceptsChild(parent, child) {
+	switch (parent.kind) {
+		case "list": return child.kind === "listItem";
+		case "table": return child.kind === "tableRow";
+		case "tableRow": return child.kind === "tableCell";
+		case "document":
+		case "blockquote":
+		case "listItem":
+		case "footnoteDefinition":
+		case "containerDirective":
+		case "jsxFlowElement": return isFlowContent(child);
+		case "emphasis":
+		case "strong":
+		case "delete":
+		case "link":
+		case "linkReference":
+		case "directiveLabel":
+		case "jsxTextElement":
+		case "paragraph":
+		case "heading":
+		case "tableCell": return isPhrasingContent(child);
+		default: return parent;
+	}
+}
+function rewriteHtmlNode(node, parent, index, handlers) {
+	const handler = handlers[node.kind];
+	const replacement = handler?.(new TreeCursor(node, parent, index));
+	if (replacement === null) return null;
+	const current = replacement ?? node;
+	if (!("children" in current)) return current;
+	const cursor = new TreeCursor(current, parent, index);
+	const children = rewriteChildren(current.children, (child, childIndex) => rewriteHtmlNode(child, cursor, childIndex, handlers));
+	return children === current.children ? current : {
+		...current,
+		children
+	};
+}
+/** Returns the original array when every child is kept unchanged. */
+function rewriteChildren(children, rewrite) {
+	let result;
+	for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		const next = rewrite(child, i);
+		if (result === void 0 && next !== child) result = children.slice(0, i);
+		if (result !== void 0 && next !== null) result.push(next);
+	}
+	return result ?? children;
+}
+function rewriteLabel(label, parent, handlers) {
+	const result = label === void 0 ? void 0 : rewriteMdxNode(label, parent, 0, handlers);
+	return result?.kind === "directiveLabel" ? result : void 0;
+}
+/** Phrasing and flow nodes may change kind within their category; other nodes keep their kind. */
+function replaceable(node, replacement) {
+	if (isPhrasingContent(node)) return isPhrasingContent(replacement);
+	if (isFlowContent(node)) return isFlowContent(replacement);
+	return replacement.kind === node.kind;
+}
+//#endregion
+export { rewriteHtml, rewriteMdx, selectHtml, selectMdx, walkHtml, walkMdx };
+
+//# sourceMappingURL=traversal.mjs.map

package/dist/traversal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"traversal.mjs","names":["exhaustive"],"sources":["../src/traversal.ts"],"sourcesContent":["import type { HtmlKind, HtmlNode, HtmlNodeForKind, HtmlRootNode } from \"./html.ts\";\nimport type {\n  DirectiveLabelNode,\n  DocumentNode,\n  FlowContent,\n  MdxKind,\n  MdxNode,\n  MdxNodeForKind,\n  PhrasingContent,\n} from \"./model.ts\";\n\nimport { htmlChildren } from \"./html.ts\";\nimport { isFlowContent, isPhrasingContent, mdxChildren } from \"./model.ts\";\nimport { selectTree, TreeCursor, walkTree } from \"./tree.ts\";\n\nexport function* walkMdx(root: MdxNode): Iterable<TreeCursor<MdxNode>> {\n  yield* walkTree(root, mdxChildren);\n}\n\nexport function* selectMdx<TKind extends MdxKind>(\n  root: MdxNode,\n  kind: TKind,\n): Iterable<TreeCursor<MdxNode, MdxNodeForKind<TKind>>> {\n  yield* selectTree(root, kind, mdxChildren);\n}\n\nexport function* walkHtml(root: HtmlNode): Iterable<TreeCursor<HtmlNode>> {\n  yield* walkTree(root, htmlChildren);\n}\n\nexport function* selectHtml<TKind extends HtmlKind>(\n  root: HtmlNode,\n  kind: TKind,\n): Iterable<TreeCursor<HtmlNode, HtmlNodeForKind<TKind>>> {\n  yield* selectTree(root, kind, htmlChildren);\n}\n\n/**\n * A node that may replace `TNode`: any phrasing node for phrasing content, any\n * flow node for flow content, and the same kind otherwise.\n */\nexport type MdxReplacement<TNode extends MdxNode> = TNode extends PhrasingContent\n  ? PhrasingContent\n  : TNode extends FlowContent\n    ? FlowContent\n    : TNode;\n\n/**\n * A rewrite handler runs before the node's children are rewritten. Returning\n * `undefined` keeps the node, a node of the same content category replaces it,\n * and `null` removes it from its parent.\n */\nexport type MdxRewriteHandlers = {\n  readonly [TKind in MdxKind]?: (\n    cursor: TreeCursor<MdxNode, MdxNodeForKind<TKind>>,\n  ) => MdxReplacement<MdxNodeForKind<TKind>> | null | undefined;\n};\n\n/** HTML handlers may replace a node with any node kind, because every parent accepts all kinds. */\nexport type HtmlRewriteHandlers = {\n  readonly [TKind in HtmlKind]?: (\n    cursor: TreeCursor<HtmlNode, HtmlNodeForKind<TKind>>,\n  ) => HtmlNode | null | undefined;\n};\n\nexport function rewriteMdx(document: DocumentNode, handlers: MdxRewriteHandlers): DocumentNode {\n  const result = rewriteMdxNode(document, undefined, undefined, handlers);\n\n  return result?.kind === \"document\" ? result : { ...document, children: [] };\n}\n\nexport function rewriteHtml(root: HtmlRootNode, handlers: HtmlRewriteHandlers): HtmlRootNode {\n  const result = rewriteHtmlNode(root, undefined, undefined, handlers);\n\n  if (result === null) {\n    return { ...root, children: [] };\n  }\n\n  return result.kind === \"root\" ? result : { ...root, children: [result] };\n}\n\nfunction rewriteMdxNode(\n  node: MdxNode,\n  parent: TreeCursor<MdxNode> | undefined,\n  index: number | undefined,\n  handlers: MdxRewriteHandlers,\n): MdxNode | null {\n  const handler: MdxRewriteHandlers[typeof node.kind] = handlers[node.kind];\n\n  const replacement = handler?.(\n    // @ts-ignore\n    new TreeCursor(node, parent, index),\n  );\n\n  if (replacement === null) {\n    return null;\n  }\n\n  if (replacement !== undefined && !replaceable(node, replacement)) {\n    throw new TypeError(`A ${node.kind} rewrite handler returned a ${replacement.kind} node`);\n  }\n\n  const current = replacement ?? node;\n  const cursor = new TreeCursor<MdxNode>(current, parent, index);\n\n  switch (current.kind) {\n    case \"textDirective\":\n    case \"leafDirective\": {\n      const label = rewriteLabel(current.label, cursor, handlers);\n\n      return label === current.label ? current : { ...current, label };\n    }\n\n    case \"containerDirective\": {\n      const offset = current.label === undefined ? 0 : 1;\n      const body = rewriteParent(current, cursor, offset, handlers);\n      const label = rewriteLabel(current.label, cursor, handlers);\n\n      return label === body.label ? body : { ...body, label };\n    }\n\n    default:\n      return \"children\" in current ? rewriteParent(current, cursor, 0, handlers) : current;\n  }\n}\n\ntype MdxParentNode = Extract<MdxNode, { readonly children: readonly MdxNode[] }>;\n\nfunction rewriteParent<TNode extends MdxParentNode>(\n  node: TNode,\n  cursor: TreeCursor<MdxNode>,\n  offset: number,\n  handlers: MdxRewriteHandlers,\n): TNode {\n  const children = rewriteChildren<MdxNode>(node.children, (child, childIndex) =>\n    rewriteMdxNode(child, cursor, childIndex + offset, handlers),\n  );\n\n  if (children === node.children) {\n    return node;\n  }\n\n  if (!fitsParent(node, children)) {\n    throw new TypeError(`A rewrite produced children that a ${node.kind} node cannot contain`);\n  }\n\n  return { ...node, children };\n}\n\n/** Rewrite handlers keep content categories, so this holds unless a handler bypassed the types. */\nfunction fitsParent<TNode extends MdxParentNode>(\n  parent: TNode,\n  children: readonly MdxNode[],\n): children is TNode[\"children\"] {\n  return children.every((child) => acceptsChild(parent, child));\n}\n\nfunction acceptsChild(parent: MdxParentNode, child: MdxNode): boolean {\n  switch (parent.kind) {\n    case \"list\":\n      return child.kind === \"listItem\";\n    case \"table\":\n      return child.kind === \"tableRow\";\n    case \"tableRow\":\n      return child.kind === \"tableCell\";\n    case \"document\":\n    case \"blockquote\":\n    case \"listItem\":\n    case \"footnoteDefinition\":\n    case \"containerDirective\":\n    case \"jsxFlowElement\":\n      return isFlowContent(child);\n    case \"emphasis\":\n    case \"strong\":\n    case \"delete\":\n    case \"link\":\n    case \"linkReference\":\n    case \"directiveLabel\":\n    case \"jsxTextElement\":\n    case \"paragraph\":\n    case \"heading\":\n    case \"tableCell\":\n      return isPhrasingContent(child);\n    default: {\n      const exhaustive: never = parent;\n\n      return exhaustive;\n    }\n  }\n}\n\nfunction rewriteHtmlNode(\n  node: HtmlNode,\n  parent: TreeCursor<HtmlNode> | undefined,\n  index: number | undefined,\n  handlers: HtmlRewriteHandlers,\n): HtmlNode | null {\n  const handler: HtmlRewriteHandlers[typeof node.kind] = handlers[node.kind];\n\n  const replacement = handler?.(\n    // @ts-ignore\n    new TreeCursor(node, parent, index),\n  );\n\n  if (replacement === null) {\n    return null;\n  }\n\n  const current = replacement ?? node;\n\n  if (!(\"children\" in current)) {\n    return current;\n  }\n\n  const cursor = new TreeCursor<HtmlNode>(current, parent, index);\n\n  const children = rewriteChildren<HtmlNode>(current.children, (child, childIndex) =>\n    rewriteHtmlNode(child, cursor, childIndex, handlers),\n  );\n\n  return children === current.children ? current : { ...current, children };\n}\n\n/** Returns the original array when every child is kept unchanged. */\nfunction rewriteChildren<TChild>(\n  children: readonly TChild[],\n  rewrite: (child: TChild, index: number) => TChild | null,\n): readonly TChild[] {\n  let result: TChild[] | undefined;\n\n  for (let i = 0; i < children.length; i++) {\n    const child = children[i];\n    const next = rewrite(child, i);\n\n    if (result === undefined && next !== child) {\n      result = children.slice(0, i);\n    }\n\n    if (result !== undefined && next !== null) {\n      result.push(next);\n    }\n  }\n\n  return result ?? children;\n}\n\nfunction rewriteLabel(\n  label: DirectiveLabelNode | undefined,\n  parent: TreeCursor<MdxNode>,\n  handlers: MdxRewriteHandlers,\n): DirectiveLabelNode | undefined {\n  const result = label === undefined ? undefined : rewriteMdxNode(label, parent, 0, handlers);\n\n  return result?.kind === \"directiveLabel\" ? result : undefined;\n}\n\n/** Phrasing and flow nodes may change kind within their category; other nodes keep their kind. */\nfunction replaceable(node: MdxNode, replacement: MdxNode): boolean {\n  if (isPhrasingContent(node)) {\n    return isPhrasingContent(replacement);\n  }\n\n  if (isFlowContent(node)) {\n    return isFlowContent(replacement);\n  }\n\n  return replacement.kind === node.kind;\n}\n"],"mappings":"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"}

package/dist/tree.d.mts

@@ -0,0 +1,18 @@
+//#region src/tree.d.ts
+export declare class TreeCursor<TRoot, TNode extends TRoot = TRoot> {
+  readonly depth: number;
+  readonly index?: number;
+  readonly node: TNode;
+  readonly parent?: TreeCursor<TRoot>;
+  readonly path: readonly number[];
+  constructor(node: TNode, parent?: TreeCursor<TRoot>, index?: number);
+  ancestors(): readonly TRoot[];
+}
+export declare function walkTree<TRoot>(root: TRoot, children: (node: TRoot) => readonly TRoot[]): Iterable<TreeCursor<TRoot>>;
+export declare function selectTree<TRoot extends {
+  readonly kind: string;
+}, TKind extends TRoot["kind"]>(root: TRoot, kind: TKind, children: (node: TRoot) => readonly TRoot[]): Iterable<TreeCursor<TRoot, Extract<TRoot, {
+  readonly kind: TKind;
+}>>>;
+//#endregion
+//# sourceMappingURL=tree.d.mts.map

package/dist/tree.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.mts","names":[],"sources":["../src/tree.ts"],"mappings":";qBAAa,WAAW,OAAO,cAAc,QAAQ;WACnC;WACA;WACA,MAAM;WACN,SAAS,WAAW;WACpB;EAEhB,YAAmB,MAAM,OAAO,SAAS,WAAW,QAAQ;EAQrD,sBAAsB;;wBAad,SAAS,OACxB,MAAM,OACN,WAAW,MAAM,mBAAmB,UACnC,SAAS,WAAW;wBAIN,WAAW;WAAyB;GAAgB,cAAc,eACjF,MAAM,OACN,MAAM,OACN,WAAW,MAAM,mBAAmB,UACnC,SAAS,WAAW,OAAO,QAAQ;WAAkB,MAAM"}

package/dist/tree.mjs

@@ -0,0 +1,43 @@
+//#region src/tree.ts
+var TreeCursor = class {
+	depth;
+	index;
+	node;
+	parent;
+	path;
+	constructor(node, parent, index) {
+		this.node = node;
+		this.parent = parent;
+		this.index = index;
+		this.depth = parent === void 0 ? 0 : parent.depth + 1;
+		this.path = parent === void 0 || index === void 0 ? [] : [...parent.path, index];
+	}
+	ancestors() {
+		const result = [];
+		let cursor = this.parent;
+		while (cursor !== void 0) {
+			result.unshift(cursor.node);
+			cursor = cursor.parent;
+		}
+		return result;
+	}
+};
+function* walkTree(root, children) {
+	yield* walkTreeNode(root, children);
+}
+function* selectTree(root, kind, children) {
+	for (const cursor of walkTree(root, children)) if (hasKind(cursor.node, kind)) yield new TreeCursor(cursor.node, cursor.parent, cursor.index);
+}
+function hasKind(node, kind) {
+	return node.kind === kind;
+}
+function* walkTreeNode(node, children, parent, index) {
+	const cursor = new TreeCursor(node, parent, index);
+	yield cursor;
+	const childNodes = children(node);
+	for (let childIndex = 0; childIndex < childNodes.length; childIndex++) yield* walkTreeNode(childNodes[childIndex], children, cursor, childIndex);
+}
+//#endregion
+export { TreeCursor, selectTree, walkTree };
+
+//# sourceMappingURL=tree.mjs.map

package/dist/tree.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.mjs","names":[],"sources":["../src/tree.ts"],"sourcesContent":["export class TreeCursor<TRoot, TNode extends TRoot = TRoot> {\n  public readonly depth: number;\n  public readonly index?: number;\n  public readonly node: TNode;\n  public readonly parent?: TreeCursor<TRoot>;\n  public readonly path: readonly number[];\n\n  public constructor(node: TNode, parent?: TreeCursor<TRoot>, index?: number) {\n    this.node = node;\n    this.parent = parent;\n    this.index = index;\n    this.depth = parent === undefined ? 0 : parent.depth + 1;\n    this.path = parent === undefined || index === undefined ? [] : [...parent.path, index];\n  }\n\n  public ancestors(): readonly TRoot[] {\n    const result: TRoot[] = [];\n    let cursor = this.parent;\n\n    while (cursor !== undefined) {\n      result.unshift(cursor.node);\n      cursor = cursor.parent;\n    }\n\n    return result;\n  }\n}\n\nexport function* walkTree<TRoot>(\n  root: TRoot,\n  children: (node: TRoot) => readonly TRoot[],\n): Iterable<TreeCursor<TRoot>> {\n  yield* walkTreeNode(root, children);\n}\n\nexport function* selectTree<TRoot extends { readonly kind: string }, TKind extends TRoot[\"kind\"]>(\n  root: TRoot,\n  kind: TKind,\n  children: (node: TRoot) => readonly TRoot[],\n): Iterable<TreeCursor<TRoot, Extract<TRoot, { readonly kind: TKind }>>> {\n  for (const cursor of walkTree(root, children)) {\n    if (hasKind(cursor.node, kind)) {\n      yield new TreeCursor(cursor.node, cursor.parent, cursor.index);\n    }\n  }\n}\n\nfunction hasKind<TRoot extends { readonly kind: string }, TKind extends TRoot[\"kind\"]>(\n  node: TRoot,\n  kind: TKind,\n): node is Extract<TRoot, { readonly kind: TKind }> {\n  return node.kind === kind;\n}\n\nfunction* walkTreeNode<TRoot, TNode extends TRoot>(\n  node: TNode,\n  children: (node: TRoot) => readonly TRoot[],\n  parent?: TreeCursor<TRoot>,\n  index?: number,\n): Iterable<TreeCursor<TRoot>> {\n  const cursor = new TreeCursor<TRoot, TNode>(node, parent, index);\n  yield cursor;\n  const childNodes = children(node);\n\n  for (let childIndex = 0; childIndex < childNodes.length; childIndex++) {\n    yield* walkTreeNode(childNodes[childIndex], children, cursor, childIndex);\n  }\n}\n"],"mappings":";AAAA,IAAa,aAAb,MAA4D;CAC1D;CACA;CACA;CACA;CACA;CAEA,YAAmB,MAAa,QAA4B,OAAgB;EAC1E,KAAK,OAAO;EACZ,KAAK,SAAS;EACd,KAAK,QAAQ;EACb,KAAK,QAAQ,WAAW,KAAA,IAAY,IAAI,OAAO,QAAQ;EACvD,KAAK,OAAO,WAAW,KAAA,KAAa,UAAU,KAAA,IAAY,CAAC,IAAI,CAAC,GAAG,OAAO,MAAM,KAAK;CACvF;CAEA,YAAqC;EACnC,MAAM,SAAkB,CAAC;EACzB,IAAI,SAAS,KAAK;EAElB,OAAO,WAAW,KAAA,GAAW;GAC3B,OAAO,QAAQ,OAAO,IAAI;GAC1B,SAAS,OAAO;EAClB;EAEA,OAAO;CACT;AACF;AAEA,UAAiB,SACf,MACA,UAC6B;CAC7B,OAAO,aAAa,MAAM,QAAQ;AACpC;AAEA,UAAiB,WACf,MACA,MACA,UACuE;CACvE,KAAK,MAAM,UAAU,SAAS,MAAM,QAAQ,GAC1C,IAAI,QAAQ,OAAO,MAAM,IAAI,GAC3B,MAAM,IAAI,WAAW,OAAO,MAAM,OAAO,QAAQ,OAAO,KAAK;AAGnE;AAEA,SAAS,QACP,MACA,MACkD;CAClD,OAAO,KAAK,SAAS;AACvB;AAEA,UAAU,aACR,MACA,UACA,QACA,OAC6B;CAC7B,MAAM,SAAS,IAAI,WAAyB,MAAM,QAAQ,KAAK;CAC/D,MAAM;CACN,MAAM,aAAa,SAAS,IAAI;CAEhC,KAAK,IAAI,aAAa,GAAG,aAAa,WAAW,QAAQ,cACvD,OAAO,aAAa,WAAW,aAAa,UAAU,QAAQ,UAAU;AAE5E"}

package/dist/unified/adapter.d.mts

@@ -0,0 +1,24 @@
+import { DocumentNode } from "../model.mjs";
+import { HtmlRootNode } from "../html.mjs";
+import { DocumentPlugin, DocumentPluginContext, HtmlPlugin, HtmlPluginContext } from "../plugin.mjs";
+import { Plugin, Preset, Transformer } from "unified";
+//#region src/unified/adapter.d.ts
+type UnifiedNode = Parameters<Transformer>[0];
+export type UnifiedAttacher<TParameters extends unknown[] = [], TInput extends UnifiedNode = UnifiedNode, TOutput extends UnifiedNode = TInput> = Plugin<TParameters, TInput, TOutput>;
+export declare class RemarkPluginAdapter<TParameters extends unknown[] = [], TInput extends UnifiedNode = UnifiedNode, TOutput extends UnifiedNode = TInput> implements DocumentPlugin {
+  #private;
+  readonly name: string;
+  constructor(preset: Preset);
+  constructor(plugin: UnifiedAttacher<TParameters, TInput, TOutput>, ...parameters: TParameters);
+  transform(context: DocumentPluginContext): DocumentNode | Promise<DocumentNode>;
+}
+export declare class RehypePluginAdapter<TParameters extends unknown[] = [], TInput extends UnifiedNode = UnifiedNode, TOutput extends UnifiedNode = TInput> implements HtmlPlugin {
+  #private;
+  readonly name: string;
+  constructor(preset: Preset);
+  constructor(plugin: UnifiedAttacher<TParameters, TInput, TOutput>, ...parameters: TParameters);
+  transform(context: HtmlPluginContext): HtmlRootNode | Promise<HtmlRootNode>;
+}
+//#endregion
+export {};
+//# sourceMappingURL=adapter.d.mts.map

package/dist/unified/adapter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.mts","names":[],"sources":["../../src/unified/adapter.ts"],"mappings":";;;;;KAgBK,cAAc,WAAW;YAElB,gBACV,oCACA,eAAe,cAAc,aAC7B,gBAAgB,cAAc,UAC5B,OAAO,aAAa,QAAQ;qBAEnB,oBACX,oCACA,eAAe,cAAc,aAC7B,gBAAgB,cAAc,mBACnB;;WACK;EAGhB,YAAmB,QAAQ;EAC3B,YACE,QAAQ,gBAAgB,aAAa,QAAQ,aAC1C,YAAY;EAUV,UAAU,SAAS,wBAAwB,eAAe,QAAQ;;qBAK9D,oBACX,oCACA,eAAe,cAAc,aAC7B,gBAAgB,cAAc,mBACnB;;WACK;EAGhB,YAAmB,QAAQ;EAC3B,YACE,QAAQ,gBAAgB,aAAa,QAAQ,aAC1C,YAAY;EAUV,UAAU,SAAS,oBAAoB,eAAe,QAAQ"}