omni-viewer-core 0.1.0

package/dist/parsers/csv/sort.js

@@ -0,0 +1,224 @@
+// CSV column sort. Ported from omni-viewer-chrome `templates/csv/js/csvSort.ts`
+// with the engine/locale-dependent pieces replaced by deterministic
+// equivalents (DESIGN.md §3-① determinism rule, ADR 41):
+//
+//   - `Date.parse(...)` (implementation-defined for non-ISO input) is replaced
+//     by an explicit ISO-shape parser (`parseDateKey`) that computes the epoch
+//     via Date.UTC. Values that don't match the supported shapes make the
+//     column non-date.
+//   - `localeCompare(..., { numeric: true })` (ICU-dependent collation) is
+//     replaced by a code-point natural compare with digit-run chunking.
+//   - `toLocaleLowerCase()` is replaced by `toLowerCase()` (Unicode default
+//     case conversion — locale-independent per spec).
+//
+// Sort semantics preserved from the original:
+//   - Three-state cycle per column: asc -> desc -> none.
+//   - Stable: equal pairs keep original order.
+//   - Empty ("", whitespace) values sort to the bottom for both directions.
+//   - Column-level type detection (number / date / text) so one mixed cell
+//     can't flip the ordering rule mid-sort.
+/** Cycle asc -> desc -> none; switching column restarts at asc. */
+export function nextSortState(current, columnIndex) {
+    if (current.columnIndex !== columnIndex) {
+        return { columnIndex, direction: 'asc' };
+    }
+    if (current.direction === 'asc') {
+        return { columnIndex, direction: 'desc' };
+    }
+    if (current.direction === 'desc') {
+        return { columnIndex: null, direction: null };
+    }
+    return { columnIndex, direction: 'asc' };
+}
+// Supported deterministic date shapes:
+//   YYYY-MM-DD / YYYY/MM/DD, optionally followed by [T or space]
+//   hh:mm[:ss[.SSS]] and an optional timezone (Z or ±hh[:]mm).
+// Timezone-less values are interpreted as UTC — deterministic and
+// order-consistent within a column.
+const DATE_RE = /^(\d{4})[-/](\d{2})[-/](\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?)?(Z|[+-]\d{2}:?\d{2})?$/;
+/** Parse a supported date shape to epoch millis; null when not date-shaped. */
+export function parseDateKey(value) {
+    const m = DATE_RE.exec(value);
+    if (!m)
+        return null;
+    const year = Number(m[1]);
+    const month = Number(m[2]);
+    const day = Number(m[3]);
+    if (month < 1 || month > 12 || day < 1 || day > 31)
+        return null;
+    // Date.UTC silently normalizes overflow (2024-02-31 -> Mar 2). Round-trip
+    // the calendar date so nonexistent dates stay text, not date keys.
+    const calendar = new Date(Date.UTC(year, month - 1, day));
+    if (calendar.getUTCFullYear() !== year ||
+        calendar.getUTCMonth() !== month - 1 ||
+        calendar.getUTCDate() !== day) {
+        return null;
+    }
+    const hour = m[4] !== undefined ? Number(m[4]) : 0;
+    const minute = m[5] !== undefined ? Number(m[5]) : 0;
+    const second = m[6] !== undefined ? Number(m[6]) : 0;
+    const millis = m[7] !== undefined ? Number(m[7].padEnd(3, '0')) : 0;
+    if (hour > 23 || minute > 59 || second > 59)
+        return null;
+    let epoch = Date.UTC(year, month - 1, day, hour, minute, second, millis);
+    const tz = m[8];
+    if (tz && tz !== 'Z') {
+        const sign = tz[0] === '-' ? -1 : 1;
+        const digits = tz.slice(1).replace(':', '');
+        const offsetHours = Number(digits.slice(0, 2));
+        const offsetMins = Number(digits.slice(2, 4));
+        // Real-world offsets span -12:00..+14:00; reject syntactic garbage
+        // like +99:99 so it stays text instead of poisoning date detection.
+        if (offsetMins > 59 || offsetHours > 14 || (offsetHours === 14 && offsetMins > 0)) {
+            return null;
+        }
+        epoch -= sign * (offsetHours * 60 + offsetMins) * 60_000;
+    }
+    return epoch;
+}
+/**
+ * Detect the type of a column from its values. Empty strings are ignored —
+ * they sort separately at the end.
+ */
+export function detectColumnType(values) {
+    let nonEmpty = 0;
+    let allNumeric = true;
+    let allDate = true;
+    for (const raw of values) {
+        const v = (raw ?? '').trim();
+        if (!v)
+            continue;
+        nonEmpty++;
+        if (allNumeric && !Number.isFinite(Number(v))) {
+            allNumeric = false;
+        }
+        if (allDate && parseDateKey(v) === null) {
+            allDate = false;
+        }
+        if (!allNumeric && !allDate)
+            break;
+    }
+    if (nonEmpty === 0)
+        return 'text';
+    if (allNumeric)
+        return 'number';
+    if (allDate)
+        return 'date';
+    return 'text';
+}
+/**
+ * Deterministic natural compare: splits both strings into digit / non-digit
+ * runs; digit runs compare numerically ("10" > "9"), other runs compare by
+ * code point over the Unicode-default lowercased form.
+ */
+export function naturalCompare(a, b) {
+    const la = a.toLowerCase();
+    const lb = b.toLowerCase();
+    let i = 0;
+    let j = 0;
+    while (i < la.length && j < lb.length) {
+        const ca = la.charCodeAt(i);
+        const cb = lb.charCodeAt(j);
+        const aDigit = ca >= 48 && ca <= 57;
+        const bDigit = cb >= 48 && cb <= 57;
+        if (aDigit && bDigit) {
+            let ia = i;
+            while (ia < la.length && isDigitCode(la.charCodeAt(ia)))
+                ia++;
+            let jb = j;
+            while (jb < lb.length && isDigitCode(lb.charCodeAt(jb)))
+                jb++;
+            // Compare digit runs numerically via zero-trimmed length + lexical.
+            const ra = trimLeadingZeros(la.slice(i, ia));
+            const rb = trimLeadingZeros(lb.slice(j, jb));
+            if (ra.length !== rb.length)
+                return ra.length - rb.length;
+            if (ra !== rb)
+                return ra < rb ? -1 : 1;
+            i = ia;
+            j = jb;
+            continue;
+        }
+        if (ca !== cb)
+            return ca - cb;
+        i++;
+        j++;
+    }
+    if (la.length !== lb.length)
+        return la.length - i - (lb.length - j);
+    // Equal ignoring case: fall back to raw code-point compare for stability.
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+function isDigitCode(code) {
+    return code >= 48 && code <= 57;
+}
+function trimLeadingZeros(s) {
+    let k = 0;
+    while (k < s.length - 1 && s[k] === '0')
+        k++;
+    return s.slice(k);
+}
+function normalize(raw, type) {
+    const v = (raw ?? '').trim();
+    if (!v)
+        return { isEmpty: true, key: '' };
+    if (type === 'number') {
+        const n = Number(v);
+        return Number.isFinite(n) ? { isEmpty: false, key: n } : { isEmpty: false, key: v };
+    }
+    if (type === 'date') {
+        const ms = parseDateKey(v);
+        return ms !== null ? { isEmpty: false, key: ms } : { isEmpty: false, key: v };
+    }
+    return { isEmpty: false, key: v };
+}
+function compareNormalized(a, b) {
+    if (a.isEmpty && b.isEmpty)
+        return 0;
+    if (a.isEmpty)
+        return 1;
+    if (b.isEmpty)
+        return -1;
+    if (typeof a.key === 'number' && typeof b.key === 'number') {
+        if (a.key < b.key)
+            return -1;
+        if (a.key > b.key)
+            return 1;
+        return 0;
+    }
+    return naturalCompare(String(a.key), String(b.key));
+}
+/**
+ * Produce a sorted copy of `rowIndices` according to `state`. Stable; never
+ * mutates the input; empties end up at the bottom in both directions.
+ */
+export function applySort(rowIndices, state, getCell, columnType) {
+    if (state.columnIndex === null || !state.direction) {
+        return [...rowIndices];
+    }
+    const { columnIndex, direction } = state;
+    const dir = direction === 'asc' ? 1 : -1;
+    const type = columnType ?? detectColumnType(rowIndices.map((i) => getCell(i, columnIndex)));
+    const decorated = rowIndices.map((rowIndex, position) => ({
+        rowIndex,
+        position,
+        norm: normalize(getCell(rowIndex, columnIndex), type)
+    }));
+    decorated.sort((a, b) => {
+        if (a.norm.isEmpty || b.norm.isEmpty) {
+            const cmp = compareNormalized(a.norm, b.norm);
+            if (cmp !== 0)
+                return cmp;
+            return a.position - b.position;
+        }
+        const cmp = compareNormalized(a.norm, b.norm);
+        if (cmp !== 0)
+            return cmp * dir;
+        return a.position - b.position;
+    });
+    return decorated.map((d) => d.rowIndex);
+}

package/dist/parsers/csv/statistics.d.ts

@@ -0,0 +1,49 @@
+export interface NumericStats {
+    count: number;
+    mean: number;
+    min: number;
+    max: number;
+}
+export interface ColumnStats {
+    header: string;
+    columnIndex: number;
+    total: number;
+    count: number;
+    nullCount: number;
+    /** nullCount / total in [0, 1]; 0 when total === 0. */
+    nullPercent: number;
+    /** Populated only when the column qualifies as numeric. */
+    numeric: NumericStats | null;
+}
+export declare function isNullCell(value: string | undefined | null): boolean;
+export declare function parseNumericCell(value: string | undefined | null): number | null;
+export declare function isNumericColumn(values: ReadonlyArray<string | undefined | null>): boolean;
+export declare function computeStatistics(rows: ReadonlyArray<ReadonlyArray<string | undefined | null>>, headers: ReadonlyArray<string>): ColumnStats[];
+/**
+ * Serialize rows (and optional header record) to normalized CSV
+ * (docs/viewers/csv.md §6 file export): RFC-4180 quoting — a cell is quoted
+ * only when it contains the delimiter, a quote, or a line break; `"` doubles
+ * to `""`. LF row separators, no BOM. Original quoting style is not preserved.
+ */
+export declare function serializeRowsToCsv(rows: ReadonlyArray<ReadonlyArray<string | undefined | null>>, headers: ReadonlyArray<string> | undefined, delimiter: string): string;
+/** RFC-4180-style escaping for a TSV cell (quote when tab/CR/LF/`"` present). */
+export declare function escapeTsvCell(value: string | undefined | null): string;
+/** Serialize rows (and optional header record) to TSV with LF separators. */
+export declare function serializeRowsToTsv(rows: ReadonlyArray<ReadonlyArray<string | undefined | null>>, headers?: ReadonlyArray<string>): string;
+/**
+ * Canonical JSON export envelope (docs/viewers/csv.md §6). Headers live in an
+ * array, not object keys, so duplicate and empty headers survive verbatim —
+ * header-keyed object arrays (and suffix-uniquified variants) are not
+ * provided (2026-07-11 decision).
+ */
+export declare const CSV_EXPORT_FORMAT = "omni-viewer/csv-export@1";
+export interface CsvExportMetadata {
+    scope: 'current-page' | 'loaded-results' | 'full-results';
+    sourceRowsLoaded: number;
+    sourceFullyScanned: boolean;
+}
+export declare function serializeRowsToJson(rows: ReadonlyArray<ReadonlyArray<string>>, headers: ReadonlyArray<string>, metadata: CsvExportMetadata): string;
+/** Stats-panel number formatting: max 4 fraction digits, no trailing zeros. */
+export declare function formatStatNumber(value: number): string;
+/** Format a 0..1 fraction as a percentage with up to one decimal place. */
+export declare function formatPercent(fraction: number): string;

package/dist/parsers/csv/statistics.js

@@ -0,0 +1,150 @@
+// CSV statistics + TSV/JSON serialization helpers. Ported unchanged (already
+// pure and deterministic) from omni-viewer-chrome
+// `templates/csv/js/csvStatistics.ts`.
+export function isNullCell(value) {
+    if (value === undefined || value === null)
+        return true;
+    return value.trim().length === 0;
+}
+export function parseNumericCell(value) {
+    if (isNullCell(value))
+        return null;
+    const n = Number(value.trim());
+    return Number.isFinite(n) ? n : null;
+}
+export function isNumericColumn(values) {
+    let nonEmpty = 0;
+    for (const v of values) {
+        if (isNullCell(v))
+            continue;
+        nonEmpty++;
+        if (parseNumericCell(v) === null)
+            return false;
+    }
+    return nonEmpty > 0;
+}
+export function computeStatistics(rows, headers) {
+    const total = rows.length;
+    const out = [];
+    for (let col = 0; col < headers.length; col++) {
+        const header = headers[col] ?? '';
+        let nullCount = 0;
+        let count = 0;
+        const numericValues = [];
+        let allNonEmptyNumeric = true;
+        for (let r = 0; r < total; r++) {
+            const rowArr = rows[r];
+            const cell = rowArr ? rowArr[col] : undefined;
+            if (isNullCell(cell)) {
+                nullCount++;
+                continue;
+            }
+            count++;
+            const n = parseNumericCell(cell);
+            if (n === null) {
+                allNonEmptyNumeric = false;
+            }
+            else {
+                numericValues.push(n);
+            }
+        }
+        const nullPercent = total === 0 ? 0 : nullCount / total;
+        let numeric = null;
+        if (allNonEmptyNumeric && numericValues.length > 0) {
+            let min = numericValues[0];
+            let max = numericValues[0];
+            let sum = 0;
+            for (const v of numericValues) {
+                if (v < min)
+                    min = v;
+                if (v > max)
+                    max = v;
+                sum += v;
+            }
+            numeric = {
+                count: numericValues.length,
+                mean: sum / numericValues.length,
+                min,
+                max
+            };
+        }
+        out.push({ header, columnIndex: col, total, count, nullCount, nullPercent, numeric });
+    }
+    return out;
+}
+/**
+ * Serialize rows (and optional header record) to normalized CSV
+ * (docs/viewers/csv.md §6 file export): RFC-4180 quoting — a cell is quoted
+ * only when it contains the delimiter, a quote, or a line break; `"` doubles
+ * to `""`. LF row separators, no BOM. Original quoting style is not preserved.
+ */
+export function serializeRowsToCsv(rows, headers, delimiter) {
+    const escapeCell = (value) => {
+        const v = value == null ? '' : String(value);
+        if (v.length === 0)
+            return '';
+        if (!v.includes(delimiter) && !/[\r\n"]/.test(v))
+            return v;
+        return '"' + v.replace(/"/g, '""') + '"';
+    };
+    const lines = [];
+    if (headers && headers.length > 0) {
+        lines.push(headers.map(escapeCell).join(delimiter));
+    }
+    for (const row of rows) {
+        lines.push(row.map(escapeCell).join(delimiter));
+    }
+    return lines.join('\n');
+}
+/** RFC-4180-style escaping for a TSV cell (quote when tab/CR/LF/`"` present). */
+export function escapeTsvCell(value) {
+    const v = value == null ? '' : String(value);
+    if (v.length === 0)
+        return '';
+    if (!/[\t\r\n"]/.test(v))
+        return v;
+    return '"' + v.replace(/"/g, '""') + '"';
+}
+/** Serialize rows (and optional header record) to TSV with LF separators. */
+export function serializeRowsToTsv(rows, headers) {
+    const lines = [];
+    if (headers && headers.length > 0) {
+        lines.push(headers.map(escapeTsvCell).join('\t'));
+    }
+    for (const row of rows) {
+        lines.push(row.map(escapeTsvCell).join('\t'));
+    }
+    return lines.join('\n');
+}
+/**
+ * Canonical JSON export envelope (docs/viewers/csv.md §6). Headers live in an
+ * array, not object keys, so duplicate and empty headers survive verbatim —
+ * header-keyed object arrays (and suffix-uniquified variants) are not
+ * provided (2026-07-11 decision).
+ */
+export const CSV_EXPORT_FORMAT = 'omni-viewer/csv-export@1';
+export function serializeRowsToJson(rows, headers, metadata) {
+    return JSON.stringify({
+        format: CSV_EXPORT_FORMAT,
+        headers: [...headers],
+        rows: rows.map((row) => [...row]),
+        metadata
+    }, null, 2);
+}
+/** Stats-panel number formatting: max 4 fraction digits, no trailing zeros. */
+export function formatStatNumber(value) {
+    if (!Number.isFinite(value))
+        return '—';
+    if (Number.isInteger(value))
+        return String(value);
+    return value.toFixed(4).replace(/\.?0+$/, '');
+}
+/** Format a 0..1 fraction as a percentage with up to one decimal place. */
+export function formatPercent(fraction) {
+    if (!Number.isFinite(fraction))
+        return '—';
+    const pct = fraction * 100;
+    if (Number.isInteger(pct))
+        return `${pct}%`;
+    return `${pct.toFixed(1).replace(/\.0$/, '')}%`;
+}

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

@@ -0,0 +1,56 @@
+export interface DbcSignalValue {
+    value: number;
+    label: string;
+}
+export interface DbcSignal {
+    name: string;
+    multiplexer: string | null;
+    startBit: number;
+    length: number;
+    byteOrder: 'little_endian' | 'big_endian';
+    valueType: 'unsigned' | 'signed';
+    factor: number;
+    offset: number;
+    minimum: number;
+    maximum: number;
+    unit: string;
+    receivers: string[];
+    comment: string | null;
+    values: DbcSignalValue[];
+    line: number;
+}
+export interface DbcMessage {
+    /** Actual 11-bit or 29-bit CAN identifier, without DBC's bit-31 flag. */
+    id: number;
+    /** Decimal identifier exactly as encoded in the BO_ declaration. */
+    encodedId: number;
+    idHex: string;
+    isExtended: boolean;
+    name: string;
+    dlc: number;
+    transmitter: string;
+    comment: string | null;
+    signals: DbcSignal[];
+    line: number;
+}
+export interface DbcViewerModel {
+    version: string;
+    busConfiguration: string | null;
+    nodes: string[];
+    messages: DbcMessage[];
+    warnings: string[];
+    stats: {
+        messageCount: number;
+        signalCount: number;
+        nodeCount: number;
+        extendedMessageCount: number;
+        maxDlc: number;
+    };
+}
+export interface DbcParseOptions {
+    maxBytes?: number;
+    maxMessages?: number;
+    maxSignals?: number;
+    signal?: AbortSignal;
+}
+export declare function parseDbc(input: string | Uint8Array, options?: DbcParseOptions): DbcViewerModel;

package/dist/parsers/dbc/index.js

@@ -0,0 +1,94 @@
+const DEFAULT_MAX_BYTES = 8 * 1024 * 1024;
+export function parseDbc(input, options = {}) {
+    if (options.signal?.aborted)
+        throw new Error('aborted');
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const bytes = typeof input === 'string' ? new TextEncoder().encode(input) : input;
+    const truncated = bytes.byteLength > maxBytes;
+    const source = new TextDecoder().decode(bytes.subarray(0, maxBytes));
+    const maxMessages = options.maxMessages ?? 2_000;
+    const maxSignals = options.maxSignals ?? 20_000;
+    const model = { version: '', busConfiguration: null, nodes: [], messages: [], warnings: [], stats: { messageCount: 0, signalCount: 0, nodeCount: 0, extendedMessageCount: 0, maxDlc: 0 } };
+    const byId = new Map();
+    let current;
+    let totalMessages = 0;
+    let totalSignals = 0;
+    for (const [index, line] of source.split(/\r?\n/).entries()) {
+        if (options.signal?.aborted)
+            throw new Error('aborted');
+        const text = line.trim();
+        if (!text)
+            continue;
+        if (text.startsWith('VERSION')) {
+            model.version = unquote(text.replace(/^VERSION\s*/, ''));
+            continue;
+        }
+        if (text.startsWith('BS_:')) {
+            model.busConfiguration = text.slice(4).trim() || null;
+            continue;
+        }
+        if (text.startsWith('BU_:')) {
+            model.nodes = text.slice(4).trim().split(/\s+/).filter(Boolean).slice(0, 10_000);
+            continue;
+        }
+        const message = /^BO_\s+(\d+)\s+([A-Za-z_][\w.]*)\s*:\s*(\d+)\s+(\S+)/.exec(text);
+        if (message?.[1] && message[2] && message[3] && message[4]) {
+            totalMessages++;
+            const encodedId = Number(message[1]);
+            const isExtended = (encodedId & 0x80000000) !== 0;
+            const id = isExtended ? encodedId & 0x1fffffff : encodedId;
+            current = { id, encodedId, idHex: `0x${id.toString(16).toUpperCase()}`, isExtended, name: message[2], dlc: Number(message[3]), transmitter: message[4], comment: null, signals: [], line: index + 1 };
+            // DBC comments and value declarations address messages using the
+            // encoded BO_ identifier, including the extended-frame flag.
+            byId.set(encodedId, current);
+            if (model.messages.length < maxMessages)
+                model.messages.push(current);
+            continue;
+        }
+        const signal = /^SG_\s+([A-Za-z_][\w.]*)\s*(M|m\d+)?\s*:\s*(\d+)\|(\d+)@([01])([+-])\s+\(([-+.\deE]+),([-+.\deE]+)\)\s+\[([-+.\deE]+)\|([-+.\deE]+)\]\s+"([^"]*)"\s*(.*)$/.exec(text);
+        if (signal?.[1]) {
+            totalSignals++;
+            if (!current) {
+                model.warnings.push(`Line ${index + 1}: signal appears before any message.`);
+                continue;
+            }
+            if (totalSignals <= maxSignals && model.messages.includes(current))
+                current.signals.push({ name: signal[1], multiplexer: signal[2] ?? null, startBit: Number(signal[3]), length: Number(signal[4]), byteOrder: signal[5] === '1' ? 'little_endian' : 'big_endian', valueType: signal[6] === '+' ? 'unsigned' : 'signed', factor: Number(signal[7]), offset: Number(signal[8]), minimum: Number(signal[9]), maximum: Number(signal[10]), unit: signal[11] ?? '', receivers: (signal[12] ?? '').split(',').map(x => x.trim()).filter(Boolean), comment: null, values: [], line: index + 1 });
+            continue;
+        }
+        let comment = /^CM_\s+BO_\s+(\d+)\s+"((?:[^"\\]|\\.)*)"\s*;/.exec(text);
+        if (comment?.[1]) {
+            const target = byId.get(Number(comment[1]));
+            if (target)
+                target.comment = unescapeDbc(comment[2] ?? '');
+            continue;
+        }
+        comment = /^CM_\s+SG_\s+(\d+)\s+([A-Za-z_][\w.]*)\s+"((?:[^"\\]|\\.)*)"\s*;/.exec(text);
+        if (comment?.[1]) {
+            const target = byId.get(Number(comment[1]))?.signals.find(x => x.name === comment[2]);
+            if (target)
+                target.comment = unescapeDbc(comment[3] ?? '');
+            continue;
+        }
+        const values = /^VAL_\s+(\d+)\s+([A-Za-z_][\w.]*)\s+(.+);$/.exec(text);
+        if (values?.[1]) {
+            const target = byId.get(Number(values[1]))?.signals.find(x => x.name === values[2]);
+            if (!target)
+                continue;
+            for (const match of (values[3] ?? '').matchAll(/(-?\d+)\s+"((?:[^"\\]|\\.)*)"/g))
+                target.values.push({ value: Number(match[1]), label: unescapeDbc(match[2] ?? '') });
+        }
+    }
+    model.stats = { messageCount: totalMessages, signalCount: totalSignals, nodeCount: model.nodes.length, extendedMessageCount: model.messages.filter(x => x.isExtended).length, maxDlc: model.messages.reduce((n, x) => Math.max(n, x.dlc), 0) };
+    if (truncated)
+        model.warnings.push(`DBC scan is limited to ${maxBytes.toLocaleString()} bytes.`);
+    if (totalMessages > model.messages.length)
+        model.warnings.push(`Message preview is limited to ${maxMessages.toLocaleString()} entries.`);
+    if (totalSignals > maxSignals)
+        model.warnings.push(`Signal preview is limited to ${maxSignals.toLocaleString()} entries.`);
+    if (totalMessages === 0)
+        model.warnings.push('No DBC BO_ messages were found.');
+    return model;
+}
+function unquote(value) { return value.trim().replace(/^"|"$/g, ''); }
+function unescapeDbc(value) { return value.replace(/\\"/g, '"').replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\\\/g, '\\'); }

package/dist/parsers/doc-binary/index.d.ts

@@ -0,0 +1,35 @@
+import type { ParseOutcome } from '../types.js';
+export { DocBinaryParser } from './vscode-parser.js';
+export interface DocTextRun {
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+}
+export interface DocParagraph {
+    kind: 'paragraph';
+    text: string;
+    runs: DocTextRun[];
+    pageBreakBefore?: boolean;
+}
+export interface DocTable {
+    kind: 'table';
+    rows: string[][];
+}
+export interface DocImage {
+    kind: 'image';
+    mimeType: string;
+    data: Uint8Array;
+    alt: string;
+}
+export type DocBlock = DocParagraph | DocTable | DocImage;
+export interface DocSection {
+    blocks: DocBlock[];
+    header?: string;
+    footer?: string;
+}
+export interface DocBinaryDocument {
+    sections: DocSection[];
+    text: string;
+}
+export declare function parseDocBinary(input: Uint8Array): ParseOutcome<DocBinaryDocument>;