markdown-codec 3.0.1 → 3.1.1

package/README.md

@@ -51,7 +51,7 @@ graph TD
 
 ## Status
 
-The scanner, block parser, and inline parser are complete hand-written implementations of CommonMark 0.31.2's two-phase algorithm plus GFM's table/strikethrough/autolink/task-list-item extensions. `readMarkdown`/`writeMarkdown`/`markdownCodec` are wired and real. Conformance suites measure the full public surface (`readMarkdown` → `writeMarkdown` → reparse → render to HTML) against the vendored CommonMark/GFM corpora — see [Fidelity](#fidelity) for why the rate is below 100% (dominated by what `ContentDocument` can represent, not parsing gaps).
+The scanner, block parser, and inline parser are complete hand-written implementations of CommonMark 0.31.2's two-phase algorithm plus GFM's table/strikethrough/autolink/task-list-item extensions and GitHub's footnotes (see [Footnotes](#footnotes)). `readMarkdown`/`writeMarkdown`/`markdownCodec` are wired and real. Conformance suites measure the full public surface (`readMarkdown` → `writeMarkdown` → reparse → render to HTML) against the vendored CommonMark/GFM corpora — see [Fidelity](#fidelity) for why the rate is below 100% (dominated by what `ContentDocument` can represent, not parsing gaps).
 
 ## Getting started
 
@@ -80,6 +80,7 @@ import { readMarkdown, writeMarkdown } from 'markdown-codec';
 
 const { document, diagnostics } = readMarkdown('# Title\n\nSome **bold** text with a [link](https://example.com).', {
   frontMatter: true, // parse a leading YAML front matter block into ContentDocument.metadata
+  footnotes: true, // recognise [^label] markers and [^label]: definitions (default; see Footnotes)
   images: (destination) => undefined, // a synchronous MarkdownImageResolver port for non-data: URI images
 });
 
@@ -112,8 +113,8 @@ Modelled on `pdf-codec`'s own layering, aimed at CommonMark+GFM instead of PDF:
 - **`src/ast/`** — markdown AST node types (document/block/inline union), Zod-first.
 - **`src/options/`** / **`src/defaults/`** — read/write options (GFM toggles, sink, `AbortSignal`, write-side style) and defaults.
 - **`src/scan/`** — CommonMark line/character scanner, plus `entity-table.ts` (generated from `assets/html-entities/entities.json`).
-- **`src/block/`** — CommonMark block-structure algorithm (open-block stack, continuation matching): paragraphs, headings, code blocks, block quotes, lists (incl. GFM task-list-item), thematic breaks, link references, GFM tables.
-- **`src/inline/`** — emphasis, code spans, links, autolinks, raw HTML, GFM strikethrough, line breaks.
+- **`src/block/`** — CommonMark block-structure algorithm (open-block stack, continuation matching): paragraphs, headings, code blocks, block quotes, lists (incl. GFM task-list-item), thematic breaks, link references, footnote definitions, GFM tables.
+- **`src/inline/`** — emphasis, code spans, links, autolinks, raw HTML, GFM strikethrough, footnote references, line breaks. `link.ts` and `footnote.ts` hold the label grammars the block phase shares.
 - **`src/html/`** — raw HTML recognition (bounded rules, not a general parser) plus `render.ts` (conformance oracle; internal only).
 - **`src/image/`** — PNG/JPEG dimension reader and base64 codec, shared by `src/lower/` and `src/emit/`.
 - **`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.
@@ -173,6 +174,23 @@ Every construct `src/lower`/`src/emit` cannot represent losslessly is a document
 - **`md/paragraph-indent-dropped`** — `indentLeftPt` without a recognised styleId; indent dropped, paragraph renders.
 - **`md/list-numid-fallback`** — a foreign or absent `numId` (depth-only `ContentListMembership`) falls back to a plain bullet list.
 - **`md/table-cell-formatting-dropped`** / **`md/table-cell-multi-paragraph-joined`** — GFM cells have no rich-formatting or multi-paragraph representation.
+- **`md/duplicate-footnote-definition`** — two definitions share a label; every reference resolves to the first, both are kept as written.
+- **`md/footnote-reference-preserved-as-text`** — a reference site is a marked run, not an `anchor` construct; see [Footnotes](#footnotes).
+- **`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.
+
+## Footnotes
+
+GitHub's footnote extension (`[^label]` markers, `[^label]: body` definitions) is on by default, alongside the four GFM toggles — switch it off with `footnotes: false`. Neither CommonMark nor the GFM spec document defines footnotes, so both spellings are ordinary text with it off.
+
+The two halves of a footnote map onto **two different mechanisms**, and that split is structural rather than a choice:
+
+- **A definition becomes an `anchor` construct.** `readMarkdown` emits document-schema.js 4.2.0's construct boundary markers — a `constructStart` carrying `{ kind: 'anchor', anchorType: 'footnote', name }`, the definition's own lowered body blocks, and a `constructEnd`. The body rides the construct's extent rather than `AnchorDescriptor.definition`, which names a key in a package-level definitions table a flat `ContentDocument` has no root to carry; a body is genuinely block content (several paragraphs, a code block, a list) that a string field could not have held either way. A bodyless `[^1]:` lowers to the point anchor the same descriptor describes: a pair with nothing between it.
+- **A reference site stays a marked run.** A construct's extent is block-scoped by document-schema.js's own definition, and a reference sits between two runs inside a paragraph, so no block-level boundary marker can bracket it without splitting the paragraph in two. The schema names this gap itself and parks the inline-anchor case on a run-level extent mechanism it has not shipped. Until it does, the reference is a `ContentRun` keeping its own `[^label]` spelling and carrying `FOOTNOTE_REFERENCE_FONT_MARKER`, reported through `md/footnote-reference-preserved-as-text`.
+
+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.
+
+`writeMarkdown` is the inverse and validates first: a section's markers must pair as balanced brackets (checked through document-schema.js's own `findConstructMarkerImbalance`, the shared definition every codec and `decompose` agree on) or it throws `MarkdownUnbalancedConstructMarkersError`. A construct kind with no markdown syntax — a bookmark, a division, a tracked change — renders transparently: its extent still appears in place, only the construct's own identity is lost.
 
 ## Fidelity
 

package/dist/ast/ast.cjs

@@ -13,7 +13,8 @@ const BLOCK_NODE_TYPES = /* @__PURE__ */ new Set([
 	"table",
 	"tableRow",
 	"tableCell",
-	"mathBlock"
+	"mathBlock",
+	"footnoteDefinition"
 ]);
 function isMarkdownBlockNode(node) {
 	return BLOCK_NODE_TYPES.has(node.type);

package/dist/ast/ast.d.cts

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

@@ -12,7 +12,8 @@ const BLOCK_NODE_TYPES = /* @__PURE__ */ new Set([
 	"table",
 	"tableRow",
 	"tableCell",
-	"mathBlock"
+	"mathBlock",
+	"footnoteDefinition"
 ]);
 function isMarkdownBlockNode(node) {
 	return BLOCK_NODE_TYPES.has(node.type);

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

@@ -6,7 +6,7 @@ interface MarkdownPosition {
   readonly endColumn: number;
 }
 type MarkdownNode = MarkdownBlockNode | MarkdownInlineNode;
-type MarkdownBlockNode = MarkdownDocumentNode | MarkdownParagraphNode | MarkdownHeadingNode | MarkdownBlockquoteNode | MarkdownListNode | MarkdownListItemNode | MarkdownCodeBlockNode | MarkdownThematicBreakNode | MarkdownHtmlBlockNode | MarkdownTableNode | MarkdownTableRowNode | MarkdownTableCellNode | MarkdownMathBlockNode;
+type MarkdownBlockNode = MarkdownDocumentNode | MarkdownParagraphNode | MarkdownHeadingNode | MarkdownBlockquoteNode | MarkdownListNode | MarkdownListItemNode | MarkdownCodeBlockNode | MarkdownThematicBreakNode | MarkdownHtmlBlockNode | MarkdownTableNode | MarkdownTableRowNode | MarkdownTableCellNode | MarkdownMathBlockNode | MarkdownFootnoteDefinitionNode;
 interface MarkdownDocumentNode {
   readonly type: 'document';
   readonly children: MarkdownBlockNode[];
@@ -89,7 +89,13 @@ interface MarkdownMathBlockNode {
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
-type MarkdownInlineNode = MarkdownTextNode | MarkdownEmphasisNode | MarkdownStrongNode | MarkdownStrikethroughNode | MarkdownCodeSpanNode | MarkdownLinkNode | MarkdownImageNode | MarkdownAutolinkNode | MarkdownHardBreakNode | MarkdownSoftBreakNode | MarkdownRawHtmlNode | MarkdownEntityNode | MarkdownMathInlineNode;
+interface MarkdownFootnoteDefinitionNode {
+  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 = '_' | '*';
 interface MarkdownTextNode {
   readonly type: 'text';
@@ -164,7 +170,12 @@ interface MarkdownMathInlineNode {
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
+interface MarkdownFootnoteReferenceNode {
+  readonly type: 'footnoteReference';
+  readonly label: string;
+  readonly position?: MarkdownPosition;
+}
 declare function isMarkdownBlockNode(node: MarkdownNode): node is MarkdownBlockNode;
 declare function isMarkdownInlineNode(node: MarkdownNode): node is MarkdownInlineNode;
 //#endregion
-export { MarkdownStrongNode as A, MarkdownNode as C, MarkdownRawHtmlNode as D, MarkdownPosition as E, MarkdownTextNode as F, MarkdownThematicBreakNode as I, isMarkdownBlockNode as L, MarkdownTableCellNode as M, MarkdownTableNode as N, MarkdownSoftBreakNode as O, MarkdownTableRowNode as P, isMarkdownInlineNode as R, MarkdownMathInlineNode as S, MarkdownParagraphNode as T, MarkdownLinkNode as _, MarkdownCodeBlockNode as a, MarkdownListNode as b, MarkdownEmphasisMarker as c, MarkdownHardBreakNode as d, MarkdownHeadingNode as f, MarkdownInlineNode as g, MarkdownImageNode as h, MarkdownBulletMarker as i, MarkdownTableAlignment as j, MarkdownStrikethroughNode as k, MarkdownEmphasisNode as l, MarkdownHtmlBlockNode as m, MarkdownBlockNode as n, MarkdownCodeSpanNode as o, MarkdownHeadingStyle as p, MarkdownBlockquoteNode as r, MarkdownDocumentNode as s, MarkdownAutolinkNode as t, MarkdownEntityNode as u, MarkdownListItemNode as v, MarkdownOrderedListDelimiter as w, MarkdownMathBlockNode as x, MarkdownListMarkerType as y };
+export { MarkdownSoftBreakNode as A, isMarkdownInlineNode as B, MarkdownMathBlockNode as C, MarkdownParagraphNode as D, MarkdownOrderedListDelimiter as E, MarkdownTableNode as F, MarkdownTableRowNode as I, MarkdownTextNode as L, MarkdownStrongNode as M, MarkdownTableAlignment as N, MarkdownPosition as O, MarkdownTableCellNode as P, MarkdownThematicBreakNode as R, MarkdownListNode as S, MarkdownNode as T, MarkdownImageNode as _, MarkdownCodeBlockNode as a, MarkdownListItemNode as b, MarkdownEmphasisMarker as c, MarkdownFootnoteDefinitionNode as d, MarkdownFootnoteReferenceNode as f, MarkdownHtmlBlockNode as g, MarkdownHeadingStyle as h, MarkdownBulletMarker as i, MarkdownStrikethroughNode as j, MarkdownRawHtmlNode as k, MarkdownEmphasisNode as l, MarkdownHeadingNode as m, MarkdownBlockNode as n, MarkdownCodeSpanNode as o, MarkdownHardBreakNode as p, MarkdownBlockquoteNode as r, MarkdownDocumentNode as s, MarkdownAutolinkNode as t, MarkdownEntityNode as u, MarkdownInlineNode as v, MarkdownMathInlineNode as w, MarkdownListMarkerType as x, MarkdownLinkNode as y, isMarkdownBlockNode as z };

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

@@ -6,7 +6,7 @@ interface MarkdownPosition {
   readonly endColumn: number;
 }
 type MarkdownNode = MarkdownBlockNode | MarkdownInlineNode;
-type MarkdownBlockNode = MarkdownDocumentNode | MarkdownParagraphNode | MarkdownHeadingNode | MarkdownBlockquoteNode | MarkdownListNode | MarkdownListItemNode | MarkdownCodeBlockNode | MarkdownThematicBreakNode | MarkdownHtmlBlockNode | MarkdownTableNode | MarkdownTableRowNode | MarkdownTableCellNode | MarkdownMathBlockNode;
+type MarkdownBlockNode = MarkdownDocumentNode | MarkdownParagraphNode | MarkdownHeadingNode | MarkdownBlockquoteNode | MarkdownListNode | MarkdownListItemNode | MarkdownCodeBlockNode | MarkdownThematicBreakNode | MarkdownHtmlBlockNode | MarkdownTableNode | MarkdownTableRowNode | MarkdownTableCellNode | MarkdownMathBlockNode | MarkdownFootnoteDefinitionNode;
 interface MarkdownDocumentNode {
   readonly type: 'document';
   readonly children: MarkdownBlockNode[];
@@ -89,7 +89,13 @@ interface MarkdownMathBlockNode {
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
-type MarkdownInlineNode = MarkdownTextNode | MarkdownEmphasisNode | MarkdownStrongNode | MarkdownStrikethroughNode | MarkdownCodeSpanNode | MarkdownLinkNode | MarkdownImageNode | MarkdownAutolinkNode | MarkdownHardBreakNode | MarkdownSoftBreakNode | MarkdownRawHtmlNode | MarkdownEntityNode | MarkdownMathInlineNode;
+interface MarkdownFootnoteDefinitionNode {
+  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 = '_' | '*';
 interface MarkdownTextNode {
   readonly type: 'text';
@@ -164,7 +170,12 @@ interface MarkdownMathInlineNode {
   readonly literal: string;
   readonly position?: MarkdownPosition;
 }
+interface MarkdownFootnoteReferenceNode {
+  readonly type: 'footnoteReference';
+  readonly label: string;
+  readonly position?: MarkdownPosition;
+}
 declare function isMarkdownBlockNode(node: MarkdownNode): node is MarkdownBlockNode;
 declare function isMarkdownInlineNode(node: MarkdownNode): node is MarkdownInlineNode;
 //#endregion
-export { MarkdownStrongNode as A, MarkdownNode as C, MarkdownRawHtmlNode as D, MarkdownPosition as E, MarkdownTextNode as F, MarkdownThematicBreakNode as I, isMarkdownBlockNode as L, MarkdownTableCellNode as M, MarkdownTableNode as N, MarkdownSoftBreakNode as O, MarkdownTableRowNode as P, isMarkdownInlineNode as R, MarkdownMathInlineNode as S, MarkdownParagraphNode as T, MarkdownLinkNode as _, MarkdownCodeBlockNode as a, MarkdownListNode as b, MarkdownEmphasisMarker as c, MarkdownHardBreakNode as d, MarkdownHeadingNode as f, MarkdownInlineNode as g, MarkdownImageNode as h, MarkdownBulletMarker as i, MarkdownTableAlignment as j, MarkdownStrikethroughNode as k, MarkdownEmphasisNode as l, MarkdownHtmlBlockNode as m, MarkdownBlockNode as n, MarkdownCodeSpanNode as o, MarkdownHeadingStyle as p, MarkdownBlockquoteNode as r, MarkdownDocumentNode as s, MarkdownAutolinkNode as t, MarkdownEntityNode as u, MarkdownListItemNode as v, MarkdownOrderedListDelimiter as w, MarkdownMathBlockNode as x, MarkdownListMarkerType as y };
+export { MarkdownSoftBreakNode as A, isMarkdownInlineNode as B, MarkdownMathBlockNode as C, MarkdownParagraphNode as D, MarkdownOrderedListDelimiter as E, MarkdownTableNode as F, MarkdownTableRowNode as I, MarkdownTextNode as L, MarkdownStrongNode as M, MarkdownTableAlignment as N, MarkdownPosition as O, MarkdownTableCellNode as P, MarkdownThematicBreakNode as R, MarkdownListNode as S, MarkdownNode as T, MarkdownImageNode as _, MarkdownCodeBlockNode as a, MarkdownListItemNode as b, MarkdownEmphasisMarker as c, MarkdownFootnoteDefinitionNode as d, MarkdownFootnoteReferenceNode as f, MarkdownHtmlBlockNode as g, MarkdownHeadingStyle as h, MarkdownBulletMarker as i, MarkdownStrikethroughNode as j, MarkdownRawHtmlNode as k, MarkdownEmphasisNode as l, MarkdownHeadingNode as m, MarkdownBlockNode as n, MarkdownCodeSpanNode as o, MarkdownHardBreakNode as p, MarkdownBlockquoteNode as r, MarkdownDocumentNode as s, MarkdownAutolinkNode as t, MarkdownEntityNode as u, MarkdownInlineNode as v, MarkdownMathInlineNode as w, MarkdownListMarkerType as x, MarkdownLinkNode as y, isMarkdownBlockNode as z };

package/dist/block/block.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_inline_footnote = require("../inline/footnote.cjs");
 require("../defaults/defaults.cjs");
 const require_diagnostics_diagnostics = require("../diagnostics/diagnostics.cjs");
 const require_html_html = require("../html/html.cjs");
@@ -14,7 +15,7 @@ const TASK_LIST_MARKER_PATTERN = /^\[([ xX])\][ \t]/;
 const NUL_REPLACEMENT = "�";
 const NUL_PATTERN = /\0/g;
 const LINE_ENDING_PATTERN = /\r\n|\n|\r/;
-const MAYBE_SPECIAL_PATTERN = /^[#$`~*+_=<>0-9|:-]/;
+const MAYBE_SPECIAL_PATTERN = /^[#$`~*+_=<>[0-9|:-]/;
 const ATX_MARKER_PATTERN = /^#{1,6}(?:[ \t]+|$)/;
 const ATX_ONLY_CLOSING_SEQUENCE_PATTERN = /^[ \t]*#+[ \t]*$/;
 const ATX_TRAILING_CLOSING_SEQUENCE_PATTERN = /[ \t]+#+[ \t]*$/;
@@ -46,8 +47,10 @@ function headingLevelOf(hashes) {
 }
 var BlockParser = class {
 	references = /* @__PURE__ */ new Map();
+	footnotes = /* @__PURE__ */ new Set();
 	document = new require_block_node.BlockNode("document", 1);
 	tables;
+	footnotesEnabled;
 	sink;
 	maxNesting;
 	tip = this.document;
@@ -59,6 +62,7 @@ var BlockParser = class {
 	nestingDepth = 0;
 	constructor(options) {
 		this.tables = options.gfmTables ?? true;
+		this.footnotesEnabled = options.footnotes ?? true;
 		this.sink = options.sink ?? require_diagnostics_diagnostics.NOOP_MARKDOWN_DIAGNOSTIC_SINK;
 		this.maxNesting = options.maxNesting ?? 250;
 	}
@@ -129,6 +133,7 @@ var BlockParser = class {
 			case "list": return "matched";
 			case "blockquote": return this.continueBlockquote();
 			case "listItem": return this.continueListItem(node);
+			case "footnoteDefinition": return this.continueFootnoteDefinition(node);
 			case "codeBlock": return this.continueCodeBlock(node);
 			case "mathBlock": return this.continueMathBlock(node);
 			case "htmlBlock": return this.line.blank && HTML_BLOCK_BLANK_LINE_END_TYPES.includes(node.htmlBlockType) ? "not-matched" : "matched";
@@ -163,6 +168,18 @@ var BlockParser = class {
 		}
 		return "not-matched";
 	}
+	continueFootnoteDefinition(node) {
+		if (this.line.blank) {
+			if (node.children.length === 0) return "not-matched";
+			this.line.advanceToNextNonspace();
+			return "matched";
+		}
+		if (this.line.indent >= 4) {
+			this.line.advance(4);
+			return "matched";
+		}
+		return "not-matched";
+	}
 	continueCodeBlock(node) {
 		if (!node.fenced) {
 			if (this.line.indent >= 4) {
@@ -216,6 +233,7 @@ var BlockParser = class {
 			() => this.tryAtxHeadingStart(),
 			() => this.tryCodeFenceStart(),
 			() => this.tryMathBlockStart(),
+			() => this.tryFootnoteDefinitionStart(container),
 			() => this.tryHtmlBlockStart(container),
 			() => this.tryPromoteParagraph(container),
 			() => this.tryThematicBreakStart(),
@@ -273,6 +291,29 @@ var BlockParser = class {
 		this.line.advance(MATH_BLOCK_MARKER_LENGTH);
 		return "leaf";
 	}
+	tryFootnoteDefinitionStart(container) {
+		if (!this.footnotesEnabled || this.line.indented || !this.footnoteDefinitionMayOpenIn(container)) return "none";
+		const marker = require_inline_footnote.matchFootnoteDefinitionMarker(this.line.restFromNextNonspace());
+		if (marker === void 0) return "none";
+		if (this.footnotes.has(marker.label)) this.sink({
+			code: require_diagnostics_diagnostics.MarkdownDiagnosticCodes.DUPLICATE_FOOTNOTE_DEFINITION,
+			severity: "warning",
+			message: `footnote "${marker.label}" was already defined earlier in the document; every reference resolves to the first definition, and both definitions are kept as written`,
+			line: this.lineNumber
+		});
+		this.footnotes.add(marker.label);
+		this.line.advanceToNextNonspace();
+		this.closeUnmatchedBlocks();
+		const node = this.addChild("footnoteDefinition");
+		node.footnoteLabel = marker.label;
+		this.line.advance(marker.markerLength);
+		return "container";
+	}
+	footnoteDefinitionMayOpenIn(container) {
+		let node = container;
+		while (node?.kind === "list") node = node.parent;
+		return node?.kind === "document";
+	}
 	tryHtmlBlockStart(container) {
 		if (this.line.indented || this.line.peekNextNonspace() !== "<") return "none";
 		const interruptsParagraph = container.kind === "paragraph" || !this.allClosed && !this.line.blank && this.tip.kind === "paragraph";
@@ -429,15 +470,15 @@ var BlockParser = class {
 		node.literal = breakIndex === -1 ? "" : node.content.slice(breakIndex + 1);
 	}
 };
-function toInlineChildren(content, references, options) {
-	return require_inline_inline.parseInlines(content.trim(), references, options);
+function toInlineChildren(content, context) {
+	return require_inline_inline.parseInlines(content.trim(), context.references, context.footnotes, context.options);
 }
-function toHeadingNode(node, references, options) {
+function toHeadingNode(node, context) {
 	return {
 		type: "heading",
 		level: node.level,
 		style: node.setext ? "setext" : "atx",
-		children: toInlineChildren(node.content, references, options)
+		children: toInlineChildren(node.content, context)
 	};
 }
 function extractTaskListMarker(itemChildren) {
@@ -448,19 +489,19 @@ function extractTaskListMarker(itemChildren) {
 	first.content = first.content.slice(match[0].length);
 	return match[1] !== " ";
 }
-function toListItemNode(item, references, options) {
-	const checked = options.gfmTaskLists ?? true ? extractTaskListMarker(item.children) : void 0;
+function toListItemNode(item, context) {
+	const checked = context.options.gfmTaskLists ?? true ? extractTaskListMarker(item.children) : void 0;
 	return checked === void 0 ? {
 		type: "listItem",
-		children: toAstBlocks(item.children, references, options)
+		children: toAstBlocks(item.children, context)
 	} : {
 		type: "listItem",
 		checked,
-		children: toAstBlocks(item.children, references, options)
+		children: toAstBlocks(item.children, context)
 	};
 }
-function toListNode(node, references, options) {
-	const children = node.children.map((item) => toListItemNode(item, references, options));
+function toListNode(node, context) {
+	const children = node.children.map((item) => toListItemNode(item, context));
 	const data = node.listData;
 	if (data?.type === "ordered") return {
 		type: "list",
@@ -478,20 +519,20 @@ function toListNode(node, references, options) {
 		children
 	};
 }
-function toTableRow(cells, header, references, options) {
+function toTableRow(cells, header, context) {
 	return {
 		type: "tableRow",
 		header,
 		children: cells.map((cell) => ({
 			type: "tableCell",
-			children: toInlineChildren(cell, references, options)
+			children: toInlineChildren(cell, context)
 		}))
 	};
 }
-function toTableNode(node, references, options) {
-	const sink = options.sink ?? require_diagnostics_diagnostics.NOOP_MARKDOWN_DIAGNOSTIC_SINK;
+function toTableNode(node, context) {
+	const sink = context.options.sink ?? require_diagnostics_diagnostics.NOOP_MARKDOWN_DIAGNOSTIC_SINK;
 	const columnCount = node.alignments.length;
-	const rows = [toTableRow(require_block_table.fitRowToColumns(require_block_table.splitTableRow(node.headerLine), columnCount), true, references, options)];
+	const rows = [toTableRow(require_block_table.fitRowToColumns(require_block_table.splitTableRow(node.headerLine), columnCount), true, context)];
 	for (const rowLine of node.content.split("\n")) {
 		if (rowLine.trim().length === 0) continue;
 		const cells = require_block_table.splitTableRow(rowLine);
@@ -501,7 +542,7 @@ function toTableNode(node, references, options) {
 			message: `table row has ${String(cells.length)} cell(s), but the header row declares ${String(columnCount)}; the row is padded with empty cells or truncated to fit`,
 			line: node.startLine
 		});
-		rows.push(toTableRow(require_block_table.fitRowToColumns(cells, columnCount), false, references, options));
+		rows.push(toTableRow(require_block_table.fitRowToColumns(cells, columnCount), false, context));
 	}
 	return {
 		type: "table",
@@ -509,18 +550,23 @@ function toTableNode(node, references, options) {
 		children: rows
 	};
 }
-function toAstBlock(node, references, options) {
+function toAstBlock(node, context) {
 	switch (node.kind) {
 		case "paragraph": return {
 			type: "paragraph",
-			children: toInlineChildren(node.content, references, options)
+			children: toInlineChildren(node.content, context)
 		};
-		case "heading": return toHeadingNode(node, references, options);
+		case "heading": return toHeadingNode(node, context);
 		case "blockquote": return {
 			type: "blockquote",
-			children: toAstBlocks(node.children, references, options)
+			children: toAstBlocks(node.children, context)
+		};
+		case "list": return toListNode(node, context);
+		case "footnoteDefinition": return {
+			type: "footnoteDefinition",
+			label: node.footnoteLabel,
+			children: toAstBlocks(node.children, context)
 		};
-		case "list": return toListNode(node, references, options);
 		case "codeBlock": return node.fenced ? {
 			type: "codeBlock",
 			fenced: true,
@@ -541,15 +587,15 @@ function toAstBlock(node, references, options) {
 			type: "mathBlock",
 			literal: node.literal
 		};
-		case "table": return toTableNode(node, references, options);
+		case "table": return toTableNode(node, context);
 		case "document":
 		case "listItem": return;
 	}
 }
-function toAstBlocks(nodes, references, options) {
+function toAstBlocks(nodes, context) {
 	const blocks = [];
 	for (const node of nodes) {
-		const converted = toAstBlock(node, references, options);
+		const converted = toAstBlock(node, context);
 		if (converted !== void 0) blocks.push(converted);
 	}
 	return blocks;
@@ -557,13 +603,18 @@ function toAstBlocks(nodes, references, options) {
 function parseMarkdown(source, options = {}) {
 	const parser = new BlockParser(options);
 	const root = parser.parse(source);
-	const references = parser.references;
+	const context = {
+		references: parser.references,
+		footnotes: parser.footnotes,
+		options
+	};
 	return {
 		document: {
 			type: "document",
-			children: toAstBlocks(root.children, references, options)
+			children: toAstBlocks(root.children, context)
 		},
-		references
+		references: context.references,
+		footnotes: context.footnotes
 	};
 }
 //#endregion

package/dist/block/block.d.cts

@@ -1,17 +1,20 @@
-import { s as MarkdownDocumentNode } from "../ast-DbjiuYr8.cjs";
-import { i as MarkdownDiagnosticSink } from "../diagnostics-B72W0P_E.cjs";
+import { s as MarkdownDocumentNode } from "../ast-8XCbjRQT.cjs";
+import { r as FootnoteLabelSet } from "../footnote-CKk4JbLk.cjs";
+import { i as MarkdownDiagnosticSink } from "../diagnostics-BuO5-SW1.cjs";
 import { n as LinkReferenceMap } from "../link-Dv4kxVjk.cjs";
-import { t as InlineParseOptions } from "../inline-uVHJ5xzT.cjs";
+import { t as InlineParseOptions } from "../inline-CXVQWQnW.cjs";
 //#region src/block/block.d.ts
 interface MarkdownParseOptions extends InlineParseOptions {
   readonly gfmTables?: boolean;
   readonly gfmTaskLists?: boolean;
+  readonly footnotes?: boolean;
   readonly maxNesting?: number;
   readonly sink?: MarkdownDiagnosticSink;
 }
 interface ParsedMarkdown {
   readonly document: MarkdownDocumentNode;
   readonly references: LinkReferenceMap;
+  readonly footnotes: FootnoteLabelSet;
 }
 declare function parseMarkdown(source: string, options?: MarkdownParseOptions): ParsedMarkdown;
 //#endregion

package/dist/block/block.d.ts

@@ -1,17 +1,20 @@
-import { s as MarkdownDocumentNode } from "../ast-DbjiuYr8.js";
-import { i as MarkdownDiagnosticSink } from "../diagnostics-B72W0P_E.js";
+import { s as MarkdownDocumentNode } from "../ast-8XCbjRQT.js";
+import { r as FootnoteLabelSet } from "../footnote-CKk4JbLk.js";
+import { i as MarkdownDiagnosticSink } from "../diagnostics-BuO5-SW1.js";
 import { n as LinkReferenceMap } from "../link-Dv4kxVjk.js";
-import { t as InlineParseOptions } from "../inline-TuBQ2TUr.js";
+import { t as InlineParseOptions } from "../inline-B_V7bs5j.js";
 //#region src/block/block.d.ts
 interface MarkdownParseOptions extends InlineParseOptions {
   readonly gfmTables?: boolean;
   readonly gfmTaskLists?: boolean;
+  readonly footnotes?: boolean;
   readonly maxNesting?: number;
   readonly sink?: MarkdownDiagnosticSink;
 }
 interface ParsedMarkdown {
   readonly document: MarkdownDocumentNode;
   readonly references: LinkReferenceMap;
+  readonly footnotes: FootnoteLabelSet;
 }
 declare function parseMarkdown(source: string, options?: MarkdownParseOptions): ParsedMarkdown;
 //#endregion