toon-parser 1.1.1 → 2.0.0

package/dist/index.cjs

@@ -1,874 +1,835 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToonError = void 0;
-exports.jsonToToon = jsonToToon;
-exports.toonToJson = toonToJson;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  ToonError: () => ToonError,
+  jsonToToon: () => jsonToToon,
+  toonToJson: () => toonToJson
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./xml.cjs"), module.exports);
 const DEFAULT_LIMITS = Object.freeze({
-    maxDepth: 64,
-    maxArrayLength: 50000,
-    maxTotalNodes: 250000,
-    disallowedKeys: ['__proto__', 'constructor', 'prototype']
+  maxDepth: 64,
+  maxArrayLength: 5e4,
+  maxTotalNodes: 25e4,
+  disallowedKeys: ["__proto__", "constructor", "prototype"]
 });
-const DEFAULT_DELIMITER = ',';
+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_.]*$/;
 class ToonError extends Error {
-    constructor(message, line) {
-        super(line ? `Line ${line}: ${message}` : message);
-        this.name = 'ToonError';
-        this.line = line;
-    }
+  constructor(message, line) {
+    super(line ? `Line ${line}: ${message}` : message);
+    this.name = "ToonError";
+    this.line = line;
+  }
 }
-exports.ToonError = ToonError;
 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');
+  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;
+    }
+    if (input instanceof Date) {
+      const line = primitiveLine(key, input.toISOString(), indentUnit.repeat(depth), activeDelimiter, limits);
+      lines.push(line);
+      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) {
+      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;
+    }
+    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 if (item instanceof Date) {
+        lines.push(`${itemPrefix}- ${encodePrimitive(item.toISOString(), activeDelimiter, activeDelimiter)}`);
+        bumpNodes(state, limits, 1);
+      } else {
+        throw new ToonError(`Unsupported array item type: ${typeof item}`);
+      }
+    }
+  };
+  encodeValue(value, 0, null, delimiter);
+  return lines.join("\n");
 }
 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);
+  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 (!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;
     };
-    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 (!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);
     }
-    if (root === null) {
-        return createSafeObject();
+    const length = parseInt(match[1], 10);
+    if (!Number.isFinite(length)) {
+      throw new ToonError("Invalid array length.", lineNo);
     }
-    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;
+    const delimiter = match[2] ?? delimiterFallback;
+    const fieldsRaw = match[4];
+    if (fieldsRaw === void 0) {
+      return { length, delimiter };
     }
-    // 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;
+    const fields = splitDelimited(fieldsRaw, delimiter, lineNo).map((f) => decodeKey(f, lineNo));
+    if (fields.length === 0 && strict) {
+      throw new ToonError("Tabular arrays require at least one field.", lineNo);
     }
-    // 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();
+    return { length, delimiter, fields };
+  };
+  const processKeyValueLine = (indentLevel, keyToken, valueToken, lineNo, parent) => {
+    const { rawKey, header } = splitKeyHeader(keyToken);
+    const key = rawKey === "" ? null : decodeKey(rawKey, 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);
-        list.value.push(obj);
-        const objContext = { type: 'object', value: obj, indent: indentLevel + 1 };
-        contexts.push(objContext);
-        processKeyValueLine(indentLevel + 1, keyToken, valueToken, lineNo, objContext);
+        attachValue(arr, parent, key, lineNo);
+        contexts.push({
+          type: "tabular",
+          value: arr,
+          indent: indentLevel + 1,
+          expectedLength: length,
+          delimiter,
+          fields
+        });
         return;
-    }
-    // Primitive value
-    const value = parsePrimitiveToken(content, list.delimiter, lineNo, strict);
+      }
+      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);
-    list.value.push(value);
+  };
+  lines.forEach((rawLine, index) => {
+    const lineNo = index + 1;
+    const trimmedEnd = rawLine.replace(/[ \t]+$/, "");
+    if (trimmedEnd.trim() === "") {
+      return;
+    }
+    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);
+    }
+    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);
+      }
+    }
+    if (indentLevel !== (parent ? parent.indent : 0)) {
+      throw new ToonError("Unexpected indentation level.", lineNo);
+    }
+    const colonIndex = findUnquotedColon(line);
+    if (colonIndex === -1) {
+      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 (parent && parent.type === "placeholder") {
+      if (!keyToken.startsWith("[")) {
+        if (!parent.current) {
+          const obj = createSafeObject();
+          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, 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: void 0,
+      assign: function(value2) {
+        if (this.current && typeof value2 === "object" && value2 !== null && !Array.isArray(value2) && Object.keys(value2).length === 0) {
+          return;
+        }
+        list.value.push(value2);
+      }
+    };
+    contexts.push(placeholder);
+    return;
+  }
+  if (content.startsWith("[")) {
+    const colonIndex2 = findUnquotedColon(content);
+    const headerToken = colonIndex2 === -1 ? content : content.slice(0, colonIndex2).trim();
+    const valueToken = colonIndex2 === -1 ? "" : content.slice(colonIndex2 + 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;
+  }
+  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;
+  }
+  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()
-            };
-        }
+  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;
     }
-    return { rawKey: token.trim() };
+    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 };
+  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, lineNo)) : void 0;
+  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;
-        }
+  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;
     }
-    return -1;
+    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;
+  let count = 0;
+  for (const ch of text) {
+    if (ch === " ") {
+      count++;
+    } else if (ch === "	") {
+      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;
+  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 (/^-?\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 (!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) {
-        throw new ToonError('Unterminated escape sequence.', lineNo);
-    }
-    return result;
+      if (ch === '"' || ch === "\\") {
+        result += ch;
+      } else if (ch === "n") {
+        result += "\n";
+      } else if (ch === "r") {
+        result += "\r";
+      } else if (ch === "t") {
+        result += "	";
+      } 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;
+  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);
+  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)}"`;
+  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');
+  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}`;
+  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)}"`;
+  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 decodeKey(token, 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);
+  }
+  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);
-    }
+  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);
+  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
-    };
+  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');
+  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;
+  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 };
+  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);
-    }
+  if (limits.disallowedKeys.includes(key)) {
+    throw new ToonError(`Disallowed key "${key}" to prevent prototype pollution.`, lineNo);
+  }
 }
 function createSafeObject() {
-    return Object.create(null);
+  return /* @__PURE__ */ Object.create(null);
 }
-//# sourceMappingURL=index.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToonError,
+  jsonToToon,
+  toonToJson,
+  ...require("./xml.cjs")
+});