toon-parser 2.2.1 → 3.0.0

package/dist/core.cjs

@@ -0,0 +1,630 @@
+"use strict";
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var core_exports = {};
+__export(core_exports, {
+  ToonError: () => import_errors2.ToonError,
+  enforceInputLength: () => import_security2.enforceInputLength,
+  jsonToToon: () => jsonToToon,
+  toonToJson: () => toonToJson
+});
+module.exports = __toCommonJS(core_exports);
+var import_constants = require("./internal/constants.cjs");
+var import_errors = require("./internal/errors.cjs");
+var import_security = require("./internal/security.cjs");
+var import_primitives = require("./internal/primitives.cjs");
+var import_errors2 = require("./internal/errors.cjs");
+var import_security2 = require("./internal/security.cjs");
+function jsonToToon(value, options = {}) {
+  const indentSize = options.indent ?? 2;
+  if (!Number.isInteger(indentSize) || indentSize <= 0) {
+    throw new import_errors.ToonError("Indent must be a positive integer.");
+  }
+  const delimiter = options.delimiter ?? import_constants.DEFAULT_DELIMITER;
+  const limits = (0, import_security.applyLimits)(options);
+  const state = { nodes: 0 };
+  const lines = [];
+  const indentUnit = " ".repeat(indentSize);
+  const keyFolding = options.keyFolding ?? "off";
+  const flattenDepth = options.flattenDepth ?? Infinity;
+  const tryFoldChain = (firstKey, firstValue, siblingKeys) => {
+    if (keyFolding !== "safe") return null;
+    if (!import_constants.IDENTIFIER_SEGMENT_RE.test(firstKey)) return null;
+    if (limits.disallowedKeys.includes(firstKey)) return null;
+    const segments = [firstKey];
+    const valuesAtEachStep = [firstValue];
+    let current = firstValue;
+    while ((0, import_security.isPlainObject)(current) && Object.keys(current).length === 1) {
+      const onlyKey = Object.keys(current)[0];
+      if (!import_constants.IDENTIFIER_SEGMENT_RE.test(onlyKey)) break;
+      if (limits.disallowedKeys.includes(onlyKey)) break;
+      const nextValue = current[onlyKey];
+      segments.push(onlyKey);
+      valuesAtEachStep.push(nextValue);
+      current = nextValue;
+    }
+    const endpointIsEmptyObject = (0, import_security.isPlainObject)(current) && Object.keys(current).length === 0;
+    const endpointFoldable = (0, import_security.isPrimitive)(current) || Array.isArray(current) || current instanceof Date || endpointIsEmptyObject;
+    if (!endpointFoldable) return null;
+    if (segments.length < 2) return null;
+    const cap = Math.max(2, Math.min(segments.length, flattenDepth));
+    const usedSegments = segments.slice(0, cap);
+    const leaf = valuesAtEachStep[cap - 1];
+    const path = usedSegments.join(".");
+    if (siblingKeys.has(path)) return null;
+    return { path, leaf };
+  };
+  const encodeValue = (input, depth, key, activeDelimiter) => {
+    (0, import_security.enforceLimits)(depth, limits, state);
+    if ((0, import_security.isPrimitive)(input)) {
+      const line = (0, import_primitives.primitiveLine)(key, input, indentUnit.repeat(depth), activeDelimiter, limits);
+      lines.push(line);
+      return;
+    }
+    if (Array.isArray(input)) {
+      encodeArray(key, input, depth, activeDelimiter);
+      return;
+    }
+    if ((0, import_security.isPlainObject)(input)) {
+      encodeObject(key, input, depth, activeDelimiter);
+      return;
+    }
+    if (input instanceof Date) {
+      const line = (0, import_primitives.primitiveLine)(key, input.toISOString(), indentUnit.repeat(depth), activeDelimiter, limits);
+      lines.push(line);
+      return;
+    }
+    throw new import_errors.ToonError(`Unsupported value type: ${typeof input}`);
+  };
+  const encodeObject = (key, obj, depth, activeDelimiter) => {
+    (0, import_security.enforceDepth)(depth, limits);
+    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) {
+      (0, import_security.validateKeySafety)(key, limits);
+      if (sortedEntries.length === 0) {
+        lines.push(`${prefix}${(0, import_primitives.encodeKey)(key, activeDelimiter)}:`);
+        return;
+      }
+      lines.push(`${prefix}${(0, import_primitives.encodeKey)(key, activeDelimiter)}:`);
+    } else if (depth > 0 && sortedEntries.length === 0) {
+      return;
+    }
+    const siblingKeys = new Set(sortedEntries.map(([k]) => k));
+    for (const [childKey, childValue] of sortedEntries) {
+      const nextDepth = key === null ? depth : depth + 1;
+      (0, import_security.enforceDepth)(nextDepth, limits);
+      const folded = tryFoldChain(childKey, childValue, siblingKeys);
+      if (folded) {
+        encodeValue(folded.leaf, nextDepth, folded.path, activeDelimiter);
+      } else {
+        encodeValue(childValue, nextDepth, childKey, activeDelimiter);
+      }
+    }
+  };
+  const encodeArray = (key, arr, depth, activeDelimiter) => {
+    (0, import_security.enforceDepth)(depth, limits);
+    if (key !== null) {
+      (0, import_security.validateKeySafety)(key, limits);
+    }
+    if (arr.length > limits.maxArrayLength) {
+      throw new import_errors.ToonError(`Array length ${arr.length} exceeds limit ${limits.maxArrayLength}.`);
+    }
+    const prefix = indentUnit.repeat(depth);
+    const headerKey = key === null ? "" : (0, import_primitives.encodeKey)(key, activeDelimiter);
+    if (arr.every(import_security.isPrimitive)) {
+      const encoded = arr.map((v) => (0, import_primitives.encodePrimitive)(v, activeDelimiter, activeDelimiter)).join(activeDelimiter);
+      const spacing = arr.length > 0 ? " " : "";
+      lines.push(`${prefix}${headerKey}[${arr.length}]:${spacing}${encoded}`);
+      (0, import_security.bumpNodes)(state, limits, arr.length);
+      return;
+    }
+    const tabular = (0, import_security.detectTabular)(arr);
+    if (tabular) {
+      const { fields, rows } = tabular;
+      const encodedFields = fields.map((f) => (0, import_primitives.encodeKey)(f, activeDelimiter)).join(activeDelimiter);
+      lines.push(`${prefix}${headerKey}[${arr.length}]{${encodedFields}}:`);
+      for (const row of rows) {
+        const rowValues = fields.map((f) => (0, import_primitives.encodePrimitive)(row[f], activeDelimiter, activeDelimiter)).join(activeDelimiter);
+        lines.push(`${indentUnit.repeat(depth + 1)}${rowValues}`);
+      }
+      (0, import_security.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) {
+      (0, import_security.enforceDepth)(itemIndent, limits);
+      if ((0, import_security.isPrimitive)(item)) {
+        lines.push(`${itemPrefix}- ${(0, import_primitives.encodePrimitive)(item, activeDelimiter, activeDelimiter)}`);
+        (0, import_security.bumpNodes)(state, limits, 1);
+      } else if (Array.isArray(item)) {
+        (0, import_security.bumpNodes)(state, limits, 1);
+        const inline = item.every(import_security.isPrimitive);
+        if (inline) {
+          const encoded = item.map((v) => (0, import_primitives.encodePrimitive)(v, activeDelimiter, activeDelimiter)).join(activeDelimiter);
+          const spacing = item.length > 0 ? " " : "";
+          lines.push(`${itemPrefix}- [${item.length}]:${spacing}${encoded}`);
+          (0, import_security.bumpNodes)(state, limits, item.length);
+        } else {
+          lines.push(`${itemPrefix}-`);
+          encodeArray(null, item, itemIndent + 1, activeDelimiter);
+        }
+      } else if ((0, import_security.isPlainObject)(item)) {
+        (0, import_security.bumpNodes)(state, limits, 1);
+        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}- ${(0, import_primitives.encodePrimitive)(item.toISOString(), activeDelimiter, activeDelimiter)}`);
+        (0, import_security.bumpNodes)(state, limits, 1);
+      } else {
+        throw new import_errors.ToonError(`Unsupported array item type: ${typeof item}`);
+      }
+    }
+  };
+  encodeValue(value, 0, null, delimiter);
+  return lines.join("\n");
+}
+function toonToJson(text, options = {}) {
+  const limits = (0, import_security.applyLimits)(options);
+  if (text.length > limits.maxInputLength) {
+    throw new import_errors.ToonError(`Input length ${text.length} exceeds limit ${limits.maxInputLength}.`);
+  }
+  const strict = options.strict ?? true;
+  const expandPaths = options.expandPaths ?? "off";
+  const delimiterFallback = import_constants.DEFAULT_DELIMITER;
+  const trySplitDottedKey = (key, lineNo) => {
+    if (expandPaths !== "safe") return null;
+    if (!key.includes(".")) return null;
+    const segments = key.split(".");
+    for (const seg of segments) {
+      if (!import_constants.IDENTIFIER_SEGMENT_RE.test(seg)) return null;
+      if (limits.disallowedKeys.includes(seg)) {
+        throw new import_errors.ToonError(
+          `Disallowed key segment "${seg}" in expanded path "${key}".`,
+          lineNo
+        );
+      }
+    }
+    return segments;
+  };
+  const assignExpandedPath = (target, segments, value, lineNo) => {
+    let cursor = target;
+    for (let i = 0; i < segments.length - 1; i++) {
+      const seg = segments[i];
+      const existing2 = cursor[seg];
+      if (existing2 === void 0) {
+        const next2 = (0, import_security.createSafeObject)();
+        cursor[seg] = next2;
+        cursor = next2;
+        continue;
+      }
+      if ((0, import_security.isPlainObject)(existing2)) {
+        cursor = existing2;
+        continue;
+      }
+      if (strict) {
+        throw new import_errors.ToonError(
+          `Expansion conflict at path "${segments.slice(0, i + 1).join(".")}" (object vs primitive).`,
+          lineNo
+        );
+      }
+      const next = (0, import_security.createSafeObject)();
+      cursor[seg] = next;
+      cursor = next;
+    }
+    const leafKey = segments[segments.length - 1];
+    const existing = cursor[leafKey];
+    if (existing === void 0) {
+      cursor[leafKey] = value;
+      return;
+    }
+    if ((0, import_security.isPlainObject)(existing) && (0, import_security.isPlainObject)(value)) {
+      Object.assign(existing, value);
+      return;
+    }
+    if (strict) {
+      throw new import_errors.ToonError(`Expansion conflict at path "${segments.join(".")}".`, lineNo);
+    }
+    cursor[leafKey] = value;
+  };
+  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 import_errors.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 import_errors.ToonError(`List length mismatch: expected ${container.expectedLength}, got ${container.value.length}.`, lineNo);
+      }
+    } else if (container.type === "placeholder") {
+      if (!container.filled) {
+        container.assign((0, import_security.createSafeObject)());
+        container.filled = true;
+      }
+    }
+  };
+  const attachValue = (value, parent, key, lineNo) => {
+    const ensureRootObject = () => {
+      if (rootContainer) {
+        return rootContainer;
+      }
+      const obj = { type: "object", value: (0, import_security.createSafeObject)(), indent: 0 };
+      rootContainer = obj;
+      root = obj.value;
+      contexts.push(obj);
+      return obj;
+    };
+    if (!parent) {
+      if (key !== null) {
+        const target = ensureRootObject();
+        const segments = trySplitDottedKey(key, lineNo);
+        if (segments) {
+          assignExpandedPath(target.value, segments, value, lineNo);
+          return;
+        }
+        if (expandPaths === "safe" && Object.prototype.hasOwnProperty.call(target.value, key)) {
+          assignExpandedPath(target.value, [key], value, lineNo);
+          return;
+        }
+        target.value[key] = value;
+        return;
+      }
+      if (root !== null) {
+        throw new import_errors.ToonError("Multiple root values detected.", lineNo);
+      }
+      root = value;
+      return;
+    }
+    if (parent.type === "object") {
+      if (key === null) {
+        throw new import_errors.ToonError("Missing key for object assignment.");
+      }
+      const segments = trySplitDottedKey(key, lineNo);
+      if (segments) {
+        assignExpandedPath(parent.value, segments, value, lineNo);
+        return;
+      }
+      if (expandPaths === "safe" && Object.prototype.hasOwnProperty.call(parent.value, key)) {
+        assignExpandedPath(parent.value, [key], value, lineNo);
+        return;
+      }
+      parent.value[key] = value;
+      return;
+    }
+    if (parent.type === "list") {
+      parent.value.push(value);
+      return;
+    }
+    if (parent.type === "placeholder") {
+      if (parent.filled) {
+        throw new import_errors.ToonError("List item already filled.", lineNo);
+      }
+      parent.assign(value);
+      parent.filled = true;
+      return;
+    }
+    throw new import_errors.ToonError("Invalid parent container.");
+  };
+  const parseArrayHeader = (token, lineNo) => {
+    const match = token.match(/^\[(\d+)([,\|\t])?\](\{(.+)\})?$/);
+    if (!match) {
+      throw new import_errors.ToonError(`Invalid array header "${token}".`, lineNo);
+    }
+    const length = parseInt(match[1], 10);
+    if (!Number.isFinite(length)) {
+      throw new import_errors.ToonError("Invalid array length.", lineNo);
+    }
+    const delimiter = match[2] ?? delimiterFallback;
+    const fieldsRaw = match[4];
+    if (fieldsRaw === void 0) {
+      return { length, delimiter };
+    }
+    const fields = (0, import_primitives.splitDelimited)(fieldsRaw, delimiter, lineNo).map((f) => (0, import_primitives.decodeKey)(f, lineNo));
+    if (fields.length === 0 && strict) {
+      throw new import_errors.ToonError("Tabular arrays require at least one field.", lineNo);
+    }
+    return { length, delimiter, fields };
+  };
+  const processKeyValueLine = (indentLevel, keyToken, valueToken, lineNo, parent) => {
+    const { rawKey, header } = (0, import_primitives.splitKeyHeader)(keyToken);
+    const key = rawKey === "" ? null : (0, import_primitives.decodeKey)(rawKey, lineNo);
+    if (key !== null) {
+      (0, import_security.validateKeySafety)(key, limits, lineNo);
+    }
+    if (header) {
+      const { length, delimiter, fields } = parseArrayHeader(header, lineNo);
+      if (length > limits.maxArrayLength) {
+        throw new import_errors.ToonError(`Array length ${length} exceeds limit ${limits.maxArrayLength}.`, lineNo);
+      }
+      if (fields) {
+        if (valueToken !== "") {
+          throw new import_errors.ToonError("Tabular array header must not have inline values.", lineNo);
+        }
+        const arr = [];
+        (0, import_security.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 = [];
+        (0, import_security.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 = (0, import_primitives.splitDelimited)(valueToken, delimiter, lineNo).map((t) => (0, import_primitives.parsePrimitiveToken)(t, delimiter, lineNo, strict));
+      if (strict && values.length !== length) {
+        throw new import_errors.ToonError(`Inline array length mismatch: expected ${length}, got ${values.length}.`, lineNo);
+      }
+      attachValue(values, parent, key, lineNo);
+      (0, import_security.bumpNodes)(state, limits, values.length, lineNo);
+      return;
+    }
+    if (valueToken === "") {
+      const obj = (0, import_security.createSafeObject)();
+      attachValue(obj, parent, key, lineNo);
+      contexts.push({ type: "object", value: obj, indent: indentLevel + 1 });
+      return;
+    }
+    const value = (0, import_primitives.parsePrimitiveToken)(valueToken, delimiterFallback, lineNo, strict);
+    attachValue(value, parent, key, lineNo);
+    (0, import_security.bumpNodes)(state, limits, 1, lineNo);
+  };
+  lines.forEach((rawLine, index) => {
+    const lineNo = index + 1;
+    const trimmedEnd = rawLine.replace(/[ \t]+$/, "");
+    if (trimmedEnd.trim() === "") {
+      return;
+    }
+    const indentSpaces = (0, import_primitives.countLeadingSpaces)(trimmedEnd, lineNo);
+    if (indentStep === null) {
+      indentStep = indentSpaces === 0 ? 2 : indentSpaces;
+    }
+    if (indentSpaces % indentStep !== 0) {
+      throw new import_errors.ToonError(`Inconsistent indentation: expected multiples of ${indentStep} spaces.`, lineNo);
+    }
+    const indentLevel = indentSpaces / indentStep;
+    if (indentLevel > limits.maxDepth) {
+      throw new import_errors.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 = (0, import_primitives.classifyTabularLine)(line, top.delimiter);
+        if (classification === "row") {
+          const cells = (0, import_primitives.splitDelimited)(line, top.delimiter, lineNo);
+          if (strict && cells.length !== top.fields.length) {
+            throw new import_errors.ToonError(
+              `Tabular row width mismatch: expected ${top.fields.length}, got ${cells.length}.`,
+              lineNo
+            );
+          }
+          const obj = (0, import_security.createSafeObject)();
+          top.fields.forEach((field, idx) => {
+            (0, import_security.validateKeySafety)(field, limits, lineNo);
+            const token = cells[idx] ?? "";
+            obj[field] = (0, import_primitives.parsePrimitiveToken)(token, top.delimiter, lineNo, strict);
+            (0, import_security.bumpNodes)(state, limits, 1, lineNo);
+          });
+          top.value.push(obj);
+          if (top.value.length > limits.maxArrayLength) {
+            throw new import_errors.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 import_errors.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 import_errors.ToonError('List item body must indent one level below "-".', lineNo);
+      }
+    }
+    if (indentLevel !== (parent ? parent.indent : 0)) {
+      throw new import_errors.ToonError("Unexpected indentation level.", lineNo);
+    }
+    const colonIndex = (0, import_primitives.findUnquotedColon)(line);
+    if (colonIndex === -1) {
+      if (root === null && !parent) {
+        const value = (0, import_primitives.parsePrimitiveToken)(line.trim(), delimiterFallback, lineNo, strict);
+        root = value;
+        (0, import_security.bumpNodes)(state, limits, 1, lineNo);
+        return;
+      }
+      throw new import_errors.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 = (0, import_security.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 (0, import_security.createSafeObject)();
+  }
+  return root;
+}
+function parseListItem(line, list, indentLevel, lineNo, processKeyValueLine, contexts, state, limits, strict) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("-")) {
+    throw new import_errors.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 = (0, import_primitives.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 } = (0, import_primitives.parseArrayHeaderFromList)(headerToken, lineNo);
+    if (length > limits.maxArrayLength) {
+      throw new import_errors.ToonError(`Array length ${length} exceeds limit ${limits.maxArrayLength}.`, lineNo);
+    }
+    if (fields) {
+      if (valueToken !== "") {
+        throw new import_errors.ToonError("Tabular header in list item cannot have inline values.", lineNo);
+      }
+      const arr = [];
+      (0, import_security.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 = [];
+      (0, import_security.bumpNodes)(state, limits, 1, lineNo);
+      list.value.push(arr);
+      contexts.push({
+        type: "list",
+        value: arr,
+        indent: indentLevel + 1,
+        expectedLength: length,
+        delimiter
+      });
+      return;
+    }
+    const values = (0, import_primitives.splitDelimited)(valueToken, delimiter, lineNo).map((t) => (0, import_primitives.parsePrimitiveToken)(t, delimiter, lineNo, strict));
+    if (strict && values.length !== length) {
+      throw new import_errors.ToonError(`Inline array length mismatch: expected ${length}, got ${values.length}.`, lineNo);
+    }
+    (0, import_security.bumpNodes)(state, limits, values.length, lineNo);
+    list.value.push(values);
+    return;
+  }
+  const colonIndex = (0, import_primitives.findUnquotedColon)(content);
+  if (colonIndex !== -1) {
+    const keyToken = content.slice(0, colonIndex).trim();
+    const valueToken = content.slice(colonIndex + 1).trim();
+    const obj = (0, import_security.createSafeObject)();
+    (0, import_security.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 = (0, import_primitives.parsePrimitiveToken)(content, list.delimiter, lineNo, strict);
+  (0, import_security.bumpNodes)(state, limits, 1, lineNo);
+  list.value.push(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToonError,
+  enforceInputLength,
+  jsonToToon,
+  toonToJson
+});