omni-viewer-core 0.1.0

package/dist/parsers/shapefile/index.js

@@ -0,0 +1,119 @@
+const NAMES = { 0: 'Null', 1: 'Point', 3: 'PolyLine', 5: 'Polygon', 8: 'MultiPoint', 11: 'PointZ', 13: 'PolyLineZ', 15: 'PolygonZ', 18: 'MultiPointZ', 21: 'PointM', 23: 'PolyLineM', 25: 'PolygonM', 28: 'MultiPointM', 31: 'MultiPatch' };
+export function parseShapefile(data, options = {}) {
+    const maxBytes = options.maxBytes ?? 128 * 1024 * 1024, maxFeatures = options.maxFeatures ?? 10_000, maxVertices = options.maxVertices ?? 200_000;
+    if (options.signal?.aborted)
+        throw new Error('aborted');
+    if (data.byteLength > maxBytes)
+        throw new Error(`Shapefile exceeds the ${maxBytes.toLocaleString()} byte limit.`);
+    if (data.byteLength < 100)
+        throw new Error('Shapefile header is truncated.');
+    const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    if (v.getInt32(0, false) !== 9994)
+        throw new Error('Invalid Shapefile file code.');
+    if (v.getInt32(28, true) !== 1000)
+        throw new Error('Unsupported Shapefile version.');
+    const type = v.getInt32(32, true);
+    const declared = v.getInt32(24, false) * 2;
+    const bbox = readBBox(v, 36);
+    const features = [];
+    const warnings = [];
+    let offset = 100, vertices = 0, truncated = false;
+    while (offset + 8 <= data.length && features.length < maxFeatures && vertices < maxVertices) {
+        if (options.signal?.aborted)
+            throw new Error('aborted');
+        const id = v.getInt32(offset, false), length = v.getInt32(offset + 4, false) * 2, start = offset + 8, end = start + length;
+        if (length < 4 || end > data.length) {
+            truncated = true;
+            break;
+        }
+        try {
+            const parsed = parseRecord(v, start, end, maxVertices - vertices);
+            features.push({ id, geometry: parsed.geometry });
+            vertices += parsed.vertices;
+        }
+        catch (error) {
+            warnings.push(`Record ${id} was skipped: ${error instanceof Error ? error.message : String(error)}`);
+            if (warnings.length >= 20) {
+                warnings.push('Additional record warnings were suppressed.');
+                break;
+            }
+        }
+        offset = end;
+    }
+    if (declared !== data.byteLength)
+        warnings.push(`Header declares ${declared.toLocaleString()} bytes; input contains ${data.byteLength.toLocaleString()} bytes.`);
+    if (truncated)
+        warnings.push('Parsing stopped at a truncated record.');
+    if (offset < data.length && (features.length >= maxFeatures || vertices >= maxVertices))
+        warnings.push(`Preview is limited to ${maxFeatures.toLocaleString()} features and ${maxVertices.toLocaleString()} vertices.`);
+    return { shapeType: type, shapeTypeName: NAMES[type] ?? `Unknown (${type})`, fileLengthBytes: data.byteLength, bbox, features, vertexCount: vertices, warnings };
+}
+function parseRecord(v, start, end, remaining) { const type = v.getInt32(start, true); if (type === 0)
+    return { geometry: null, vertices: 0 }; if (type === 31)
+    throw new Error('unsupported MultiPatch geometry'); const base = type % 10; if (base === 1) {
+    bounds(start + 4, 16, end);
+    const point = readPoint(v, start + 4);
+    return { geometry: { type: 'Point', coordinates: point }, vertices: 1 };
+} if (base !== 3 && base !== 5 && base !== 8)
+    throw new Error(`unsupported shape type ${type}`); bounds(start + 4, 36, end); let cursor = start + 36; if (base === 8) {
+    const count = v.getInt32(cursor, true);
+    cursor += 4;
+    checkCount(count, remaining);
+    bounds(cursor, count * 16, end);
+    const points = readPoints(v, cursor, count);
+    return { geometry: { type: 'MultiPoint', coordinates: points }, vertices: count };
+} const partCount = v.getInt32(cursor, true), pointCount = v.getInt32(cursor + 4, true); cursor += 8; checkCount(partCount, 100_000); checkCount(pointCount, remaining); bounds(cursor, partCount * 4 + pointCount * 16, end); const parts = []; for (let i = 0; i < partCount; i++)
+    parts.push(v.getInt32(cursor + i * 4, true)); cursor += partCount * 4; const points = readPoints(v, cursor, pointCount); const groups = parts.map((at, i) => points.slice(at, parts[i + 1] ?? points.length)).filter(x => x.length > 0); if (base === 3)
+    return { geometry: groups.length === 1 ? { type: 'LineString', coordinates: groups[0] } : { type: 'MultiLineString', coordinates: groups }, vertices: pointCount }; return { geometry: buildPolygonGeometry(groups), vertices: pointCount }; }
+function buildPolygonGeometry(rings) {
+    const outers = rings.filter(ring => signedRingArea(ring) < 0);
+    const holes = rings.filter(ring => signedRingArea(ring) >= 0);
+    const polygons = outers.map(outer => [outer]);
+    for (const hole of holes) {
+        const point = hole[0];
+        const owner = point === undefined ? undefined : outers
+            .map((outer, index) => ({ index, area: Math.abs(signedRingArea(outer)), contains: pointInRing(point, outer) }))
+            .filter(candidate => candidate.contains)
+            .sort((left, right) => left.area - right.area)[0]?.index;
+        if (owner !== undefined)
+            polygons[owner].push(hole);
+        else
+            polygons.push([signedRingArea(hole) > 0 ? [...hole].reverse() : hole]);
+    }
+    if (polygons.length === 1)
+        return { type: 'Polygon', coordinates: polygons[0] };
+    return { type: 'MultiPolygon', coordinates: polygons };
+}
+function signedRingArea(ring) {
+    let area = 0;
+    for (let index = 0; index < ring.length; index++) {
+        const current = ring[index];
+        const next = ring[(index + 1) % ring.length];
+        if (current && next)
+            area += current[0] * next[1] - next[0] * current[1];
+    }
+    return area / 2;
+}
+function pointInRing(point, ring) {
+    let inside = false;
+    for (let current = 0, previous = ring.length - 1; current < ring.length; previous = current++) {
+        const a = ring[current];
+        const b = ring[previous];
+        if (!a || !b)
+            continue;
+        const crosses = (a[1] > point[1]) !== (b[1] > point[1]) &&
+            point[0] < ((b[0] - a[0]) * (point[1] - a[1])) / (b[1] - a[1]) + a[0];
+        if (crosses)
+            inside = !inside;
+    }
+    return inside;
+}
+function readBBox(v, o) { const b = [v.getFloat64(o, true), v.getFloat64(o + 8, true), v.getFloat64(o + 16, true), v.getFloat64(o + 24, true)]; return b.every(Number.isFinite) ? b : null; }
+function readPoint(v, o) { const p = [v.getFloat64(o, true), v.getFloat64(o + 8, true)]; if (!p.every(Number.isFinite))
+    throw new Error('non-finite coordinate'); return p; }
+function readPoints(v, o, n) { const r = []; for (let i = 0; i < n; i++)
+    r.push(readPoint(v, o + i * 16)); return r; }
+function bounds(o, n, end) { if (o < 0 || n < 0 || o + n > end)
+    throw new Error('truncated geometry'); }
+function checkCount(n, max) { if (!Number.isInteger(n) || n < 0 || n > max)
+    throw new Error('geometry count exceeds the resource limit'); }

package/dist/parsers/shapefile/reproject.d.ts

@@ -0,0 +1,10 @@
+import type { ShapefileModel, ShpPosition } from './index.js';
+export type CoordinateConverter = (position: ShpPosition) => ShpPosition;
+/** WKT PROJCS/GEOGCS name, used for the projection label in the viewer. */
+export declare function projectionName(wkt: string): string | null;
+/** True for WKT that is already geographic (lon/lat) — no reprojection needed. */
+export declare function isGeographicWkt(wkt: string): boolean;
+/** Returns a new model with every coordinate converted; bbox is recomputed.
+ *  Non-finite conversion results fail the whole reprojection (throw) so the
+ *  caller can fall back to rendering native coordinates. */
+export declare function reprojectModel(model: ShapefileModel, convert: CoordinateConverter): ShapefileModel;

package/dist/parsers/shapefile/reproject.js

@@ -0,0 +1,41 @@
+// Coordinate reprojection over a parsed shapefile model. The converter is
+// injected (proj4 is an optional peer loaded by the adapter or the viewer's
+// self-loading entry); this module only walks the geometry.
+/** WKT PROJCS/GEOGCS name, used for the projection label in the viewer. */
+export function projectionName(wkt) {
+    return /^\s*(?:PROJCS|GEOGCS|GEOGCRS|PROJCRS)\s*\[\s*"([^"]+)"/i.exec(wkt)?.[1] ?? null;
+}
+/** True for WKT that is already geographic (lon/lat) — no reprojection needed. */
+export function isGeographicWkt(wkt) {
+    return /^\s*(?:GEOGCS|GEOGCRS)\s*\[/i.test(wkt);
+}
+/** Returns a new model with every coordinate converted; bbox is recomputed.
+ *  Non-finite conversion results fail the whole reprojection (throw) so the
+ *  caller can fall back to rendering native coordinates. */
+export function reprojectModel(model, convert) {
+    let bbox = null;
+    const convertChecked = (position) => {
+        const next = convert(position);
+        if (!Number.isFinite(next[0]) || !Number.isFinite(next[1]))
+            throw new Error('reprojection produced a non-finite coordinate');
+        bbox = bbox
+            ? [Math.min(bbox[0], next[0]), Math.min(bbox[1], next[1]), Math.max(bbox[2], next[0]), Math.max(bbox[3], next[1])]
+            : [next[0], next[1], next[0], next[1]];
+        return next;
+    };
+    const features = model.features.map((feature) => ({
+        ...feature,
+        geometry: feature.geometry ? convertGeometry(feature.geometry, convertChecked) : null
+    }));
+    return { ...model, features, bbox };
+}
+function convertGeometry(geometry, convert) {
+    switch (geometry.type) {
+        case 'Point': return { type: 'Point', coordinates: convert(geometry.coordinates) };
+        case 'MultiPoint': return { type: 'MultiPoint', coordinates: geometry.coordinates.map(convert) };
+        case 'LineString': return { type: 'LineString', coordinates: geometry.coordinates.map(convert) };
+        case 'MultiLineString': return { type: 'MultiLineString', coordinates: geometry.coordinates.map((line) => line.map(convert)) };
+        case 'Polygon': return { type: 'Polygon', coordinates: geometry.coordinates.map((ring) => ring.map(convert)) };
+        case 'MultiPolygon': return { type: 'MultiPolygon', coordinates: geometry.coordinates.map((polygon) => polygon.map((ring) => ring.map(convert))) };
+    }
+}

package/dist/parsers/slide-model.d.ts

@@ -0,0 +1,106 @@
+export interface SlideTextRun {
+    text: string;
+    fontSizePx?: number;
+    bold?: boolean;
+    italic?: boolean;
+    color?: string;
+}
+export interface SlideParagraph {
+    text: string;
+    level: number;
+    bullet?: boolean;
+    align?: string;
+    fontSizePx?: number;
+    bold?: boolean;
+    italic?: boolean;
+    color?: string;
+    runs?: SlideTextRun[];
+}
+export interface SlideChartSeries {
+    name: string;
+    color: string;
+    values: number[];
+    valueFormat?: string;
+    dataLabel?: {
+        showValue?: boolean;
+        numFmt?: string;
+        fontSizePx?: number;
+        color?: string;
+    };
+}
+export interface SlideChartData {
+    kind: 'stackedColumn' | 'line';
+    categories: string[];
+    series: SlideChartSeries[];
+    gapWidth?: number;
+    overlap?: number;
+    legend?: {
+        position?: string;
+        fontSizePx?: number;
+        color?: string;
+        align?: string;
+    };
+    categoryAxis?: SlideChartAxis;
+    valueAxis?: SlideChartAxis & {
+        gridColor?: string;
+        majorUnit?: number;
+        min?: number;
+        max?: number;
+        crossesAt?: number;
+    };
+}
+export interface SlideChartAxis {
+    numFmt?: string;
+    fontSizePx?: number;
+    color?: string;
+    lineColor?: string;
+}
+export interface SlideElement {
+    type: 'text' | 'image' | 'table' | 'chart' | 'shape';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotateDeg?: number;
+    zIndex: number;
+    placeholderKey?: string;
+    isTitle?: boolean;
+    paragraphs?: SlideParagraph[];
+    src?: string;
+    srcRect?: {
+        l: number;
+        t: number;
+        r: number;
+        b: number;
+    };
+    vectorFallback?: boolean;
+    tableRows?: string[][];
+    chartKind?: string;
+    chartTitle?: string;
+    chartData?: SlideChartData;
+    fillColor?: string;
+    borderColor?: string;
+    borderWidthPx?: number;
+    customSvgPath?: string;
+    presetGeom?: string;
+    headEnd?: string;
+    tailEnd?: string;
+    flipH?: boolean;
+    flipV?: boolean;
+    textStylePreset?: string;
+}
+export interface Slide {
+    slideNumber: number;
+    widthPx: number;
+    heightPx: number;
+    backgroundColor: string;
+    elements: SlideElement[];
+}
+export interface SlideDeck {
+    slides: Slide[];
+    totalSlides: number;
+    slideSize?: {
+        widthPx: number;
+        heightPx: number;
+    };
+}

package/dist/parsers/slide-model.js

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

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

@@ -0,0 +1,15 @@
+import type { ParseOutcome } from '../types.js';
+import type { TomlDocument } from './model.js';
+export * from './model.js';
+export { parseTomlText } from './parse.js';
+export declare const TOML_INPUT_OWNERSHIP: "borrows";
+export declare function parseToml(input: Uint8Array | string, options?: {
+    limits?: {
+        maxInputBytes?: number;
+        maxEntries?: number;
+        maxTables?: number;
+        maxArrayLength?: number;
+    };
+    signal?: AbortSignal;
+    maxDepth?: number;
+}): ParseOutcome<TomlDocument>;

package/dist/parsers/toml/index.js

@@ -0,0 +1,18 @@
+import { decodeUtf8, utf8ByteLength } from '../types.js';
+import { parseTomlText } from './parse.js';
+export * from './model.js';
+export { parseTomlText } from './parse.js';
+export const TOML_INPUT_OWNERSHIP = 'borrows';
+export function parseToml(input, options = {}) {
+    const started = Date.now();
+    const bytes = typeof input === 'string' ? utf8ByteLength(input) : input.byteLength;
+    const max = options.limits?.maxInputBytes ?? 10 * 1024 * 1024;
+    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 treeLimits = { ...(options.maxDepth === undefined ? {} : { maxDepth: options.maxDepth }), ...(options.limits?.maxEntries === undefined ? {} : { maxNodes: options.limits.maxEntries }), ...(options.limits?.maxTables === undefined ? {} : { maxTables: options.limits.maxTables }), ...(options.limits?.maxArrayLength === undefined ? {} : { maxArrayLength: options.limits.maxArrayLength }), ...(options.signal ? { signal: options.signal } : {}) };
+    const tree = parseTomlText(typeof input === 'string' ? input : decodeUtf8(input), treeLimits);
+    return finish(tree.diagnostics.some(d => d.severity === 'error') ? { status: 'partial', document: tree.document, diagnostics: tree.diagnostics } : { status: 'ok', document: tree.document, diagnostics: tree.diagnostics });
+}

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

@@ -0,0 +1,15 @@
+export type TomlValueKind = 'table' | 'array' | 'string' | 'integer' | 'float' | 'boolean' | 'datetime';
+export interface TomlNode {
+    kind: TomlValueKind;
+    key: string;
+    path: string;
+    value?: string | boolean;
+    raw: string;
+    line: number;
+    children?: TomlNode[];
+}
+export interface TomlDocument {
+    text: string;
+    root: TomlNode;
+}
+export declare const tomlPath: (parent: string, key: string) => string;

package/dist/parsers/toml/model.js

@@ -0,0 +1 @@
+export const tomlPath = (parent, key) => parent ? `${parent}.${key}` : key;

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

@@ -0,0 +1,16 @@
+import type { Diagnostic } from '../types.js';
+import { type TomlDocument } from './model.js';
+export interface TomlParseTree {
+    document: TomlDocument;
+    diagnostics: Diagnostic[];
+}
+/** A deliberately small, lossless TOML 1.0 reader. Values retain `raw` so
+ * datetime and unsafe integers never pass through JavaScript Number. */
+export interface TomlTreeLimits {
+    maxDepth?: number;
+    maxNodes?: number;
+    maxTables?: number;
+    maxArrayLength?: number;
+    signal?: AbortSignal;
+}
+export declare function parseTomlText(text: string, limits?: TomlTreeLimits | number): TomlParseTree;

package/dist/parsers/toml/parse.js

@@ -0,0 +1,266 @@
+import { tomlPath } from './model.js';
+export function parseTomlText(text, limits = {}) {
+    const settings = typeof limits === 'number' ? { maxDepth: limits } : limits;
+    const maxDepth = settings.maxDepth ?? 100, maxNodes = settings.maxNodes ?? 100_000, maxTables = settings.maxTables ?? 50_000, maxArrayLength = settings.maxArrayLength ?? 100_000;
+    const root = { kind: 'table', key: '$', path: '', raw: '', line: 1, children: [] };
+    const diagnostics = [];
+    let current = root, nodeCount = 1, tableCount = 1, stopped = false;
+    const tables = new Map([['', root]]);
+    const lines = logicalTomlLines(text.replace(/^\uFEFF/, ''));
+    const error = (code, line) => diagnostics.push({ severity: 'error', code, messageKey: `diag.${code}`, location: `line:${line}` });
+    const unquote = (value) => {
+        if (value.startsWith('"""') && value.endsWith('"""')) {
+            // TOML multiline basic strings allow literal newlines. Reuse the
+            // JSON escape decoder after making those newlines explicit.
+            const body = value.slice(3, -3).replace(/^\r?\n/, '');
+            try {
+                return JSON.parse(`"${body.replace(/\r?\n/g, '\\n')}"`);
+            }
+            catch {
+                return body;
+            }
+        }
+        if (value.startsWith("'''") && value.endsWith("'''"))
+            return value.slice(3, -3).replace(/^\r?\n/, '');
+        if (value.startsWith('"') && value.endsWith('"')) {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value.slice(1, -1);
+            }
+        }
+        if (value.startsWith("'") && value.endsWith("'"))
+            return value.slice(1, -1);
+        return value;
+    };
+    const split = (value) => {
+        const out = [];
+        let start = 0;
+        let quote = '';
+        let depth = 0;
+        for (let i = 0; i < value.length; i++) {
+            const c = value[i];
+            if (quote) {
+                if (c === quote && value[i - 1] !== '\\')
+                    quote = '';
+            }
+            else if (c === '"' || c === "'")
+                quote = c;
+            else if (c === '[' || c === '{')
+                depth++;
+            else if (c === ']' || c === '}')
+                depth--;
+            else if (c === ',' && depth === 0) {
+                out.push(value.slice(start, i).trim());
+                start = i + 1;
+            }
+        }
+        out.push(value.slice(start).trim());
+        return out.filter(Boolean);
+    };
+    const keyParts = (key) => splitKey(key).map(unquote);
+    const makeValue = (key, path, rawValue, line, depth) => {
+        const raw = rawValue.trim();
+        let kind = 'string';
+        let value = unquote(raw);
+        if (/^(true|false)$/.test(raw)) {
+            kind = 'boolean';
+            value = raw === 'true';
+        }
+        else if (/^[+-]?(?:0x[\da-fA-F_]+|0o[0-7_]+|0b[01_]+|\d[\d_]*)$/.test(raw))
+            kind = 'integer';
+        else if (/^[+-]?(?:\d[\d_]*\.\d[\d_]*|\d[\d_]*(?:\.\d[\d_]*)?[eE][+-]?\d[\d_]*|nan|inf)$/i.test(raw))
+            kind = 'float';
+        else if (/^\d{4}-\d\d-\d\d(?:[Tt ]\d\d:\d\d(?::\d\d(?:\.\d+)?)?(?:[Zz]|[+-]\d\d:\d\d)?)?$|^\d\d:\d\d(?::\d\d(?:\.\d+)?)?$/.test(raw))
+            kind = 'datetime';
+        else if (raw.startsWith('[') && raw.endsWith(']')) {
+            kind = 'array';
+            const values = split(raw.slice(1, -1));
+            if (values.length > maxArrayLength) {
+                error('toml.array-limit', line);
+                values.length = maxArrayLength;
+            }
+            const children = values.map((v, i) => makeValue(String(i), `${path}[${i}]`, v, line, depth + 1));
+            nodeCount += children.length;
+            return { kind, key, path, raw, line, children };
+        }
+        else if (raw.startsWith('{') && raw.endsWith('}')) {
+            kind = 'table';
+            const children = [];
+            for (const pair of split(raw.slice(1, -1))) {
+                const eq = indexOfEquals(pair);
+                if (eq < 0) {
+                    error('toml.invalid-inline-table', line);
+                    continue;
+                }
+                const childKey = unquote(pair.slice(0, eq).trim());
+                children.push(makeValue(childKey, tomlPath(path, childKey), pair.slice(eq + 1), line, depth + 1));
+            }
+            return { kind, key, path, raw, line, children };
+        }
+        if (depth > maxDepth)
+            error('toml.max-depth', line);
+        nodeCount++;
+        return { kind, key, path, value, raw, line };
+    };
+    for (const logical of lines) {
+        if (settings.signal?.aborted) {
+            error('aborted', logical.line);
+            stopped = true;
+            break;
+        }
+        if (nodeCount > maxNodes || tableCount > maxTables) {
+            error(nodeCount > maxNodes ? 'toml.node-limit' : 'toml.table-limit', logical.line);
+            stopped = true;
+            break;
+        }
+        const i = logical.line - 1;
+        const source = stripComment(logical.text).trim();
+        if (!source)
+            continue;
+        const arrayTable = source.match(/^\[\[(.+)\]\]$/);
+        const table = source.match(/^\[(.+)\]$/);
+        if (arrayTable || table) {
+            const matched = arrayTable ?? table;
+            const parts = keyParts((matched?.[1] ?? '').trim());
+            if (!parts.length) {
+                error('toml.invalid-table', i + 1);
+                continue;
+            }
+            const path = parts.join('.');
+            if (arrayTable) {
+                const parentPath = parts.slice(0, -1).join('.');
+                const parent = tables.get(parentPath) ?? root;
+                let collection = parent.children.find(node => node.key === parts.at(-1) && node.kind === 'array');
+                if (!collection) {
+                    collection = { kind: 'array', key: parts.at(-1), path, raw: '', line: i + 1, children: [] };
+                    parent.children.push(collection);
+                    nodeCount++;
+                }
+                const index = collection.children.length;
+                const node = { kind: 'table', key: String(index), path: `${path}[${index}]`, raw: '', line: i + 1, children: [] };
+                collection.children.push(node);
+                tables.set(path, node);
+                current = node;
+                nodeCount++;
+                tableCount++;
+            }
+            else {
+                let node = tables.get(path);
+                if (!node) {
+                    node = { kind: 'table', key: parts.at(-1), path, raw: '', line: i + 1, children: [] };
+                    (tables.get(parts.slice(0, -1).join('.')) ?? root).children.push(node);
+                    tables.set(path, node);
+                    nodeCount++;
+                    tableCount++;
+                }
+                else if (node !== current && node.line !== i + 1 && node.children?.length)
+                    error('toml.duplicate-table', i + 1);
+                current = node;
+            }
+            continue;
+        }
+        const eq = indexOfEquals(source);
+        if (eq < 0) {
+            error('toml.invalid-assignment', i + 1);
+            continue;
+        }
+        const parts = keyParts(source.slice(0, eq).trim());
+        if (!parts.length) {
+            error('toml.invalid-key', i + 1);
+            continue;
+        }
+        let parent = current;
+        for (const part of parts.slice(0, -1)) {
+            let nested = parent.children.find(n => n.key === part && n.kind === 'table');
+            if (!nested) {
+                nested = { kind: 'table', key: part, path: tomlPath(parent.path, part), raw: '', line: i + 1, children: [] };
+                parent.children.push(nested);
+            }
+            parent = nested;
+        }
+        const key = parts.at(-1);
+        if (parent.children.some(n => n.key === key))
+            error('toml.duplicate-key', i + 1);
+        else
+            parent.children.push(makeValue(key, tomlPath(parent.path, key), source.slice(eq + 1), i + 1, 0));
+    }
+    return { document: { text, root }, diagnostics };
+}
+/** Group physical lines while a multiline string or a composite array/table
+ * remains open. This preserves the declaration line for diagnostics. */
+function logicalTomlLines(text) {
+    const physical = text.split(/\r\n|\n|\r/);
+    const out = [];
+    let buffer = '';
+    let start = 1;
+    let triple = '';
+    let depth = 0;
+    for (let i = 0; i < physical.length; i++) {
+        const line = physical[i] ?? '';
+        if (!buffer)
+            start = i + 1;
+        buffer += (buffer ? '\n' : '') + line;
+        for (let p = 0; p < line.length; p++) {
+            if (line.startsWith('"""', p) || line.startsWith("'''", p)) {
+                const token = line.slice(p, p + 3);
+                triple = triple === token ? '' : (triple || token);
+                p += 2;
+                continue;
+            }
+            if (triple)
+                continue;
+            const c = line[p];
+            if (c === '#')
+                break;
+            if (c === '[' || c === '{')
+                depth++;
+            else if (c === ']' || c === '}')
+                depth--;
+        }
+        if (!triple && depth <= 0) {
+            out.push({ line: start, text: buffer });
+            buffer = '';
+            depth = 0;
+        }
+    }
+    if (buffer)
+        out.push({ line: start, text: buffer });
+    return out;
+}
+function stripComment(line) { let q = ''; for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (q) {
+        if (c === q && line[i - 1] !== '\\')
+            q = '';
+    }
+    else if (c === '"' || c === "'")
+        q = c;
+    else if (c === '#')
+        return line.slice(0, i);
+} return line; }
+function indexOfEquals(line) { let q = ''; for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (q) {
+        if (c === q && line[i - 1] !== '\\')
+            q = '';
+    }
+    else if (c === '"' || c === "'")
+        q = c;
+    else if (c === '=')
+        return i;
+} return -1; }
+function splitKey(value) { const out = []; let q = ''; let start = 0; for (let i = 0; i < value.length; i++) {
+    const c = value[i];
+    if (q) {
+        if (c === q && value[i - 1] !== '\\')
+            q = '';
+    }
+    else if (c === '"' || c === "'")
+        q = c;
+    else if (c === '.') {
+        out.push(value.slice(start, i).trim());
+        start = i + 1;
+    }
+} out.push(value.slice(start).trim()); return out.filter(Boolean); }