markdown-codec 6.4.3 → 6.5.1

package/README.md

@@ -142,11 +142,11 @@ Modelled on `pdf-codec`'s own layering, aimed at CommonMark+GFM instead of PDF:
 - **`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, 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/html/`** — raw HTML recognition (bounded rules, not a general parser) plus `render.ts` (conformance oracle; internal only). `html-table.ts` is the one exception to "never parsed as markup": a block-level HTML that is, in full, one well-formed `<table>` recognises straight to a real `ContentTable` instead of opaque text — see [HTML-table fallback](#html-table-fallback).
 - **`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.
 - **`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/emit/`** — `ContentDocument` → markdown text emission, the structural inverse of `src/lower`. `html-table.ts` is `src/html/html-table.ts`'s own write-side counterpart.
 - **`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
@@ -195,7 +195,7 @@ Every construct `src/lower`/`src/emit` cannot represent losslessly is a document
 - **`md/math-inline-preserved-as-text`** — inline `\( \)` math stays a Cambria-Math-marked raw-LaTeX run; display `$$` math is a real embedded formula carrying the presentation layer.
 - **`md/image-unresolved`** — no resolver, `undefined` return, or non-PNG/JPEG bytes degrades to alt-text run.
 - **`md/raw-html-preserved-as-text` / `md/raw-html-dropped`** — raw HTML kept as literal text (default) or dropped; never interpreted. The preserved text's verbatim original quarantines as markdown residue on its node, and this package's own writer re-emits that residue as-is.
-- **`md/front-matter-key-unmapped`** — no YAML/TOML engine; only five known `LayoutMetadata` keys recognised. The verbatim original block rides the package-level residue table (`readMarkdown`'s `documentPackage.source.frontmatter`), which `writeMarkdown` re-emits as-is.
+- **`md/front-matter-key-unmapped`** — no YAML/TOML engine; only `LayoutMetadata`'s own string/array/enum fields are recognised (every one of them except `producer`, which is PDF-writer-only), each as a flat `key: value` (or `keywords: [a, b]`) line. The verbatim original block rides the package-level residue table (`readMarkdown`'s `documentPackage.source.frontmatter`), which `writeMarkdown` re-emits as-is.
 - **`md/heading-level-clamped`** — styleId beyond `Heading6` (from another format) clamps to level 6 via document-schema.js's shared `clampHeadingLevel()`.
 - **`md/heading-line-break-collapsed`** — a hard or soft break embedded in a heading's own runs (most commonly a setext heading read with more than one physical line) is promoted to setext output whenever the level admits one (1 or 2) and the break's own placement is safe to promote, the only markdown grammar that can hold a genuine line break inside heading text; a level 3-6 heading with the same shape has no such fallback and always collapses the break to a single space instead, as does a level 1/2 heading whose break placement is unsafe to promote (see `md/heading-line-break-unsafe-for-setext` below).
 - **`md/heading-line-break-unsafe-for-setext`** — a level 1/2 heading's own embedded break sits where promoting to setext would violate one of the three clauses packed into setext's own grammar sentence (spec 0.31.2, "Setext headings"): "one or more lines of text, not interrupted by a blank line, of which the first line does not have more than 3 spaces of indentation, followed by a setext heading underline. The lines of text must be such that, were they not followed by the setext heading underline, they would be interpreted as a paragraph: they cannot be interpretable as a code fence, ATX heading, block quote, thematic break, list item, or HTML block." Reported when promoting would leave a blank line immediately before the underline (a trailing break) or in the middle of the heading's own text (an interior break between two embedded breaks, or a break immediately followed by incidental whitespace-only content); when the heading's own first content line opens with 4 or more columns of space/tab indentation — CommonMark's own tab-stop rule counts a tab by the same 4-column stop, so a single leading tab is exactly as unsafe as 4 leading spaces — since that line would read back as an indented code block rather than heading text; or when a line AFTER the first would itself be read as one of the spec's six interrupting constructs (a code fence, ATX heading, block quote, thematic break, list item, or HTML block) instead of ordinary paragraph continuation text — reachable from a bold or strikethrough run that becomes empty immediately after a break, whose bare pair of emphasis markers spells as a thematic break (`____`/`****`) or a code-fence opener (`~~~~`). ATX collapses the break to a single space instead of promoting into any of these corrupt reparses. A break at the very START of the heading's own text stays eligible for setext, but that exemption covers only a single leading blank line, and only the blank line itself: it sits before the text-and-underline run even begins, so it reparses as ordinary inter-block whitespace ahead of the heading rather than corrupting anything. A second consecutive leading blank line is not exempt — CommonMark's own list-item grammar allows at most one, so a second closes a list item as empty and spills the heading out with its list membership lost, even though it would be harmless at top level or inside a blockquote — and the indentation clause above still applies in full to the line that follows the leading blank line, the heading's own first real content: a leading break immediately followed by 4 or more columns of indentation is refused exactly as an unbroken heading in the same shape would be, since promoting would read that following line back as an indented code block regardless of the leading break ahead of it.
@@ -204,9 +204,10 @@ 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/raw-html-preserved-as-text`** — see the raw-HTML entry above.
-- **`md/table-cell-formatting-dropped`** — colSpan/rowSpan/background, or a non-paragraph, non-image block (a nested table, say), have no GFM cell representation at all; the cell still renders, unmerged/unstyled, with that content dropped.
-- **`md/table-cell-multi-paragraph-joined`** — a cell carrying more than one block joins their rendered text with a literal `<br>`, real inline HTML every GFM table renderer treats as a genuine line break.
-- **`md/table-cell-image-degraded`** — an `image`-kind cell block emits inline (`![alt](data:...)`) rather than being dropped; on read-back it degrades to a run carrying the alt text with the image's own data URI as that run's hyperlink, the same "nested image" shape an image inside emphasis/a link already degrades to elsewhere in this package.
+- **`md/table-html-fallback`** — a cell's own colSpan/rowSpan/background, or a block a plain GFM cell cannot represent at all (most commonly a nested table), sends the WHOLE table through the HTML-table fallback instead of plain pipe syntax — see [HTML-table fallback](#html-table-fallback). Fires once per table that falls back.
+- **`md/table-cell-formatting-dropped`** — the residual gap even inside the HTML-table fallback: a cell's own pattern background fill (only a solid fill maps onto CSS `background-color`), a nested table mixed with sibling content in the same cell (a cell's own nested table must be its entire content), or any other block kind (`embeddedObject`, `pageBreak`) — none of these have a representation this bounded recogniser attempts; the cell still renders, unmerged/unstyled, with that content dropped.
+- **`md/table-cell-multi-paragraph-joined`** — a cell carrying more than one block joins their rendered content with a literal `<br>`, real inline HTML every GFM table renderer treats as a genuine line break — markdown syntax in the plain pipe-syntax writer, a real `<br>` HTML tag in the HTML-table fallback.
+- **`md/table-cell-image-degraded`** — plain pipe-syntax writer only: an `image`-kind cell block emits inline (`![alt](data:...)`) rather than being dropped; on read-back it degrades to a run carrying the alt text with the image's own data URI as that run's hyperlink, the same "nested image" shape an image inside emphasis/a link already degrades to elsewhere in this package. The HTML-table fallback represents an image losslessly instead, as a real `<img>` tag.
 - **`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.
@@ -221,10 +222,22 @@ The two halves of a footnote map onto the **same `anchor` construct at two diffe
 - **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.
+Definitions are recognised at the document's own top level, directly inside a block quote, or directly inside a list item (ExaDev/markdown-codec#957) — a blockquote's own division construct threads its enclosing container's context straight through the definition's anchor pair the same way it already does for a nested blockquote, and a list item whose own first block is the anchor pair picks up the same placeholder-paragraph carry a nested blockquote already relies on. Not recognised inside another definition's own body: a footnote-in-a-footnote has no cross-format shape, so a `[^2]:` line there stays ordinary body text. A heading inside a definition body is still flattened to literal ATX text, and a blockquote containing a heading anywhere in its own subtree still degrades to indent-only structure — both because a construct boundary marker's extent may not open or close a heading-group scope, a document-schema.js-level limitation this package cannot route around from its own side.
 
 Emission 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 `writeMarkdownContent` throws `MarkdownUnbalancedConstructMarkersError`. A tree already satisfies that balance by construction — `decompose` refuses to build one from an unbalanced stream — so `writeMarkdown` reaches this check only on a hand-built package flattened back to an unbalanced flow. 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.
 
+## HTML-table fallback
+
+GFM's own pipe-table syntax (github.github.com/gfm, "Tables (extension)") holds inline content only — no cell can carry `colSpan`/`rowSpan`/a background, and no cell can hold a block that isn't inlinable (a nested table, most notably). `writeMarkdownContent` detects this per table (`tableNeedsHtmlFallback`, `src/emit/html-table.ts`): the moment ANY cell needs one of these, the WHOLE table renders as a raw HTML `<table>` block instead of the plain `| a | b |` writer — GFM's own cell grammar cannot mix an HTML sub-block into one cell of an otherwise pipe-syntax table, so a partial, per-cell fallback is not an option. A raw HTML `<table>` block is legal CommonMark regardless (spec 0.31.2, "HTML blocks" start condition 6 names `table` directly — <https://spec.commonmark.org/0.31.2/#html-blocks>). A table with none of these needs still emits the existing, human-readable pipe syntax, unaffected.
+
+`readMarkdownContent`/`readMarkdown` recognise this same shape on the way back in (`parseHtmlTable`, `src/html/html-table.ts`) — the one exception to this package's own "raw HTML is never parsed as markup" rule (see the raw-HTML gotcha above and `src/html/html.ts`'s own top comment): a block-level HTML that is, in full, one well-formed `<table>` lowers straight to a real `ContentTable`, so a table written through this fallback reads back as an equal (or equivalent) `ContentTable` rather than degrading to opaque preserved text. This recognition is gated on GFM's table extension being enabled (`gfmTables`, default `true`) exactly the way plain pipe-table promotion already is — with it disabled, a `<table>` block stays exactly the opaque raw HTML it always was, since a `ContentTable` is a GFM-table-extension construct either way it is spelled in the source.
+
+Both halves are **bounded recognisers, not a general HTML/DOM parser** — matching `src/html/html.ts`'s own deliberate scope. They recognise `<table>`/`<tr>`/`<td>`/`<th>` and, on each cell, `colspan`/`rowspan` (positive integers) and a `style="background-color:#rrggbb"` declaration (a `ContentCellFill`'s `solid` variant only — a `pattern` fill has no plain-CSS equivalent this writer attempts, and degrades with `TABLE_CELL_FORMATTING_DROPPED`), plus `style="text-align:..."` for the cell's own paragraph alignment — read per cell rather than only from the header row, a strictly richer fidelity than plain GFM's single per-column delimiter marker can ever express, so a table already falling back for another reason never silently loses alignment plain GFM would have kept. Attribute values must be double-quoted, matching exactly what the writer itself emits; a single-quoted or unquoted value is a real HTML shape neither side attempts.
+
+A cell's own inline formatting renders as real HTML tags — `<strong>`/`<em>`/`<del>`/`<code>`/`<a href>`, the identical bold/italic/strike/hyperlink/Courier-New-as-code-span vocabulary the plain writer already spells in markdown syntax — because raw HTML block content is never reprocessed as markdown, so writing markdown punctuation inside this block would render as its own literal characters rather than formatting. The reader also recognises the common `<b>`/`<i>`/`<s>`/`<strike>` synonyms real hand-authored HTML tends to use, in any nesting order or combination.
+
+A cell's own nested-block content is bounded to two shapes: several paragraph/image blocks join with a literal `<br>`, exactly as the plain writer already joins a multi-paragraph cell (`TABLE_CELL_MULTI_PARAGRAPH_JOINED`); or, when a cell's ENTIRE content is one nested table and nothing else, that table recurses through the identical fallback, unconditionally, since a table nested inside another table's cell can never itself be pipe syntax. A nested table mixed with sibling content in the same cell, or any other block kind (`embeddedObject`, `pageBreak`), has no representation either side attempts and is dropped with `TABLE_CELL_FORMATTING_DROPPED`, exactly as it always was before this fallback existed.
+
 ## Fidelity
 
 **Markdown → `ContentDocument` is dominated by target-schema limits, not parsing gaps.** The parser recognises every construct CommonMark and GFM define; the limiting factor is what `ContentDocument` can hold — a cross-format pivot shaped around docx/pptx/odt/odp/ods/odg, not markdown's richer model. Each gap is a permanent structural mismatch.

package/dist/block/block.cjs

@@ -312,7 +312,7 @@ var BlockParser = class {
 	footnoteDefinitionMayOpenIn(container) {
 		let node = container;
 		while (node?.kind === "list") node = node.parent;
-		return node?.kind === "document";
+		return node?.kind === "document" || node?.kind === "blockquote" || node?.kind === "listItem";
 	}
 	tryHtmlBlockStart(container) {
 		if (this.line.indented || this.line.peekNextNonspace() !== "<") return "none";

package/dist/block/block.d.cts

@@ -1,6 +1,6 @@
 import { s as MarkdownDocumentNode } from "../ast-CNfTgS0N.cjs";
 import { r as FootnoteLabelSet } from "../footnote-CKk4JbLk.cjs";
-import { i as MarkdownDiagnosticSink } from "../diagnostics-eL5c8OWm.cjs";
+import { i as MarkdownDiagnosticSink } from "../diagnostics-DLum7kY6.cjs";
 import { LinkReferenceMap } from "../inline/link.cjs";
 import { t as InlineParseOptions } from "../inline-CnO86zMw.cjs";
 //#region src/block/block.d.ts

package/dist/block/block.d.ts

@@ -1,6 +1,6 @@
 import { s as MarkdownDocumentNode } from "../ast-CNfTgS0N.js";
 import { r as FootnoteLabelSet } from "../footnote-CKk4JbLk.js";
-import { i as MarkdownDiagnosticSink } from "../diagnostics-eL5c8OWm.js";
+import { i as MarkdownDiagnosticSink } from "../diagnostics-DLum7kY6.js";
 import { LinkReferenceMap } from "../inline/link.js";
 import { t as InlineParseOptions } from "../inline-DItZ-VVw.js";
 //#region src/block/block.d.ts

package/dist/block/block.js

@@ -311,7 +311,7 @@ var BlockParser = class {
 	footnoteDefinitionMayOpenIn(container) {
 		let node = container;
 		while (node?.kind === "list") node = node.parent;
-		return node?.kind === "document";
+		return node?.kind === "document" || node?.kind === "blockquote" || node?.kind === "listItem";
 	}
 	tryHtmlBlockStart(container) {
 		if (this.line.indented || this.line.peekNextNonspace() !== "<") return "none";

package/dist/block/definitions.d.cts

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

package/dist/block/definitions.d.ts

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

package/dist/codec.d.cts

@@ -2271,6 +2271,52 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
         g: z.ZodNumber;
         b: z.ZodNumber;
       }, z.core.$strip>>;
+      fillPattern: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"gradient">;
+        style: z.ZodEnum<{
+          linear: "linear";
+          axial: "axial";
+          radial: "radial";
+          ellipsoid: "ellipsoid";
+          square: "square";
+          rectangular: "rectangular";
+        }>;
+        startColor: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        endColor: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        angleDeg: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"hatch">;
+        style: z.ZodEnum<{
+          double: "double";
+          single: "single";
+          triple: "triple";
+        }>;
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        distancePt: z.ZodNumber;
+        rotationDeg: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"bitmap">;
+        format: z.ZodEnum<{
+          png: "png";
+          jpeg: "jpeg";
+          svg: "svg";
+          gif: "gif";
+        }>;
+        base64: z.ZodString;
+      }, z.core.$strip>], "kind">>;
+      fillOpacity: z.ZodOptional<z.ZodNumber>;
       stroke: z.ZodOptional<z.ZodObject<{
         color: z.ZodObject<{
           r: z.ZodNumber;
@@ -2284,6 +2330,14 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
           dotted: "dotted";
           double: "double";
         }>>;
+        opacity: z.ZodOptional<z.ZodNumber>;
+        dashPattern: z.ZodOptional<z.ZodObject<{
+          dots1: z.ZodNumber;
+          dots1LengthPt: z.ZodNumber;
+          dots2: z.ZodOptional<z.ZodNumber>;
+          dots2LengthPt: z.ZodOptional<z.ZodNumber>;
+          distancePt: z.ZodNumber;
+        }, z.core.$strip>>;
       }, z.core.$strip>>;
       paintOrder: z.ZodOptional<z.ZodNumber>;
       sourcePath: z.ZodOptional<z.ZodString>;
@@ -2327,6 +2381,52 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
         g: z.ZodNumber;
         b: z.ZodNumber;
       }, z.core.$strip>>;
+      fillPattern: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"gradient">;
+        style: z.ZodEnum<{
+          linear: "linear";
+          axial: "axial";
+          radial: "radial";
+          ellipsoid: "ellipsoid";
+          square: "square";
+          rectangular: "rectangular";
+        }>;
+        startColor: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        endColor: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        angleDeg: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"hatch">;
+        style: z.ZodEnum<{
+          double: "double";
+          single: "single";
+          triple: "triple";
+        }>;
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        distancePt: z.ZodNumber;
+        rotationDeg: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"bitmap">;
+        format: z.ZodEnum<{
+          png: "png";
+          jpeg: "jpeg";
+          svg: "svg";
+          gif: "gif";
+        }>;
+        base64: z.ZodString;
+      }, z.core.$strip>], "kind">>;
+      fillOpacity: z.ZodOptional<z.ZodNumber>;
       stroke: z.ZodOptional<z.ZodObject<{
         color: z.ZodObject<{
           r: z.ZodNumber;
@@ -2340,6 +2440,14 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
           dotted: "dotted";
           double: "double";
         }>>;
+        opacity: z.ZodOptional<z.ZodNumber>;
+        dashPattern: z.ZodOptional<z.ZodObject<{
+          dots1: z.ZodNumber;
+          dots1LengthPt: z.ZodNumber;
+          dots2: z.ZodOptional<z.ZodNumber>;
+          dots2LengthPt: z.ZodOptional<z.ZodNumber>;
+          distancePt: z.ZodNumber;
+        }, z.core.$strip>>;
       }, z.core.$strip>>;
       paintOrder: z.ZodOptional<z.ZodNumber>;
       sourcePath: z.ZodOptional<z.ZodString>;
@@ -2392,6 +2500,14 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
           dotted: "dotted";
           double: "double";
         }>>;
+        opacity: z.ZodOptional<z.ZodNumber>;
+        dashPattern: z.ZodOptional<z.ZodObject<{
+          dots1: z.ZodNumber;
+          dots1LengthPt: z.ZodNumber;
+          dots2: z.ZodOptional<z.ZodNumber>;
+          dots2LengthPt: z.ZodOptional<z.ZodNumber>;
+          distancePt: z.ZodNumber;
+        }, z.core.$strip>>;
       }, z.core.$strip>;
       paintOrder: z.ZodOptional<z.ZodNumber>;
       sourcePath: z.ZodOptional<z.ZodString>;
@@ -2463,6 +2579,52 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
         g: z.ZodNumber;
         b: z.ZodNumber;
       }, z.core.$strip>>;
+      fillPattern: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"gradient">;
+        style: z.ZodEnum<{
+          linear: "linear";
+          axial: "axial";
+          radial: "radial";
+          ellipsoid: "ellipsoid";
+          square: "square";
+          rectangular: "rectangular";
+        }>;
+        startColor: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        endColor: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        angleDeg: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"hatch">;
+        style: z.ZodEnum<{
+          double: "double";
+          single: "single";
+          triple: "triple";
+        }>;
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        distancePt: z.ZodNumber;
+        rotationDeg: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"bitmap">;
+        format: z.ZodEnum<{
+          png: "png";
+          jpeg: "jpeg";
+          svg: "svg";
+          gif: "gif";
+        }>;
+        base64: z.ZodString;
+      }, z.core.$strip>], "kind">>;
+      fillOpacity: z.ZodOptional<z.ZodNumber>;
       fillRule: z.ZodOptional<z.ZodEnum<{
         nonzero: "nonzero";
         evenodd: "evenodd";
@@ -2480,6 +2642,14 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
           dotted: "dotted";
           double: "double";
         }>>;
+        opacity: z.ZodOptional<z.ZodNumber>;
+        dashPattern: z.ZodOptional<z.ZodObject<{
+          dots1: z.ZodNumber;
+          dots1LengthPt: z.ZodNumber;
+          dots2: z.ZodOptional<z.ZodNumber>;
+          dots2LengthPt: z.ZodOptional<z.ZodNumber>;
+          distancePt: z.ZodNumber;
+        }, z.core.$strip>>;
       }, z.core.$strip>>;
       paintOrder: z.ZodOptional<z.ZodNumber>;
       sourcePath: z.ZodOptional<z.ZodString>;

package/dist/codec.d.ts

@@ -2271,6 +2271,52 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
         g: z.ZodNumber;
         b: z.ZodNumber;
       }, z.core.$strip>>;
+      fillPattern: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"gradient">;
+        style: z.ZodEnum<{
+          linear: "linear";
+          axial: "axial";
+          radial: "radial";
+          ellipsoid: "ellipsoid";
+          square: "square";
+          rectangular: "rectangular";
+        }>;
+        startColor: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        endColor: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        angleDeg: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"hatch">;
+        style: z.ZodEnum<{
+          double: "double";
+          single: "single";
+          triple: "triple";
+        }>;
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        distancePt: z.ZodNumber;
+        rotationDeg: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"bitmap">;
+        format: z.ZodEnum<{
+          png: "png";
+          jpeg: "jpeg";
+          svg: "svg";
+          gif: "gif";
+        }>;
+        base64: z.ZodString;
+      }, z.core.$strip>], "kind">>;
+      fillOpacity: z.ZodOptional<z.ZodNumber>;
       stroke: z.ZodOptional<z.ZodObject<{
         color: z.ZodObject<{
           r: z.ZodNumber;
@@ -2284,6 +2330,14 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
           dotted: "dotted";
           double: "double";
         }>>;
+        opacity: z.ZodOptional<z.ZodNumber>;
+        dashPattern: z.ZodOptional<z.ZodObject<{
+          dots1: z.ZodNumber;
+          dots1LengthPt: z.ZodNumber;
+          dots2: z.ZodOptional<z.ZodNumber>;
+          dots2LengthPt: z.ZodOptional<z.ZodNumber>;
+          distancePt: z.ZodNumber;
+        }, z.core.$strip>>;
       }, z.core.$strip>>;
       paintOrder: z.ZodOptional<z.ZodNumber>;
       sourcePath: z.ZodOptional<z.ZodString>;
@@ -2327,6 +2381,52 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
         g: z.ZodNumber;
         b: z.ZodNumber;
       }, z.core.$strip>>;
+      fillPattern: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"gradient">;
+        style: z.ZodEnum<{
+          linear: "linear";
+          axial: "axial";
+          radial: "radial";
+          ellipsoid: "ellipsoid";
+          square: "square";
+          rectangular: "rectangular";
+        }>;
+        startColor: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        endColor: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        angleDeg: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"hatch">;
+        style: z.ZodEnum<{
+          double: "double";
+          single: "single";
+          triple: "triple";
+        }>;
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        distancePt: z.ZodNumber;
+        rotationDeg: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"bitmap">;
+        format: z.ZodEnum<{
+          png: "png";
+          jpeg: "jpeg";
+          svg: "svg";
+          gif: "gif";
+        }>;
+        base64: z.ZodString;
+      }, z.core.$strip>], "kind">>;
+      fillOpacity: z.ZodOptional<z.ZodNumber>;
       stroke: z.ZodOptional<z.ZodObject<{
         color: z.ZodObject<{
           r: z.ZodNumber;
@@ -2340,6 +2440,14 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
           dotted: "dotted";
           double: "double";
         }>>;
+        opacity: z.ZodOptional<z.ZodNumber>;
+        dashPattern: z.ZodOptional<z.ZodObject<{
+          dots1: z.ZodNumber;
+          dots1LengthPt: z.ZodNumber;
+          dots2: z.ZodOptional<z.ZodNumber>;
+          dots2LengthPt: z.ZodOptional<z.ZodNumber>;
+          distancePt: z.ZodNumber;
+        }, z.core.$strip>>;
       }, z.core.$strip>>;
       paintOrder: z.ZodOptional<z.ZodNumber>;
       sourcePath: z.ZodOptional<z.ZodString>;
@@ -2392,6 +2500,14 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
           dotted: "dotted";
           double: "double";
         }>>;
+        opacity: z.ZodOptional<z.ZodNumber>;
+        dashPattern: z.ZodOptional<z.ZodObject<{
+          dots1: z.ZodNumber;
+          dots1LengthPt: z.ZodNumber;
+          dots2: z.ZodOptional<z.ZodNumber>;
+          dots2LengthPt: z.ZodOptional<z.ZodNumber>;
+          distancePt: z.ZodNumber;
+        }, z.core.$strip>>;
       }, z.core.$strip>;
       paintOrder: z.ZodOptional<z.ZodNumber>;
       sourcePath: z.ZodOptional<z.ZodString>;
@@ -2463,6 +2579,52 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
         g: z.ZodNumber;
         b: z.ZodNumber;
       }, z.core.$strip>>;
+      fillPattern: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"gradient">;
+        style: z.ZodEnum<{
+          linear: "linear";
+          axial: "axial";
+          radial: "radial";
+          ellipsoid: "ellipsoid";
+          square: "square";
+          rectangular: "rectangular";
+        }>;
+        startColor: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        endColor: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        angleDeg: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"hatch">;
+        style: z.ZodEnum<{
+          double: "double";
+          single: "single";
+          triple: "triple";
+        }>;
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        distancePt: z.ZodNumber;
+        rotationDeg: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"bitmap">;
+        format: z.ZodEnum<{
+          png: "png";
+          jpeg: "jpeg";
+          svg: "svg";
+          gif: "gif";
+        }>;
+        base64: z.ZodString;
+      }, z.core.$strip>], "kind">>;
+      fillOpacity: z.ZodOptional<z.ZodNumber>;
       fillRule: z.ZodOptional<z.ZodEnum<{
         nonzero: "nonzero";
         evenodd: "evenodd";
@@ -2480,6 +2642,14 @@ declare const markdownContentCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffe
           dotted: "dotted";
           double: "double";
         }>>;
+        opacity: z.ZodOptional<z.ZodNumber>;
+        dashPattern: z.ZodOptional<z.ZodObject<{
+          dots1: z.ZodNumber;
+          dots1LengthPt: z.ZodNumber;
+          dots2: z.ZodOptional<z.ZodNumber>;
+          dots2LengthPt: z.ZodOptional<z.ZodNumber>;
+          distancePt: z.ZodNumber;
+        }, z.core.$strip>>;
       }, z.core.$strip>>;
       paintOrder: z.ZodOptional<z.ZodNumber>;
       sourcePath: z.ZodOptional<z.ZodString>;

package/dist/diagnostics/diagnostics.cjs

@@ -32,7 +32,8 @@ const MarkdownDiagnosticCodes = {
 	LIST_NUMID_FALLBACK: "md/list-numid-fallback",
 	TABLE_CELL_FORMATTING_DROPPED: "md/table-cell-formatting-dropped",
 	TABLE_CELL_MULTI_PARAGRAPH_JOINED: "md/table-cell-multi-paragraph-joined",
-	TABLE_CELL_IMAGE_DEGRADED: "md/table-cell-image-degraded"
+	TABLE_CELL_IMAGE_DEGRADED: "md/table-cell-image-degraded",
+	TABLE_HTML_FALLBACK: "md/table-html-fallback"
 };
 var MarkdownParseError = class extends Error {
 	code;

package/dist/diagnostics/diagnostics.d.cts

@@ -1,2 +1,2 @@
-import { a as MarkdownInputTooLargeError, c as MarkdownNestingLimitExceededError, d as MarkdownUnbalancedConstructMarkersError, f as MarkdownUnsupportedDocumentKindError, i as MarkdownDiagnosticSink, l as MarkdownPackageFlattenError, m as NOOP_MARKDOWN_DIAGNOSTIC_SINK, n as MarkdownDiagnosticCodes, o as MarkdownInvalidRunConstructExtentError, p as MarkdownWriteError, r as MarkdownDiagnosticSeverity, s as MarkdownInvalidUtf8Error, t as MarkdownDiagnostic, u as MarkdownParseError } from "../diagnostics-eL5c8OWm.cjs";
+import { a as MarkdownInputTooLargeError, c as MarkdownNestingLimitExceededError, d as MarkdownUnbalancedConstructMarkersError, f as MarkdownUnsupportedDocumentKindError, i as MarkdownDiagnosticSink, l as MarkdownPackageFlattenError, m as NOOP_MARKDOWN_DIAGNOSTIC_SINK, n as MarkdownDiagnosticCodes, o as MarkdownInvalidRunConstructExtentError, p as MarkdownWriteError, r as MarkdownDiagnosticSeverity, s as MarkdownInvalidUtf8Error, t as MarkdownDiagnostic, u as MarkdownParseError } from "../diagnostics-DLum7kY6.cjs";
 export { MarkdownDiagnostic, MarkdownDiagnosticCodes, MarkdownDiagnosticSeverity, MarkdownDiagnosticSink, MarkdownInputTooLargeError, MarkdownInvalidRunConstructExtentError, MarkdownInvalidUtf8Error, MarkdownNestingLimitExceededError, MarkdownPackageFlattenError, MarkdownParseError, MarkdownUnbalancedConstructMarkersError, MarkdownUnsupportedDocumentKindError, MarkdownWriteError, NOOP_MARKDOWN_DIAGNOSTIC_SINK };

package/dist/diagnostics/diagnostics.d.ts

@@ -1,2 +1,2 @@
-import { a as MarkdownInputTooLargeError, c as MarkdownNestingLimitExceededError, d as MarkdownUnbalancedConstructMarkersError, f as MarkdownUnsupportedDocumentKindError, i as MarkdownDiagnosticSink, l as MarkdownPackageFlattenError, m as NOOP_MARKDOWN_DIAGNOSTIC_SINK, n as MarkdownDiagnosticCodes, o as MarkdownInvalidRunConstructExtentError, p as MarkdownWriteError, r as MarkdownDiagnosticSeverity, s as MarkdownInvalidUtf8Error, t as MarkdownDiagnostic, u as MarkdownParseError } from "../diagnostics-eL5c8OWm.js";
+import { a as MarkdownInputTooLargeError, c as MarkdownNestingLimitExceededError, d as MarkdownUnbalancedConstructMarkersError, f as MarkdownUnsupportedDocumentKindError, i as MarkdownDiagnosticSink, l as MarkdownPackageFlattenError, m as NOOP_MARKDOWN_DIAGNOSTIC_SINK, n as MarkdownDiagnosticCodes, o as MarkdownInvalidRunConstructExtentError, p as MarkdownWriteError, r as MarkdownDiagnosticSeverity, s as MarkdownInvalidUtf8Error, t as MarkdownDiagnostic, u as MarkdownParseError } from "../diagnostics-DLum7kY6.js";
 export { MarkdownDiagnostic, MarkdownDiagnosticCodes, MarkdownDiagnosticSeverity, MarkdownDiagnosticSink, MarkdownInputTooLargeError, MarkdownInvalidRunConstructExtentError, MarkdownInvalidUtf8Error, MarkdownNestingLimitExceededError, MarkdownPackageFlattenError, MarkdownParseError, MarkdownUnbalancedConstructMarkersError, MarkdownUnsupportedDocumentKindError, MarkdownWriteError, NOOP_MARKDOWN_DIAGNOSTIC_SINK };

package/dist/diagnostics/diagnostics.js

@@ -31,7 +31,8 @@ const MarkdownDiagnosticCodes = {
 	LIST_NUMID_FALLBACK: "md/list-numid-fallback",
 	TABLE_CELL_FORMATTING_DROPPED: "md/table-cell-formatting-dropped",
 	TABLE_CELL_MULTI_PARAGRAPH_JOINED: "md/table-cell-multi-paragraph-joined",
-	TABLE_CELL_IMAGE_DEGRADED: "md/table-cell-image-degraded"
+	TABLE_CELL_IMAGE_DEGRADED: "md/table-cell-image-degraded",
+	TABLE_HTML_FALLBACK: "md/table-html-fallback"
 };
 var MarkdownParseError = class extends Error {
 	code;

package/dist/{diagnostics-eL5c8OWm.d.cts → diagnostics-DLum7kY6.d.cts}

@@ -40,6 +40,7 @@ declare const MarkdownDiagnosticCodes: {
   readonly TABLE_CELL_FORMATTING_DROPPED: "md/table-cell-formatting-dropped";
   readonly TABLE_CELL_MULTI_PARAGRAPH_JOINED: "md/table-cell-multi-paragraph-joined";
   readonly TABLE_CELL_IMAGE_DEGRADED: "md/table-cell-image-degraded";
+  readonly TABLE_HTML_FALLBACK: "md/table-html-fallback";
 };
 declare class MarkdownParseError extends Error {
   readonly code: string;

package/dist/{diagnostics-eL5c8OWm.d.ts → diagnostics-DLum7kY6.d.ts}

@@ -40,6 +40,7 @@ declare const MarkdownDiagnosticCodes: {
   readonly TABLE_CELL_FORMATTING_DROPPED: "md/table-cell-formatting-dropped";
   readonly TABLE_CELL_MULTI_PARAGRAPH_JOINED: "md/table-cell-multi-paragraph-joined";
   readonly TABLE_CELL_IMAGE_DEGRADED: "md/table-cell-image-degraded";
+  readonly TABLE_HTML_FALLBACK: "md/table-html-fallback";
 };
 declare class MarkdownParseError extends Error {
   readonly code: string;