@notectl/core 2.2.5 → 2.3.1

package/dist/serialization/HTMLSanitization.d.ts

@@ -0,0 +1,15 @@
+/** DOMPurify options required to preserve semantic HTML IDs. */
+export interface HTMLIdSanitizeConfig {
+    readonly SANITIZE_DOM: false;
+    readonly FORBID_ATTR?: string[];
+}
+/**
+ * Builds the shared DOMPurify policy for HTML carrying document-local targets.
+ *
+ * DOMPurify's `SANITIZE_DOM` option removes otherwise valid IDs such as `target`
+ * when their value matches a property on `document` or a form. Those removals
+ * break the fragment-link contract. Callers may add attributes that a broad
+ * sanitizer pass must always reject; schema-driven allowlists remain authoritative.
+ */
+export declare function preserveHTMLIdSanitizeConfig(...additionalForbiddenAttrs: readonly string[]): HTMLIdSanitizeConfig;
+//# sourceMappingURL=HTMLSanitization.d.ts.map

package/dist/serialization/HTMLSanitization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HTMLSanitization.d.ts","sourceRoot":"","sources":["../../src/serialization/HTMLSanitization.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC3C,GAAG,wBAAwB,EAAE,SAAS,MAAM,EAAE,GAC5C,oBAAoB,CAItB"}

package/dist/serialization/MarkSerializer.d.ts

@@ -10,10 +10,22 @@ export declare function buildMarkOrder(registry: SchemaRegistry): Map<string, nu
  * Tag-based marks (`toHTMLString`) wrap the content in rank order.
  */
 export declare function serializeMarksToHTML(text: string, marks: readonly Mark[], registry: SchemaRegistry, markOrder?: Map<string, number>, exportCtx?: HTMLExportContext): string;
+/**
+ * Wraps an already-rendered inline-node HTML fragment (e.g. `<img>`) in its marks
+ * using inline-style spans, mirroring {@link serializeMarksToHTML} but without
+ * escaping the fragment. Lets a linked inline image export as `<a …><img …></a>`.
+ */
+export declare function serializeInlineNodeMarksToHTML(innerHTML: string, marks: readonly Mark[], registry: SchemaRegistry, markOrder?: Map<string, number>, exportCtx?: HTMLExportContext): string;
 /**
  * Serializes text with marks to HTML using CSS class names instead of inline styles.
  * Style-based marks (`toHTMLStyle`) are collected into a `CSSClassCollector` and emitted
  * as `<span class="...">`. Tag-based marks (`toHTMLString`) wrap identically to the inline path.
  */
 export declare function serializeMarksToClassHTML(text: string, marks: readonly Mark[], registry: SchemaRegistry, collector: CSSClassCollector, markOrder?: Map<string, number>, exportCtx?: HTMLExportContext): string;
+/**
+ * Wraps an already-rendered inline-node HTML fragment in its marks using
+ * CSS-class spans, mirroring {@link serializeMarksToClassHTML} but without
+ * escaping the fragment.
+ */
+export declare function serializeInlineNodeMarksToClassHTML(innerHTML: string, marks: readonly Mark[], registry: SchemaRegistry, collector: CSSClassCollector, markOrder?: Map<string, number>, exportCtx?: HTMLExportContext): string;
 //# sourceMappingURL=MarkSerializer.d.ts.map

package/dist/serialization/MarkSerializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkSerializer.d.ts","sourceRoot":"","sources":["../../src/serialization/MarkSerializer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAGjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAKhE,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAQ5E;AA0DD;;;;GAIG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,QAAQ,EAAE,cAAc,EACxB,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,SAAS,CAAC,EAAE,iBAAiB,GAC3B,MAAM,CAKR;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACxC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,QAAQ,EAAE,cAAc,EACxB,SAAS,EAAE,iBAAiB,EAC5B,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,SAAS,CAAC,EAAE,iBAAiB,GAC3B,MAAM,CASR"}
+{"version":3,"file":"MarkSerializer.d.ts","sourceRoot":"","sources":["../../src/serialization/MarkSerializer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAGjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAKhE,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAQ5E;AA2FD;;;;GAIG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,QAAQ,EAAE,cAAc,EACxB,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,SAAS,CAAC,EAAE,iBAAiB,GAC3B,MAAM,CASR;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC7C,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,QAAQ,EAAE,cAAc,EACxB,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,SAAS,CAAC,EAAE,iBAAiB,GAC3B,MAAM,CASR;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACxC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,QAAQ,EAAE,cAAc,EACxB,SAAS,EAAE,iBAAiB,EAC5B,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,SAAS,CAAC,EAAE,iBAAiB,GAC3B,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,mCAAmC,CAClD,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,QAAQ,EAAE,cAAc,EACxB,SAAS,EAAE,iBAAiB,EAC5B,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,SAAS,CAAC,EAAE,iBAAiB,GAC3B,MAAM,CAER"}

package/dist/serialization/MarkdownParser.d.ts

@@ -0,0 +1,6 @@
+import { Document } from '../model/Document.js';
+import { SchemaRegistry } from '../model/SchemaRegistry.js';
+import { MarkdownParseOptions } from './MarkdownTypes.js';
+/** Parses a Markdown string into a Document. */
+export declare function parseMarkdownToDocument(markdown: string, registry?: SchemaRegistry, options?: MarkdownParseOptions): Document;
+//# sourceMappingURL=MarkdownParser.d.ts.map

package/dist/serialization/MarkdownParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownParser.d.ts","sourceRoot":"","sources":["../../src/serialization/MarkdownParser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAa,QAAQ,EAAwB,MAAM,sBAAsB,CAAC;AAOtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAGjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAS/D,gDAAgD;AAChD,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,cAAc,EACzB,OAAO,CAAC,EAAE,oBAAoB,GAC5B,QAAQ,CAkBV"}

package/dist/serialization/MarkdownSerializer.d.ts

@@ -0,0 +1,12 @@
+import { Document } from '../model/Document.js';
+import { SchemaRegistry } from '../model/SchemaRegistry.js';
+import { MarkdownSerializeOptions } from './MarkdownTypes.js';
+/**
+ * Serializes a document to a Markdown string.
+ *
+ * Standard CommonMark/GFM constructs are emitted by the engine's built-in
+ * by-type mappings; unrepresentable nodes/marks emit raw HTML (valid Markdown)
+ * when `htmlFallback` is on (default), or degrade gracefully when off (D3).
+ */
+export declare function serializeDocumentToMarkdown(doc: Document, registry?: SchemaRegistry, options?: MarkdownSerializeOptions): string;
+//# sourceMappingURL=MarkdownSerializer.d.ts.map

package/dist/serialization/MarkdownSerializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownSerializer.d.ts","sourceRoot":"","sources":["../../src/serialization/MarkdownSerializer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEjE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAInE;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAC1C,GAAG,EAAE,QAAQ,EACb,QAAQ,CAAC,EAAE,cAAc,EACzB,OAAO,CAAC,EAAE,wBAAwB,GAChC,MAAM,CAQR"}

package/dist/serialization/MarkdownTypes.d.ts

@@ -0,0 +1,59 @@
+import { Document } from '../model/Document.js';
+import { MarkdownSyntaxExtension } from '../model/MarkdownSyntaxRegistry.js';
+/** Markdown dialect. `gfm` adds tables, task lists, strikethrough and autolinks. */
+export type MarkdownFlavor = 'commonmark' | 'gfm';
+/** ATX (`# h`) vs. setext (`h\n===`) heading style on export. */
+export type HeadingStyle = 'atx' | 'setext';
+/** Bullet marker used for unordered list items on export. */
+export type BulletMarker = '-' | '*' | '+';
+/** Emphasis delimiter used for italic on export. */
+export type EmphasisMarker = '*' | '_';
+/** Fence used for fenced code blocks on export. */
+export type CodeFence = '```' | '~~~';
+/** Options for {@link serializeDocumentToMarkdown} / {@link NotectlEditor.getContentMarkdown}. */
+export interface MarkdownSerializeOptions {
+    /** Dialect to emit. Default `gfm`. */
+    readonly flavor?: MarkdownFlavor;
+    /**
+     * When `true` (default), nodes/marks with no portable Markdown representation
+     * (underline, highlight, color, video, …) serialize as raw HTML so the
+     * round-trip stays lossless (D3). When `false`, styling-only features degrade
+     * gracefully (text kept, styling dropped) for clean portable Markdown.
+     */
+    readonly htmlFallback?: boolean;
+    /** Heading style. Default `atx`. */
+    readonly headingStyle?: HeadingStyle;
+    /** Bullet marker for unordered lists. Default `-`. */
+    readonly bullet?: BulletMarker;
+    /** Emphasis delimiter for italic. Default `*`. */
+    readonly emphasis?: EmphasisMarker;
+    /** Fenced code block fence. Default ` ``` `. */
+    readonly codeFence?: CodeFence;
+    /** Spaces per indent level for nested lists. Default `2`. */
+    readonly listIndent?: number;
+}
+/** Re-exported from `model/` so the extension type sits at the dependency floor (D4). */
+export type { MarkdownSyntaxExtension } from '../model/MarkdownSyntaxRegistry.js';
+/** Options for {@link parseMarkdownToDocument} / {@link NotectlEditor.setContentMarkdown}. */
+export interface MarkdownParseOptions {
+    /** Dialect to accept. Default `gfm`. */
+    readonly flavor?: MarkdownFlavor;
+    /**
+     * Import-only Obsidian/Pandoc extensions (`==highlight==`, `^sup^`, `~sub~`).
+     * Default `false` — single `~` collides with `~~` strikethrough and these are
+     * not portable on output (D2).
+     */
+    readonly extendedInlineSyntax?: boolean;
+    /**
+     * When `true` (default), raw HTML embedded in the Markdown is parsed back via
+     * the HTML parser so superset features survive the round-trip (D3).
+     */
+    readonly htmlFallback?: boolean;
+    /** Plugin-contributed grammar extensions (formula `$...$`, etc.). */
+    readonly syntaxExtensions?: readonly MarkdownSyntaxExtension[];
+}
+/** Document → Markdown serializer signature (for typing the lazy import). */
+export type SerializeDocumentToMarkdown = (doc: Document, registry?: import('../model/SchemaRegistry.js').SchemaRegistry, options?: MarkdownSerializeOptions) => string;
+/** Markdown → Document parser signature (for typing the lazy import). */
+export type ParseMarkdownToDocument = (markdown: string, registry?: import('../model/SchemaRegistry.js').SchemaRegistry, options?: MarkdownParseOptions) => Document;
+//# sourceMappingURL=MarkdownTypes.d.ts.map

package/dist/serialization/MarkdownTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownTypes.d.ts","sourceRoot":"","sources":["../../src/serialization/MarkdownTypes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,oFAAoF;AACpF,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,KAAK,CAAC;AAElD,iEAAiE;AACjE,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,QAAQ,CAAC;AAE5C,6DAA6D;AAC7D,MAAM,MAAM,YAAY,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAE3C,oDAAoD;AACpD,MAAM,MAAM,cAAc,GAAG,GAAG,GAAG,GAAG,CAAC;AAEvC,mDAAmD;AACnD,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,CAAC;AAEtC,kGAAkG;AAClG,MAAM,WAAW,wBAAwB;IACxC,sCAAsC;IACtC,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,oCAAoC;IACpC,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;IACrC,sDAAsD;IACtD,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IACnC,gDAAgD;IAChD,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,6DAA6D;IAC7D,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,yFAAyF;AACzF,YAAY,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAClF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAElF,8FAA8F;AAC9F,MAAM,WAAW,oBAAoB;IACpC,wCAAwC;IACxC,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IACxC;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,qEAAqE;IACrE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,uBAAuB,EAAE,CAAC;CAC/D;AAED,6EAA6E;AAC7E,MAAM,MAAM,2BAA2B,GAAG,CACzC,GAAG,EAAE,QAAQ,EACb,QAAQ,CAAC,EAAE,OAAO,4BAA4B,EAAE,cAAc,EAC9D,OAAO,CAAC,EAAE,wBAAwB,KAC9B,MAAM,CAAC;AAEZ,yEAAyE;AACzE,MAAM,MAAM,uBAAuB,GAAG,CACrC,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,OAAO,4BAA4B,EAAE,cAAc,EAC9D,OAAO,CAAC,EAAE,oBAAoB,KAC1B,QAAQ,CAAC"}

package/dist/serialization/TableDimensions.d.ts

@@ -0,0 +1,37 @@
+import { HTMLExportContext } from '../model/NodeSpec.js';
+/** Canonical HTML metadata carrying one logical column's width in CSS pixels. */
+export declare const TABLE_COLUMN_WIDTH_DATA_ATTRIBUTE = "data-notectl-width-px";
+/** Canonical HTML metadata carrying one logical row's minimum height in CSS pixels. */
+export declare const TABLE_ROW_MIN_HEIGHT_DATA_ATTRIBUTE = "data-notectl-min-height-px";
+/** Defensive upper bound for a serialized `<col>` vector. */
+export declare const MAX_SERIALIZED_TABLE_COLUMNS = 1000;
+/** HTML's upper bound for a `<col span>` value. */
+export declare const MAX_TABLE_COLUMN_SPAN = 1000;
+/** Returns a bounded, finite CSS-pixel value without clamping untrusted serialized input. */
+export declare function normalizeSerializedTableDimensionPx(value: unknown): number | undefined;
+/** Parses notectl's canonical numeric `data-notectl-*-px` value. */
+export declare function parseTableDimensionMetadata(raw: string | null): number | undefined;
+/** Parses a conventional numeric or `px` presentation attribute. */
+export declare function parseConventionalTableDimension(raw: string | null): number | undefined;
+/** Parses an exact CSS `<length>` in pixels. Other units and expressions are rejected. */
+export declare function parseCSSTableDimension(raw: string | null): number | undefined;
+/**
+ * Reads a dimension from an element using deterministic precedence:
+ * notectl metadata, exact CSS properties, then a conventional HTML attribute.
+ */
+export declare function readTableDimensionPx(element: HTMLElement, metadataAttribute: string, cssProperties: readonly string[], conventionalAttribute: string): number | undefined;
+/** Parses a bounded positive integer HTML span, falling back to one when malformed. */
+export declare function parseTableColumnSpan(raw: string | null): number;
+/**
+ * Normalizes an untrusted logical column-width vector. Invalid entries become
+ * automatic (`null`); a vector with no explicit width is omitted.
+ */
+export declare function normalizeTableColumnWidthsPx(value: unknown): readonly (number | null)[] | undefined;
+/** True when a table column-width vector contains at least one safe explicit value. */
+export declare function hasExplicitTableColumnWidth(value: unknown): boolean;
+/**
+ * Emits canonical metadata plus mode-aware visual CSS for one safe dimension.
+ * `ctx.styleAttr()` remains the sole generated-style path in class/CSP mode.
+ */
+export declare function serializeTableDimensionAttrs(metadataAttribute: string, cssProperty: 'width' | 'height', value: unknown, ctx?: HTMLExportContext): string;
+//# sourceMappingURL=TableDimensions.d.ts.map

package/dist/serialization/TableDimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableDimensions.d.ts","sourceRoot":"","sources":["../../src/serialization/TableDimensions.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAO9D,iFAAiF;AACjF,eAAO,MAAM,iCAAiC,0BAA0B,CAAC;AAEzE,uFAAuF;AACvF,eAAO,MAAM,mCAAmC,+BAA+B,CAAC;AAEhF,6DAA6D;AAC7D,eAAO,MAAM,4BAA4B,OAAQ,CAAC;AAElD,mDAAmD;AACnD,eAAO,MAAM,qBAAqB,OAAQ,CAAC;AAM3C,6FAA6F;AAC7F,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAItF;AAED,oEAAoE;AACpE,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,SAAS,CAElF;AAED,oEAAoE;AACpE,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,SAAS,CAEtF;AAED,0FAA0F;AAC1F,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,SAAS,CAI7E;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,WAAW,EACpB,iBAAiB,EAAE,MAAM,EACzB,aAAa,EAAE,SAAS,MAAM,EAAE,EAChC,qBAAqB,EAAE,MAAM,GAC3B,MAAM,GAAG,SAAS,CAcpB;AAED,uFAAuF;AACvF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAO/D;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC3C,KAAK,EAAE,OAAO,GACZ,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,CAOxC;AAED,uFAAuF;AACvF,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEnE;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC3C,iBAAiB,EAAE,MAAM,EACzB,WAAW,EAAE,OAAO,GAAG,QAAQ,EAC/B,KAAK,EAAE,OAAO,EACd,GAAG,CAAC,EAAE,iBAAiB,GACrB,MAAM,CAMR"}

package/dist/serialization/markdown/BlockSerializers.d.ts

@@ -0,0 +1,7 @@
+import { BlockNode } from '../../model/Document.js';
+import { SerContext } from './MarkdownContext.js';
+/** Serializes a sequence of blocks, grouping consecutive list items, joined by blank lines. */
+export declare function serializeBlocks(blocks: readonly BlockNode[], ctx: SerContext): string;
+/** Serializes a single (non-list-item) block. */
+export declare function serializeBlock(block: BlockNode, ctx: SerContext): string;
+//# sourceMappingURL=BlockSerializers.d.ts.map

package/dist/serialization/markdown/BlockSerializers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockSerializers.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/BlockSerializers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAczD,OAAO,EAAE,KAAK,UAAU,EAAiB,MAAM,sBAAsB,CAAC;AAStE,+FAA+F;AAC/F,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,CA4BrF;AAED,iDAAiD;AACjD,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,CAiBxE"}

package/dist/serialization/markdown/BlockTokenizer.d.ts

@@ -0,0 +1,54 @@
+import { MarkdownSyntaxExtension } from '../../model/MarkdownSyntaxRegistry.js';
+import { ColumnAlign } from './GfmTableParser.js';
+/** A parsed block-level token. Inline text is left raw for the inline parser. */
+export type BlockToken = {
+    readonly type: 'heading';
+    readonly level: number;
+    readonly text: string;
+} | {
+    readonly type: 'paragraph';
+    readonly text: string;
+} | {
+    readonly type: 'code_block';
+    readonly language: string;
+    readonly code: string;
+} | {
+    readonly type: 'hr';
+} | {
+    readonly type: 'blockquote';
+    readonly children: readonly BlockToken[];
+} | {
+    readonly type: 'list_item';
+    readonly listType: 'bullet' | 'ordered' | 'checklist';
+    readonly indent: number;
+    readonly checked: boolean;
+    /** Inline text of a leaf item; empty when `children` is present. */
+    readonly text: string;
+    /** Block children of a multi-block (container) item, absent for leaves. */
+    readonly children?: readonly BlockToken[];
+} | {
+    readonly type: 'html';
+    readonly html: string;
+} | {
+    readonly type: 'table';
+    readonly aligns: readonly ColumnAlign[];
+    readonly header: readonly string[];
+    readonly rows: readonly (readonly string[])[];
+} | {
+    readonly type: 'extension_block';
+    readonly nodeType: string;
+    readonly attrs: Record<string, string | number | boolean>;
+};
+export declare const ATX_HEADING: RegExp;
+export declare const FENCE_OPEN: RegExp;
+export declare const THEMATIC_BREAK: RegExp;
+export declare const SETEXT_H1: RegExp;
+export declare const SETEXT_H2: RegExp;
+/**
+ * Matches a fence opener. A backtick fence whose info string contains a
+ * backtick is not a fence per CommonMark (it reads as an inline code span).
+ */
+export declare function matchFenceOpen(line: string): RegExpMatchArray | null;
+/** Tokenizes a full Markdown source string into block tokens. */
+export declare function tokenizeBlocks(source: string, gfm?: boolean, extensions?: readonly MarkdownSyntaxExtension[]): BlockToken[];
+//# sourceMappingURL=BlockTokenizer.d.ts.map

package/dist/serialization/markdown/BlockTokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockTokenizer.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/BlockTokenizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AACrF,OAAO,EAAE,KAAK,WAAW,EAA8B,MAAM,qBAAqB,CAAC;AAGnF,iFAAiF;AACjF,MAAM,MAAM,UAAU,GACnB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC3E;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACjF;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CAAE,GACvB;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAA;CAAE,GACzE;IACA,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,GAAG,WAAW,CAAC;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CACzC,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IACA,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC;CAC7C,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;CACzD,CAAC;AA6CL,eAAO,MAAM,WAAW,QAAwD,CAAC;AACjF,eAAO,MAAM,UAAU,QAAoC,CAAC;AAC5D,eAAO,MAAM,cAAc,QAA0C,CAAC;AAQtE,eAAO,MAAM,SAAS,QAAqB,CAAC;AAC5C,eAAO,MAAM,SAAS,QAAqB,CAAC;AAwB5C;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAKpE;AAED,iEAAiE;AACjE,wBAAgB,cAAc,CAC7B,MAAM,EAAE,MAAM,EACd,GAAG,UAAO,EACV,UAAU,GAAE,SAAS,uBAAuB,EAAO,GACjD,UAAU,EAAE,CAKd"}

package/dist/serialization/markdown/GfmAutolink.d.ts

@@ -0,0 +1,20 @@
+import { InlineAstNode } from './InlineAst.js';
+/** A matched GFM autolink: destination, display text, and source length. */
+export interface GfmAutolinkMatch {
+    readonly href: string;
+    readonly display: string;
+    readonly length: number;
+}
+/** Cheap pre-check: whether `pos` could start a GFM autolink (boundary + prefix). */
+export declare function isGfmAutolinkCandidate(text: string, pos: number): boolean;
+/** Matches a GFM autolink at `pos` (boundary included in the check), or null. */
+export declare function matchGfmAutolinkAt(text: string, pos: number): GfmAutolinkMatch | null;
+/**
+ * Post-pass over the resolved inline AST: turns bare `user@host.tld` emails in
+ * plain text into `mailto:` links. Adjacent text nodes (including leftover
+ * delimiter runs) are merged first so a local part like `a_b` is scanned as one
+ * string. Subtrees that must not be linkified (links, images, code, raw HTML,
+ * plugin inline nodes) are skipped.
+ */
+export declare function applyGfmEmailAutolinks(nodes: InlineAstNode[]): void;
+//# sourceMappingURL=GfmAutolink.d.ts.map

package/dist/serialization/markdown/GfmAutolink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GfmAutolink.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/GfmAutolink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,aAAa,EAAY,MAAM,gBAAgB,CAAC;AAE9D,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB;AAiBD,qFAAqF;AACrF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAYzE;AAED,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAWrF;AAkGD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,IAAI,CAenE"}

package/dist/serialization/markdown/GfmTableParser.d.ts

@@ -0,0 +1,26 @@
+/**
+ * GFM table detection and row parsing.
+ *
+ * A table is a header row, a delimiter row (`| --- | :--: |`), and zero or more
+ * body rows. Column alignment is derived from the colons in the delimiter row.
+ * Cells hold raw inline text, parsed later by the inline tokenizer.
+ */
+/** Column alignment derived from the delimiter row. */
+export type ColumnAlign = 'start' | 'center' | 'end' | null;
+/** A parsed GFM table (cells are raw inline strings). */
+export interface TableData {
+    readonly aligns: readonly ColumnAlign[];
+    readonly header: readonly string[];
+    readonly rows: readonly (readonly string[])[];
+    readonly linesConsumed: number;
+}
+/**
+ * Attempts to parse a GFM table beginning at `start`. Returns the table data or
+ * null when the two leading lines are not a header + delimiter pair. The body
+ * extends until a blank line or the start of another block (`interrupts`); a
+ * plain paragraph-like line inside that range is a lazy single-cell row, per
+ * the GFM spec ("the table is broken at the first empty line or beginning of
+ * another block-level structural element").
+ */
+export declare function matchTable(lines: readonly string[], start: number, interrupts?: (line: string) => boolean): TableData | null;
+//# sourceMappingURL=GfmTableParser.d.ts.map

package/dist/serialization/markdown/GfmTableParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GfmTableParser.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/GfmTableParser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,uDAAuD;AACvD,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,IAAI,CAAC;AAE5D,yDAAyD;AACzD,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC;IAC9C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAC/B;AAyCD;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GACpC,SAAS,GAAG,IAAI,CAqBlB"}

package/dist/serialization/markdown/InlineAst.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Inline AST node model + linked-list helpers shared by the inline parser.
+ *
+ * A doubly-linked list of nodes is used during parsing so the emphasis
+ * delimiter-stack algorithm runs in linear time (no array splicing), which is
+ * the ReDoS-safety guarantee for untrusted pasted Markdown (D1).
+ */
+/** Inline AST node kind. */
+export type InlineKind = 'text' | 'code' | 'softbreak' | 'hardbreak' | 'emph' | 'strong' | 'strike' | 'highlight' | 'sup' | 'sub' | 'link' | 'image' | 'inline_node' | 'html_inline';
+/** A single inline AST node (mutable; linked into a sibling list). */
+export interface InlineAstNode {
+    type: InlineKind;
+    /** Literal text for `text` / `code` / `html_inline`. */
+    literal: string;
+    /** Container children (`emph`, `strong`, `link`, …). */
+    children: InlineAstNode[];
+    /** Link/image destination + title. */
+    href: string;
+    title: string;
+    /** Image alt text (plain). */
+    alt: string;
+    /** Generic inline-node passthrough (plugin extensions, e.g. math). */
+    inlineType: string;
+    attrs: Record<string, string | number | boolean>;
+    prev: InlineAstNode | null;
+    next: InlineAstNode | null;
+}
+/** Creates a fresh inline AST node of the given kind. */
+export declare function makeNode(type: InlineKind, literal?: string): InlineAstNode;
+/** Appends `node` after `target` in the sibling linked list. */
+export declare function insertAfter(target: InlineAstNode, node: InlineAstNode): void;
+/** Removes `node` from its sibling linked list. */
+export declare function unlink(node: InlineAstNode): void;
+//# sourceMappingURL=InlineAst.d.ts.map

package/dist/serialization/markdown/InlineAst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineAst.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/InlineAst.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,4BAA4B;AAC5B,MAAM,MAAM,UAAU,GACnB,MAAM,GACN,MAAM,GACN,WAAW,GACX,WAAW,GACX,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,KAAK,GACL,KAAK,GACL,MAAM,GACN,OAAO,GACP,aAAa,GACb,aAAa,CAAC;AAEjB,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,8BAA8B;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,sEAAsE;IACtE,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IACjD,IAAI,EAAE,aAAa,GAAG,IAAI,CAAC;IAC3B,IAAI,EAAE,aAAa,GAAG,IAAI,CAAC;CAC3B;AAED,yDAAyD;AACzD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,SAAK,GAAG,aAAa,CAatE;AAED,gEAAgE;AAChE,wBAAgB,WAAW,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAK5E;AAED,mDAAmD;AACnD,wBAAgB,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CAKhD"}

package/dist/serialization/markdown/InlineSerializers.d.ts

@@ -0,0 +1,5 @@
+import { InlineNode, TextNode } from '../../model/Document.js';
+import { SerContext } from './MarkdownContext.js';
+/** Serializes inline children of a leaf block to a Markdown string. */
+export declare function serializeInlineContent(children: readonly (TextNode | InlineNode)[], ctx: SerContext): string;
+//# sourceMappingURL=InlineSerializers.d.ts.map

package/dist/serialization/markdown/InlineSerializers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineSerializers.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/InlineSerializers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAQ,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAI1E,OAAO,EAAE,KAAK,UAAU,EAAiB,MAAM,sBAAsB,CAAC;AAqQtE,uEAAuE;AACvE,wBAAgB,sBAAsB,CACrC,QAAQ,EAAE,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,EAC5C,GAAG,EAAE,UAAU,GACb,MAAM,CAyCR"}

package/dist/serialization/markdown/InlineTokenizer.d.ts

@@ -0,0 +1,5 @@
+import { InlineNode, TextNode } from '../../model/Document.js';
+import { ParseContext } from './MarkdownParseContext.js';
+/** Parses inline Markdown into text/inline nodes (linear-time, ReDoS-safe). */
+export declare function parseInline(text: string, ctx: ParseContext): (TextNode | InlineNode)[];
+//# sourceMappingURL=InlineTokenizer.d.ts.map

package/dist/serialization/markdown/InlineTokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineTokenizer.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/InlineTokenizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAQ,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAmB1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AA66B9D,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,CAOtF"}

package/dist/serialization/markdown/LinkReferenceExtractor.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Link reference definition extraction (`[label]: dest "title"`).
+ *
+ * Runs as a pre-pass over the source before block tokenization, mirroring how
+ * commonmark.js resolves references before inline parsing. CommonMark rules
+ * honored here:
+ *
+ * - A definition never interrupts an open paragraph (a def-shaped line that
+ *   lazily continues a paragraph stays paragraph text).
+ * - Def-shaped lines inside fenced code are code and survive verbatim.
+ * - The destination may sit on the line after the label, and a title may sit
+ *   on its own following line (multi-line labels and multi-line titles are not
+ *   supported; such lines stay paragraph text, which never drops content).
+ * - Titles honor backslash escapes; destinations and titles decode escapes and
+ *   entity references; labels match case-folded (Unicode, `ẞ` ↔ `SS`).
+ * - A definition inside a blockquote is recognized too; the quote marker line
+ *   is kept so the (now empty) container survives.
+ *
+ * First definition of a label wins, as per spec.
+ */
+/** A link reference definition target. */
+export interface LinkRef {
+    readonly href: string;
+    readonly title?: string;
+}
+/**
+ * Case-folds a reference label for matching. `toUpperCase().toLowerCase()`
+ * approximates Unicode case folding (it maps `ẞ`/`ß` and `SS` to the same
+ * string), which plain `toLowerCase()` does not.
+ */
+export declare function foldReferenceLabel(label: string): string;
+/** Removes link reference definitions from the source and returns them as a map. */
+export declare function extractLinkReferences(source: string): {
+    source: string;
+    linkRefs: Map<string, LinkRef>;
+};
+//# sourceMappingURL=LinkReferenceExtractor.d.ts.map

package/dist/serialization/markdown/LinkReferenceExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinkReferenceExtractor.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/LinkReferenceExtractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAKH,0CAA0C;AAC1C,MAAM,WAAW,OAAO;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACxB;AAcD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOxD;AAED,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,CA+CA"}

package/dist/serialization/markdown/MarkdownContext.d.ts

@@ -0,0 +1,32 @@
+import { MarkdownExportContext } from '../../model/NodeSpec.js';
+import { SchemaRegistry } from '../../model/SchemaRegistry.js';
+import { MarkdownSerializeOptions } from '../MarkdownTypes.js';
+/** Fully-resolved serialization options (no `undefined`). */
+export interface ResolvedSerializeOptions {
+    readonly flavor: 'commonmark' | 'gfm';
+    readonly gfm: boolean;
+    readonly htmlFallback: boolean;
+    readonly headingStyle: 'atx' | 'setext';
+    readonly bullet: string;
+    readonly emphasis: string;
+    readonly codeFence: string;
+    readonly listIndent: number;
+}
+/** Internal context shared by all serialization helpers. */
+export interface SerContext {
+    readonly registry?: SchemaRegistry;
+    readonly opts: ResolvedSerializeOptions;
+    /** Precomputed mark rank map (built once per pass) for HTML-fallback marks. */
+    readonly markOrder?: Map<string, number>;
+    /**
+     * True while serializing the block children of a list item (#194): thematic
+     * breaks emit `***` there, because `---` on an indented continuation line
+     * would re-parse as a setext underline or a bullet marker.
+     */
+    readonly inListItem?: boolean;
+}
+/** Resolves user-facing options into a complete settings object with defaults. */
+export declare function resolveSerializeOptions(options?: MarkdownSerializeOptions): ResolvedSerializeOptions;
+/** Builds the public {@link MarkdownExportContext} passed to per-spec hooks. */
+export declare function exportContext(opts: ResolvedSerializeOptions): MarkdownExportContext;
+//# sourceMappingURL=MarkdownContext.d.ts.map

package/dist/serialization/markdown/MarkdownContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownContext.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/MarkdownContext.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAEpE,6DAA6D;AAC7D,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,KAAK,CAAC;IACtC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,KAAK,GAAG,QAAQ,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC5B;AAED,4DAA4D;AAC5D,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,kFAAkF;AAClF,wBAAgB,uBAAuB,CACtC,OAAO,CAAC,EAAE,wBAAwB,GAChC,wBAAwB,CAY1B;AAED,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,IAAI,EAAE,wBAAwB,GAAG,qBAAqB,CAEnF"}

package/dist/serialization/markdown/MarkdownEntities.d.ts

@@ -0,0 +1,33 @@
+/**
+ * HTML entity and backslash-escape decoding shared by the Markdown parser.
+ *
+ * CommonMark recognizes entity and numeric character references (and backslash
+ * escapes) not only in inline text but also inside link destinations, link
+ * titles, link reference definitions, and code-fence info strings. The small
+ * built-in table covers the common names; uncommon names are decoded through
+ * the environment's HTML parser when a DOM is available (browser, happy-dom),
+ * because embedding the full HTML5 table (~2200 names) would bloat the chunk.
+ * Without a DOM (pure Node) unknown entities stay literal, which never loses
+ * content.
+ */
+/** Characters a backslash may escape (CommonMark ASCII punctuation). */
+export declare const ESCAPABLE: RegExp;
+/**
+ * Decodes a single HTML entity body (without `&`/`;`), or returns it verbatim.
+ * Per CommonMark, U+0000 and invalid code points decode to U+FFFD; decoded
+ * line separators become plain spaces so a text node never carries a raw
+ * newline (block boundaries are structural in the editor model).
+ */
+export declare function decodeEntity(body: string): string;
+/** Matches an entity reference at `pos` in `text`, or null. */
+export declare function matchEntityAt(text: string, pos: number): RegExpExecArray | null;
+/**
+ * Decodes backslash escapes and entity references in a single left-to-right
+ * pass (an escaped `&` therefore never starts an entity). Used for the string
+ * contexts CommonMark decodes outside inline text: link destinations, titles,
+ * reference definitions, and fence info strings.
+ */
+export declare function decodeEscapesAndEntities(text: string): string;
+/** Decodes only entity references (escapes were already consumed by the caller). */
+export declare function decodeEntitiesOnly(text: string): string;
+//# sourceMappingURL=MarkdownEntities.d.ts.map

package/dist/serialization/markdown/MarkdownEntities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownEntities.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/MarkdownEntities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,wEAAwE;AACxE,eAAO,MAAM,SAAS,QAAmB,CAAC;AAmB1C;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAcjD;AAED,+DAA+D;AAC/D,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAG/E;AAiBD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAsB7D;AAED,oFAAoF;AACpF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAiBvD"}

package/dist/serialization/markdown/MarkdownEscape.d.ts

@@ -0,0 +1,33 @@
+/**
+ * CommonMark escaping rules for Markdown serialization.
+ *
+ * Escaping is contextual: inline text backslash-escapes characters that would
+ * otherwise start emphasis/code/links, while the start of a line additionally
+ * escapes block markers (`#`, `>`, `-`, …) so prose never accidentally becomes
+ * a heading or list on re-parse. Output stays minimal: we do not escape every
+ * punctuation character, only those that are actually ambiguous in context.
+ */
+/**
+ * Escapes inline text so it round-trips as literal content. `~` is escaped only
+ * for GFM (where `~~` is strikethrough); `_` is escaped only when it is not
+ * intra-word, matching CommonMark's emphasis rules (so `a_b_c` stays literal).
+ */
+export declare function escapeInline(text: string, gfm: boolean): string;
+/**
+ * Escapes leading block markers at the start of a paragraph line so the text
+ * does not re-parse as a heading, blockquote, list, thematic break, setext
+ * underline, or code fence.
+ */
+export declare function escapeLineStart(line: string): string;
+/** Escapes the destination of a link/image so spaces and parens stay intact. */
+export declare function escapeLinkDestination(url: string): string;
+/** Escapes a link/image title for the `"..."` form. */
+export declare function escapeLinkTitle(title: string): string;
+/**
+ * Picks a backtick fence long enough to wrap `content` as an inline code span.
+ * CommonMark requires a fence longer than any backtick run inside the content.
+ */
+export declare function codeSpanFence(content: string): string;
+/** Wraps `content` in a correctly sized inline code span, padding when needed. */
+export declare function wrapCodeSpan(content: string): string;
+//# sourceMappingURL=MarkdownEscape.d.ts.map

package/dist/serialization/markdown/MarkdownEscape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownEscape.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/MarkdownEscape.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAeH;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,MAAM,CAuB/D;AA0BD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAsBpD;AAED,gFAAgF;AAChF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKzD;AAED,uDAAuD;AACvD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAYrD;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAUpD"}

package/dist/serialization/markdown/MarkdownHTMLRegistry.d.ts

@@ -0,0 +1,4 @@
+import { SchemaRegistry } from '../../model/SchemaRegistry.js';
+/** Resolves the schema at an HTML boundary without supplementing an explicit schema. */
+export declare function resolveMarkdownHTMLRegistry(registry?: SchemaRegistry): SchemaRegistry;
+//# sourceMappingURL=MarkdownHTMLRegistry.d.ts.map

package/dist/serialization/markdown/MarkdownHTMLRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownHTMLRegistry.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/MarkdownHTMLRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAU/D,wFAAwF;AACxF,wBAAgB,2BAA2B,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,cAAc,CAIrF"}

package/dist/serialization/markdown/MarkdownParseContext.d.ts

@@ -0,0 +1,23 @@
+import { SchemaRegistry } from '../../model/SchemaRegistry.js';
+import { MarkdownParseOptions, MarkdownSyntaxExtension } from '../MarkdownTypes.js';
+/** Fully-resolved parse options (no `undefined`). */
+export interface ResolvedParseOptions {
+    readonly flavor: 'commonmark' | 'gfm';
+    readonly gfm: boolean;
+    readonly extendedInlineSyntax: boolean;
+    readonly htmlFallback: boolean;
+    readonly syntaxExtensions: readonly MarkdownSyntaxExtension[];
+}
+/** Internal context shared by the block and inline parsers. */
+export interface ParseContext {
+    readonly registry?: SchemaRegistry;
+    readonly opts: ResolvedParseOptions;
+    /** Link reference definitions collected from the source (`[ref]: url "title"`). */
+    readonly linkRefs: ReadonlyMap<string, {
+        readonly href: string;
+        readonly title?: string;
+    }>;
+}
+/** Resolves user-facing parse options into a complete settings object with defaults. */
+export declare function resolveParseOptions(options?: MarkdownParseOptions): ResolvedParseOptions;
+//# sourceMappingURL=MarkdownParseContext.d.ts.map

package/dist/serialization/markdown/MarkdownParseContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownParseContext.d.ts","sourceRoot":"","sources":["../../../src/serialization/markdown/MarkdownParseContext.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAEzF,qDAAqD;AACrD,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,KAAK,CAAC;IACtC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,gBAAgB,EAAE,SAAS,uBAAuB,EAAE,CAAC;CAC9D;AAED,+DAA+D;AAC/D,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,mFAAmF;IACnF,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC3F;AAED,wFAAwF;AACxF,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,oBAAoB,CASxF"}