markdown-codec 5.0.3 → 6.1.0

package/README.md

@@ -2,9 +2,9 @@
 
 [![GitHub](https://img.shields.io/badge/GitHub-181717?logo=github&logoColor=white)](https://github.com/ExaDev/documents.js/tree/main/packages/markdown-codec) [![npm](https://img.shields.io/badge/npm-CB3837?logo=npm&logoColor=white)](https://www.npmjs.com/package/markdown-codec) [![npm version](https://img.shields.io/npm/v/markdown-codec)](https://www.npmjs.com/package/markdown-codec) [![CI](https://img.shields.io/github/actions/workflow/status/ExaDev/documents.js/ci.yml?branch=main)](https://github.com/ExaDev/documents.js/actions)
 
-> Hand-written CommonMark+GFM ⇄ `DocumentPackage` codec, built on [document-schema.js](../document-schema.js/README.md).
+> 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 `DocumentPackage`; `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 `DocumentPackage` — 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 `flattenPackage`. 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 `DocumentPackage`'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.
+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);
@@ -107,23 +110,23 @@ const bytes2 = z.encode(markdownCodec, documentPackage);
 
 `MarkdownBytesSchema` checks for well-formed UTF-8. The no-options form only; `readMarkdown`/`writeMarkdown` remain the entry points for an `AbortSignal` or diagnostic sink. Every construct-mapping gap reports through the sink as a stable code (e.g. `md/nested-emphasis-flattened`) — see `MarkdownDiagnosticCodes` and [Gotchas](#gotchas-and-quirks).
 
-## Two encodings: `DocumentPackage` and `ContentDocument`
+## Two encodings: `DocumentTree` and `ContentDocument`
 
-document-schema.js states one document in two shapes, and owns the transform between them: the flat `ContentDocument` every codec's lowering pipeline actually builds, and the tree-form `DocumentPackage` a serialised artefact carries — sections, headings, lists, and construct boundaries as real nested groups, plus a styles table minted over repeated property tuples. `assemblePackage` goes flat → tree (`decompose` then `factorStyles`), `flattenPackage` goes tree → flat. Only one direction is a genuine round trip: `flattenPackage(assemblePackage(document))` reproduces `document` exactly, for any `ContentDocument` this package's own read side produces (checked against the full CommonMark and GFM conformance corpora, not just a hand-picked fixture — see `src/conformance.test.ts`/`src/gfm-conformance.test.ts`'s own "tree pair matches the flat pair" suite). `assemblePackage(flattenPackage(documentPackage))` does not, in general, reproduce `documentPackage` — a package carrying `definitions`/`layers`/`attachments`/`destinations`/`pages` loses all of them on the way through `flattenPackage`, which carries forward only `metadata` and `symbolTable` (see [Gotchas](#gotchas-and-quirks)).
+document-schema.js states one document in two shapes, and owns the transform between them: the flat `ContentDocument` every codec's lowering pipeline actually builds, and the tree-form `DocumentTree` a serialised artefact carries — sections, headings, lists, and construct boundaries as real nested groups, plus a styles table minted over repeated property tuples. `assembleTree` goes flat → tree (`decompose` then `factorStyles`), `flattenTree` goes tree → flat. Only one direction is a genuine round trip: `flattenTree(assembleTree(document))` reproduces `document` exactly, for any `ContentDocument` this package's own read side produces (checked against the full CommonMark and GFM conformance corpora, not just a hand-picked fixture — see `src/conformance.test.ts`/`src/gfm-conformance.test.ts`'s own "tree pair matches the flat pair" suite). `assembleTree(flattenTree(documentPackage))` does not, in general, reproduce `documentPackage` — a package carrying `definitions`/`layers`/`attachments`/`destinations`/`pages` loses all of them on the way through `flattenTree`, which carries forward only `metadata` and `symbolTable` (see [Gotchas](#gotchas-and-quirks)).
 
 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` | `DocumentPackage` |
-| 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 `assemblePackage` over `readMarkdownContent`, `writeMarkdown` is `flattenPackage` 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.
+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`/`flattenPackage` 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.
+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);
@@ -144,7 +147,7 @@ Modelled on `pdf-codec`'s own layering, aimed at CommonMark+GFM instead of PDF:
 - **`src/shared/`** — string-shape conventions `src/lower`/`src/emit` agree on (`style-constants.ts`, `list-id.ts`'s opaque `numId`). Re-exported so `documents.js`'s `MarkdownEditor` reuses the identical grammar.
 - **`src/lower/`** — AST → `ContentDocument` lowering (thin adapter, not a second parser); top-of-file table maps each construct to its diagnostic gap.
 - **`src/emit/`** — `ContentDocument` → markdown text emission, the structural inverse of `src/lower`.
-- **`src/read.ts`** / **`src/write.ts`** / **`src/codec.ts`** — the public entry points at both levels: `readMarkdown`/`writeMarkdown`/`markdownCodec` over `DocumentPackage`, and `readMarkdownContent`/`writeMarkdownContent`/`markdownContentCodec` over `ContentDocument`. The tree-form functions are thin compositions of `document-schema.js`'s `assemblePackage`/`flattenPackage` onto the flat ones; no conversion logic of their own lives here.
+- **`src/read.ts`** / **`src/write.ts`** / **`src/codec.ts`** — the public entry points at both levels: `readMarkdown`/`writeMarkdown`/`markdownCodec` over `DocumentTree`, and `readMarkdownContent`/`writeMarkdownContent`/`markdownContentCodec` over `ContentDocument`. The tree-form functions are thin compositions of `document-schema.js`'s `assembleTree`/`flattenTree` onto the flat ones; no conversion logic of their own lives here.
 
 ## Vendored assets
 
@@ -202,7 +205,7 @@ Every construct `src/lower`/`src/emit` cannot represent losslessly is a document
 - **`md/duplicate-footnote-definition`** — two definitions share a label; every reference resolves to the first, both are kept as written.
 - **`md/footnote-body-heading-flattened`** — a heading inside a definition body is carried as literal ATX text, since a construct extent may not open or close a heading scope.
 - **`md/construct-unrepresented`** — a construct kind markdown has no syntax for renders transparently: its extent still appears, the construct itself does not.
-- **`md/package-table-dropped`** — `writeMarkdown` only, ahead of flattening: a `DocumentPackage`'s own `definitions`/`layers`/`attachments`/`destinations`/`pages` table has no flat-`ContentDocument` home (`flattenPackage`'s own envelope carries forward only `metadata` and `symbolTable`); fires once per non-empty table present.
+- **`md/package-table-dropped`** — `writeMarkdown` only, ahead of flattening: a `DocumentTree`'s own `definitions`/`layers`/`attachments`/`destinations`/`pages` table has no flat-`ContentDocument` home (`flattenTree`'s own envelope carries forward only `metadata` and `symbolTable`); fires once per non-empty table present.
 
 ## Footnotes
 
@@ -210,8 +213,8 @@ GitHub's footnote extension (`[^label]` markers, `[^label]: body` definitions) i
 
 The two halves of a footnote map onto the **same `anchor` construct at two different scopes**, and that split is structural rather than a choice:
 
-- **A definition becomes an `anchor` construct.** Lowering emits document-schema.js's construct boundary markers — a `constructStart` carrying `{ kind: 'anchor', anchorType: 'footnote', name }`, the definition's own lowered body blocks, and a `constructEnd` — which is what `readMarkdownContent` returns in its block flow, and what `decompose` promotes to a construct group of its own in the `DocumentPackage` `readMarkdown` returns (the descriptor rides the group's `node`, the body blocks its `children`). The body rides the construct's extent rather than `AnchorDescriptor.definition`, which names a key in a package-level definitions table: `DocumentPackage` does carry that table as a root (unlike the flat `ContentDocument`), but a table entry there is a flat descriptor record, not a container for block content, so a body that is genuinely several paragraphs, a code block, or a list still has nowhere to live as a table value either way — the construct's own bracketed extent is the one shape in this schema built to hold real block content. A bodyless `[^1]:` lowers to the point anchor the same descriptor describes: a pair with nothing between it.
-- **A reference site becomes a point run-level `anchor` extent.** A reference sits between two runs inside a paragraph, so no block-level boundary marker can bracket it without splitting the paragraph in two — but a run-level construct extent (`RunConstructExtent` on `ContentParagraph.constructs`, document-schema.js 4.5.0) names exactly that shape. Lowering emits an ordinary text run keeping the reference's own `[^label]` spelling (the materialised rendering, so a consumer that ignores constructs still shows `[^1]`) plus a point extent — `{ kind: 'anchor', anchorType: 'footnote', name }` at `startRun === endRun` naming that run, the same wiring ooxml.js's docx reader mints for a `w:footnoteReference` — carried through `decompose`/`flattenPackage` verbatim, exactly the way a table cell's own markers are. The writer spells `[^label]` back out from the covering extent rather than from anything about the run's text (which is what still distinguishes a genuine reference from a deliberately-escaped literal `\[^1\]`), gated by the same label grammar as the definition marker: a foreign name that grammar cannot spell degrades to the run's own escaped text plus `md/construct-unrepresented`.
+- **A definition becomes an `anchor` construct.** Lowering emits document-schema.js's construct boundary markers — a `constructStart` carrying `{ kind: 'anchor', anchorType: 'footnote', name }`, the definition's own lowered body blocks, and a `constructEnd` — which is what `readMarkdownContent` returns in its block flow, and what `decompose` promotes to a construct group of its own in the `DocumentTree` `readMarkdown` returns (the descriptor rides the group's `node`, the body blocks its `children`). The body rides the construct's extent rather than `AnchorDescriptor.definition`, which names a key in a package-level definitions table: `DocumentTree` does carry that table as a root (unlike the flat `ContentDocument`), but a table entry there is a flat descriptor record, not a container for block content, so a body that is genuinely several paragraphs, a code block, or a list still has nowhere to live as a table value either way — the construct's own bracketed extent is the one shape in this schema built to hold real block content. A bodyless `[^1]:` lowers to the point anchor the same descriptor describes: a pair with nothing between it.
+- **A reference site becomes a point run-level `anchor` extent.** A reference sits between two runs inside a paragraph, so no block-level boundary marker can bracket it without splitting the paragraph in two — but a run-level construct extent (`RunConstructExtent` on `ContentParagraph.constructs`, document-schema.js 4.5.0) names exactly that shape. Lowering emits an ordinary text run keeping the reference's own `[^label]` spelling (the materialised rendering, so a consumer that ignores constructs still shows `[^1]`) plus a point extent — `{ kind: 'anchor', anchorType: 'footnote', name }` at `startRun === endRun` naming that run, the same wiring ooxml.js's docx reader mints for a `w:footnoteReference` — carried through `decompose`/`flattenTree` verbatim, exactly the way a table cell's own markers are. The writer spells `[^label]` back out from the covering extent rather than from anything about the run's text (which is what still distinguishes a genuine reference from a deliberately-escaped literal `\[^1\]`), gated by the same label grammar as the definition marker: a foreign name that grammar cannot spell degrades to the run's own escaped text plus `md/construct-unrepresented`.
 
 Definitions are recognised only at the document's own top level. Inside a block quote or a list item, the pair's extent would sit inside a scope the enclosing container had already opened, which the marker contract forbids a producer from emitting — so the text stays an ordinary paragraph there. A heading inside a definition body is flattened to literal ATX text for the same reason.
 
@@ -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.
@@ -245,7 +246,7 @@ Conventional Commits, enforced workspace-wide by commitlint through a root `comm
 
 ## References
 
-- [document-schema.js](../document-schema.js/README.md) — owns both shared encodings (`ContentDocument`, `DocumentPackage`) and the `assemblePackage`/`flattenPackage` transform between them.
+- [document-schema.js](../document-schema.js/README.md) — owns both shared encodings (`ContentDocument`, `DocumentTree`) and the `assembleTree`/`flattenTree` transform between them.
 - [pdf-codec](../pdf-codec/README.md) — the sibling whose scaffold, tooling, and "hand-write the format" philosophy this project mirrors.
 - [documents.js](https://github.com/ExaDev/documents.js) — bridges markdown to docx/odt/PDF via this package's `ContentDocument` (the flat pair; its own conversion pipeline assembles the package itself). Markdown has no presentation/spreadsheet/drawing variant, so pptx/odp/ods/odg are structurally out of reach.
 - [CommonMark Spec](https://spec.commonmark.org/) — the base specification targeted.

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;