toon-parser 1.0.0 → 1.1.1

package/dist/index.js

@@ -0,0 +1,868 @@
+const DEFAULT_LIMITS = Object.freeze({
+    maxDepth: 64,
+    maxArrayLength: 50000,
+    maxTotalNodes: 250000,
+    disallowedKeys: ['__proto__', 'constructor', 'prototype']
+});
+const DEFAULT_DELIMITER = ',';
+const NUMERIC_RE = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+const NUMERIC_LIKE_RE = /^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i;
+const LEADING_ZERO_RE = /^0\d+$/;
+const SAFE_KEY_RE = /^[A-Za-z_][A-Za-z0-9_.]*$/;
+export class ToonError extends Error {
+    constructor(message, line) {
+        super(line ? `Line ${line}: ${message}` : message);
+        this.name = 'ToonError';
+        this.line = line;
+    }
+}
+export function jsonToToon(value, options = {}) {
+    const indentSize = options.indent ?? 2;
+    if (!Number.isInteger(indentSize) || indentSize <= 0) {
+        throw new ToonError('Indent must be a positive integer.');
+    }
+    const delimiter = options.delimiter ?? DEFAULT_DELIMITER;
+    const limits = applyLimits(options);
+    const state = { nodes: 0 };
+    const lines = [];
+    const indentUnit = ' '.repeat(indentSize);
+    const encodeValue = (input, depth, key, activeDelimiter) => {
+        enforceLimits(depth, limits, state);
+        if (isPrimitive(input)) {
+            const line = primitiveLine(key, input, indentUnit.repeat(depth), activeDelimiter, limits);
+            lines.push(line);
+            return;
+        }
+        if (Array.isArray(input)) {
+            encodeArray(key, input, depth, activeDelimiter);
+            return;
+        }
+        if (isPlainObject(input)) {
+            encodeObject(key, input, depth, activeDelimiter);
+            return;
+        }
+        throw new ToonError(`Unsupported value type: ${typeof input}`);
+    };
+    const encodeObject = (key, obj, depth, activeDelimiter) => {
+        enforceLimits(depth, limits, state);
+        const entries = Object.entries(obj);
+        const sortedEntries = options.sortKeys ? [...entries].sort(([a], [b]) => a.localeCompare(b)) : entries;
+        const prefix = indentUnit.repeat(depth);
+        if (key !== null) {
+            validateKeySafety(key, limits);
+            if (sortedEntries.length === 0) {
+                lines.push(`${prefix}${encodeKey(key, activeDelimiter)}:`);
+                return;
+            }
+            lines.push(`${prefix}${encodeKey(key, activeDelimiter)}:`);
+        }
+        else if (depth > 0 && sortedEntries.length === 0) {
+            // empty anonymous object
+            return;
+        }
+        for (const [childKey, childValue] of sortedEntries) {
+            const nextDepth = key === null ? depth : depth + 1;
+            enforceLimits(nextDepth, limits, state);
+            encodeValue(childValue, nextDepth, childKey, activeDelimiter);
+        }
+    };
+    const encodeArray = (key, arr, depth, activeDelimiter) => {
+        enforceLimits(depth, limits, state);
+        if (key !== null) {
+            validateKeySafety(key, limits);
+        }
+        if (arr.length > limits.maxArrayLength) {
+            throw new ToonError(`Array length ${arr.length} exceeds limit ${limits.maxArrayLength}.`);
+        }
+        const prefix = indentUnit.repeat(depth);
+        const headerKey = key === null ? '' : encodeKey(key, activeDelimiter);
+        if (arr.every(isPrimitive)) {
+            const encoded = arr.map(v => encodePrimitive(v, activeDelimiter, activeDelimiter)).join(activeDelimiter);
+            const spacing = arr.length > 0 ? ' ' : '';
+            lines.push(`${prefix}${headerKey}[${arr.length}]:${spacing}${encoded}`);
+            bumpNodes(state, limits, arr.length);
+            return;
+        }
+        const tabular = detectTabular(arr);
+        if (tabular) {
+            const { fields, rows } = tabular;
+            const encodedFields = fields.map(f => encodeKey(f, activeDelimiter)).join(activeDelimiter);
+            lines.push(`${prefix}${headerKey}[${arr.length}]{${encodedFields}}:`);
+            for (const row of rows) {
+                const rowValues = fields
+                    .map(f => encodePrimitive(row[f], activeDelimiter, activeDelimiter))
+                    .join(activeDelimiter);
+                lines.push(`${indentUnit.repeat(depth + 1)}${rowValues}`);
+            }
+            bumpNodes(state, limits, arr.length * fields.length);
+            return;
+        }
+        // expanded list
+        lines.push(`${prefix}${headerKey}[${arr.length}]:`);
+        const itemIndent = depth + 1;
+        const itemPrefix = indentUnit.repeat(itemIndent);
+        for (const item of arr) {
+            enforceLimits(itemIndent, limits, state);
+            if (isPrimitive(item)) {
+                lines.push(`${itemPrefix}- ${encodePrimitive(item, activeDelimiter, activeDelimiter)}`);
+                bumpNodes(state, limits, 1);
+            }
+            else if (Array.isArray(item)) {
+                const inline = item.every(isPrimitive);
+                if (inline) {
+                    const encoded = item.map(v => encodePrimitive(v, activeDelimiter, activeDelimiter)).join(activeDelimiter);
+                    const spacing = item.length > 0 ? ' ' : '';
+                    lines.push(`${itemPrefix}- [${item.length}]:${spacing}${encoded}`);
+                    bumpNodes(state, limits, item.length);
+                }
+                else {
+                    lines.push(`${itemPrefix}-`);
+                    encodeArray(null, item, itemIndent + 1, activeDelimiter);
+                }
+            }
+            else if (isPlainObject(item)) {
+                const objEntries = Object.entries(item);
+                if (objEntries.length === 0) {
+                    lines.push(`${itemPrefix}-`);
+                    continue;
+                }
+                lines.push(`${itemPrefix}-`);
+                for (const [childKey, childValue] of objEntries) {
+                    encodeValue(childValue, itemIndent + 1, childKey, activeDelimiter);
+                }
+            }
+            else {
+                throw new ToonError(`Unsupported array item type: ${typeof item}`);
+            }
+        }
+    };
+    encodeValue(value, 0, null, delimiter);
+    return lines.join('\n');
+}
+export function toonToJson(text, options = {}) {
+    const limits = applyLimits(options);
+    const strict = options.strict ?? true;
+    const delimiterFallback = DEFAULT_DELIMITER;
+    const lines = text.split(/\r?\n/);
+    const contexts = [];
+    let rootContainer = null;
+    let indentStep = null;
+    let root = null;
+    const state = { nodes: 0 };
+    const finalizeContainer = (container, lineNo) => {
+        if (container.type === 'tabular') {
+            if (strict && container.value.length !== container.expectedLength) {
+                throw new ToonError(`Tabular array length mismatch: expected ${container.expectedLength}, got ${container.value.length}.`, lineNo);
+            }
+        }
+        else if (container.type === 'list') {
+            if (strict && container.expectedLength !== null && container.value.length !== container.expectedLength) {
+                throw new ToonError(`List length mismatch: expected ${container.expectedLength}, got ${container.value.length}.`, lineNo);
+            }
+        }
+        else if (container.type === 'placeholder') {
+            // If a placeholder was not filled, treat it as an empty object value.
+            // This matches how `jsonToToon` emits empty objects as a `-` list item with no body.
+            if (!container.filled) {
+                container.assign(createSafeObject());
+                container.filled = true;
+            }
+        }
+    };
+    const attachValue = (value, parent, key, lineNo) => {
+        const ensureRootObject = () => {
+            if (rootContainer) {
+                return rootContainer;
+            }
+            const obj = { type: 'object', value: createSafeObject(), indent: 0 };
+            rootContainer = obj;
+            root = obj.value;
+            contexts.push(obj);
+            return obj;
+        };
+        if (!parent) {
+            if (key !== null) {
+                const target = ensureRootObject();
+                target.value[key] = value;
+                return;
+            }
+            if (root !== null) {
+                throw new ToonError('Multiple root values detected.', lineNo);
+            }
+            root = value;
+            return;
+        }
+        if (parent.type === 'object') {
+            if (key === null) {
+                throw new ToonError('Missing key for object assignment.');
+            }
+            parent.value[key] = value;
+            return;
+        }
+        if (parent.type === 'list') {
+            parent.value.push(value);
+            return;
+        }
+        if (parent.type === 'placeholder') {
+            if (parent.filled) {
+                throw new ToonError('List item already filled.', lineNo);
+            }
+            parent.assign(value);
+            parent.filled = true;
+            return;
+        }
+        throw new ToonError('Invalid parent container.');
+    };
+    const parseArrayHeader = (token, lineNo) => {
+        const match = token.match(/^\[(\d+)([,\|\t])?\](\{(.+)\})?$/);
+        if (!match) {
+            throw new ToonError(`Invalid array header "${token}".`, lineNo);
+        }
+        const length = parseInt(match[1], 10);
+        if (!Number.isFinite(length)) {
+            throw new ToonError('Invalid array length.', lineNo);
+        }
+        const delimiter = match[2] ?? delimiterFallback;
+        const fieldsRaw = match[4];
+        if (fieldsRaw === undefined) {
+            return { length, delimiter };
+        }
+        const fields = splitDelimited(fieldsRaw, delimiter, lineNo).map(f => decodeKey(f, delimiter, lineNo));
+        if (fields.length === 0 && strict) {
+            throw new ToonError('Tabular arrays require at least one field.', lineNo);
+        }
+        return { length, delimiter, fields };
+    };
+    const processKeyValueLine = (indentLevel, keyToken, valueToken, lineNo, parent) => {
+        const { rawKey, header } = splitKeyHeader(keyToken);
+        const key = rawKey === '' ? null : decodeKey(rawKey, delimiterFallback, lineNo);
+        if (key !== null) {
+            validateKeySafety(key, limits, lineNo);
+        }
+        if (header) {
+            const { length, delimiter, fields } = parseArrayHeader(header, lineNo);
+            if (length > limits.maxArrayLength) {
+                throw new ToonError(`Array length ${length} exceeds limit ${limits.maxArrayLength}.`, lineNo);
+            }
+            if (fields) {
+                if (valueToken !== '') {
+                    throw new ToonError('Tabular array header must not have inline values.', lineNo);
+                }
+                const arr = [];
+                bumpNodes(state, limits, 1, lineNo);
+                attachValue(arr, parent, key, lineNo);
+                contexts.push({
+                    type: 'tabular',
+                    value: arr,
+                    indent: indentLevel + 1,
+                    expectedLength: length,
+                    delimiter,
+                    fields
+                });
+                return;
+            }
+            if (valueToken === '') {
+                const arr = [];
+                bumpNodes(state, limits, 1, lineNo);
+                attachValue(arr, parent, key, lineNo);
+                contexts.push({
+                    type: 'list',
+                    value: arr,
+                    indent: indentLevel + 1,
+                    expectedLength: length,
+                    delimiter
+                });
+                return;
+            }
+            const values = splitDelimited(valueToken, delimiter, lineNo).map(t => parsePrimitiveToken(t, delimiter, lineNo, strict));
+            if (strict && values.length !== length) {
+                throw new ToonError(`Inline array length mismatch: expected ${length}, got ${values.length}.`, lineNo);
+            }
+            attachValue(values, parent, key, lineNo);
+            bumpNodes(state, limits, values.length, lineNo);
+            return;
+        }
+        if (valueToken === '') {
+            const obj = createSafeObject();
+            attachValue(obj, parent, key, lineNo);
+            contexts.push({ type: 'object', value: obj, indent: indentLevel + 1 });
+            return;
+        }
+        const value = parsePrimitiveToken(valueToken, delimiterFallback, lineNo, strict);
+        attachValue(value, parent, key, lineNo);
+        bumpNodes(state, limits, 1, lineNo);
+    };
+    lines.forEach((rawLine, index) => {
+        const lineNo = index + 1;
+        const trimmedEnd = rawLine.replace(/[ \t]+$/, '');
+        if (trimmedEnd.trim() === '') {
+            return; // skip blank lines
+        }
+        const indentSpaces = countLeadingSpaces(trimmedEnd, lineNo);
+        if (indentStep === null) {
+            indentStep = indentSpaces === 0 ? 2 : indentSpaces;
+        }
+        if (indentSpaces % indentStep !== 0) {
+            throw new ToonError(`Inconsistent indentation: expected multiples of ${indentStep} spaces.`, lineNo);
+        }
+        const indentLevel = indentSpaces / indentStep;
+        if (indentLevel > limits.maxDepth) {
+            throw new ToonError(`Maximum depth ${limits.maxDepth} exceeded.`, lineNo);
+        }
+        const line = trimmedEnd.slice(indentSpaces);
+        while (true) {
+            const top = contexts[contexts.length - 1];
+            if (!top || indentLevel >= top.indent) {
+                break;
+            }
+            contexts.pop();
+            finalizeContainer(top, lineNo);
+        }
+        // tabular row disambiguation
+        let handled = false;
+        let consumed = false;
+        while (!handled) {
+            const top = contexts[contexts.length - 1];
+            if (top && top.type === 'tabular' && indentLevel === top.indent) {
+                const classification = classifyTabularLine(line, top.delimiter);
+                if (classification === 'row') {
+                    const cells = splitDelimited(line, top.delimiter, lineNo);
+                    if (strict && cells.length !== top.fields.length) {
+                        throw new ToonError(`Tabular row width mismatch: expected ${top.fields.length}, got ${cells.length}.`, lineNo);
+                    }
+                    const obj = createSafeObject();
+                    top.fields.forEach((field, idx) => {
+                        validateKeySafety(field, limits, lineNo);
+                        const token = cells[idx] ?? '';
+                        obj[field] = parsePrimitiveToken(token, top.delimiter, lineNo, strict);
+                        bumpNodes(state, limits, 1, lineNo);
+                    });
+                    top.value.push(obj);
+                    if (top.value.length > limits.maxArrayLength) {
+                        throw new ToonError(`Tabular array length exceeds limit ${limits.maxArrayLength}.`, lineNo);
+                    }
+                    handled = true;
+                    consumed = true;
+                    break;
+                }
+                finalizeContainer(top, lineNo);
+                contexts.pop();
+                continue;
+            }
+            handled = true;
+        }
+        if (consumed) {
+            return;
+        }
+        const parent = contexts[contexts.length - 1];
+        if (parent && parent.type === 'list') {
+            if (indentLevel !== parent.indent) {
+                throw new ToonError('List items must align under their header.', lineNo);
+            }
+            parseListItem(line, parent, indentLevel, lineNo, processKeyValueLine, contexts, state, limits, strict);
+            return;
+        }
+        if (parent && parent.type === 'placeholder') {
+            if (indentLevel !== parent.indent) {
+                throw new ToonError('List item body must indent one level below "-".', lineNo);
+            }
+            // allow body to be parsed as if parent were absent; attachValue will route through placeholder.
+        }
+        if (indentLevel !== (parent ? parent.indent : 0)) {
+            throw new ToonError('Unexpected indentation level.', lineNo);
+        }
+        const colonIndex = findUnquotedColon(line);
+        if (colonIndex === -1) {
+            // possible root primitive
+            if (root === null && !parent) {
+                const value = parsePrimitiveToken(line.trim(), delimiterFallback, lineNo, strict);
+                root = value;
+                bumpNodes(state, limits, 1, lineNo);
+                return;
+            }
+            throw new ToonError('Expected key-value pair.', lineNo);
+        }
+        const keyToken = line.slice(0, colonIndex).trim();
+        const valueToken = line.slice(colonIndex + 1).trim();
+        // If we're in a placeholder parent (a `-` with no inline content), and the body
+        // line contains a key:value, we should attach to the current object context.
+        // If this is the first body line, create and track the object on placeholder.current.
+        // Subsequent body lines will reuse the same object.
+        if (parent && parent.type === 'placeholder') {
+            // Don't automatically create an object for array headers (e.g., `[2]{...}:`)
+            // — handle those via the normal `processKeyValueLine` flow so headers attach
+            // to the placeholder correctly as arrays/tabular types.
+            if (!keyToken.startsWith('[')) {
+                // Reuse existing current object or create new one on first body line
+                if (!parent.current) {
+                    const obj = createSafeObject();
+                    // Call assign BEFORE setting current, so the skip logic can distinguish
+                    // first assignment from finalizeContainer's empty object push
+                    parent.assign(obj);
+                    parent.current = { value: obj, indent: indentLevel + 1 };
+                    parent.filled = true;
+                }
+                const objContext = { type: 'object', value: parent.current.value, indent: indentLevel + 1 };
+                processKeyValueLine(indentLevel + 1, keyToken, valueToken, lineNo, objContext);
+                return;
+            }
+        }
+        processKeyValueLine(indentLevel, keyToken, valueToken, lineNo, parent);
+    });
+    while (contexts.length > 0) {
+        const container = contexts.pop();
+        finalizeContainer(container, lines.length);
+    }
+    if (root === null) {
+        return createSafeObject();
+    }
+    return root;
+}
+function classifyTabularLine(line, delimiter) {
+    let inQuote = false;
+    let escape = false;
+    let firstColon = -1;
+    let firstDelim = -1;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escape = true;
+            continue;
+        }
+        if (ch === '"') {
+            inQuote = !inQuote;
+            continue;
+        }
+        if (inQuote)
+            continue;
+        if (ch === ':' && firstColon === -1)
+            firstColon = i;
+        if (ch === delimiter && firstDelim === -1)
+            firstDelim = i;
+    }
+    if (firstColon === -1)
+        return 'row';
+    if (firstDelim === -1)
+        return 'field';
+    return firstDelim < firstColon ? 'row' : 'field';
+}
+function parseListItem(line, list, indentLevel, lineNo, processKeyValueLine, contexts, state, limits, strict) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('-')) {
+        throw new ToonError('List items must start with "-".', lineNo);
+    }
+    const content = trimmed.slice(1).trim();
+    if (content === '') {
+        const placeholder = {
+            type: 'placeholder',
+            indent: indentLevel + 1,
+            filled: false,
+            current: undefined,
+            assign: function (value) {
+                // Push value to list; the current field tracks multi-line object context
+                // Skip only if: current already exists (meaning we've already assigned) AND
+                // the value being assigned is an empty object (from finalizeContainer).
+                if (this.current && typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length === 0) {
+                    // Empty object from finalizeContainer; skip pushing again
+                    return;
+                }
+                list.value.push(value);
+            }
+        };
+        contexts.push(placeholder);
+        return;
+    }
+    // Array list item (header on the same line)
+    if (content.startsWith('[')) {
+        const colonIndex = findUnquotedColon(content);
+        const headerToken = colonIndex === -1 ? content : content.slice(0, colonIndex).trim();
+        const valueToken = colonIndex === -1 ? '' : content.slice(colonIndex + 1).trim();
+        const { length, delimiter, fields } = parseArrayHeaderFromList(headerToken, lineNo);
+        if (length > limits.maxArrayLength) {
+            throw new ToonError(`Array length ${length} exceeds limit ${limits.maxArrayLength}.`, lineNo);
+        }
+        if (fields) {
+            if (valueToken !== '') {
+                throw new ToonError('Tabular header in list item cannot have inline values.', lineNo);
+            }
+            const arr = [];
+            bumpNodes(state, limits, 1, lineNo);
+            list.value.push(arr);
+            contexts.push({
+                type: 'tabular',
+                value: arr,
+                indent: indentLevel + 1,
+                expectedLength: length,
+                delimiter,
+                fields
+            });
+            return;
+        }
+        if (valueToken === '') {
+            const arr = [];
+            bumpNodes(state, limits, 1, lineNo);
+            list.value.push(arr);
+            contexts.push({
+                type: 'list',
+                value: arr,
+                indent: indentLevel + 1,
+                expectedLength: length,
+                delimiter
+            });
+            return;
+        }
+        const values = splitDelimited(valueToken, delimiter, lineNo).map(t => parsePrimitiveToken(t, delimiter, lineNo, strict));
+        if (strict && values.length !== length) {
+            throw new ToonError(`Inline array length mismatch: expected ${length}, got ${values.length}.`, lineNo);
+        }
+        bumpNodes(state, limits, values.length, lineNo);
+        list.value.push(values);
+        return;
+    }
+    // Inline object field or array header
+    const colonIndex = findUnquotedColon(content);
+    if (colonIndex !== -1) {
+        const keyToken = content.slice(0, colonIndex).trim();
+        const valueToken = content.slice(colonIndex + 1).trim();
+        const obj = createSafeObject();
+        bumpNodes(state, limits, 1, lineNo);
+        list.value.push(obj);
+        const objContext = { type: 'object', value: obj, indent: indentLevel + 1 };
+        contexts.push(objContext);
+        processKeyValueLine(indentLevel + 1, keyToken, valueToken, lineNo, objContext);
+        return;
+    }
+    // Primitive value
+    const value = parsePrimitiveToken(content, list.delimiter, lineNo, strict);
+    bumpNodes(state, limits, 1, lineNo);
+    list.value.push(value);
+}
+function splitKeyHeader(token) {
+    let inQuote = false;
+    let escape = false;
+    for (let i = 0; i < token.length; i++) {
+        const ch = token[i];
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escape = true;
+            continue;
+        }
+        if (ch === '"') {
+            inQuote = !inQuote;
+            continue;
+        }
+        if (!inQuote && ch === '[') {
+            return {
+                rawKey: token.slice(0, i).trim(),
+                header: token.slice(i).trim()
+            };
+        }
+    }
+    return { rawKey: token.trim() };
+}
+function parseArrayHeaderFromList(token, lineNo) {
+    const match = token.match(/^\[(\d+)([,\|\t])?\](\{(.+)\})?$/);
+    if (!match) {
+        throw new ToonError(`Invalid array header "${token}".`, lineNo);
+    }
+    const length = parseInt(match[1], 10);
+    const delimiter = match[2] ?? DEFAULT_DELIMITER;
+    const fieldsRaw = match[4];
+    const fields = fieldsRaw ? splitDelimited(fieldsRaw, delimiter, lineNo).map(f => decodeKey(f, delimiter, lineNo)) : undefined;
+    return { length, delimiter, fields };
+}
+function findUnquotedColon(text) {
+    let inQuote = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escape = true;
+            continue;
+        }
+        if (ch === '"') {
+            inQuote = !inQuote;
+            continue;
+        }
+        if (!inQuote && ch === ':') {
+            return i;
+        }
+    }
+    return -1;
+}
+function countLeadingSpaces(text, lineNo) {
+    let count = 0;
+    for (const ch of text) {
+        if (ch === ' ') {
+            count++;
+        }
+        else if (ch === '\t') {
+            throw new ToonError('Tabs are not allowed for indentation.', lineNo);
+        }
+        else {
+            break;
+        }
+    }
+    return count;
+}
+function parsePrimitiveToken(token, delimiter, lineNo, strict) {
+    if (token === '') {
+        return '';
+    }
+    const trimmed = token.trim();
+    if (trimmed !== token && strict) {
+        throw new ToonError('Unquoted values may not contain leading or trailing whitespace.', lineNo);
+    }
+    if (trimmed.startsWith('"')) {
+        return decodeQuotedString(trimmed, lineNo);
+    }
+    if (trimmed === 'true')
+        return true;
+    if (trimmed === 'false')
+        return false;
+    if (trimmed === 'null')
+        return null;
+    // If token is a plain integer with leading zeros (e.g., 007) this is disallowed
+    // and should be quoted - reject early.
+    if (/^-?\d+$/.test(trimmed) && /^-?0\d+$/.test(trimmed)) {
+        throw new ToonError('Numbers with leading zeros must be quoted.', lineNo);
+    }
+    if (NUMERIC_RE.test(trimmed)) {
+        if (/^-?0\d+/.test(trimmed)) {
+            throw new ToonError('Numbers with leading zeros must be quoted.', lineNo);
+        }
+        const num = Number(trimmed);
+        if (!Number.isFinite(num)) {
+            throw new ToonError('Invalid numeric value.', lineNo);
+        }
+        return num;
+    }
+    if (strict && trimmed.includes(delimiter)) {
+        throw new ToonError('Unquoted value contains the active delimiter.', lineNo);
+    }
+    return trimmed;
+}
+function decodeQuotedString(token, lineNo) {
+    if (!token.endsWith('"')) {
+        throw new ToonError('Unterminated string.', lineNo);
+    }
+    let result = '';
+    let escape = false;
+    for (let i = 1; i < token.length - 1; i++) {
+        const ch = token[i];
+        if (escape) {
+            if (ch === '"' || ch === '\\') {
+                result += ch;
+            }
+            else if (ch === 'n') {
+                result += '\n';
+            }
+            else if (ch === 'r') {
+                result += '\r';
+            }
+            else if (ch === 't') {
+                result += '\t';
+            }
+            else {
+                throw new ToonError(`Invalid escape sequence \\${ch}.`, lineNo);
+            }
+            escape = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escape = true;
+            continue;
+        }
+        result += ch;
+    }
+    if (escape) {
+        throw new ToonError('Unterminated escape sequence.', lineNo);
+    }
+    return result;
+}
+function splitDelimited(text, delimiter, lineNo) {
+    const tokens = [];
+    let current = '';
+    let inQuote = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (escape) {
+            current += ch;
+            escape = false;
+            continue;
+        }
+        if (ch === '\\') {
+            current += ch;
+            escape = true;
+            continue;
+        }
+        if (ch === '"') {
+            current += ch;
+            inQuote = !inQuote;
+            continue;
+        }
+        if (!inQuote && ch === delimiter) {
+            tokens.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    if (inQuote) {
+        throw new ToonError('Unterminated quoted value.', lineNo);
+    }
+    tokens.push(current);
+    return tokens;
+}
+function encodePrimitive(value, activeDelimiter, documentDelimiter) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new ToonError('Numeric values must be finite.');
+        }
+        if (Object.is(value, -0))
+            return '-0';
+        return String(value);
+    }
+    return encodeString(value, activeDelimiter, documentDelimiter);
+}
+function encodeString(value, activeDelimiter, documentDelimiter) {
+    const needsQuote = value.length === 0 ||
+        /^\s|\s$/.test(value) ||
+        value === 'true' ||
+        value === 'false' ||
+        value === 'null' ||
+        NUMERIC_LIKE_RE.test(value) ||
+        LEADING_ZERO_RE.test(value) ||
+        value.includes(':') ||
+        value.includes('"') ||
+        value.includes('\\') ||
+        /[\[\]{}]/.test(value) ||
+        /[\n\r\t]/.test(value) ||
+        value.includes(activeDelimiter) ||
+        value.includes(documentDelimiter) ||
+        value === '-' ||
+        value.startsWith('-');
+    if (!needsQuote) {
+        return value;
+    }
+    return `"${escapeString(value)}"`;
+}
+function escapeString(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t');
+}
+function primitiveLine(key, value, indent, activeDelimiter, limits = DEFAULT_LIMITS) {
+    const encodedValue = encodePrimitive(value, activeDelimiter, activeDelimiter);
+    if (key === null) {
+        return `${indent}${encodedValue}`;
+    }
+    validateKeySafety(key, limits);
+    return `${indent}${encodeKey(key, activeDelimiter)}: ${encodedValue}`;
+}
+function encodeKey(key, activeDelimiter) {
+    if (SAFE_KEY_RE.test(key) && !key.includes(activeDelimiter)) {
+        return key;
+    }
+    return `"${escapeString(key)}"`;
+}
+function decodeKey(token, delimiter, lineNo) {
+    const trimmed = token.trim();
+    if (trimmed.startsWith('"')) {
+        return decodeQuotedString(trimmed, lineNo);
+    }
+    if (!SAFE_KEY_RE.test(trimmed)) {
+        throw new ToonError('Invalid key token.', lineNo);
+    }
+    if (trimmed.includes(delimiter)) {
+        throw new ToonError('Key contains active delimiter and must be quoted.', lineNo);
+    }
+    return trimmed;
+}
+function bumpNodes(state, limits, count, lineNo) {
+    state.nodes += count;
+    if (state.nodes > limits.maxTotalNodes) {
+        throw new ToonError(`Node count ${state.nodes} exceeds limit ${limits.maxTotalNodes}.`, lineNo);
+    }
+}
+function enforceLimits(depth, limits, state) {
+    if (depth > limits.maxDepth) {
+        throw new ToonError(`Maximum depth ${limits.maxDepth} exceeded.`);
+    }
+    bumpNodes(state, limits, 1);
+}
+function applyLimits(options) {
+    return {
+        maxDepth: options.maxDepth ?? DEFAULT_LIMITS.maxDepth,
+        maxArrayLength: options.maxArrayLength ?? DEFAULT_LIMITS.maxArrayLength,
+        maxTotalNodes: options.maxTotalNodes ?? DEFAULT_LIMITS.maxTotalNodes,
+        disallowedKeys: options.disallowedKeys ?? DEFAULT_LIMITS.disallowedKeys
+    };
+}
+function isPrimitive(value) {
+    return (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean');
+}
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function detectTabular(arr) {
+    if (arr.length === 0)
+        return null;
+    if (!arr.every(item => isPlainObject(item))) {
+        return null;
+    }
+    const first = arr[0];
+    const fields = Object.keys(first);
+    if (fields.length === 0) {
+        return null;
+    }
+    const rows = [];
+    for (const item of arr) {
+        const obj = item;
+        const objKeys = Object.keys(obj);
+        if (objKeys.length !== fields.length)
+            return null;
+        for (const field of fields) {
+            if (!Object.prototype.hasOwnProperty.call(obj, field))
+                return null;
+            if (!isPrimitive(obj[field]))
+                return null;
+        }
+        rows.push(obj);
+    }
+    return { fields, rows };
+}
+function validateKeySafety(key, limits = DEFAULT_LIMITS, lineNo) {
+    if (limits.disallowedKeys.includes(key)) {
+        throw new ToonError(`Disallowed key "${key}" to prevent prototype pollution.`, lineNo);
+    }
+}
+function createSafeObject() {
+    return Object.create(null);
+}
+//# sourceMappingURL=index.js.map