omni-viewer-core 0.1.0

package/dist/parsers/json/parse.js

@@ -0,0 +1,279 @@
+// Recursive-descent JSON parser producing the fidelity-preserving JsonNode
+// tree (docs/parsers/json.md). Separate from the tokenizer (which serves
+// highlighting): this builds the document model with source spans, raw number
+// text, and ordered duplicate keys. Never throws — syntax errors record a
+// diagnostic and stop, yielding whatever prefix parsed (partial recovery).
+import { appendPath, decodeJsonString } from './model.js';
+import { isDigit, isWhitespace, scanNumber, scanString } from './tokenizer.js';
+export const JSON_DEFAULT_MAX_DEPTH = 500;
+export function parseJsonDocument(text, options = {}) {
+    const maxDepth = options.maxDepth ?? JSON_DEFAULT_MAX_DEPTH;
+    const onNode = options.onNode;
+    const len = text.length;
+    const diagnostics = [];
+    let pos = 0;
+    let stopped = false;
+    let stopReason = null;
+    let errored = false;
+    let trailing = false;
+    const skipWs = () => {
+        while (pos < len && isWhitespace(text.charCodeAt(pos)))
+            pos++;
+    };
+    const fail = (code, at) => {
+        if (errored)
+            return; // first error only — the rest is unreliable
+        errored = true;
+        diagnostics.push({
+            severity: 'error',
+            code,
+            messageKey: `diag.${code}`,
+            location: `@${at}`
+        });
+    };
+    /** Register a node with the checkpoint; returns false if parsing must stop. */
+    const enter = () => {
+        if (!onNode)
+            return true;
+        const reason = onNode();
+        if (reason) {
+            stopped = true;
+            stopReason = reason;
+            return false;
+        }
+        return true;
+    };
+    function parseValue(key, path, depth) {
+        if (stopped || errored)
+            return null;
+        if (!enter())
+            return null;
+        if (depth > maxDepth) {
+            diagnostics.push({
+                severity: 'warning',
+                code: 'json.max-depth',
+                messageKey: 'diag.json.max-depth',
+                location: path
+            });
+            stopped = true;
+            stopReason = 'limit';
+            return null;
+        }
+        skipWs();
+        if (pos >= len) {
+            fail('json.unexpected-eof', pos);
+            return null;
+        }
+        const ch = text.charCodeAt(pos);
+        if (ch === 0x7b /* { */)
+            return parseObject(key, path, depth);
+        if (ch === 0x5b /* [ */)
+            return parseArray(key, path, depth);
+        if (ch === 0x22 /* " */)
+            return parseString(key, path, depth);
+        if (ch === 0x2d /* - */ || isDigit(ch))
+            return parseNumber(key, path, depth);
+        if (text.startsWith('true', pos))
+            return literal(key, path, depth, 'boolean', true, 4);
+        if (text.startsWith('false', pos))
+            return literal(key, path, depth, 'boolean', false, 5);
+        if (text.startsWith('null', pos))
+            return literal(key, path, depth, 'null', null, 4);
+        fail('json.invalid-token', pos);
+        return null;
+    }
+    function literal(key, path, depth, kind, value, length) {
+        const start = pos;
+        pos += length;
+        return { kind, key, path, depth, value, span: { start, end: pos } };
+    }
+    function parseString(key, path, depth) {
+        const start = pos;
+        const scan = scanString(text, pos);
+        const raw = text.slice(pos, pos + scan.length);
+        pos += scan.length;
+        if (!scan.terminated) {
+            fail('json.unterminated-string', start);
+        }
+        else {
+            const err = stringContentError(raw);
+            if (err)
+                fail(err, start);
+        }
+        return {
+            kind: 'string',
+            key,
+            path,
+            depth,
+            value: decodeJsonString(raw),
+            span: { start, end: pos }
+        };
+    }
+    function parseNumber(key, path, depth) {
+        const start = pos;
+        const n = scanNumber(text, pos);
+        if (n === 0) {
+            fail('json.invalid-token', start);
+            return null;
+        }
+        pos += n;
+        return {
+            kind: 'number',
+            key,
+            path,
+            depth,
+            rawNumber: text.slice(start, pos),
+            span: { start, end: pos }
+        };
+    }
+    function parseObject(key, path, depth) {
+        const start = pos;
+        pos++; // consume '{'
+        const children = [];
+        const seen = new Set();
+        skipWs();
+        if (pos < len && text.charCodeAt(pos) === 0x7d /* } */) {
+            pos++;
+        }
+        else {
+            for (;;) {
+                skipWs();
+                if (pos >= len || text.charCodeAt(pos) !== 0x22 /* " */) {
+                    fail('json.invalid-token', pos);
+                    break;
+                }
+                const keyScan = scanString(text, pos);
+                const keyRaw = text.slice(pos, pos + keyScan.length);
+                const keyStr = decodeJsonString(keyRaw);
+                if (!keyScan.terminated) {
+                    fail('json.unterminated-string', pos);
+                    break;
+                }
+                const keyErr = stringContentError(keyRaw);
+                if (keyErr) {
+                    fail(keyErr, pos);
+                    break;
+                }
+                pos += keyScan.length;
+                skipWs();
+                if (pos >= len || text.charCodeAt(pos) !== 0x3a /* : */) {
+                    fail('json.invalid-token', pos);
+                    break;
+                }
+                pos++; // consume ':'
+                const childPath = appendPath(path, keyStr, false);
+                const child = parseValue(keyStr, childPath, depth + 1);
+                if (!child)
+                    break;
+                if (seen.has(keyStr)) {
+                    diagnostics.push({
+                        severity: 'warning',
+                        code: 'json.duplicate-key',
+                        messageKey: 'diag.json.duplicate-key',
+                        args: { key: keyStr },
+                        location: childPath
+                    });
+                }
+                else {
+                    seen.add(keyStr);
+                }
+                children.push(child);
+                skipWs();
+                if (pos < len && text.charCodeAt(pos) === 0x2c /* , */) {
+                    pos++;
+                    continue;
+                }
+                if (pos < len && text.charCodeAt(pos) === 0x7d /* } */) {
+                    pos++;
+                    break;
+                }
+                fail('json.invalid-token', pos);
+                break;
+            }
+        }
+        return { kind: 'object', key, path, depth, children, span: { start, end: pos } };
+    }
+    function parseArray(key, path, depth) {
+        const start = pos;
+        pos++; // consume '['
+        const children = [];
+        skipWs();
+        if (pos < len && text.charCodeAt(pos) === 0x5d /* ] */) {
+            pos++;
+        }
+        else {
+            let index = 0;
+            for (;;) {
+                const childPath = appendPath(path, String(index), true);
+                const child = parseValue(String(index), childPath, depth + 1);
+                if (!child)
+                    break;
+                children.push(child);
+                index++;
+                skipWs();
+                if (pos < len && text.charCodeAt(pos) === 0x2c /* , */) {
+                    pos++;
+                    continue;
+                }
+                if (pos < len && text.charCodeAt(pos) === 0x5d /* ] */) {
+                    pos++;
+                    break;
+                }
+                fail('json.invalid-token', pos);
+                break;
+            }
+        }
+        return { kind: 'array', key, path, depth, children, span: { start, end: pos } };
+    }
+    skipWs();
+    const root = pos >= len ? (fail('json.unexpected-eof', pos), null) : parseValue('$', '$', 0);
+    if (root && !stopped && !errored) {
+        skipWs();
+        if (pos < len) {
+            trailing = true;
+            diagnostics.push({
+                severity: 'warning',
+                code: 'json.trailing-content',
+                messageKey: 'diag.json.trailing-content',
+                location: `@${pos}`
+            });
+        }
+    }
+    return { root, diagnostics, stopped, stopReason, errored, trailing };
+}
+/**
+ * Validate a terminated JSON string literal's content per RFC 8259: no
+ * unescaped control characters (< U+0020), only the allowed escapes
+ * (`" \ / b f n r t`), and `\u` followed by exactly four hex digits. Returns a
+ * diagnostic code or null. This is what keeps invalid strings ("\q", "\u12G4",
+ * a raw newline) from being reported as valid JSON (P1a).
+ */
+function stringContentError(raw) {
+    const end = raw.length - 1; // exclude the closing quote
+    let i = 1; // skip the opening quote
+    while (i < end) {
+        const c = raw.charCodeAt(i);
+        if (c === 0x5c /* \ */) {
+            const next = raw[i + 1];
+            if (next === undefined)
+                return 'json.invalid-escape';
+            if (next === '"' || next === '\\' || next === '/' || next === 'b' ||
+                next === 'f' || next === 'n' || next === 'r' || next === 't') {
+                i += 2;
+                continue;
+            }
+            if (next === 'u') {
+                const hex = raw.slice(i + 2, i + 6);
+                if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                    return 'json.invalid-unicode-escape';
+                i += 6;
+                continue;
+            }
+            return 'json.invalid-escape';
+        }
+        if (c < 0x20)
+            return 'json.control-char';
+        i++;
+    }
+    return null;
+}

package/dist/parsers/json/tokenizer.d.ts

@@ -0,0 +1,17 @@
+export type JsonTokenKind = 'key' | 'string' | 'number' | 'bool' | 'null' | 'punct' | 'whitespace' | 'unknown';
+export interface JsonToken {
+    kind: JsonTokenKind;
+    text: string;
+}
+export declare function tokenizeJson(input: string): JsonToken[];
+interface StringScan {
+    length: number;
+    terminated: boolean;
+}
+/** Scan a string literal at `start` (points at the opening `"`). Honours `\`. */
+export declare function scanString(input: string, start: number): StringScan;
+/** Scan a JSON number at `start`; returns chars consumed, or 0 if not a number. */
+export declare function scanNumber(input: string, start: number): number;
+export declare function isWhitespace(ch: number): boolean;
+export declare function isDigit(ch: number): boolean;
+export {};

package/dist/parsers/json/tokenizer.js

@@ -0,0 +1,175 @@
+// Pure JSON tokenizer — flat token list for source syntax highlighting
+// (docs/viewers/json.md J14 verbatim view). Ported from the chrome viewer
+// (jsonTokenizer). DOM-free and never throws: malformed input falls through to
+// `unknown` tokens so the caller can still render the prefix that scanned
+// cleanly. The sum of token.text equals the input, so the source can be
+// reconstructed by concatenating tokens in order.
+//
+// The document model (parse.ts) is a separate recursive-descent parser; this
+// tokenizer only serves highlighting, mirroring the chrome split.
+export function tokenizeJson(input) {
+    const tokens = [];
+    if (typeof input !== 'string' || input.length === 0) {
+        return tokens;
+    }
+    const len = input.length;
+    let i = 0;
+    while (i < len) {
+        const ch = input.charCodeAt(i);
+        if (isWhitespace(ch)) {
+            const start = i;
+            i++;
+            while (i < len && isWhitespace(input.charCodeAt(i)))
+                i++;
+            tokens.push({ kind: 'whitespace', text: input.slice(start, i) });
+            continue;
+        }
+        if (ch === 0x7b /* { */ ||
+            ch === 0x7d /* } */ ||
+            ch === 0x5b /* [ */ ||
+            ch === 0x5d /* ] */ ||
+            ch === 0x2c /* , */ ||
+            ch === 0x3a /* : */) {
+            tokens.push({ kind: 'punct', text: input[i] });
+            i++;
+            continue;
+        }
+        if (ch === 0x22 /* " */) {
+            const consumed = scanString(input, i);
+            const text = input.slice(i, i + consumed.length);
+            i += consumed.length;
+            if (consumed.terminated) {
+                let j = i;
+                while (j < len && isWhitespace(input.charCodeAt(j)))
+                    j++;
+                const isKey = j < len && input.charCodeAt(j) === 0x3a; /* : */
+                tokens.push({ kind: isKey ? 'key' : 'string', text });
+            }
+            else {
+                tokens.push({ kind: 'unknown', text });
+            }
+            continue;
+        }
+        if (ch === 0x74 /* t */ && input.startsWith('true', i)) {
+            tokens.push({ kind: 'bool', text: 'true' });
+            i += 4;
+            continue;
+        }
+        if (ch === 0x66 /* f */ && input.startsWith('false', i)) {
+            tokens.push({ kind: 'bool', text: 'false' });
+            i += 5;
+            continue;
+        }
+        if (ch === 0x6e /* n */ && input.startsWith('null', i)) {
+            tokens.push({ kind: 'null', text: 'null' });
+            i += 4;
+            continue;
+        }
+        if (ch === 0x2d /* - */ || isDigit(ch)) {
+            const consumed = scanNumber(input, i);
+            if (consumed > 0) {
+                tokens.push({ kind: 'number', text: input.slice(i, i + consumed) });
+                i += consumed;
+                continue;
+            }
+        }
+        const start = i;
+        i++;
+        while (i < len && !canStartToken(input.charCodeAt(i)))
+            i++;
+        tokens.push({ kind: 'unknown', text: input.slice(start, i) });
+    }
+    return tokens;
+}
+/** Scan a string literal at `start` (points at the opening `"`). Honours `\`. */
+export function scanString(input, start) {
+    const len = input.length;
+    let i = start + 1;
+    while (i < len) {
+        const c = input.charCodeAt(i);
+        if (c === 0x5c /* \ */) {
+            i += 2;
+            continue;
+        }
+        if (c === 0x22 /* " */) {
+            return { length: i - start + 1, terminated: true };
+        }
+        i++;
+    }
+    return { length: len - start, terminated: false };
+}
+/** Scan a JSON number at `start`; returns chars consumed, or 0 if not a number. */
+export function scanNumber(input, start) {
+    const len = input.length;
+    let i = start;
+    if (i < len && input.charCodeAt(i) === 0x2d /* - */)
+        i++;
+    if (i >= len)
+        return 0;
+    const c = input.charCodeAt(i);
+    if (c === 0x30 /* 0 */) {
+        i++;
+    }
+    else if (c >= 0x31 /* 1 */ && c <= 0x39 /* 9 */) {
+        i++;
+        while (i < len && isDigit(input.charCodeAt(i)))
+            i++;
+    }
+    else {
+        return 0;
+    }
+    if (i < len && input.charCodeAt(i) === 0x2e /* . */) {
+        i++;
+        const fracStart = i;
+        while (i < len && isDigit(input.charCodeAt(i)))
+            i++;
+        if (i === fracStart)
+            return 0;
+    }
+    if (i < len) {
+        const e = input.charCodeAt(i);
+        if (e === 0x65 /* e */ || e === 0x45 /* E */) {
+            i++;
+            if (i < len) {
+                const sign = input.charCodeAt(i);
+                if (sign === 0x2b /* + */ || sign === 0x2d /* - */)
+                    i++;
+            }
+            const expStart = i;
+            while (i < len && isDigit(input.charCodeAt(i)))
+                i++;
+            if (i === expStart)
+                return 0;
+        }
+    }
+    return i - start;
+}
+export function isWhitespace(ch) {
+    return (ch === 0x20 ||
+        ch === 0x09 ||
+        ch === 0x0a ||
+        ch === 0x0d ||
+        ch === 0x0b ||
+        ch === 0x0c);
+}
+export function isDigit(ch) {
+    return ch >= 0x30 && ch <= 0x39;
+}
+function canStartToken(ch) {
+    if (isWhitespace(ch))
+        return true;
+    if (isDigit(ch))
+        return true;
+    return (ch === 0x7b || // {
+        ch === 0x7d || // }
+        ch === 0x5b || // [
+        ch === 0x5d || // ]
+        ch === 0x2c || // ,
+        ch === 0x3a || // :
+        ch === 0x22 || // "
+        ch === 0x2d || // -
+        ch === 0x74 || // t
+        ch === 0x66 || // f
+        ch === 0x6e //   n
+    );
+}

package/dist/parsers/jsonl/index.d.ts

@@ -0,0 +1,14 @@
+import type { ParseOutcome } from '../types.js';
+import type { JsonlDocument } from './model.js';
+export * from './model.js';
+export { parseJsonlText } from './parse.js';
+export declare const JSONL_INPUT_OWNERSHIP: "borrows";
+export interface JsonlParseOptions {
+    limits?: {
+        maxInputBytes?: number;
+        maxEntries?: number;
+        maxLineBytes?: number;
+    };
+    signal?: AbortSignal;
+}
+export declare function parseJsonl(input: Uint8Array | string, options?: JsonlParseOptions): ParseOutcome<JsonlDocument>;

package/dist/parsers/jsonl/index.js

@@ -0,0 +1,18 @@
+import { decodeUtf8, utf8ByteLength } from '../types.js';
+import { parseJsonlText } from './parse.js';
+export * from './model.js';
+export { parseJsonlText } from './parse.js';
+export const JSONL_INPUT_OWNERSHIP = 'borrows';
+export function parseJsonl(input, options = {}) {
+    const started = Date.now(), max = options.limits?.maxInputBytes ?? 256 * 1024 * 1024, bytes = typeof input === 'string' ? utf8ByteLength(input) : input.byteLength;
+    const finish = (result) => ({ result, execution: { workerUsed: false, hardLimitEnforced: false, elapsedMillis: Date.now() - started } });
+    if (bytes > max)
+        return finish({ status: 'failed', failure: { code: 'limit-exceeded', retryable: false, messageKey: 'diag.limit-exceeded.input', args: { maxBytes: max } }, diagnostics: [] });
+    if (options.signal?.aborted)
+        return finish({ status: 'failed', failure: { code: 'aborted', retryable: true, messageKey: 'diag.aborted' }, diagnostics: [] });
+    const parsed = parseJsonlText(typeof input === 'string' ? input : decodeUtf8(input), options.limits?.maxEntries ?? 1_000_000);
+    const long = parsed.document.entries.find(e => utf8ByteLength(e.raw) > (options.limits?.maxLineBytes ?? 1024 * 1024));
+    if (long)
+        parsed.diagnostics.push({ severity: 'warning', code: 'jsonl.line-limit', messageKey: 'diag.jsonl.line-limit', args: { line: long.line }, location: `line:${long.line}` });
+    return finish(parsed.limited || parsed.diagnostics.length ? { status: 'partial', document: parsed.document, diagnostics: parsed.diagnostics } : { status: 'ok', document: parsed.document, diagnostics: [] });
+}

package/dist/parsers/jsonl/model.d.ts

@@ -0,0 +1,23 @@
+import type { JsonNode } from '../json/index.js';
+export interface JsonlEntry {
+    /** Immutable controller identity; physical `line` is presentation only. */
+    id: string;
+    line: number;
+    raw: string;
+    lineEnding: '\n' | '\r\n' | '';
+    value: JsonNode | null;
+    diagnostics: import('../types.js').Diagnostic[];
+}
+export interface JsonlDocument {
+    text: string;
+    entries: JsonlEntry[];
+}
+/** Deterministic append-only preview protocol (docs/viewers/jsonl.md JNL3). */
+export interface JsonlPagedInput {
+    initialData: Uint8Array;
+    totalBytes?: number;
+    loadMore?: () => Promise<{
+        data: Uint8Array;
+        done: boolean;
+    }>;
+}

package/dist/parsers/jsonl/model.js

@@ -0,0 +1 @@
+export {};

package/dist/parsers/jsonl/parse.d.ts

@@ -0,0 +1,7 @@
+import type { Diagnostic } from '../types.js';
+import type { JsonlDocument } from './model.js';
+export declare function parseJsonlText(text: string, maxEntries: number): {
+    document: JsonlDocument;
+    diagnostics: Diagnostic[];
+    limited: boolean;
+};

package/dist/parsers/jsonl/parse.js

@@ -0,0 +1,34 @@
+import { parseJsonDocument } from '../json/index.js';
+export function parseJsonlText(text, maxEntries) {
+    const entries = [];
+    const diagnostics = [];
+    const lines = text.match(/.*(?:\r\n|\n|$)/g) ?? [];
+    let line = 1;
+    let limited = false;
+    for (const item of lines) {
+        if (!item && line > 1)
+            continue;
+        if (entries.length >= maxEntries) {
+            limited = true;
+            break;
+        }
+        const ending = item.endsWith('\r\n') ? '\r\n' : item.endsWith('\n') ? '\n' : '';
+        const raw = ending ? item.slice(0, -ending.length) : item;
+        if (!raw.trim()) {
+            entries.push({ id: `line:${line}`, line, raw, lineEnding: ending, value: null, diagnostics: [] });
+            line++;
+            continue;
+        }
+        const parsed = parseJsonDocument(raw);
+        const entryDiagnostics = parsed.diagnostics;
+        if (!parsed.root || parsed.errored || parsed.trailing) {
+            const diagnostic = { severity: 'warning', code: 'invalid-jsonl-line', messageKey: 'diag.jsonl.invalid-line', args: { line }, location: `line:${line}` };
+            entries.push({ id: `line:${line}`, line, raw, lineEnding: ending, value: parsed.root, diagnostics: [...entryDiagnostics, diagnostic] });
+            diagnostics.push(diagnostic);
+        }
+        else
+            entries.push({ id: `line:${line}`, line, raw, lineEnding: ending, value: parsed.root, diagnostics: entryDiagnostics });
+        line++;
+    }
+    return { document: { text, entries }, diagnostics, limited };
+}

package/dist/parsers/markdown/index.d.ts

@@ -0,0 +1,37 @@
+import { type ParseOutcome, type ParseOptions } from '../types.js';
+export interface MarkdownHeading {
+    level: number;
+    text: string;
+    id: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownBlock {
+    start: number;
+    end: number;
+}
+export interface MarkdownDocument {
+    /** Complete decoded source, retained for source view/edit/writeback. */
+    text: string;
+    /** Prefix that passed all structural limits and is safe to hand to a renderer. */
+    renderText: string;
+    headings: MarkdownHeading[];
+    blocks: MarkdownBlock[];
+}
+export declare const MARKDOWN_DEFAULT_LIMITS: {
+    readonly maxInputBytes: number;
+    readonly maxBlocks: 200000;
+    readonly maxHeadings: 10000;
+    readonly maxDepth: 64;
+};
+export interface MarkdownStructuralLimits {
+    maxBlocks: number;
+    maxHeadings: number;
+    maxDepth: number;
+}
+export interface MarkdownParseOptions extends ParseOptions {
+    markdownLimits?: Partial<MarkdownStructuralLimits>;
+}
+/** A deliberately lightweight source index. Rendering is owned by the viewer's
+ * marked dependency; this parser gives TOC/search deterministic source spans. */
+export declare function parseMarkdown(data: Uint8Array, options?: MarkdownParseOptions): ParseOutcome<MarkdownDocument>;

package/dist/parsers/markdown/index.js

@@ -0,0 +1,59 @@
+import { decodeUtf8 } from '../types.js';
+export const MARKDOWN_DEFAULT_LIMITS = { maxInputBytes: 10 * 1024 * 1024, maxBlocks: 200_000, maxHeadings: 10_000, maxDepth: 64 };
+/** A deliberately lightweight source index. Rendering is owned by the viewer's
+ * marked dependency; this parser gives TOC/search deterministic source spans. */
+export function parseMarkdown(data, options = {}) {
+    const started = Date.now();
+    if (data.byteLength > (options.limits?.maxInputBytes ?? MARKDOWN_DEFAULT_LIMITS.maxInputBytes)) {
+        return { result: { status: 'failed', failure: { code: 'limit-exceeded', retryable: false, messageKey: 'diag.markdown.limit-exceeded' }, diagnostics: [] }, execution: { workerUsed: false, hardLimitEnforced: true, elapsedMillis: Date.now() - started } };
+    }
+    const maxBlocks = options.markdownLimits?.maxBlocks ?? MARKDOWN_DEFAULT_LIMITS.maxBlocks;
+    const maxHeadings = options.markdownLimits?.maxHeadings ?? MARKDOWN_DEFAULT_LIMITS.maxHeadings;
+    const maxDepth = options.markdownLimits?.maxDepth ?? MARKDOWN_DEFAULT_LIMITS.maxDepth;
+    const text = decodeUtf8(data);
+    const headings = [];
+    const blocks = [];
+    let offset = 0;
+    let ordinal = 0;
+    for (const line of text.split(/(?<=\n)/)) {
+        if (options.signal?.aborted)
+            return { result: { status: 'failed', failure: { code: 'aborted', retryable: true, messageKey: 'diag.aborted' }, diagnostics: [] }, execution: { workerUsed: false, hardLimitEnforced: true, elapsedMillis: Date.now() - started } };
+        if (blocks.length >= maxBlocks)
+            break;
+        blocks.push({ start: offset, end: offset + line.length });
+        const hit = /^(#{1,6})\s+(.+?)\s*#*\s*(?:\n|$)/.exec(line) ?? /^\s*<h([1-6])[^>]*>(.*?)<\/h\1>\s*$/i.exec(line);
+        const depth = markdownDepth(line);
+        const headingLevel = hit ? (/^\s*</.test(line) ? Number(hit[1]) : hit[1].length) : 0;
+        if ((hit && headingLevel > maxDepth) || depth > maxDepth)
+            break;
+        if (hit) {
+            if (headings.length >= maxHeadings)
+                break;
+            headings.push({ level: headingLevel, text: hit[2], id: `heading-${ordinal++}`, start: offset, end: offset + line.length });
+        }
+        offset += line.length;
+    }
+    const diagnostics = [];
+    const partial = offset < text.length;
+    if (partial)
+        diagnostics.push({ severity: 'warning', code: 'markdown.limit-exceeded', messageKey: 'diag.markdown.limit-exceeded' });
+    // `text` must remain complete so a partial preview can never truncate the
+    // source on save. Renderers, however, must consume only this bounded prefix.
+    const document = { text, renderText: text.slice(0, offset), headings, blocks };
+    return { result: partial ? { status: 'partial', document, diagnostics } : { status: 'ok', document, diagnostics }, execution: { workerUsed: false, hardLimitEnforced: true, elapsedMillis: Date.now() - started } };
+}
+function markdownDepth(line) { let i = 0, depth = 0; while (i < line.length) {
+    const quote = /^\s*>\s?/.exec(line.slice(i));
+    if (quote) {
+        depth++;
+        i += quote[0].length;
+        continue;
+    }
+    const list = /^\s*(?:[-+*]|\d+[.)])\s+/.exec(line.slice(i));
+    if (list) {
+        depth++;
+        i += list[0].length;
+        continue;
+    }
+    break;
+} return depth; }