@tehw0lf/n8n-nodes-toon 1.3.4 → 1.4.1

package/dist/nodes/Toon/ToonDecoder.js

@@ -38,476 +38,486 @@ const types_1 = require("./types");
 const utils = __importStar(require("./ToonUtils"));
 class ToonDecoder {
     constructor(options) {
+        this.lines = [];
+        this.pos = 0;
+        this.inHeaderSpan = false;
         this.options = options;
     }
     decode(toonText) {
-        const lines = this.parseLines(toonText);
-        const nonEmptyLines = lines.filter((line) => !line.isEmpty);
-        if (nonEmptyLines.length === 0) {
-            return null;
-        }
-        const rootForm = this.determineRootForm(nonEmptyLines);
-        let result;
-        if (rootForm === 'array') {
-            result = this.parseArray(nonEmptyLines, 0);
-        }
-        else if (rootForm === 'primitive') {
-            const token = nonEmptyLines[0].content.trim();
-            result = this.parseTokenValue(token);
-        }
-        else {
-            result = this.parseObject(nonEmptyLines, 0, 0);
+        this.lines = this.parseLines(toonText);
+        this.pos = 0;
+        if (this.lines.length === 0) {
+            return {};
         }
+        let result = this.parseRoot();
         if (this.options.expandPaths === 'safe' && utils.isPlainObject(result)) {
             result = this.expandPaths(result);
         }
         return result;
     }
     parseLines(text) {
-        const rawLines = text.split('\n');
+        var _a, _b;
+        const withoutBom = text.startsWith('') ? text.slice(1) : text;
+        const rawLines = withoutBom.split('\n');
         const parsed = [];
+        let blankBefore = false;
         for (let i = 0; i < rawLines.length; i++) {
-            const line = rawLines[i];
-            if (this.options.strict && /^\t/.test(line)) {
-                throw new types_1.ToonDecodingError('Tabs not allowed in indentation', {
-                    lineNumber: i + 1,
-                    line,
-                });
+            let line = rawLines[i].replace(/\r$/, '');
+            line = line.replace(/ +$/, '');
+            const lineNumber = i + 1;
+            if (/^ *#/.test(line)) {
+                continue;
             }
-            const match = line.match(/^( *)/);
-            const indent = match ? match[1].length : 0;
-            if (this.options.strict && indent > 0 && indent % this.options.indent !== 0) {
-                throw new types_1.ToonDecodingError(`Indentation must be multiple of ${this.options.indent}, got ${indent} spaces`, {
-                    lineNumber: i + 1,
-                    line,
-                });
+            if (line.trim() === '') {
+                blankBefore = true;
+                continue;
+            }
+            if (/^[ \t]*\t/.test(line)) {
+                if (this.options.strict) {
+                    throw new types_1.ToonDecodingError('Tabs not allowed in indentation', {
+                        lineNumber,
+                        line,
+                    });
+                }
+                line = line.replace(/^[ \t]+/, (ws) => ws.replace(/\t/g, ''));
+            }
+            const indent = (_b = (_a = line.match(/^( *)/)) === null || _a === void 0 ? void 0 : _a[1].length) !== null && _b !== void 0 ? _b : 0;
+            if (this.options.strict && indent % this.options.indent !== 0) {
+                throw new types_1.ToonDecodingError(`Indentation must be multiple of ${this.options.indent}, got ${indent} spaces`, { lineNumber, line });
             }
             parsed.push({
-                content: line,
+                content: line.slice(indent),
                 indent,
-                lineNumber: i + 1,
-                isEmpty: line.trim() === '',
+                lineNumber,
+                isEmpty: false,
+                blankBefore,
             });
+            blankBefore = false;
         }
         return parsed;
     }
-    determineRootForm(lines) {
-        const firstLine = lines[0].content.trim();
-        if (/^\[(?:0|[1-9]\d*)[\t|]?\]/.test(firstLine) && this.isValidArrayHeader(firstLine)) {
-            return 'array';
-        }
-        if (firstLine === '[]') {
-            return 'array';
+    withinHeaderSpan(parse) {
+        const previous = this.inHeaderSpan;
+        this.inHeaderSpan = true;
+        try {
+            return parse();
         }
-        if (this.options.strict && this.isInvalidArrayHeader(firstLine)) {
-            throw new types_1.ToonDecodingError('Non-whitespace content between bracket segment and colon/fields: line MUST NOT be parsed as array header', { lineNumber: lines[0].lineNumber, line: firstLine });
+        finally {
+            this.inHeaderSpan = previous;
         }
-        if (lines.length === 1 && !firstLine.includes(':')) {
-            return 'primitive';
+    }
+    checkBlankInSpan(line, seen) {
+        const insideSpan = seen > 0 || this.inHeaderSpan;
+        if (this.options.strict && insideSpan && line.blankBefore) {
+            throw new types_1.ToonDecodingError('Blank line inside a header span', {
+                lineNumber: line.lineNumber,
+                line: line.content,
+            });
         }
-        return 'object';
     }
-    parseArrayHeader(line) {
-        const content = line.content.trim();
+    depthOf(line) {
+        return Math.floor(line.indent / this.options.indent);
+    }
+    peek() {
+        return this.pos < this.lines.length ? this.lines[this.pos] : null;
+    }
+    parseRoot() {
+        const first = this.lines[0];
+        const content = first.content;
+        if (this.options.strict && this.depthOf(first) !== 0) {
+            throw new types_1.ToonDecodingError('Root content must start at depth 0', {
+                lineNumber: first.lineNumber,
+                line: first.content,
+            });
+        }
         if (content === '[]') {
-            return { key: null, length: 0, delimiter: ',', fields: null, rawLine: content, lineNumber: line.lineNumber };
+            this.pos = 1;
+            this.checkNoTrailingContent();
+            return [];
         }
-        const match = content.match(/^(.*?)\[(0|[1-9]\d*)([\t|])?\]\s*(?:\{([^}]+)\}\s*)?:(.*)$/);
-        if (!match) {
-            if (this.options.strict && /\[0\d+[\t|]?\]/.test(content)) {
-                throw new types_1.ToonDecodingError(`Invalid array length: leading zeros are not allowed in bracket segment`, { lineNumber: line.lineNumber, line: content });
+        const header = this.tryParseHeader(first);
+        if (header !== null && header.key === null && this.depthOf(first) === 0) {
+            if (header.keyed) {
+                const value = this.parseKeyedTabular(header, 0);
+                this.checkNoTrailingContent();
+                return value;
             }
-            throw new types_1.ToonDecodingError('Invalid array header format', {
-                lineNumber: line.lineNumber,
-                line: content,
-            });
+            const value = this.parseArrayBody(header, 0);
+            this.checkNoTrailingContent();
+            return value;
         }
-        const [, keyPart, lengthStr, delimSym, fieldsPart] = match;
-        let key = keyPart.trim();
-        if (key) {
-            if (key.startsWith('"') && key.endsWith('"')) {
-                key = utils.unescapeString(key.slice(1, -1));
-            }
+        if (this.lines.length === 1 && utils.findUnquoted(content, ':') < 0) {
+            this.pos = 1;
+            return this.parseValueToken(content, first);
         }
-        else {
-            key = null;
+        const scalarLines = this.lines.filter((line) => this.depthOf(line) === 0 &&
+            utils.findUnquoted(line.content, ':') < 0 &&
+            !line.content.startsWith('- '));
+        if (scalarLines.length >= 2) {
+            throw new types_1.ToonDecodingError('Multiple depth-0 lines that are neither headers nor key-value lines', { lineNumber: scalarLines[1].lineNumber, line: scalarLines[1].content });
         }
-        const length = parseInt(lengthStr, 10);
-        if (isNaN(length) || length < 0) {
-            throw new types_1.ToonDecodingError(`Invalid array length: ${lengthStr}`, {
-                lineNumber: line.lineNumber,
+        return this.parseObject(0);
+    }
+    checkNoTrailingContent() {
+        const next = this.peek();
+        if (next === null) {
+            return;
+        }
+        if (this.options.strict) {
+            throw new types_1.ToonDecodingError('Trailing content after completed root form', {
+                lineNumber: next.lineNumber,
+                line: next.content,
             });
         }
-        let delimiter = ',';
-        if (delimSym === '\t') {
-            delimiter = '\t';
-        }
-        else if (delimSym === '|') {
-            delimiter = '|';
-        }
-        let fields = null;
-        if (fieldsPart) {
-            fields = this.parseDelimitedTokens(fieldsPart, delimiter).map((token) => {
-                if (token.startsWith('"') && token.endsWith('"')) {
-                    return utils.unescapeString(token.slice(1, -1));
-                }
-                return token;
+        this.pos = this.lines.length;
+    }
+    tryParseHeader(line) {
+        const outcome = utils.tryParseHeader(line.content);
+        if (outcome.error !== null && this.options.strict) {
+            throw new types_1.ToonDecodingError(outcome.error, {
+                lineNumber: line.lineNumber,
+                line: line.content,
             });
         }
-        return {
-            key,
-            length,
-            delimiter,
-            fields,
-            rawLine: content,
-            lineNumber: line.lineNumber,
-        };
+        return outcome.header;
     }
-    parseDelimitedTokens(text, delimiter) {
-        const tokens = [];
-        let current = '';
-        let inQuotes = false;
-        let escaped = false;
-        for (let i = 0; i < text.length; i++) {
-            const char = text[i];
-            if (escaped) {
-                current += char;
-                escaped = false;
-                continue;
-            }
-            if (char === '\\') {
-                current += char;
-                escaped = true;
-                continue;
+    parseObject(depth) {
+        const obj = {};
+        while (this.pos < this.lines.length) {
+            const line = this.lines[this.pos];
+            const lineDepth = this.depthOf(line);
+            if (lineDepth < depth) {
+                break;
             }
-            if (char === '"' && !escaped) {
-                inQuotes = !inQuotes;
-                current += char;
+            if (lineDepth > depth) {
+                if (this.options.strict) {
+                    throw new types_1.ToonDecodingError('Over-indented line: no enclosing scope was opened', { lineNumber: line.lineNumber, line: line.content });
+                }
+                this.pos++;
                 continue;
             }
-            if (!inQuotes) {
-                if (delimiter === ',' && text.slice(i, i + 2) === ', ') {
-                    tokens.push(current.trim());
-                    current = '';
-                    i++;
-                    continue;
-                }
-                else if (char === delimiter) {
-                    tokens.push(current.trim());
-                    current = '';
-                    continue;
+            this.checkBlankInSpan(line, 0);
+            const { key, value } = this.parseFieldLine(line, depth);
+            this.assignKey(obj, key, line);
+            utils.setDecodedKey(obj, key, value);
+        }
+        return obj;
+    }
+    assignKey(obj, key, line) {
+        if (Object.prototype.hasOwnProperty.call(obj, key) && this.options.strict) {
+            throw new types_1.ToonDecodingError(`Duplicate key '${key}' at the same depth`, {
+                lineNumber: line.lineNumber,
+                line: line.content,
+            });
+        }
+    }
+    parseFieldLine(line, depth) {
+        const header = this.tryParseHeader(line);
+        if (header !== null) {
+            if (header.key === null) {
+                if (this.options.strict) {
+                    throw new types_1.ToonDecodingError('Keyless header is not valid in object-field position', { lineNumber: line.lineNumber, line: line.content });
                 }
             }
-            current += char;
+            else {
+                this.pos++;
+                const value = header.keyed
+                    ? this.parseKeyedTabularBody(header, depth + 1)
+                    : this.parseArrayBodyAfterHeader(header, depth);
+                return { key: header.key, value };
+            }
         }
-        if (current.trim()) {
-            tokens.push(current.trim());
+        const colonIndex = utils.findUnquoted(line.content, ':');
+        if (colonIndex < 0) {
+            throw new types_1.ToonDecodingError('Missing colon in key context', {
+                lineNumber: line.lineNumber,
+                line: line.content,
+            });
         }
-        return tokens;
+        const key = this.decodeKeyToken(line.content.slice(0, colonIndex), line);
+        const rest = utils.trimSpaces(line.content.slice(colonIndex + 1));
+        this.pos++;
+        if (rest === '[]') {
+            return { key, value: [] };
+        }
+        if (rest !== '') {
+            return { key, value: this.parseValueToken(rest, line) };
+        }
+        return { key, value: this.parseNestedScope(depth) };
     }
-    parseArray(lines, startIndex) {
-        const headerLine = lines[startIndex];
-        const header = this.parseArrayHeader(headerLine);
-        if (header.rawLine === '[]') {
-            return [];
+    parseNestedScope(depth) {
+        const next = this.peek();
+        if (next === null || this.depthOf(next) <= depth) {
+            return {};
         }
-        const inlineMatch = header.rawLine.match(/:\s*(.+)$/);
-        if (inlineMatch && inlineMatch[1].trim()) {
-            const valuesStr = inlineMatch[1].trim();
-            const tokens = this.parseDelimitedTokens(valuesStr, header.delimiter);
-            const values = tokens.map((token) => this.parseTokenValue(token));
-            if (this.options.strict && values.length !== header.length) {
-                throw new types_1.ToonDecodingError(`Array length mismatch: expected ${header.length}, got ${values.length}`, {
-                    lineNumber: header.lineNumber,
-                });
-            }
+        if (this.options.strict && this.depthOf(next) > depth + 1) {
+            throw new types_1.ToonDecodingError('Indentation depth jump: nested scope must start one level deeper', { lineNumber: next.lineNumber, line: next.content });
+        }
+        return this.parseObject(depth + 1);
+    }
+    parseArrayBodyAfterHeader(header, headerDepth) {
+        return this.parseArrayContent(header, headerDepth + 1);
+    }
+    parseArrayBody(header, headerDepth) {
+        this.pos++;
+        return this.parseArrayContent(header, headerDepth + 1);
+    }
+    parseArrayContent(header, contentDepth) {
+        var _a;
+        if (header.fields !== null && header.inline !== '') {
+            throw new types_1.ToonDecodingError('Content after a fields-bearing header colon', {
+                lineNumber: (_a = this.lines[this.pos - 1]) === null || _a === void 0 ? void 0 : _a.lineNumber,
+                line: header.inline,
+            });
+        }
+        if (header.fields !== null) {
+            return this.parseTabularRows(header, contentDepth);
+        }
+        if (header.inline !== '') {
+            const values = utils
+                .splitDelimited(header.inline, header.delimiter)
+                .map((token) => this.parseValueToken(token, this.lines[this.pos - 1]));
+            this.checkCount(values.length, header.length, 'inline array values');
             return values;
         }
-        const baseIndent = headerLine.indent;
-        const valueIndent = baseIndent + this.options.indent;
-        if (header.fields) {
-            return this.parseTabularArray(lines, startIndex, header);
-        }
-        const values = [];
-        let currentIndex = startIndex + 1;
-        let currentObj = null;
-        const seenKeys = new Set();
-        while (currentIndex < lines.length) {
-            const line = lines[currentIndex];
-            if (line.isEmpty) {
-                if (this.options.strict) {
-                    throw new types_1.ToonDecodingError('Blank lines not allowed in arrays in strict mode', {
-                        lineNumber: line.lineNumber,
-                    });
-                }
-                currentIndex++;
-                continue;
+        if (header.length === 0) {
+            const next = this.peek();
+            if (next === null || this.depthOf(next) < contentDepth) {
+                return [];
             }
-            if (line.indent <= baseIndent) {
-                if (currentObj !== null) {
-                    values.push(currentObj);
-                    currentObj = null;
-                }
+        }
+        return this.parseListItems(header, contentDepth);
+    }
+    parseTabularRows(header, rowDepth) {
+        const fields = header.fields;
+        const leafCount = utils.countLeafFields(fields);
+        const rows = [];
+        while (this.pos < this.lines.length) {
+            const line = this.lines[this.pos];
+            if (this.depthOf(line) !== rowDepth) {
                 break;
             }
-            if (line.indent < valueIndent) {
-                throw new types_1.ToonDecodingError(`Invalid indentation: expected ${valueIndent}, got ${line.indent}`, {
-                    lineNumber: line.lineNumber,
-                });
-            }
-            const content = line.content.trim();
-            if (this.options.strict && this.isInvalidArrayHeader(content)) {
-                throw new types_1.ToonDecodingError('Non-whitespace content between bracket segment and colon/fields: line MUST NOT be parsed as array header', { lineNumber: line.lineNumber, line: content });
-            }
-            if (/^\[\d+[\t|]?\]/.test(content) && this.isValidArrayHeader(content)) {
-                if (currentObj !== null) {
-                    values.push(currentObj);
-                    currentObj = null;
-                    seenKeys.clear();
-                }
-                const nestedArray = this.parseArray(lines, currentIndex);
-                values.push(nestedArray);
-                const arrayHeader = this.parseArrayHeader(lines[currentIndex]);
-                const inlineMatch = arrayHeader.rawLine.match(/:\s*(.+)$/);
-                if (inlineMatch && inlineMatch[1].trim()) {
-                    currentIndex++;
-                }
-                else {
-                    currentIndex = this.findNextSiblingIndex(lines, currentIndex, valueIndent);
-                }
+            const colonIndex = utils.findUnquoted(line.content, ':');
+            const delimIndex = utils.findUnquoted(line.content, header.delimiter);
+            if (colonIndex >= 0 && (delimIndex < 0 || colonIndex < delimIndex)) {
+                break;
             }
-            else if (content.includes(':')) {
-                const colonIndex = this.findUnquotedColon(content);
-                if (colonIndex > 0) {
-                    const valuePart = content.slice(colonIndex + 1).trim();
-                    const keyPart = content.slice(0, colonIndex).trim();
-                    let key;
-                    if (keyPart.startsWith('"') && keyPart.endsWith('"')) {
-                        key = utils.unescapeString(keyPart.slice(1, -1));
-                    }
-                    else {
-                        key = keyPart;
-                    }
-                    if (!valuePart) {
-                        if (currentObj !== null) {
-                            values.push(currentObj);
-                            currentObj = null;
-                            seenKeys.clear();
-                        }
-                        const obj = this.parseObject(lines, currentIndex, valueIndent);
-                        values.push(obj);
-                        currentIndex = this.findNextSiblingIndex(lines, currentIndex, valueIndent);
-                    }
-                    else {
-                        if (seenKeys.has(key)) {
-                            if (currentObj !== null) {
-                                values.push(currentObj);
-                            }
-                            currentObj = {};
-                            seenKeys.clear();
-                        }
-                        if (currentObj === null) {
-                            currentObj = {};
-                        }
-                        currentObj[key] = this.parseTokenValue(valuePart);
-                        seenKeys.add(key);
-                        currentIndex++;
+            this.checkBlankInSpan(line, rows.length);
+            const cells = utils.splitDelimited(line.content, header.delimiter);
+            this.checkWidth(cells.length, leafCount, line);
+            rows.push(this.materializeRow(cells, fields, line));
+            this.pos++;
+        }
+        this.checkCount(rows.length, header.length, 'tabular rows');
+        return rows;
+    }
+    materializeRow(cells, fields, line) {
+        let index = 0;
+        const walk = (entries) => {
+            const obj = {};
+            for (const entry of entries) {
+                if (entry.children === null) {
+                    if (index < cells.length) {
+                        utils.setDecodedKey(obj, entry.name, this.parseValueToken(cells[index], line));
                     }
+                    index++;
                 }
                 else {
-                    if (currentObj !== null) {
-                        values.push(currentObj);
-                        currentObj = null;
-                        seenKeys.clear();
-                    }
-                    values.push(this.parseTokenValue(content));
-                    currentIndex++;
+                    utils.setDecodedKey(obj, entry.name, walk(entry.children));
                 }
             }
-            else {
-                if (currentObj !== null) {
-                    values.push(currentObj);
-                    currentObj = null;
-                    seenKeys.clear();
-                }
-                values.push(this.parseTokenValue(content));
-                currentIndex++;
-            }
-        }
-        if (currentObj !== null) {
-            values.push(currentObj);
-        }
-        if (this.options.strict && values.length !== header.length) {
-            throw new types_1.ToonDecodingError(`Array length mismatch: expected ${header.length}, got ${values.length}`, {
-                lineNumber: header.lineNumber,
+            return obj;
+        };
+        return walk(fields);
+    }
+    parseKeyedTabular(header, headerDepth) {
+        this.pos++;
+        return this.parseKeyedTabularBody(header, headerDepth + 1);
+    }
+    parseKeyedTabularBody(header, entryDepth) {
+        var _a;
+        if (header.inline !== '') {
+            throw new types_1.ToonDecodingError('Content after a keyed header colon', {
+                lineNumber: (_a = this.lines[this.pos - 1]) === null || _a === void 0 ? void 0 : _a.lineNumber,
+                line: header.inline,
             });
         }
-        return values;
-    }
-    parseTabularArray(lines, startIndex, header) {
-        const rows = [];
-        let currentIndex = startIndex + 1;
-        const baseIndent = lines[startIndex].indent;
-        while (currentIndex < lines.length && rows.length < header.length) {
-            const line = lines[currentIndex];
-            if (line.isEmpty) {
+        const fields = header.fields;
+        const leafCount = utils.countLeafFields(fields);
+        const obj = {};
+        let count = 0;
+        while (this.pos < this.lines.length) {
+            const line = this.lines[this.pos];
+            if (this.depthOf(line) < entryDepth) {
+                break;
+            }
+            if (this.depthOf(line) > entryDepth) {
                 if (this.options.strict) {
-                    throw new types_1.ToonDecodingError('Blank lines not allowed in arrays in strict mode', {
+                    throw new types_1.ToonDecodingError('Over-indented line in keyed tabular scope', {
                         lineNumber: line.lineNumber,
+                        line: line.content,
                     });
                 }
-                currentIndex++;
+                this.pos++;
                 continue;
             }
-            if (line.indent <= baseIndent) {
-                break;
-            }
-            const content = line.content.trim();
-            const tokens = this.parseDelimitedTokens(content, header.delimiter);
-            if (this.options.strict && tokens.length !== header.fields.length) {
-                throw new types_1.ToonDecodingError(`Row field count mismatch: expected ${header.fields.length}, got ${tokens.length}`, {
-                    lineNumber: line.lineNumber,
-                });
-            }
-            const row = {};
-            for (let i = 0; i < header.fields.length; i++) {
-                const field = header.fields[i];
-                const value = i < tokens.length ? this.parseTokenValue(tokens[i]) : null;
-                row[field] = value;
-            }
-            rows.push(row);
-            currentIndex++;
-        }
-        return rows;
-    }
-    parseObject(lines, startIndex, expectedIndent) {
-        const obj = {};
-        let currentIndex = startIndex;
-        while (currentIndex < lines.length) {
-            const line = lines[currentIndex];
-            if (line.isEmpty) {
-                currentIndex++;
+            const colonIndex = utils.findUnquoted(line.content, ':');
+            if (colonIndex < 0) {
+                if (this.options.strict) {
+                    throw new types_1.ToonDecodingError('Line at entry depth without an unquoted colon', {
+                        lineNumber: line.lineNumber,
+                        line: line.content,
+                    });
+                }
+                this.pos++;
                 continue;
             }
-            if (currentIndex > startIndex && line.indent < expectedIndent) {
+            this.checkBlankInSpan(line, count);
+            const entryKey = this.decodeKeyToken(line.content.slice(0, colonIndex), line);
+            const rest = utils.trimSpaces(line.content.slice(colonIndex + 1));
+            const cells = rest === '' ? [] : utils.splitDelimited(rest, header.delimiter);
+            this.checkWidth(cells.length, leafCount, line);
+            this.assignKey(obj, entryKey, line);
+            utils.setDecodedKey(obj, entryKey, this.materializeRow(cells, fields, line));
+            count++;
+            this.pos++;
+        }
+        this.checkCount(count, header.length, 'keyed entry rows');
+        return obj;
+    }
+    parseListItems(header, itemDepth) {
+        const items = [];
+        while (this.pos < this.lines.length) {
+            const line = this.lines[this.pos];
+            const lineDepth = this.depthOf(line);
+            if (lineDepth < itemDepth) {
                 break;
             }
-            const content = line.content.trim();
-            if (this.options.strict && this.isInvalidArrayHeader(content)) {
-                throw new types_1.ToonDecodingError('Non-whitespace content between bracket segment and colon/fields: line MUST NOT be parsed as array header', { lineNumber: line.lineNumber, line: content });
+            if (lineDepth === itemDepth && !this.isListItemLine(line)) {
+                break;
             }
-            if (/\[\d+[\t|]?\]/.test(content) && this.isValidArrayHeader(content)) {
-                const headerMatch = content.match(/^(.*?)\[/);
-                if (headerMatch && headerMatch[1].trim()) {
-                    const header = this.parseArrayHeader(line);
-                    const array = this.parseArray(lines, currentIndex);
-                    if (header.key) {
-                        obj[header.key] = array;
-                    }
-                    currentIndex = this.findNextSiblingIndex(lines, currentIndex, expectedIndent);
-                }
-                else {
-                    currentIndex++;
+            if (lineDepth > itemDepth) {
+                if (this.options.strict) {
+                    throw new types_1.ToonDecodingError('Over-indented line in list scope', {
+                        lineNumber: line.lineNumber,
+                        line: line.content,
+                    });
                 }
+                this.pos++;
                 continue;
             }
-            const colonIndex = this.findUnquotedColon(content);
-            if (colonIndex < 0) {
-                currentIndex++;
-                continue;
-            }
-            const keyPart = content.slice(0, colonIndex).trim();
-            const valuePart = content.slice(colonIndex + 1).trim();
-            let key;
-            if (keyPart.startsWith('"') && keyPart.endsWith('"')) {
-                key = utils.unescapeString(keyPart.slice(1, -1));
-            }
-            else {
-                key = keyPart;
-            }
-            if (!valuePart) {
-                const nextLine = currentIndex + 1 < lines.length ? lines[currentIndex + 1] : null;
-                if (nextLine && !nextLine.isEmpty && nextLine.indent > line.indent) {
-                    if (/\[\d+[\t|]?\]/.test(nextLine.content.trim()) && this.isValidArrayHeader(nextLine.content.trim())) {
-                        const array = this.parseArray(lines, currentIndex + 1);
-                        obj[key] = array;
-                        currentIndex = this.findNextSiblingIndex(lines, currentIndex + 1, line.indent);
-                    }
-                    else {
-                        const nestedObj = this.parseObject(lines, currentIndex + 1, line.indent + this.options.indent);
-                        obj[key] = nestedObj;
-                        currentIndex = this.findNextSiblingIndex(lines, currentIndex + 1, line.indent);
-                    }
-                }
-                else {
-                    obj[key] = null;
-                    currentIndex++;
+            this.checkBlankInSpan(line, items.length);
+            items.push(this.withinHeaderSpan(() => this.parseListItem(line, itemDepth)));
+        }
+        this.checkCount(items.length, header.length, 'list items');
+        return items;
+    }
+    isListItemLine(line) {
+        return line.content === '-' || line.content.startsWith('- ');
+    }
+    parseListItem(line, itemDepth) {
+        if (line.content === '-') {
+            this.pos++;
+            return {};
+        }
+        const rest = line.content.slice(2);
+        if (rest === '[]') {
+            this.pos++;
+            return [];
+        }
+        const inner = {
+            content: rest,
+            indent: line.indent + 2,
+            lineNumber: line.lineNumber,
+            isEmpty: false,
+            blankBefore: false,
+        };
+        const header = this.tryParseHeader(inner);
+        if (header !== null) {
+            this.pos++;
+            if (header.key === null) {
+                if (header.fields !== null && this.options.strict) {
+                    throw new types_1.ToonDecodingError('Keyless fields-bearing header is not valid as a list item', { lineNumber: line.lineNumber, line: line.content });
                 }
+                return this.parseArrayContent(header, itemDepth + 1);
+            }
+            const obj = {};
+            utils.setDecodedKey(obj, header.key, header.keyed
+                ? this.parseKeyedTabularBody(header, itemDepth + 2)
+                : this.parseArrayContent(header, itemDepth + 2));
+            this.parseListItemRestFields(obj, itemDepth + 1);
+            return obj;
+        }
+        const colonIndex = utils.findUnquoted(rest, ':');
+        if (colonIndex >= 0) {
+            const key = this.decodeKeyToken(rest.slice(0, colonIndex), line);
+            const valuePart = utils.trimSpaces(rest.slice(colonIndex + 1));
+            this.pos++;
+            const obj = {};
+            if (valuePart === '[]') {
+                utils.setDecodedKey(obj, key, []);
+            }
+            else if (valuePart !== '') {
+                utils.setDecodedKey(obj, key, this.parseValueToken(valuePart, line));
             }
             else {
-                if (valuePart === '[]') {
-                    obj[key] = [];
-                }
-                else {
-                    obj[key] = this.parseTokenValue(valuePart);
-                }
-                currentIndex++;
+                utils.setDecodedKey(obj, key, this.parseNestedScope(itemDepth + 1));
             }
+            this.parseListItemRestFields(obj, itemDepth + 1);
+            return obj;
         }
-        return obj;
+        this.pos++;
+        return this.parseValueToken(rest, line);
     }
-    isValidArrayHeader(content) {
-        if (content === '[]')
-            return true;
-        return /^(.*?)\[(0|[1-9]\d*)([\t|])?\]\s*(?:\{[^}]+\}\s*)?:/.test(content);
-    }
-    isInvalidArrayHeader(content) {
-        return /\[\d+[\t|]?\]/.test(content) && !this.isValidArrayHeader(content);
-    }
-    findUnquotedColon(text) {
-        let inQuotes = false;
-        let escaped = false;
-        for (let i = 0; i < text.length; i++) {
-            const char = text[i];
-            if (escaped) {
-                escaped = false;
-                continue;
-            }
-            if (char === '\\') {
-                escaped = true;
-                continue;
-            }
-            if (char === '"') {
-                inQuotes = !inQuotes;
-                continue;
-            }
-            if (char === ':' && !inQuotes) {
-                return i;
+    parseListItemRestFields(obj, fieldDepth) {
+        while (this.pos < this.lines.length) {
+            const line = this.lines[this.pos];
+            if (this.depthOf(line) !== fieldDepth || this.isListItemLine(line)) {
+                break;
             }
+            this.checkBlankInSpan(line, 1);
+            const { key, value } = this.parseFieldLine(line, fieldDepth);
+            this.assignKey(obj, key, line);
+            utils.setDecodedKey(obj, key, value);
         }
-        return -1;
     }
-    findNextSiblingIndex(lines, currentIndex, expectedIndent) {
-        let index = currentIndex + 1;
-        while (index < lines.length) {
-            const line = lines[index];
-            if (line.isEmpty) {
-                index++;
-                continue;
-            }
-            if (line.indent <= expectedIndent) {
-                return index;
+    checkCount(actual, declared, what) {
+        if (this.options.strict && actual !== declared) {
+            throw new types_1.ToonDecodingError(`Count mismatch for ${what}: expected ${declared}, got ${actual}`);
+        }
+    }
+    checkWidth(actual, expected, line) {
+        if (this.options.strict && actual !== expected) {
+            throw new types_1.ToonDecodingError(`Row width mismatch: expected ${expected} cells, got ${actual}`, { lineNumber: line.lineNumber, line: line.content });
+        }
+    }
+    decodeKeyToken(token, line) {
+        const trimmed = utils.trimSpaces(token);
+        if (trimmed.startsWith('"')) {
+            const decoded = utils.tryUnescapeQuotedToken(trimmed, 'key');
+            if (decoded.error !== null) {
+                throw new types_1.ToonDecodingError(decoded.error, {
+                    lineNumber: line.lineNumber,
+                    line: line.content,
+                });
             }
-            index++;
+            return decoded.value;
         }
-        return lines.length;
+        return trimmed;
     }
-    parseTokenValue(token) {
-        token = token.trim();
-        if (token.startsWith('"') && token.endsWith('"')) {
-            return utils.unescapeString(token.slice(1, -1));
+    parseValueToken(token, line) {
+        const trimmed = utils.trimSpaces(token);
+        if (trimmed.startsWith('"')) {
+            const decoded = utils.tryUnescapeQuotedToken(trimmed, 'string');
+            if (decoded.error !== null) {
+                throw new types_1.ToonDecodingError(decoded.error, {
+                    lineNumber: line === null || line === void 0 ? void 0 : line.lineNumber,
+                    line: line === null || line === void 0 ? void 0 : line.content,
+                });
+            }
+            return decoded.value;
         }
-        return utils.parseToken(token);
+        return utils.parseToken(trimmed);
     }
     expandPaths(obj) {
         const result = {};