@texuli/deck 0.0.0-stage → 0.4.0

package/dist/markdown/frontmatter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The frontmatter: a closed key set with scalar values only (no YAML parser,
+ * no lists, maps, anchors, tags or multi-line values). Values are typed by
+ * key; the deck model validates them afterwards, and its issues map back to
+ * the key's line.
+ */
+import { type PathSegment } from '../schema/index.js';
+import type { IssueSink } from './issues.js';
+import type { Line } from './scan.js';
+type Kind = 'string' | 'boolean' | 'int';
+interface KeySpec {
+    kind: Kind;
+    /** Where the value goes in the deck. */
+    path: readonly PathSegment[];
+}
+/** The closed frontmatter keys, in canonical (written) order. */
+export declare const FRONTMATTER_KEYS: Readonly<Record<string, KeySpec>>;
+export interface Frontmatter {
+    /** Key → typed value, in the order read. */
+    values: Map<string, string | number | boolean>;
+    /** Key → line. */
+    lines: Map<string, number>;
+}
+/** Read the frontmatter lines. Unknown keys and non-scalar values are errors. */
+export declare function readFrontmatter(lines: readonly Line[], sink: IssueSink): Frontmatter;
+/** The JSON paths a frontmatter key's value lands on (for the source map). */
+export declare function frontmatterPath(key: string): string;
+/** A frontmatter scalar written canonically: bare when unambiguous, else double-quoted. */
+export declare function writeScalar(value: string | number | boolean): string;
+export {};

package/dist/markdown/frontmatter.js

@@ -0,0 +1,165 @@
+/**
+ * The frontmatter: a closed key set with scalar values only (no YAML parser,
+ * no lists, maps, anchors, tags or multi-line values). Values are typed by
+ * key; the deck model validates them afterwards, and its issues map back to
+ * the key's line.
+ */
+import { toJsonPath } from "../schema/index.js";
+import { trimBlankEnd } from "./text.js";
+/** The closed frontmatter keys, in canonical (written) order. */
+export const FRONTMATTER_KEYS = Object.freeze({
+    title: { kind: 'string', path: ['meta', 'title'] },
+    description: { kind: 'string', path: ['meta', 'description'] },
+    author: { kind: 'string', path: ['meta', 'author'] },
+    date: { kind: 'string', path: ['meta', 'date'] },
+    locale: { kind: 'string', path: ['meta', 'locale'] },
+    dir: { kind: 'string', path: ['meta', 'dir'] },
+    theme: { kind: 'string', path: ['style', 'theme'] },
+    themeMode: { kind: 'string', path: ['style', 'theme', 'mode'] },
+    themeSeed: { kind: 'int', path: ['style', 'theme', 'seed'] },
+    fontPair: { kind: 'string', path: ['style', 'fontPair'] },
+    aspect: { kind: 'string', path: ['style', 'aspect'] },
+    density: { kind: 'string', path: ['style', 'density'] },
+    radius: { kind: 'string', path: ['style', 'radius'] },
+    motion: { kind: 'string', path: ['style', 'motion'] },
+    transition: { kind: 'string', path: ['style', 'transition'] },
+    background: { kind: 'string', path: ['style', 'background'] },
+    logo: { kind: 'string', path: ['style', 'logo'] },
+    footer: { kind: 'string', path: ['style', 'footer'] },
+    slideNumbers: { kind: 'boolean', path: ['style', 'slideNumbers'] },
+    progress: { kind: 'string', path: ['style', 'progress'] },
+    codeTheme: { kind: 'string', path: ['style', 'codeTheme'] },
+    math: { kind: 'boolean', path: ['style', 'math'] },
+    start: { kind: 'string', path: ['navigation', 'start'] },
+    loop: { kind: 'boolean', path: ['navigation', 'loop'] },
+    autoSlide: { kind: 'int', path: ['navigation', 'autoSlideMs'] },
+    outlineTitle: { kind: 'string', path: ['outline', 'title'] },
+});
+/** Kebab-case spellings accepted on input (the writer uses camelCase). */
+const ALIASES = Object.freeze({
+    'font-pair': 'fontPair',
+    'slide-numbers': 'slideNumbers',
+    'code-theme': 'codeTheme',
+    'auto-slide': 'autoSlide',
+    'theme-mode': 'themeMode',
+    'theme-seed': 'themeSeed',
+    'outline-title': 'outlineTitle',
+});
+/** Runs on `trimBlankEnd(text)`: no trailing `[ \t]*` competes with the value. */
+const KEY = /^([A-Za-z][A-Za-z0-9-]*)[ \t]*:(?:[ \t]+(.*))?$/;
+function scalar(raw) {
+    if (raw.startsWith('"')) {
+        if (!raw.endsWith('"') || raw.length < 2)
+            return { error: 'The quoted value never closes.' };
+        const inner = raw.slice(1, -1);
+        let out = '';
+        for (let i = 0; i < inner.length; i++) {
+            const c = inner[i];
+            if (c === '\\') {
+                const next = inner[i + 1];
+                if (next === '"' || next === '\\') {
+                    out += next;
+                    i++;
+                    continue;
+                }
+                return { error: 'Only \\" and \\\\ escapes are read in a quoted value.' };
+            }
+            if (c === '"')
+                return { error: 'Escape a " inside a quoted value as \\".' };
+            out += c;
+        }
+        return { value: out };
+    }
+    if (raw.startsWith("'")) {
+        if (!raw.endsWith("'") || raw.length < 2)
+            return { error: 'The quoted value never closes.' };
+        const inner = raw.slice(1, -1);
+        if (/(?<!')'(?!')/.test(inner.replaceAll("''", ''))) {
+            return { error: "Escape a ' inside a single-quoted value as ''." };
+        }
+        return { value: inner.replaceAll("''", "'") };
+    }
+    if (/^[[{|>&*!%@`]/.test(raw)) {
+        return { error: 'Only scalar values: no lists, maps, blocks, anchors or tags.' };
+    }
+    return { value: raw };
+}
+/** Read the frontmatter lines. Unknown keys and non-scalar values are errors. */
+export function readFrontmatter(lines, sink) {
+    const values = new Map();
+    const lineOf = new Map();
+    for (const line of lines) {
+        const text = line.text;
+        if (text.trim() === '' || text.trimStart().startsWith('#'))
+            continue;
+        const match = KEY.exec(trimBlankEnd(text));
+        if (!match) {
+            sink.report('md-frontmatter-value', 'A frontmatter line is `key: value`.', { line: line.n, column: 1 }, [], 'Write one scalar per line, e.g. `title: Quarterly review`.');
+            continue;
+        }
+        const written = match[1] ?? '';
+        const key = Object.hasOwn(ALIASES, written) ? (ALIASES[written] ?? written) : written;
+        const spec = Object.hasOwn(FRONTMATTER_KEYS, key) ? FRONTMATTER_KEYS[key] : undefined;
+        const column = text.indexOf(':') + 2;
+        if (!spec) {
+            sink.report('md-frontmatter-key', `Unknown frontmatter key "${written.slice(0, 40)}".`, { line: line.n, column: 1 }, [], `Use one of: ${Object.keys(FRONTMATTER_KEYS).join(', ')}.`);
+            continue;
+        }
+        if (values.has(key)) {
+            sink.report('md-frontmatter-key', `"${key}" is set twice.`, { line: line.n, column: 1 });
+            continue;
+        }
+        const raw = match[2] ?? '';
+        if (raw === '') {
+            sink.report('md-frontmatter-value', `"${key}" needs a value.`, { line: line.n, column });
+            continue;
+        }
+        const read = scalar(raw);
+        if ('error' in read) {
+            sink.report('md-frontmatter-value', read.error, { line: line.n, column });
+            continue;
+        }
+        let value = read.value;
+        if (spec.kind === 'boolean') {
+            if (read.value !== 'true' && read.value !== 'false') {
+                sink.report('md-frontmatter-value', `"${key}" is true or false.`, { line: line.n, column });
+                continue;
+            }
+            value = read.value === 'true';
+        }
+        else if (spec.kind === 'int') {
+            if (!/^-?\d{1,10}$/.test(read.value)) {
+                sink.report('md-frontmatter-value', `"${key}" is a whole number.`, {
+                    line: line.n,
+                    column,
+                });
+                continue;
+            }
+            value = Number(read.value);
+        }
+        values.set(key, value);
+        lineOf.set(key, line.n);
+    }
+    return { values, lines: lineOf };
+}
+/** The JSON paths a frontmatter key's value lands on (for the source map). */
+export function frontmatterPath(key) {
+    const spec = FRONTMATTER_KEYS[key];
+    return spec ? toJsonPath(spec.path) : '$';
+}
+/** A frontmatter scalar written canonically: bare when unambiguous, else double-quoted. */
+export function writeScalar(value) {
+    if (typeof value !== 'string')
+        return String(value);
+    if (value === '' ||
+        value !== value.trim() ||
+        /^[[{|>&*!%@`"'#]/.test(value) ||
+        value === 'true' ||
+        value === 'false' ||
+        /^-?\d+$/.test(value) ||
+        value.includes(': ') ||
+        value.includes(' #')) {
+        return `"${value.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+    }
+    return value;
+}

package/dist/markdown/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @texuli/deck/markdown: the deck Markdown dialect (ADR-009). reveal.js is an
+ * inspiration, not a compatibility target, and there is no HTML:
+ *
+ * - `parseDeckMarkdown(text, options)` reads closed-key scalar frontmatter,
+ *   `---` slides and `--` vertical stacks, `Note:`, `<!-- .slide: -->` and
+ *   `<!-- .element: -->` attributes from a closed set (reveal.js aliases
+ *   mapped), fragments, code fences with `[1-2|4-6]` steps, `$$` math, the
+ *   20 layouts through `layout="<id>"` and `:::` regions, and
+ *   `::: component <id>` fences with a bounded JSON body. Raw HTML, iframes,
+ *   `class`, `style` and `on*` are refused with a diagnostic. It returns the
+ *   same validated `Deck` as `parseDeck`, every issue with a source line and
+ *   column, and the source map.
+ * - `deckToMarkdown(deck)` writes canonical Markdown that reads back as the
+ *   same deck (JSON fences where Markdown would not round-trip).
+ * - `deckToText` and `deckOutline` are the one-way text twins.
+ *
+ * Inline `$…$` math stays inside text blocks as written; block `$$` math
+ * becomes a `{ type: "math", tex }` block (see `@texuli/deck/math`).
+ */
+export { type Attr, attributeWritable, readAttributes, writeAttribute } from './attributes.js';
+export { mapEffect } from './attrs-closed.js';
+export { FRONTMATTER_KEYS } from './frontmatter.js';
+export { DECK_MARKDOWN_CODES, type DeckMarkdownCode, type DeckMarkdownCodeInfo } from './issues.js';
+export { type JsonReadOptions, type JsonReadResult, readJson } from './json.js';
+export { DECK_MARKDOWN_LIMITS } from './limits.js';
+export { type DeckDraft, type DeckMarkdownResult, deriveSlideId, type ParseDeckMarkdownOptions, parseDeckMarkdown, readDeckDraft, } from './parse.js';
+export { type DeckOutlineSlide, type DeckOutlineText, type DeckTextOptions, deckOutline, deckToText, formatDeckOutline, slideTitle, } from './twin.js';
+export { type DeckMarkdownWriteResult, deckToMarkdown, writeDeckMarkdown } from './write.js';

package/dist/markdown/index.js

@@ -0,0 +1,29 @@
+/**
+ * @texuli/deck/markdown: the deck Markdown dialect (ADR-009). reveal.js is an
+ * inspiration, not a compatibility target, and there is no HTML:
+ *
+ * - `parseDeckMarkdown(text, options)` reads closed-key scalar frontmatter,
+ *   `---` slides and `--` vertical stacks, `Note:`, `<!-- .slide: -->` and
+ *   `<!-- .element: -->` attributes from a closed set (reveal.js aliases
+ *   mapped), fragments, code fences with `[1-2|4-6]` steps, `$$` math, the
+ *   20 layouts through `layout="<id>"` and `:::` regions, and
+ *   `::: component <id>` fences with a bounded JSON body. Raw HTML, iframes,
+ *   `class`, `style` and `on*` are refused with a diagnostic. It returns the
+ *   same validated `Deck` as `parseDeck`, every issue with a source line and
+ *   column, and the source map.
+ * - `deckToMarkdown(deck)` writes canonical Markdown that reads back as the
+ *   same deck (JSON fences where Markdown would not round-trip).
+ * - `deckToText` and `deckOutline` are the one-way text twins.
+ *
+ * Inline `$…$` math stays inside text blocks as written; block `$$` math
+ * becomes a `{ type: "math", tex }` block (see `@texuli/deck/math`).
+ */
+export { attributeWritable, readAttributes, writeAttribute } from "./attributes.js";
+export { mapEffect } from "./attrs-closed.js";
+export { FRONTMATTER_KEYS } from "./frontmatter.js";
+export { DECK_MARKDOWN_CODES } from "./issues.js";
+export { readJson } from "./json.js";
+export { DECK_MARKDOWN_LIMITS } from "./limits.js";
+export { deriveSlideId, parseDeckMarkdown, readDeckDraft, } from "./parse.js";
+export { deckOutline, deckToText, formatDeckOutline, slideTitle, } from "./twin.js";
+export { deckToMarkdown, writeDeckMarkdown } from "./write.js";

package/dist/markdown/issues.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The diagnostics of the deck Markdown dialect: stable `md-*` codes, each
+ * with its severity and meaning, reported as the engine's `DeckDiagnostic`
+ * with a `source` line and column (1-based; columns count UTF-16 units).
+ */
+import { type DeckDiagnostic, type DiagnosticSeverity, type DiagnosticSource, type PathSegment } from '../schema/index.js';
+export interface DeckMarkdownCodeInfo {
+    readonly severity: DiagnosticSeverity;
+    readonly meaning: string;
+}
+/** Every code the Markdown reader and writer report. */
+export declare const DECK_MARKDOWN_CODES: Readonly<{
+    readonly 'md-too-large': DeckMarkdownCodeInfo;
+    readonly 'md-invisible-char': DeckMarkdownCodeInfo;
+    readonly 'md-frontmatter-key': DeckMarkdownCodeInfo;
+    readonly 'md-frontmatter-value': DeckMarkdownCodeInfo;
+    readonly 'md-frontmatter-unclosed': DeckMarkdownCodeInfo;
+    readonly 'md-title-missing': DeckMarkdownCodeInfo;
+    readonly 'md-html-refused': DeckMarkdownCodeInfo;
+    readonly 'md-iframe-refused': DeckMarkdownCodeInfo;
+    readonly 'md-css-refused': DeckMarkdownCodeInfo;
+    readonly 'md-class-refused': DeckMarkdownCodeInfo;
+    readonly 'md-style-refused': DeckMarkdownCodeInfo;
+    readonly 'md-handler-refused': DeckMarkdownCodeInfo;
+    readonly 'md-attr-unknown': DeckMarkdownCodeInfo;
+    readonly 'md-attr-unsupported': DeckMarkdownCodeInfo;
+    readonly 'md-attr-value': DeckMarkdownCodeInfo;
+    readonly 'md-attr-duplicate': DeckMarkdownCodeInfo;
+    readonly 'md-attr-conflict': DeckMarkdownCodeInfo;
+    readonly 'md-comment-unclosed': DeckMarkdownCodeInfo;
+    readonly 'md-element-orphan': DeckMarkdownCodeInfo;
+    readonly 'md-effect-approximated': DeckMarkdownCodeInfo;
+    readonly 'md-fragment-approximated': DeckMarkdownCodeInfo;
+    readonly 'md-fragment-not-steppable': DeckMarkdownCodeInfo;
+    readonly 'md-layout-unknown': DeckMarkdownCodeInfo;
+    readonly 'md-layout-extra': DeckMarkdownCodeInfo;
+    readonly 'md-layout-missing': DeckMarkdownCodeInfo;
+    readonly 'md-region-unknown': DeckMarkdownCodeInfo;
+    readonly 'md-region-unclosed': DeckMarkdownCodeInfo;
+    readonly 'md-directive-depth': DeckMarkdownCodeInfo;
+    readonly 'md-json': DeckMarkdownCodeInfo;
+    readonly 'md-json-limit': DeckMarkdownCodeInfo;
+    readonly 'md-tier-ignored': DeckMarkdownCodeInfo;
+    readonly 'md-code-unclosed': DeckMarkdownCodeInfo;
+    readonly 'md-code-steps': DeckMarkdownCodeInfo;
+    readonly 'md-code-offset-unsupported': DeckMarkdownCodeInfo;
+    readonly 'md-code-info': DeckMarkdownCodeInfo;
+    readonly 'md-math-unclosed': DeckMarkdownCodeInfo;
+    readonly 'md-tex-unsupported': DeckMarkdownCodeInfo;
+    readonly 'md-tex-limit': DeckMarkdownCodeInfo;
+    readonly 'md-url-refused': DeckMarkdownCodeInfo;
+    readonly 'md-inline-image': DeckMarkdownCodeInfo;
+    readonly 'md-heading-inline': DeckMarkdownCodeInfo;
+    readonly 'md-too-many-slides': DeckMarkdownCodeInfo;
+    readonly 'md-stack-start': DeckMarkdownCodeInfo;
+    readonly 'md-unrepresentable': DeckMarkdownCodeInfo;
+}>;
+export type DeckMarkdownCode = keyof typeof DECK_MARKDOWN_CODES;
+/** Collects issues with the dialect's cap; errors are counted past the cap. */
+export declare class IssueSink {
+    readonly issues: DeckDiagnostic[];
+    errors: number;
+    truncated: boolean;
+    readonly max: number;
+    constructor(max?: number);
+    add(issue: DeckDiagnostic): void;
+    report(code: DeckMarkdownCode, message: string, source: DiagnosticSource, path?: readonly PathSegment[], fix?: string): void;
+}

package/dist/markdown/issues.js

@@ -0,0 +1,83 @@
+/**
+ * The diagnostics of the deck Markdown dialect: stable `md-*` codes, each
+ * with its severity and meaning, reported as the engine's `DeckDiagnostic`
+ * with a `source` line and column (1-based; columns count UTF-16 units).
+ */
+import { createDiagnostic, } from "../schema/index.js";
+import { DECK_MARKDOWN_LIMITS } from "./limits.js";
+function code(severity, meaning) {
+    return Object.freeze({ severity, meaning });
+}
+/** Every code the Markdown reader and writer report. */
+export const DECK_MARKDOWN_CODES = Object.freeze({
+    'md-too-large': code('error', 'The document is over the byte, line or line-length bound.'),
+    'md-invisible-char': code('error', 'A control, bidi or invisible formatting character (removed before parsing).'),
+    'md-frontmatter-key': code('error', 'The frontmatter key is not in the closed key set.'),
+    'md-frontmatter-value': code('error', 'The frontmatter value is not a scalar of the right type (no lists, maps or YAML tags).'),
+    'md-frontmatter-unclosed': code('error', 'The frontmatter has no closing `---`.'),
+    'md-title-missing': code('warning', 'No `title` in the frontmatter; one was derived.'),
+    'md-html-refused': code('error', 'Raw HTML is refused; it renders nothing (inline tags stay text).'),
+    'md-iframe-refused': code('error', 'iframes (tags and backgrounds) are refused.'),
+    'md-css-refused': code('error', 'A CSS value (gradient, url()) is refused; use a preset.'),
+    'md-class-refused': code('error', 'A `class` that maps to nothing is refused.'),
+    'md-style-refused': code('error', 'A `style` attribute is refused.'),
+    'md-handler-refused': code('error', 'An `on*` event handler attribute is refused.'),
+    'md-attr-unknown': code('error', 'The attribute is not in the closed attribute set.'),
+    'md-attr-unsupported': code('warning', 'A reveal.js attribute with no deck equivalent; dropped.'),
+    'md-attr-value': code('error', 'The attribute value is invalid, or the comment is malformed.'),
+    'md-attr-duplicate': code('error', 'The attribute is set twice for the same target.'),
+    'md-attr-conflict': code('error', 'Two attributes contradict each other.'),
+    'md-comment-unclosed': code('error', 'An HTML comment never closes before the end of the slide.'),
+    'md-element-orphan': code('error', 'An `.element` comment has no element before it.'),
+    'md-effect-approximated': code('warning', 'A reveal.js fragment effect with no exact equivalent was mapped to the nearest one.'),
+    'md-fragment-approximated': code('warning', 'Per-item fragments that differ were folded into one list-level step.'),
+    'md-fragment-not-steppable': code('warning', 'This layout does not reveal that element; the fragment was dropped.'),
+    'md-layout-unknown': code('error', 'The `layout` is not one of the 20 layouts or a slide kind.'),
+    'md-layout-extra': code('error', 'Content the layout has no field for.'),
+    'md-layout-missing': code('error', 'A field the layout needs is missing from the slide.'),
+    'md-region-unknown': code('error', 'The `:::` directive is unknown, or not allowed here.'),
+    'md-region-unclosed': code('error', 'A `:::` directive never closes before the end of the slide.'),
+    'md-directive-depth': code('error', 'Directives nest deeper than a region holding a fence.'),
+    'md-json': code('error', 'A `:::` JSON body is not one valid JSON object.'),
+    'md-json-limit': code('error', 'A `:::` JSON body is over a size, depth or node bound.'),
+    'md-tier-ignored': code('warning', 'The document cannot choose a trust tier; the host does.'),
+    'md-code-unclosed': code('error', 'A code fence never closes before the end of the slide.'),
+    'md-code-steps': code('error', 'A `[1-2|4-6]` highlight step list is malformed or too long.'),
+    'md-code-offset-unsupported': code('warning', 'A `[n: …]` line offset is not supported; dropped.'),
+    'md-code-info': code('warning', 'Unread text after a code fence language; dropped.'),
+    'md-math-unclosed': code('error', 'A `$$` block never closes before the end of the slide.'),
+    'md-tex-unsupported': code('error', 'The formula uses TeX outside the supported subset.'),
+    'md-tex-limit': code('error', 'The formula is over a size, nesting or node bound.'),
+    'md-url-refused': code('error', 'A link or media URL fails the deck URL syntax.'),
+    'md-inline-image': code('warning', 'An image inside text renders as its alt text only.'),
+    'md-heading-inline': code('warning', 'Headings are plain text; inline Markdown shows literally.'),
+    'md-too-many-slides': code('error', 'More than 200 slides; the rest were not read.'),
+    'md-stack-start': code('error', 'A `--` vertical slide with no horizontal slide before it.'),
+    'md-unrepresentable': code('warning', 'A deck field the Markdown dialect cannot express.'),
+});
+/** Collects issues with the dialect's cap; errors are counted past the cap. */
+export class IssueSink {
+    issues = [];
+    errors = 0;
+    truncated = false;
+    max;
+    constructor(max = DECK_MARKDOWN_LIMITS.issues) {
+        this.max = max;
+    }
+    add(issue) {
+        if (issue.severity === 'error')
+            this.errors++;
+        if (this.issues.length >= this.max) {
+            this.truncated = true;
+            return;
+        }
+        this.issues.push(issue);
+    }
+    report(code, message, source, path = [], fix) {
+        this.add(createDiagnostic(code, message, path, {
+            severity: DECK_MARKDOWN_CODES[code].severity,
+            source,
+            ...(fix === undefined ? {} : { fix }),
+        }));
+    }
+}

package/dist/markdown/json.d.ts

@@ -0,0 +1,21 @@
+export interface JsonReadOptions {
+    /** Values this read may still produce (a document-wide budget). */
+    nodes: number;
+    maxDepth?: number;
+    maxLength?: number;
+}
+export type JsonReadResult = {
+    ok: true;
+    value: unknown;
+    /** `toJsonPath(path)` (relative to the body) → UTF-16 offset of the value. */
+    offsets: Map<string, number>;
+    nodes: number;
+} | {
+    ok: false;
+    message: string;
+    offset: number;
+    limit: boolean;
+    nodes: number;
+};
+/** Read one JSON value from a fence body. Never throws. */
+export declare function readJson(text: string, options: JsonReadOptions): JsonReadResult;

package/dist/markdown/json.js

@@ -0,0 +1,236 @@
+/**
+ * The owned bounded JSON reader for `:::` fence bodies. Strict RFC 8259
+ * JSON with explicit bounds (size, depth, nodes, string length), no
+ * prototype keys, no duplicate keys and finite numbers only. It records the
+ * source offset of every value by its path, so model issues inside a
+ * component's props point at the exact line and column.
+ */
+import { toJsonPath } from "../schema/index.js";
+import { DECK_MARKDOWN_LIMITS } from "./limits.js";
+const UNSAFE = new Set(['__proto__', 'constructor', 'prototype']);
+class JsonError extends Error {
+    offset;
+    limit;
+    constructor(message, offset, limit = false) {
+        super(message);
+        this.offset = offset;
+        this.limit = limit;
+    }
+}
+class Reader {
+    text;
+    maxDepth;
+    budget;
+    offsets = new Map();
+    i = 0;
+    nodes = 0;
+    constructor(text, budget, maxDepth) {
+        this.text = text;
+        this.budget = budget;
+        this.maxDepth = maxDepth;
+    }
+    fail(message, limit = false) {
+        throw new JsonError(message, this.i, limit);
+    }
+    space() {
+        while (this.i < this.text.length) {
+            const c = this.text.charCodeAt(this.i);
+            if (c === 0x20 || c === 0x0a || c === 0x09 || c === 0x0d)
+                this.i++;
+            else
+                break;
+        }
+    }
+    value(path, depth) {
+        this.space();
+        this.nodes++;
+        if (this.nodes > this.budget) {
+            this.fail(`JSON bodies hold at most ${DECK_MARKDOWN_LIMITS.jsonNodes} values per document.`, true);
+        }
+        if (depth > this.maxDepth)
+            this.fail(`JSON nests at most ${this.maxDepth} levels.`, true);
+        this.offsets.set(toJsonPath(path), this.i);
+        const c = this.text[this.i];
+        if (c === '{')
+            return this.object(path, depth);
+        if (c === '[')
+            return this.array(path, depth);
+        if (c === '"')
+            return this.string();
+        if (c === 't' && this.text.startsWith('true', this.i)) {
+            this.i += 4;
+            return true;
+        }
+        if (c === 'f' && this.text.startsWith('false', this.i)) {
+            this.i += 5;
+            return false;
+        }
+        if (c === 'n' && this.text.startsWith('null', this.i)) {
+            this.i += 4;
+            return null;
+        }
+        if (c === '-' || (c !== undefined && c >= '0' && c <= '9'))
+            return this.number();
+        return this.fail(c === undefined ? 'The JSON ends early.' : `Unexpected \`${c}\` in JSON.`);
+    }
+    object(path, depth) {
+        this.i++;
+        const out = {};
+        this.space();
+        if (this.text[this.i] === '}') {
+            this.i++;
+            return out;
+        }
+        for (;;) {
+            this.space();
+            if (this.text[this.i] !== '"')
+                this.fail('A JSON key must be a "string".');
+            const keyAt = this.i;
+            const key = this.string();
+            if (UNSAFE.has(key)) {
+                this.i = keyAt;
+                this.fail(`The key "${key}" is refused.`);
+            }
+            if (Object.hasOwn(out, key)) {
+                this.i = keyAt;
+                this.fail(`The key "${key.slice(0, 64)}" appears twice.`);
+            }
+            this.space();
+            if (this.text[this.i] !== ':')
+                this.fail('Expected `:` after a JSON key.');
+            this.i++;
+            out[key] = this.value([...path, key], depth + 1);
+            this.space();
+            const c = this.text[this.i];
+            if (c === ',') {
+                this.i++;
+                continue;
+            }
+            if (c === '}') {
+                this.i++;
+                return out;
+            }
+            this.fail('Expected `,` or `}` in a JSON object.');
+        }
+    }
+    array(path, depth) {
+        this.i++;
+        const out = [];
+        this.space();
+        if (this.text[this.i] === ']') {
+            this.i++;
+            return out;
+        }
+        for (;;) {
+            out.push(this.value([...path, out.length], depth + 1));
+            this.space();
+            const c = this.text[this.i];
+            if (c === ',') {
+                this.i++;
+                continue;
+            }
+            if (c === ']') {
+                this.i++;
+                return out;
+            }
+            this.fail('Expected `,` or `]` in a JSON array.');
+        }
+    }
+    string() {
+        const start = this.i;
+        this.i++;
+        let out = '';
+        let run = this.i;
+        while (this.i < this.text.length) {
+            const c = this.text.charCodeAt(this.i);
+            if (c === 0x22) {
+                out += this.text.slice(run, this.i);
+                this.i++;
+                return out;
+            }
+            if (c < 0x20)
+                this.fail('Control characters must be escaped in JSON strings.');
+            if (c === 0x5c) {
+                out += this.text.slice(run, this.i);
+                const e = this.text[this.i + 1];
+                const simple = {
+                    '"': '"',
+                    '\\': '\\',
+                    '/': '/',
+                    b: '\b',
+                    f: '\f',
+                    n: '\n',
+                    r: '\r',
+                    t: '\t',
+                };
+                if (e !== undefined && Object.hasOwn(simple, e)) {
+                    out += simple[e];
+                    this.i += 2;
+                }
+                else if (e === 'u') {
+                    const hex = this.text.slice(this.i + 2, this.i + 6);
+                    if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                        this.fail('A \\u escape needs four hex digits.');
+                    out += String.fromCharCode(Number.parseInt(hex, 16));
+                    this.i += 6;
+                }
+                else
+                    this.fail('Invalid escape in a JSON string.');
+                run = this.i;
+                continue;
+            }
+            this.i++;
+        }
+        this.i = start;
+        return this.fail('A JSON string never closes.');
+    }
+    number() {
+        const match = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/.exec(this.text.slice(this.i, this.i + 400));
+        if (!match)
+            this.fail('Invalid JSON number.');
+        const value = Number(match[0]);
+        if (!Number.isFinite(value))
+            this.fail('JSON numbers must be finite.');
+        this.i += match[0].length;
+        return value;
+    }
+}
+/** Read one JSON value from a fence body. Never throws. */
+export function readJson(text, options) {
+    const maxLength = options.maxLength ?? DECK_MARKDOWN_LIMITS.jsonBody;
+    if (text.length > maxLength) {
+        return {
+            ok: false,
+            message: `A JSON body is at most ${maxLength} characters.`,
+            offset: maxLength,
+            limit: true,
+            nodes: 0,
+        };
+    }
+    const reader = new Reader(text, options.nodes, options.maxDepth ?? DECK_MARKDOWN_LIMITS.jsonDepth);
+    try {
+        const value = reader.value([], 0);
+        reader.space();
+        if (reader.i < text.length)
+            reader.fail('Unexpected text after the JSON value.');
+        return { ok: true, value, offsets: reader.offsets, nodes: reader.nodes };
+    }
+    catch (error) {
+        if (error instanceof JsonError) {
+            return {
+                ok: false,
+                message: error.message,
+                offset: error.offset,
+                limit: error.limit,
+                nodes: reader.nodes,
+            };
+        }
+        return {
+            ok: false,
+            message: 'The JSON could not be read.',
+            offset: 0,
+            limit: false,
+            nodes: reader.nodes,
+        };
+    }
+}