markdown-codec 6.0.0 → 6.1.1

package/README.md

@@ -4,7 +4,7 @@
 
 > Hand-written CommonMark+GFM ⇄ `DocumentTree` codec, built on [document-schema.js](../document-schema.js/README.md).
 
-The same "hand-write the format instead of wrapping a third-party library" bet as [`pdf-codec`](../pdf-codec/README.md), aimed at CommonMark and GFM. No `micromark`/`remark`/`marked`/`markdown-it`/`commonmark`/`mdast`/`unified`/`turndown`/`showdown` dependency (enforced by eslint `no-restricted-imports`). Runtime dependencies: `document-schema.js` (the shared pivot) and `zod`. `readMarkdown`/`writeMarkdown` read and write that pivot's tree-form `DocumentTree`; `readMarkdownContent`/`writeMarkdownContent` read and write the flat `ContentDocument` underneath it — the same model [`documents.js`](https://github.com/ExaDev/documents.js) builds docx/pptx/odt/odp conversions around. See [Two encodings](#two-encodings-documentpackage-and-contentdocument).
+The same "hand-write the format instead of wrapping a third-party library" bet as [`pdf-codec`](../pdf-codec/README.md), aimed at CommonMark and GFM. No `micromark`/`remark`/`marked`/`markdown-it`/`commonmark`/`mdast`/`unified`/`turndown`/`showdown` dependency (enforced by eslint `no-restricted-imports`). Runtime dependencies: `document-schema.js` (the shared pivot) and `zod`. `readMarkdown`/`writeMarkdown` read and write that pivot's tree-form `DocumentTree`; `readMarkdownContent`/`writeMarkdownContent` read and write the flat `ContentDocument` underneath it — the same model [`documents.js`](https://github.com/ExaDev/documents.js) builds docx/pptx/odt/odp conversions around. See [Two encodings](#two-encodings-documenttree-and-contentdocument).
 
 ```mermaid
 graph TD
@@ -76,30 +76,33 @@ Published to [npmjs.org](https://www.npmjs.com/package/markdown-codec) via OIDC
 Reading and writing markdown text:
 
 ```ts
-import { readMarkdown, writeMarkdown } from 'markdown-codec';
+import { readMarkdown, writeMarkdown } from "markdown-codec";
 
-const { documentPackage, diagnostics } = readMarkdown('# Title\n\nSome **bold** text with a [link](https://example.com).', {
-  frontMatter: true, // parse a leading YAML front matter block into the package's metadata
-  footnotes: true, // recognise [^label] markers and [^label]: definitions (default; see Footnotes)
-  images: (destination) => undefined, // a synchronous MarkdownImageResolver port for non-data: URI images
-});
+const { documentPackage, diagnostics } = readMarkdown(
+  "# Title\n\nSome **bold** text with a [link](https://example.com).",
+  {
+    frontMatter: true, // parse a leading YAML front matter block into the package's metadata
+    footnotes: true, // recognise [^label] markers and [^label]: definitions (default; see Footnotes)
+    images: (destination) => undefined, // a synchronous MarkdownImageResolver port for non-data: URI images
+  },
+);
 
 const markdown = writeMarkdown(documentPackage, {
-  bulletListMarker: '-',
-  emphasisMarker: '_',
+  bulletListMarker: "-",
+  emphasisMarker: "_",
   frontMatter: true, // emit the package's metadata back out as a leading front matter block
 });
 ```
 
-`documentPackage` is a `DocumentTree` — document-schema.js's tree form, with a minted styles table (see [Two encodings](#two-encodings-documentpackage-and-contentdocument)). The field is named `documentPackage` rather than `package` because `package` is a reserved word in strict mode, so `const { package } = readMarkdown(src)` would not parse.
+`documentPackage` is a `DocumentTree` — document-schema.js's tree form, with a minted styles table (see [Two encodings](#two-encodings-documenttree-and-contentdocument)). The field is named `documentPackage` rather than `package` because `package` is a reserved word in strict mode, so `const { package } = readMarkdown(src)` would not parse.
 
 Both accept an optional `signal` (`AbortSignal`) and `sink` (`MarkdownDiagnosticSink`, called once per recoverable issue or construct-mapping gap — see [Gotchas](#gotchas-and-quirks)). `writeMarkdown` throws `MarkdownUnsupportedDocumentKindError` for a package whose `kind` is not `'wordprocessing'`, checked before flattening so every non-`'wordprocessing'` package reaches it the same way regardless of what else about that package would have failed document-schema.js's own `flattenTree`. A `'wordprocessing'` package can still fail to flatten — a group carrying a style reference the package's own `styles` table has no entry for — and that failure surfaces as `MarkdownPackageFlattenError`, not a bare `Error` from the dependency. A `DocumentTree`'s own `layers`/`attachments`/`destinations`/`pages` tables have no flat-`ContentDocument` home to land in; `writeMarkdown` reports one `PACKAGE_TABLE_DROPPED` diagnostic per non-empty table it finds rather than dropping them without a trace. The `definitions` table is the one exemption: this package's own link-tenant entries (what `readMarkdown` splices there from the source's reference definitions) render back out as `[label]: destination "title"` lines, so only a table holding foreign tenants reports.
 
 The same round trip as a schema-validated [`z.codec()`](https://zod.dev) pair, mirroring `pdf-codec`'s `pdfCodec`:
 
 ```ts
-import { z } from 'zod';
-import { markdownCodec, MarkdownBytesSchema } from 'markdown-codec';
+import { z } from "zod";
+import { markdownCodec, MarkdownBytesSchema } from "markdown-codec";
 
 const documentPackage = z.decode(markdownCodec, bytes); // throws if bytes are not well-formed UTF-8
 const bytes2 = z.encode(markdownCodec, documentPackage);
@@ -113,17 +116,17 @@ document-schema.js states one document in two shapes, and owns the transform bet
 
 This package exposes a read/write pair and a codec at each level. The unsuffixed names are the tree-form ones and are what to reach for by default — a codec is a construction site, so the tree is what a caller gets unless they ask for otherwise. The `Content`-suffixed names are the flat pair one level down, mirroring the `readXlsx`/`readXlsxContent` naming already in [`ooxml.js`](../ooxml.js/README.md):
 
-| Level | Read | Write | Codec | Value type |
-| --- | --- | --- | --- | --- |
-| Tree (default) | `readMarkdown` | `writeMarkdown` | `markdownCodec` | `DocumentTree` |
-| Flat | `readMarkdownContent` | `writeMarkdownContent` | `markdownContentCodec` | `ContentDocument` |
+| Level          | Read                  | Write                  | Codec                  | Value type        |
+| -------------- | --------------------- | ---------------------- | ---------------------- | ----------------- |
+| Tree (default) | `readMarkdown`        | `writeMarkdown`        | `markdownCodec`        | `DocumentTree`    |
+| Flat           | `readMarkdownContent` | `writeMarkdownContent` | `markdownContentCodec` | `ContentDocument` |
 
 The tree pair is the flat pair with the transform composed on — `readMarkdown` is `assembleTree` over `readMarkdownContent`, `writeMarkdown` is `flattenTree` before `writeMarkdownContent` — plus the two tree-only carries the flat form has no root for: the source's reference definitions splice into `documentPackage.definitions` (link tenant, keyed by normalised label) and the verbatim front-matter block into `documentPackage.source.frontmatter`, both rendered back out by `writeMarkdown` (`[label]: dest "title"` lines after the body; the original front matter verbatim in place of the regenerated block). Sources carrying neither render identically to the flat pair, pinned in `src/package.test.ts`; a source carrying either renders its extra block, which is the point of reaching for the tree. Options, diagnostics, and error behaviour are identical at both levels.
 
 Reach for the flat pair when composing a package boundary by hand (`decompose`/`flattenTree` directly, or `factorStyles` with your own minting policy), when feeding a `ContentDocument`-consuming builder such as `documents.js`'s conversion pipeline, or when a layout stage needs to stamp frames onto content before it is decomposed. Everything else wants the tree.
 
 ```ts
-import { readMarkdownContent, writeMarkdownContent } from 'markdown-codec';
+import { readMarkdownContent, writeMarkdownContent } from "markdown-codec";
 
 const { document } = readMarkdownContent(source); // a ContentDocument: kind, metadata, sections
 const markdown = writeMarkdownContent(document);
@@ -223,18 +226,16 @@ Emission is the inverse and validates first: a section's markers must pair as ba
 
 **Round-trip conformance rate** (read → write → reparse → render to HTML, compared byte for byte against expected HTML):
 
-| Corpus | Examples | Passing round trip | Rate |
-| --- | --- | --- | --- |
-| CommonMark 0.31.2 (`assets/commonmark/spec.json`) | 652 | 511 | 78.4% |
-| GFM tagged extensions (table/strikethrough/autolink/task-list, `assets/gfm/spec.txt`) | 23 | 22 | 95.7% |
-| Combined | 675 | 533 | 79.0% |
+| Corpus                                                                                | Examples | Passing round trip | Rate  |
+| ------------------------------------------------------------------------------------- | -------- | ------------------ | ----- |
+| CommonMark 0.31.2 (`assets/commonmark/spec.json`)                                     | 652      | 511                | 78.4% |
+| GFM tagged extensions (table/strikethrough/autolink/task-list, `assets/gfm/spec.txt`) | 23       | 22                 | 95.7% |
+| Combined                                                                              | 675      | 533                | 79.0% |
 
 Every non-passing example is named individually in `src/test-support/conformance-exclusions.ts`, attributed to a closed set of causes (shrink-only — see [Conventions](#conventions)): most commonly a soft line break collapsing to a space, a nested/unresolved image title, an emphasis-span collision, or a blockquote whose heading content skips its container pair.
 
 **Optional real-world corpus.** `test/corpus/` (gitignored) holds a `pnpm test:corpus` project for a manual sanity check against sibling READMEs on disk — asserts no throw and real content on reparse, not byte fidelity. Not part of `pnpm test`; run locally before significant parser/lower/emit changes.
 
-
-
 ## Release and publishing
 
 Release, CI, and commit-message conventions are all workspace-wide, not package-local — see the [monorepo root README](../../README.md#releases) for the mechanism (topological per-package `semantic-release` via `@exadev/semantic-release-workspace`, OIDC trusted npm publishing, automatic sibling dependency-range rewriting) and its [post-release republishing and attestation](../../README.md#releases) note on the restored GitHub Packages mirrors, npm aliases, and SBOM/provenance signing.

package/dist/ast/ast.d.cts

@@ -1,2 +1,2 @@
-import { A as MarkdownSoftBreakNode, B as isMarkdownInlineNode, C as MarkdownMathBlockNode, D as MarkdownParagraphNode, E as MarkdownOrderedListDelimiter, F as MarkdownTableNode, I as MarkdownTableRowNode, L as MarkdownTextNode, M as MarkdownStrongNode, N as MarkdownTableAlignment, O as MarkdownPosition, P as MarkdownTableCellNode, R as MarkdownThematicBreakNode, S as MarkdownListNode, T as MarkdownNode, _ as MarkdownImageNode, a as MarkdownCodeBlockNode, b as MarkdownListItemNode, c as MarkdownEmphasisMarker, d as MarkdownFootnoteDefinitionNode, f as MarkdownFootnoteReferenceNode, g as MarkdownHtmlBlockNode, h as MarkdownHeadingStyle, i as MarkdownBulletMarker, j as MarkdownStrikethroughNode, k as MarkdownRawHtmlNode, l as MarkdownEmphasisNode, m as MarkdownHeadingNode, n as MarkdownBlockNode, o as MarkdownCodeSpanNode, p as MarkdownHardBreakNode, r as MarkdownBlockquoteNode, s as MarkdownDocumentNode, t as MarkdownAutolinkNode, u as MarkdownEntityNode, v as MarkdownInlineNode, w as MarkdownMathInlineNode, x as MarkdownListMarkerType, y as MarkdownLinkNode, z as isMarkdownBlockNode } from "../ast-8XCbjRQT.cjs";
+import { A as MarkdownSoftBreakNode, B as isMarkdownInlineNode, C as MarkdownMathBlockNode, D as MarkdownParagraphNode, E as MarkdownOrderedListDelimiter, F as MarkdownTableNode, I as MarkdownTableRowNode, L as MarkdownTextNode, M as MarkdownStrongNode, N as MarkdownTableAlignment, O as MarkdownPosition, P as MarkdownTableCellNode, R as MarkdownThematicBreakNode, S as MarkdownListNode, T as MarkdownNode, _ as MarkdownImageNode, a as MarkdownCodeBlockNode, b as MarkdownListItemNode, c as MarkdownEmphasisMarker, d as MarkdownFootnoteDefinitionNode, f as MarkdownFootnoteReferenceNode, g as MarkdownHtmlBlockNode, h as MarkdownHeadingStyle, i as MarkdownBulletMarker, j as MarkdownStrikethroughNode, k as MarkdownRawHtmlNode, l as MarkdownEmphasisNode, m as MarkdownHeadingNode, n as MarkdownBlockNode, o as MarkdownCodeSpanNode, p as MarkdownHardBreakNode, r as MarkdownBlockquoteNode, s as MarkdownDocumentNode, t as MarkdownAutolinkNode, u as MarkdownEntityNode, v as MarkdownInlineNode, w as MarkdownMathInlineNode, x as MarkdownListMarkerType, y as MarkdownLinkNode, z as isMarkdownBlockNode } from "../ast-CNfTgS0N.cjs";
 export { MarkdownAutolinkNode, MarkdownBlockNode, MarkdownBlockquoteNode, MarkdownBulletMarker, MarkdownCodeBlockNode, MarkdownCodeSpanNode, MarkdownDocumentNode, MarkdownEmphasisMarker, MarkdownEmphasisNode, MarkdownEntityNode, MarkdownFootnoteDefinitionNode, MarkdownFootnoteReferenceNode, MarkdownHardBreakNode, MarkdownHeadingNode, MarkdownHeadingStyle, MarkdownHtmlBlockNode, MarkdownImageNode, MarkdownInlineNode, MarkdownLinkNode, MarkdownListItemNode, MarkdownListMarkerType, MarkdownListNode, MarkdownMathBlockNode, MarkdownMathInlineNode, MarkdownNode, MarkdownOrderedListDelimiter, MarkdownParagraphNode, MarkdownPosition, MarkdownRawHtmlNode, MarkdownSoftBreakNode, MarkdownStrikethroughNode, MarkdownStrongNode, MarkdownTableAlignment, MarkdownTableCellNode, MarkdownTableNode, MarkdownTableRowNode, MarkdownTextNode, MarkdownThematicBreakNode, isMarkdownBlockNode, isMarkdownInlineNode };

package/dist/ast/ast.d.ts

@@ -1,2 +1,2 @@
-import { A as MarkdownSoftBreakNode, B as isMarkdownInlineNode, C as MarkdownMathBlockNode, D as MarkdownParagraphNode, E as MarkdownOrderedListDelimiter, F as MarkdownTableNode, I as MarkdownTableRowNode, L as MarkdownTextNode, M as MarkdownStrongNode, N as MarkdownTableAlignment, O as MarkdownPosition, P as MarkdownTableCellNode, R as MarkdownThematicBreakNode, S as MarkdownListNode, T as MarkdownNode, _ as MarkdownImageNode, a as MarkdownCodeBlockNode, b as MarkdownListItemNode, c as MarkdownEmphasisMarker, d as MarkdownFootnoteDefinitionNode, f as MarkdownFootnoteReferenceNode, g as MarkdownHtmlBlockNode, h as MarkdownHeadingStyle, i as MarkdownBulletMarker, j as MarkdownStrikethroughNode, k as MarkdownRawHtmlNode, l as MarkdownEmphasisNode, m as MarkdownHeadingNode, n as MarkdownBlockNode, o as MarkdownCodeSpanNode, p as MarkdownHardBreakNode, r as MarkdownBlockquoteNode, s as MarkdownDocumentNode, t as MarkdownAutolinkNode, u as MarkdownEntityNode, v as MarkdownInlineNode, w as MarkdownMathInlineNode, x as MarkdownListMarkerType, y as MarkdownLinkNode, z as isMarkdownBlockNode } from "../ast-8XCbjRQT.js";
+import { A as MarkdownSoftBreakNode, B as isMarkdownInlineNode, C as MarkdownMathBlockNode, D as MarkdownParagraphNode, E as MarkdownOrderedListDelimiter, F as MarkdownTableNode, I as MarkdownTableRowNode, L as MarkdownTextNode, M as MarkdownStrongNode, N as MarkdownTableAlignment, O as MarkdownPosition, P as MarkdownTableCellNode, R as MarkdownThematicBreakNode, S as MarkdownListNode, T as MarkdownNode, _ as MarkdownImageNode, a as MarkdownCodeBlockNode, b as MarkdownListItemNode, c as MarkdownEmphasisMarker, d as MarkdownFootnoteDefinitionNode, f as MarkdownFootnoteReferenceNode, g as MarkdownHtmlBlockNode, h as MarkdownHeadingStyle, i as MarkdownBulletMarker, j as MarkdownStrikethroughNode, k as MarkdownRawHtmlNode, l as MarkdownEmphasisNode, m as MarkdownHeadingNode, n as MarkdownBlockNode, o as MarkdownCodeSpanNode, p as MarkdownHardBreakNode, r as MarkdownBlockquoteNode, s as MarkdownDocumentNode, t as MarkdownAutolinkNode, u as MarkdownEntityNode, v as MarkdownInlineNode, w as MarkdownMathInlineNode, x as MarkdownListMarkerType, y as MarkdownLinkNode, z as isMarkdownBlockNode } from "../ast-CNfTgS0N.js";
 export { MarkdownAutolinkNode, MarkdownBlockNode, MarkdownBlockquoteNode, MarkdownBulletMarker, MarkdownCodeBlockNode, MarkdownCodeSpanNode, MarkdownDocumentNode, MarkdownEmphasisMarker, MarkdownEmphasisNode, MarkdownEntityNode, MarkdownFootnoteDefinitionNode, MarkdownFootnoteReferenceNode, MarkdownHardBreakNode, MarkdownHeadingNode, MarkdownHeadingStyle, MarkdownHtmlBlockNode, MarkdownImageNode, MarkdownInlineNode, MarkdownLinkNode, MarkdownListItemNode, MarkdownListMarkerType, MarkdownListNode, MarkdownMathBlockNode, MarkdownMathInlineNode, MarkdownNode, MarkdownOrderedListDelimiter, MarkdownParagraphNode, MarkdownPosition, MarkdownRawHtmlNode, MarkdownSoftBreakNode, MarkdownStrikethroughNode, MarkdownStrongNode, MarkdownTableAlignment, MarkdownTableCellNode, MarkdownTableNode, MarkdownTableRowNode, MarkdownTextNode, MarkdownThematicBreakNode, isMarkdownBlockNode, isMarkdownInlineNode };

package/dist/{ast-8XCbjRQT.d.cts → ast-CNfTgS0N.d.cts}

@@ -8,33 +8,33 @@ interface MarkdownPosition {
 type MarkdownNode = MarkdownBlockNode | MarkdownInlineNode;
 type MarkdownBlockNode = MarkdownDocumentNode | MarkdownParagraphNode | MarkdownHeadingNode | MarkdownBlockquoteNode | MarkdownListNode | MarkdownListItemNode | MarkdownCodeBlockNode | MarkdownThematicBreakNode | MarkdownHtmlBlockNode | MarkdownTableNode | MarkdownTableRowNode | MarkdownTableCellNode | MarkdownMathBlockNode | MarkdownFootnoteDefinitionNode;
 interface MarkdownDocumentNode {
-  readonly type: 'document';
+  readonly type: "document";
   readonly children: MarkdownBlockNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownParagraphNode {
-  readonly type: 'paragraph';
+  readonly type: "paragraph";
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
-type MarkdownHeadingStyle = 'atx' | 'setext';
+type MarkdownHeadingStyle = "atx" | "setext";
 interface MarkdownHeadingNode {
-  readonly type: 'heading';
+  readonly type: "heading";
   readonly level: 1 | 2 | 3 | 4 | 5 | 6;
   readonly style: MarkdownHeadingStyle;
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownBlockquoteNode {
-  readonly type: 'blockquote';
+  readonly type: "blockquote";
   readonly children: MarkdownBlockNode[];
   readonly position?: MarkdownPosition;
 }
-type MarkdownListMarkerType = 'bullet' | 'ordered';
-type MarkdownBulletMarker = '-' | '*' | '+';
-type MarkdownOrderedListDelimiter = '.' | ')';
+type MarkdownListMarkerType = "bullet" | "ordered";
+type MarkdownBulletMarker = "-" | "*" | "+";
+type MarkdownOrderedListDelimiter = "." | ")";
 interface MarkdownListNode {
-  readonly type: 'list';
+  readonly type: "list";
   readonly markerType: MarkdownListMarkerType;
   readonly bulletMarker?: MarkdownBulletMarker;
   readonly orderedDelimiter?: MarkdownOrderedListDelimiter;
@@ -44,95 +44,95 @@ interface MarkdownListNode {
   readonly position?: MarkdownPosition;
 }
 interface MarkdownListItemNode {
-  readonly type: 'listItem';
+  readonly type: "listItem";
   readonly checked?: boolean;
   readonly children: MarkdownBlockNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownCodeBlockNode {
-  readonly type: 'codeBlock';
+  readonly type: "codeBlock";
   readonly fenced: boolean;
-  readonly fenceChar?: '`' | '~';
+  readonly fenceChar?: "`" | "~";
   readonly infoString?: string;
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownThematicBreakNode {
-  readonly type: 'thematicBreak';
+  readonly type: "thematicBreak";
   readonly position?: MarkdownPosition;
 }
 interface MarkdownHtmlBlockNode {
-  readonly type: 'htmlBlock';
+  readonly type: "htmlBlock";
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
-type MarkdownTableAlignment = 'left' | 'right' | 'center' | 'none';
+type MarkdownTableAlignment = "left" | "right" | "center" | "none";
 interface MarkdownTableNode {
-  readonly type: 'table';
+  readonly type: "table";
   readonly alignments: MarkdownTableAlignment[];
   readonly children: MarkdownTableRowNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownTableRowNode {
-  readonly type: 'tableRow';
+  readonly type: "tableRow";
   readonly header: boolean;
   readonly children: MarkdownTableCellNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownTableCellNode {
-  readonly type: 'tableCell';
+  readonly type: "tableCell";
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownMathBlockNode {
-  readonly type: 'mathBlock';
+  readonly type: "mathBlock";
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownFootnoteDefinitionNode {
-  readonly type: 'footnoteDefinition';
+  readonly type: "footnoteDefinition";
   readonly label: string;
   readonly children: MarkdownBlockNode[];
   readonly position?: MarkdownPosition;
 }
 type MarkdownInlineNode = MarkdownTextNode | MarkdownEmphasisNode | MarkdownStrongNode | MarkdownStrikethroughNode | MarkdownCodeSpanNode | MarkdownLinkNode | MarkdownImageNode | MarkdownAutolinkNode | MarkdownHardBreakNode | MarkdownSoftBreakNode | MarkdownRawHtmlNode | MarkdownEntityNode | MarkdownMathInlineNode | MarkdownFootnoteReferenceNode;
-type MarkdownEmphasisMarker = '_' | '*';
+type MarkdownEmphasisMarker = "_" | "*";
 interface MarkdownTextNode {
-  readonly type: 'text';
+  readonly type: "text";
   readonly value: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownEmphasisNode {
-  readonly type: 'emphasis';
+  readonly type: "emphasis";
   readonly marker: MarkdownEmphasisMarker;
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownStrongNode {
-  readonly type: 'strong';
+  readonly type: "strong";
   readonly marker: MarkdownEmphasisMarker;
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownStrikethroughNode {
-  readonly type: 'strikethrough';
+  readonly type: "strikethrough";
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownCodeSpanNode {
-  readonly type: 'codeSpan';
+  readonly type: "codeSpan";
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownLinkNode {
-  readonly type: 'link';
+  readonly type: "link";
   readonly destination: string;
   readonly title?: string;
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownImageNode {
-  readonly type: 'image';
+  readonly type: "image";
   readonly destination: string;
   readonly title?: string;
   readonly alt: string;
@@ -141,37 +141,37 @@ interface MarkdownImageNode {
   readonly position?: MarkdownPosition;
 }
 interface MarkdownAutolinkNode {
-  readonly type: 'autolink';
+  readonly type: "autolink";
   readonly destination: string;
   readonly email: boolean;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownHardBreakNode {
-  readonly type: 'hardBreak';
+  readonly type: "hardBreak";
   readonly position?: MarkdownPosition;
 }
 interface MarkdownSoftBreakNode {
-  readonly type: 'softBreak';
+  readonly type: "softBreak";
   readonly position?: MarkdownPosition;
 }
 interface MarkdownRawHtmlNode {
-  readonly type: 'rawHtml';
+  readonly type: "rawHtml";
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownEntityNode {
-  readonly type: 'entity';
+  readonly type: "entity";
   readonly raw: string;
   readonly value: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownMathInlineNode {
-  readonly type: 'mathInline';
+  readonly type: "mathInline";
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownFootnoteReferenceNode {
-  readonly type: 'footnoteReference';
+  readonly type: "footnoteReference";
   readonly label: string;
   readonly position?: MarkdownPosition;
 }

package/dist/{ast-8XCbjRQT.d.ts → ast-CNfTgS0N.d.ts}

@@ -8,33 +8,33 @@ interface MarkdownPosition {
 type MarkdownNode = MarkdownBlockNode | MarkdownInlineNode;
 type MarkdownBlockNode = MarkdownDocumentNode | MarkdownParagraphNode | MarkdownHeadingNode | MarkdownBlockquoteNode | MarkdownListNode | MarkdownListItemNode | MarkdownCodeBlockNode | MarkdownThematicBreakNode | MarkdownHtmlBlockNode | MarkdownTableNode | MarkdownTableRowNode | MarkdownTableCellNode | MarkdownMathBlockNode | MarkdownFootnoteDefinitionNode;
 interface MarkdownDocumentNode {
-  readonly type: 'document';
+  readonly type: "document";
   readonly children: MarkdownBlockNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownParagraphNode {
-  readonly type: 'paragraph';
+  readonly type: "paragraph";
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
-type MarkdownHeadingStyle = 'atx' | 'setext';
+type MarkdownHeadingStyle = "atx" | "setext";
 interface MarkdownHeadingNode {
-  readonly type: 'heading';
+  readonly type: "heading";
   readonly level: 1 | 2 | 3 | 4 | 5 | 6;
   readonly style: MarkdownHeadingStyle;
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownBlockquoteNode {
-  readonly type: 'blockquote';
+  readonly type: "blockquote";
   readonly children: MarkdownBlockNode[];
   readonly position?: MarkdownPosition;
 }
-type MarkdownListMarkerType = 'bullet' | 'ordered';
-type MarkdownBulletMarker = '-' | '*' | '+';
-type MarkdownOrderedListDelimiter = '.' | ')';
+type MarkdownListMarkerType = "bullet" | "ordered";
+type MarkdownBulletMarker = "-" | "*" | "+";
+type MarkdownOrderedListDelimiter = "." | ")";
 interface MarkdownListNode {
-  readonly type: 'list';
+  readonly type: "list";
   readonly markerType: MarkdownListMarkerType;
   readonly bulletMarker?: MarkdownBulletMarker;
   readonly orderedDelimiter?: MarkdownOrderedListDelimiter;
@@ -44,95 +44,95 @@ interface MarkdownListNode {
   readonly position?: MarkdownPosition;
 }
 interface MarkdownListItemNode {
-  readonly type: 'listItem';
+  readonly type: "listItem";
   readonly checked?: boolean;
   readonly children: MarkdownBlockNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownCodeBlockNode {
-  readonly type: 'codeBlock';
+  readonly type: "codeBlock";
   readonly fenced: boolean;
-  readonly fenceChar?: '`' | '~';
+  readonly fenceChar?: "`" | "~";
   readonly infoString?: string;
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownThematicBreakNode {
-  readonly type: 'thematicBreak';
+  readonly type: "thematicBreak";
   readonly position?: MarkdownPosition;
 }
 interface MarkdownHtmlBlockNode {
-  readonly type: 'htmlBlock';
+  readonly type: "htmlBlock";
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
-type MarkdownTableAlignment = 'left' | 'right' | 'center' | 'none';
+type MarkdownTableAlignment = "left" | "right" | "center" | "none";
 interface MarkdownTableNode {
-  readonly type: 'table';
+  readonly type: "table";
   readonly alignments: MarkdownTableAlignment[];
   readonly children: MarkdownTableRowNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownTableRowNode {
-  readonly type: 'tableRow';
+  readonly type: "tableRow";
   readonly header: boolean;
   readonly children: MarkdownTableCellNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownTableCellNode {
-  readonly type: 'tableCell';
+  readonly type: "tableCell";
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownMathBlockNode {
-  readonly type: 'mathBlock';
+  readonly type: "mathBlock";
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownFootnoteDefinitionNode {
-  readonly type: 'footnoteDefinition';
+  readonly type: "footnoteDefinition";
   readonly label: string;
   readonly children: MarkdownBlockNode[];
   readonly position?: MarkdownPosition;
 }
 type MarkdownInlineNode = MarkdownTextNode | MarkdownEmphasisNode | MarkdownStrongNode | MarkdownStrikethroughNode | MarkdownCodeSpanNode | MarkdownLinkNode | MarkdownImageNode | MarkdownAutolinkNode | MarkdownHardBreakNode | MarkdownSoftBreakNode | MarkdownRawHtmlNode | MarkdownEntityNode | MarkdownMathInlineNode | MarkdownFootnoteReferenceNode;
-type MarkdownEmphasisMarker = '_' | '*';
+type MarkdownEmphasisMarker = "_" | "*";
 interface MarkdownTextNode {
-  readonly type: 'text';
+  readonly type: "text";
   readonly value: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownEmphasisNode {
-  readonly type: 'emphasis';
+  readonly type: "emphasis";
   readonly marker: MarkdownEmphasisMarker;
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownStrongNode {
-  readonly type: 'strong';
+  readonly type: "strong";
   readonly marker: MarkdownEmphasisMarker;
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownStrikethroughNode {
-  readonly type: 'strikethrough';
+  readonly type: "strikethrough";
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownCodeSpanNode {
-  readonly type: 'codeSpan';
+  readonly type: "codeSpan";
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownLinkNode {
-  readonly type: 'link';
+  readonly type: "link";
   readonly destination: string;
   readonly title?: string;
   readonly children: MarkdownInlineNode[];
   readonly position?: MarkdownPosition;
 }
 interface MarkdownImageNode {
-  readonly type: 'image';
+  readonly type: "image";
   readonly destination: string;
   readonly title?: string;
   readonly alt: string;
@@ -141,37 +141,37 @@ interface MarkdownImageNode {
   readonly position?: MarkdownPosition;
 }
 interface MarkdownAutolinkNode {
-  readonly type: 'autolink';
+  readonly type: "autolink";
   readonly destination: string;
   readonly email: boolean;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownHardBreakNode {
-  readonly type: 'hardBreak';
+  readonly type: "hardBreak";
   readonly position?: MarkdownPosition;
 }
 interface MarkdownSoftBreakNode {
-  readonly type: 'softBreak';
+  readonly type: "softBreak";
   readonly position?: MarkdownPosition;
 }
 interface MarkdownRawHtmlNode {
-  readonly type: 'rawHtml';
+  readonly type: "rawHtml";
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownEntityNode {
-  readonly type: 'entity';
+  readonly type: "entity";
   readonly raw: string;
   readonly value: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownMathInlineNode {
-  readonly type: 'mathInline';
+  readonly type: "mathInline";
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
 interface MarkdownFootnoteReferenceNode {
-  readonly type: 'footnoteReference';
+  readonly type: "footnoteReference";
   readonly label: string;
   readonly position?: MarkdownPosition;
 }

package/dist/block/block.d.cts

@@ -1,8 +1,8 @@
-import { s as MarkdownDocumentNode } from "../ast-8XCbjRQT.cjs";
+import { s as MarkdownDocumentNode } from "../ast-CNfTgS0N.cjs";
 import { r as FootnoteLabelSet } from "../footnote-CKk4JbLk.cjs";
-import { i as MarkdownDiagnosticSink } from "../diagnostics-CkcSYZf1.cjs";
+import { i as MarkdownDiagnosticSink } from "../diagnostics-CH-xa2-s.cjs";
 import { LinkReferenceMap } from "../inline/link.cjs";
-import { t as InlineParseOptions } from "../inline-CoS1JzxI.cjs";
+import { t as InlineParseOptions } from "../inline-CnO86zMw.cjs";
 //#region src/block/block.d.ts
 interface MarkdownParseOptions extends InlineParseOptions {
   readonly gfmTables?: boolean;

package/dist/block/block.d.ts

@@ -1,8 +1,8 @@
-import { s as MarkdownDocumentNode } from "../ast-8XCbjRQT.js";
+import { s as MarkdownDocumentNode } from "../ast-CNfTgS0N.js";
 import { r as FootnoteLabelSet } from "../footnote-CKk4JbLk.js";
-import { i as MarkdownDiagnosticSink } from "../diagnostics-CkcSYZf1.js";
+import { i as MarkdownDiagnosticSink } from "../diagnostics-CH-xa2-s.js";
 import { LinkReferenceMap } from "../inline/link.js";
-import { t as InlineParseOptions } from "../inline-OGXVE6hB.js";
+import { t as InlineParseOptions } from "../inline-DItZ-VVw.js";
 //#region src/block/block.d.ts
 interface MarkdownParseOptions extends InlineParseOptions {
   readonly gfmTables?: boolean;

package/dist/block/definitions.d.cts

@@ -1,4 +1,4 @@
-import { i as MarkdownDiagnosticSink } from "../diagnostics-CkcSYZf1.cjs";
+import { i as MarkdownDiagnosticSink } from "../diagnostics-CH-xa2-s.cjs";
 import { LinkReferenceDefinition } from "../inline/link.cjs";
 //#region src/block/definitions.d.ts
 declare function extractDefinitions(content: string, references: Map<string, LinkReferenceDefinition>, sink?: MarkdownDiagnosticSink, startLine?: number): string;

package/dist/block/definitions.d.ts

@@ -1,4 +1,4 @@
-import { i as MarkdownDiagnosticSink } from "../diagnostics-CkcSYZf1.js";
+import { i as MarkdownDiagnosticSink } from "../diagnostics-CH-xa2-s.js";
 import { LinkReferenceDefinition } from "../inline/link.js";
 //#region src/block/definitions.d.ts
 declare function extractDefinitions(content: string, references: Map<string, LinkReferenceDefinition>, sink?: MarkdownDiagnosticSink, startLine?: number): string;

package/dist/block/node.d.cts

@@ -1,10 +1,10 @@
-import { E as MarkdownOrderedListDelimiter, N as MarkdownTableAlignment, i as MarkdownBulletMarker } from "../ast-8XCbjRQT.cjs";
+import { E as MarkdownOrderedListDelimiter, N as MarkdownTableAlignment, i as MarkdownBulletMarker } from "../ast-CNfTgS0N.cjs";
 import { t as HtmlBlockType } from "../html-bkz2QTuq.cjs";
 //#region src/block/node.d.ts
-type BlockNodeKind = 'document' | 'paragraph' | 'heading' | 'blockquote' | 'list' | 'listItem' | 'codeBlock' | 'htmlBlock' | 'thematicBreak' | 'table' | 'mathBlock' | 'footnoteDefinition';
+type BlockNodeKind = "document" | "paragraph" | "heading" | "blockquote" | "list" | "listItem" | "codeBlock" | "htmlBlock" | "thematicBreak" | "table" | "mathBlock" | "footnoteDefinition";
 type BlockHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
 interface ListMarkerData {
-  readonly type: 'bullet' | 'ordered';
+  readonly type: "bullet" | "ordered";
   readonly bulletChar?: MarkdownBulletMarker;
   readonly delimiter?: MarkdownOrderedListDelimiter;
   readonly start?: number;
@@ -23,7 +23,7 @@ declare class BlockNode {
   level: BlockHeadingLevel;
   setext: boolean;
   fenced: boolean;
-  fenceChar: '`' | '~';
+  fenceChar: "`" | "~";
   fenceLength: number;
   fenceOffset: number;
   infoString: string;

package/dist/block/node.d.ts

@@ -1,10 +1,10 @@
-import { E as MarkdownOrderedListDelimiter, N as MarkdownTableAlignment, i as MarkdownBulletMarker } from "../ast-8XCbjRQT.js";
+import { E as MarkdownOrderedListDelimiter, N as MarkdownTableAlignment, i as MarkdownBulletMarker } from "../ast-CNfTgS0N.js";
 import { t as HtmlBlockType } from "../html-bkz2QTuq.js";
 //#region src/block/node.d.ts
-type BlockNodeKind = 'document' | 'paragraph' | 'heading' | 'blockquote' | 'list' | 'listItem' | 'codeBlock' | 'htmlBlock' | 'thematicBreak' | 'table' | 'mathBlock' | 'footnoteDefinition';
+type BlockNodeKind = "document" | "paragraph" | "heading" | "blockquote" | "list" | "listItem" | "codeBlock" | "htmlBlock" | "thematicBreak" | "table" | "mathBlock" | "footnoteDefinition";
 type BlockHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
 interface ListMarkerData {
-  readonly type: 'bullet' | 'ordered';
+  readonly type: "bullet" | "ordered";
   readonly bulletChar?: MarkdownBulletMarker;
   readonly delimiter?: MarkdownOrderedListDelimiter;
   readonly start?: number;
@@ -23,7 +23,7 @@ declare class BlockNode {
   level: BlockHeadingLevel;
   setext: boolean;
   fenced: boolean;
-  fenceChar: '`' | '~';
+  fenceChar: "`" | "~";
   fenceLength: number;
   fenceOffset: number;
   infoString: string;

package/dist/block/table.d.cts

@@ -1,4 +1,4 @@
-import { N as MarkdownTableAlignment } from "../ast-8XCbjRQT.cjs";
+import { N as MarkdownTableAlignment } from "../ast-CNfTgS0N.cjs";
 //#region src/block/table.d.ts
 declare function splitTableRow(line: string): string[];
 declare function parseTableDelimiterRow(line: string): MarkdownTableAlignment[] | undefined;