@unbrained/pm-cli 2026.10.15 → 2026.10.18

package/node_modules/@toon-format/toon/dist/index.mjs

@@ -294,27 +294,28 @@ function isNumericLiteral(token) {
 * strict-mode policy: callers decide how to treat `invalid` and `strictError`.
 */
 function parseArrayHeaderLine(content, defaultDelimiter) {
-	const trimmedToken = content.trimStart();
 	let bracketStart = -1;
-	if (trimmedToken.startsWith("\"")) {
-		const closingQuoteIndex = findClosingQuote(trimmedToken, 0);
+	if (content.startsWith("\"")) {
+		const closingQuoteIndex = findClosingQuote(content, 0);
 		if (closingQuoteIndex === -1) return { kind: "notHeader" };
-		if (!trimmedToken.slice(closingQuoteIndex + 1).startsWith("[")) return { kind: "notHeader" };
-		const keyEndIndex = content.length - trimmedToken.length + closingQuoteIndex + 1;
-		bracketStart = content.indexOf("[", keyEndIndex);
+		if (content[closingQuoteIndex + 1] !== "[") return { kind: "notHeader" };
+		bracketStart = closingQuoteIndex + 1;
 	} else bracketStart = findUnquotedChar(content, "[");
 	if (bracketStart === -1) return { kind: "notHeader" };
 	const firstColonIndex = findUnquotedChar(content, ":");
-	if (firstColonIndex !== -1 && firstColonIndex < bracketStart) return { kind: "notHeader" };
+	if (firstColonIndex === -1 || firstColonIndex < bracketStart) return { kind: "notHeader" };
 	const bracketEnd = findUnquotedChar(content, "]", bracketStart);
-	if (bracketEnd === -1) return { kind: "notHeader" };
+	if (bracketEnd === -1) return {
+		kind: "invalid",
+		reason: "Unterminated bracket segment"
+	};
 	let colonIndex = bracketEnd + 1;
 	let braceEnd = colonIndex;
 	const braceStart = findUnquotedChar(content, "{", bracketEnd);
 	if (braceStart !== -1 && braceStart < findUnquotedChar(content, ":", bracketEnd)) {
 		const gapBeforeBrace = content.slice(bracketEnd + 1, braceStart);
 		if (gapBeforeBrace !== "") {
-			const trimmedGap = gapBeforeBrace.trim();
+			const trimmedGap = trimWhitespace(gapBeforeBrace);
 			return {
 				kind: "invalid",
 				reason: trimmedGap === "" ? `Unexpected whitespace between bracket segment and field list` : `Unexpected content "${trimmedGap}" between bracket segment and field list`
@@ -324,11 +325,14 @@ function parseArrayHeaderLine(content, defaultDelimiter) {
 		if (foundBraceEnd !== -1) braceEnd = foundBraceEnd + 1;
 	}
 	colonIndex = findUnquotedChar(content, ":", Math.max(bracketEnd, braceEnd));
-	if (colonIndex === -1) return { kind: "notHeader" };
+	if (colonIndex === -1) return {
+		kind: "invalid",
+		reason: "Missing colon after array header"
+	};
 	const gapStart = Math.max(bracketEnd + 1, braceEnd);
 	const gapBeforeColon = content.slice(gapStart, colonIndex);
 	if (gapBeforeColon !== "") {
-		const trimmedGap = gapBeforeColon.trim();
+		const trimmedGap = trimWhitespace(gapBeforeColon);
 		return {
 			kind: "invalid",
 			reason: trimmedGap === "" ? `Unexpected whitespace between bracket segment and colon` : `Unexpected content "${trimmedGap}" between bracket segment and colon`
@@ -337,7 +341,7 @@ function parseArrayHeaderLine(content, defaultDelimiter) {
 	let key;
 	if (bracketStart > 0) {
 		const rawKey = content.slice(0, bracketStart);
-		if (rawKey !== rawKey.trimEnd()) return {
+		if (endsWithWhitespace(rawKey)) return {
 			kind: "invalid",
 			reason: "Unexpected whitespace between key and bracket segment"
 		};
@@ -426,8 +430,8 @@ function parseBracketSegment(seg, defaultDelimiter) {
 * descending into nested field groups (`field{sub1,sub2}`).
 *
 * @remarks
-* Throws on empty segments, empty names, unmatched braces, and content
-* after a nested group's closing brace; callers decide strict fallthrough.
+* Throws on empty segments, empty names, whitespace before a nested group,
+* unmatched braces, and content after a nested group's closing brace.
 */
 function parseFieldEntries(fieldsContent, delimiter) {
 	return splitFieldEntries(fieldsContent, delimiter).map((entry) => {
@@ -435,8 +439,9 @@ function parseFieldEntries(fieldsContent, delimiter) {
 		if (!trimmedEntry) throw new SyntaxError("Empty field name in field list");
 		const groupStart = findUnquotedChar(trimmedEntry, "{");
 		if (groupStart === -1) return { name: parseStringLiteral(trimmedEntry) };
-		const namePart = trimSpaces(trimmedEntry.slice(0, groupStart));
+		const namePart = trimmedEntry.slice(0, groupStart);
 		if (!namePart) throw new SyntaxError("Missing field name before nested field group");
+		if (namePart.endsWith(" ")) throw new SyntaxError("Unexpected whitespace before nested field group");
 		const groupEnd = findMatchingBrace(trimmedEntry, groupStart);
 		if (groupEnd === -1) throw new SyntaxError("Unmatched brace in field list");
 		if (groupEnd !== trimmedEntry.length - 1) throw new SyntaxError("Unexpected content after nested field group");
@@ -623,6 +628,7 @@ function parseQuotedKey(content, start) {
 	if (closingQuoteIndex === -1) throw new SyntaxError("Unterminated quoted key");
 	const key = unescapeString(content.slice(start + 1, closingQuoteIndex));
 	let parsePosition = closingQuoteIndex + 1;
+	while (content[parsePosition] === " ") parsePosition++;
 	if (parsePosition >= content.length || content[parsePosition] !== ":") throw new SyntaxError("Missing colon after key");
 	parsePosition++;
 	return {
@@ -633,16 +639,22 @@ function parseQuotedKey(content, start) {
 function parseKeyToken(content, start) {
 	return content[start] === "\"" ? parseQuotedKey(content, start) : parseUnquotedKey(content, start);
 }
+function endsWithWhitespace(value) {
+	return value.endsWith(" ") || value.endsWith("	");
+}
+function trimWhitespace(value) {
+	return value.replace(/^[ \t]+|[ \t]+$/g, "");
+}
 function isArrayHeaderContent(content) {
-	return content.trim().startsWith("[") && findUnquotedChar(content, ":") !== -1;
+	return trimSpaces(content).startsWith("[") && findUnquotedChar(content, ":") !== -1;
 }
 function isKeyValueContent(content) {
 	return findUnquotedChar(content, ":") !== -1;
 }
 //#endregion
 //#region src/decode/validation.ts
-function assertExpectedCount(actual, expected, itemType, options, line) {
-	if (options.strict && actual !== expected) throw new ToonDecodeError(`Expected ${expected} ${itemType}, but got ${actual}`, {
+function assertExpectedCount(actual, expected, itemType, line) {
+	if (actual !== expected) throw new ToonDecodeError(`Expected ${expected} ${itemType}, but got ${actual}`, {
 		line: line.lineNumber,
 		source: line.raw
 	});
@@ -659,8 +671,8 @@ function validateNoExtraTabularRows(nextLine, rowDepth, header) {
 		source: nextLine.raw
 	});
 }
-function validateNoBlankLinesInRange(startLine, endLine, blankLines, strict, context) {
-	if (!strict) return;
+function validateNoBlankLinesInRange(startLine, endLine, blankLines, context) {
+	if (startLine === void 0 || endLine === void 0) return;
 	const firstBlank = blankLines.find((blank) => blank.lineNumber > startLine && blank.lineNumber < endLine);
 	if (firstBlank) throw new ToonDecodeError(`Blank lines inside ${context} are not allowed in strict mode`, { line: firstBlank.lineNumber });
 }
@@ -690,6 +702,7 @@ function decodeStream$1(source, options) {
 }
 function* decodeDocument(reader, options) {
 	const first = yield* peekLine(reader);
+	if (first && first.depth !== 0) throw overIndentedLineError(first, 0);
 	if (!first) {
 		yield { type: "startObject" };
 		yield { type: "endObject" };
@@ -702,7 +715,7 @@ function* decodeDocument(reader, options) {
 			length: 0
 		};
 		yield { type: "endArray" };
-		yield* assertFullyConsumed(reader, options.strict);
+		yield* assertFullyConsumed(reader);
 		return;
 	}
 	if (isArrayHeaderContent(first.content)) {
@@ -710,20 +723,20 @@ function* decodeDocument(reader, options) {
 		if (headerInfo) {
 			yield* readLine(reader);
 			yield* decodeArrayFromHeader(headerInfo.header, headerInfo.inlineValues, reader, 0, options, first);
-			yield* assertFullyConsumed(reader, options.strict);
+			yield* assertFullyConsumed(reader);
 			return;
 		}
 	}
 	yield* readLine(reader);
 	const following = yield* peekLine(reader);
-	if (!(following !== void 0) && !isKeyValueLine(first)) {
+	if (!(following !== void 0) && !isKeyValueContent(first.content)) {
 		yield {
 			type: "primitive",
 			value: withLine(first, () => parsePrimitiveToken(first.content))
 		};
 		return;
 	}
-	if (!isKeyValueLine(first) && following?.depth === 0) throw new ToonDecodeError("Top-level document must start with a key-value or array-header line", {
+	if (!isKeyValueContent(first.content) && following?.depth === 0) throw new ToonDecodeError("Top-level document must start with a key-value or array-header line", {
 		line: first.lineNumber,
 		source: first.raw
 	});
@@ -733,12 +746,7 @@ function* decodeDocument(reader, options) {
 	while (true) {
 		const line = yield* peekLine(reader);
 		if (!line) break;
-		if (line.depth !== 0) {
-			if (options.strict) throw overIndentedLineError(line, 0);
-			assertNotScalarLine(line);
-			yield* readLine(reader);
-			continue;
-		}
+		if (line.depth !== 0) throw overIndentedLineError(line, 0);
 		yield* readLine(reader);
 		yield* decodeKeyValue(line, reader, 0, options, rootSeenKeys);
 	}
@@ -756,13 +764,6 @@ function overIndentedLineError(line, expectedDepth) {
 		source: line.raw
 	});
 }
-function assertNotScalarLine(line) {
-	if (line.content.startsWith("- ") || line.content === "-" || findUnquotedChar(line.content, ":") !== -1) return;
-	throw new ToonDecodeError("Unexpected bare token line outside root primitive position", {
-		line: line.lineNumber,
-		source: line.raw
-	});
-}
 function keylessKeyedError(line) {
 	return new ToonDecodeError("Keyless keyed header is only valid at the document root", {
 		line: line.lineNumber,
@@ -781,8 +782,7 @@ function keylessFieldsHeaderError(line) {
 		source: line.raw
 	});
 }
-function* assertFullyConsumed(reader, strict) {
-	if (!strict) return;
+function* assertFullyConsumed(reader) {
 	const line = yield* peekLine(reader);
 	if (line) throw new ToonDecodeError("Unexpected content after the document root", {
 		line: line.lineNumber,
@@ -809,7 +809,7 @@ function* decodeKeyValue(line, reader, baseDepth, options, seenKeys) {
 		yield* decodeArrayFromHeader(arrayHeader.header, arrayHeader.inlineValues, reader, baseDepth, options, line);
 		return;
 	}
-	if (arrayHeader && arrayHeader.header.key === void 0 && options.strict) throw arrayHeader.header.keyed ? keylessKeyedError(line) : keylessHeaderError(line);
+	if (arrayHeader && arrayHeader.header.key === void 0) throw arrayHeader.header.keyed ? keylessKeyedError(line) : keylessHeaderError(line);
 	const { key, end } = withLine(line, () => parseKeyToken(content, 0));
 	const rest = trimSpaces(content.slice(end));
 	assertNoDuplicateKey(key, line, seenKeys);
@@ -849,17 +849,18 @@ function* decodeObjectFields(reader, baseDepth, options) {
 	while (true) {
 		const line = yield* peekLine(reader);
 		if (!line || line.depth < baseDepth) break;
-		if (computedDepth === void 0 && line.depth >= baseDepth) computedDepth = line.depth;
-		if (line.depth === computedDepth) {
-			yield* readLine(reader);
-			yield* decodeKeyValue(line, reader, computedDepth, options, seenKeys);
-		} else if (computedDepth !== void 0 && line.depth > computedDepth) {
-			if (options.strict) throw overIndentedLineError(line, computedDepth);
-			assertNotScalarLine(line);
-			yield* readLine(reader);
-		} else break;
+		computedDepth ??= line.depth;
+		if (line.depth !== computedDepth) throw overIndentedLineError(line, computedDepth);
+		yield* readLine(reader);
+		yield* decodeKeyValue(line, reader, computedDepth, options, seenKeys);
 	}
 }
+function* scopeContentDepth(reader, baseDepth, strict) {
+	const first = yield* peekLine(reader);
+	if (!first || first.depth <= baseDepth + 1) return baseDepth + 1;
+	assertNoDepthJump(first, baseDepth, strict);
+	return first.depth;
+}
 function* decodeArrayFromHeader(header, inlineValues, reader, baseDepth, options, headerLine) {
 	if (header.keyed) {
 		yield* decodeKeyedObject(header, reader, baseDepth, options, headerLine);
@@ -883,20 +884,16 @@ function* decodeArrayFromHeader(header, inlineValues, reader, baseDepth, options
 	yield { type: "endArray" };
 }
 function* decodeInlinePrimitiveArray(header, inlineValues, options, headerLine) {
-	if (!trimSpaces(inlineValues)) {
-		assertExpectedCount(0, header.length, "inline-form values", options, headerLine);
-		return;
-	}
 	const values = withLine(headerLine, () => parseDelimitedValues(inlineValues, header.delimiter));
 	const primitives = withLine(headerLine, () => mapRowValuesToPrimitives(values));
-	assertExpectedCount(primitives.length, header.length, "inline-form values", options, headerLine);
+	if (options.strict) assertExpectedCount(primitives.length, header.length, "inline-form values", headerLine);
 	for (const primitive of primitives) yield {
 		type: "primitive",
 		value: primitive
 	};
 }
 function* decodeKeyedObject(header, reader, baseDepth, options, headerLine) {
-	const entryDepth = baseDepth + 1;
+	const entryDepth = yield* scopeContentDepth(reader, baseDepth, options.strict);
 	const leafFieldCount = countLeafFields(header.fields);
 	const seenEntryKeys = options.strict ? /* @__PURE__ */ new Set() : void 0;
 	let entryCount = 0;
@@ -907,22 +904,11 @@ function* decodeKeyedObject(header, reader, baseDepth, options, headerLine) {
 	while (true) {
 		const line = yield* peekLine(reader);
 		if (!line || line.depth <= baseDepth) break;
-		if (line.depth > entryDepth) {
-			if (options.strict) throw new ToonDecodeError("Unexpected indentation inside keyed tabular object", {
-				line: line.lineNumber,
-				source: line.raw
-			});
-			yield* readLine(reader);
-			continue;
-		}
-		if (findUnquotedChar(line.content, ":") === -1) {
-			if (options.strict) throw new ToonDecodeError("Expected entry row inside keyed tabular object", {
-				line: line.lineNumber,
-				source: line.raw
-			});
-			yield* readLine(reader);
-			continue;
-		}
+		if (line.depth !== entryDepth) throw overIndentedLineError(line, entryDepth);
+		if (findUnquotedChar(line.content, ":") === -1) throw new ToonDecodeError("Expected entry row inside keyed tabular object", {
+			line: line.lineNumber,
+			source: line.raw
+		});
 		yield* readLine(reader);
 		if (startLine === void 0) startLine = line.lineNumber;
 		endLine = line.lineNumber;
@@ -935,67 +921,71 @@ function* decodeKeyedObject(header, reader, baseDepth, options, headerLine) {
 		};
 		const cellsContent = trimSpaces(line.content.slice(end));
 		const values = cellsContent === "" ? [] : withLine(line, () => parseDelimitedValues(cellsContent, header.delimiter));
-		assertExpectedCount(values.length, leafFieldCount, "keyed entry cells", options, line);
+		assertExpectedCount(values.length, leafFieldCount, "keyed entry cells", line);
 		const primitives = withLine(line, () => mapRowValuesToPrimitives(values));
 		yield* yieldObjectFromFields(header.fields, primitives);
 		entryCount++;
 	}
-	assertExpectedCount(entryCount, header.length, "keyed entries", options, lastEntryLine);
-	if (options.strict && startLine !== void 0 && endLine !== void 0) validateNoBlankLinesInRange(startLine, endLine, reader.scanState.blankLines, options.strict, "keyed tabular object");
+	if (options.strict) {
+		assertExpectedCount(entryCount, header.length, "keyed entries", lastEntryLine);
+		validateNoBlankLinesInRange(startLine, endLine, reader.scanState.blankLines, "keyed tabular object");
+	}
 	yield { type: "endObject" };
 }
 function* decodeTabularArray(header, reader, baseDepth, options, headerLine) {
-	const rowDepth = baseDepth + 1;
+	const rowDepth = yield* scopeContentDepth(reader, baseDepth, options.strict);
 	let rowCount = 0;
 	let startLine;
 	let endLine;
 	let lastRowLine = headerLine;
 	while (!options.strict || rowCount < header.length) {
 		const line = yield* peekLine(reader);
-		if (!line || line.depth < rowDepth) break;
-		if (line.depth === rowDepth) {
-			if (!isDataRow(line.content, header.delimiter)) break;
-			if (startLine === void 0) startLine = line.lineNumber;
-			endLine = line.lineNumber;
-			lastRowLine = line;
-			yield* readLine(reader);
-			const values = withLine(line, () => parseDelimitedValues(line.content, header.delimiter));
-			assertExpectedCount(values.length, countLeafFields(header.fields), "tabular row values", options, line);
-			const primitives = withLine(line, () => mapRowValuesToPrimitives(values));
-			yield* yieldObjectFromFields(header.fields, primitives);
-			rowCount++;
-		} else break;
+		if (!line || line.depth <= baseDepth) break;
+		if (line.depth !== rowDepth) throw overIndentedLineError(line, rowDepth);
+		if (!isDataRow(line.content, header.delimiter)) break;
+		if (startLine === void 0) startLine = line.lineNumber;
+		endLine = line.lineNumber;
+		lastRowLine = line;
+		yield* readLine(reader);
+		const values = withLine(line, () => parseDelimitedValues(line.content, header.delimiter));
+		assertExpectedCount(values.length, countLeafFields(header.fields), "tabular row values", line);
+		const primitives = withLine(line, () => mapRowValuesToPrimitives(values));
+		yield* yieldObjectFromFields(header.fields, primitives);
+		rowCount++;
+	}
+	if (options.strict) {
+		assertExpectedCount(rowCount, header.length, "tabular rows", lastRowLine);
+		validateNoBlankLinesInRange(startLine, endLine, reader.scanState.blankLines, "tabular array");
+		validateNoExtraTabularRows(yield* peekLine(reader), rowDepth, header);
 	}
-	assertExpectedCount(rowCount, header.length, "tabular rows", options, lastRowLine);
-	if (options.strict && startLine !== void 0 && endLine !== void 0) validateNoBlankLinesInRange(startLine, endLine, reader.scanState.blankLines, options.strict, "tabular array");
-	if (options.strict) validateNoExtraTabularRows(yield* peekLine(reader), rowDepth, header);
 }
 function* decodeListArray(header, reader, baseDepth, options, headerLine) {
-	const itemDepth = baseDepth + 1;
+	const itemDepth = yield* scopeContentDepth(reader, baseDepth, options.strict);
 	let itemCount = 0;
 	let startLine;
 	let endLine;
 	let lastItemLine = headerLine;
 	while (!options.strict || itemCount < header.length) {
 		const line = yield* peekLine(reader);
-		if (!line || line.depth < itemDepth) break;
-		const isListItem = line.content.startsWith("- ") || line.content === "-";
-		if (line.depth === itemDepth && isListItem) {
-			if (startLine === void 0) startLine = line.lineNumber;
-			endLine = line.lineNumber;
-			lastItemLine = line;
-			yield* decodeListItem(reader, itemDepth, options);
-			const lastConsumedLine = reader.lastLine;
-			if (lastConsumedLine) {
-				endLine = lastConsumedLine.lineNumber;
-				lastItemLine = lastConsumedLine;
-			}
-			itemCount++;
-		} else break;
+		if (!line || line.depth <= baseDepth) break;
+		if (line.depth !== itemDepth) throw overIndentedLineError(line, itemDepth);
+		if (!(line.content.startsWith("- ") || line.content === "-")) break;
+		if (startLine === void 0) startLine = line.lineNumber;
+		endLine = line.lineNumber;
+		lastItemLine = line;
+		yield* decodeListItem(reader, itemDepth, options);
+		const lastConsumedLine = reader.lastLine;
+		if (lastConsumedLine) {
+			endLine = lastConsumedLine.lineNumber;
+			lastItemLine = lastConsumedLine;
+		}
+		itemCount++;
+	}
+	if (options.strict) {
+		assertExpectedCount(itemCount, header.length, "list-form items", lastItemLine);
+		validateNoBlankLinesInRange(startLine, endLine, reader.scanState.blankLines, "list-form array");
+		validateNoExtraListItems(yield* peekLine(reader), itemDepth, header.length);
 	}
-	assertExpectedCount(itemCount, header.length, "list-form items", options, lastItemLine);
-	if (options.strict && startLine !== void 0 && endLine !== void 0) validateNoBlankLinesInRange(startLine, endLine, reader.scanState.blankLines, options.strict, "list-form array");
-	if (options.strict) validateNoExtraListItems(yield* peekLine(reader), itemDepth, header.length);
 }
 function* decodeListItem(reader, baseDepth, options) {
 	const line = yield* readLine(reader);
@@ -1005,7 +995,7 @@ function* decodeListItem(reader, baseDepth, options) {
 		yield { type: "startObject" };
 		yield { type: "endObject" };
 		return;
-	} else if (line.content.startsWith("- ")) afterHyphen = line.content.slice(2);
+	} else if (line.content.startsWith("- ")) afterHyphen = line.content.slice(2).replace(/^ +/, "");
 	else throw new ToonDecodeError(`Expected list item to start with "- "`, {
 		line: line.lineNumber,
 		source: line.raw
@@ -1029,9 +1019,8 @@ function* decodeListItem(reader, baseDepth, options) {
 	};
 	if (isArrayHeaderContent(afterHyphen)) {
 		const arrayHeader = withLine(itemLine, () => resolveArrayHeader(parseArrayHeaderLine(afterHyphen, DEFAULT_DELIMITER), options.strict));
-		if (arrayHeader) if (arrayHeader.header.keyed || arrayHeader.header.fields !== void 0) {
-			if (options.strict) throw arrayHeader.header.keyed ? keylessKeyedError(itemLine) : keylessFieldsHeaderError(itemLine);
-		} else {
+		if (arrayHeader) {
+			if (arrayHeader.header.keyed || arrayHeader.header.fields !== void 0) throw arrayHeader.header.keyed ? keylessKeyedError(itemLine) : keylessFieldsHeaderError(itemLine);
 			yield* decodeArrayFromHeader(arrayHeader.header, arrayHeader.inlineValues, reader, baseDepth, options, itemLine);
 			return;
 		}
@@ -1067,26 +1056,14 @@ function* followSiblingFields(reader, followDepth, options, seenKeys) {
 	while (true) {
 		const nextLine = yield* peekLine(reader);
 		if (!nextLine || nextLine.depth < followDepth) break;
-		if (nextLine.depth === followDepth && !nextLine.content.startsWith("- ")) {
-			yield* readLine(reader);
-			yield* decodeKeyValue(nextLine, reader, followDepth, options, seenKeys);
-		} else break;
+		if (nextLine.depth !== followDepth) throw overIndentedLineError(nextLine, followDepth);
+		yield* readLine(reader);
+		yield* decodeKeyValue(nextLine, reader, followDepth, options, seenKeys);
 	}
 }
-function isKeyValueLine(line) {
-	const content = line.content;
-	if (content.startsWith("\"")) {
-		const closingQuoteIndex = findClosingQuote(content, 0);
-		if (closingQuoteIndex === -1) return false;
-		return content.slice(closingQuoteIndex + 1).includes(":");
-	} else return content.includes(":");
-}
 function resolveArrayHeader(result, strict) {
 	if (result.kind === "notHeader") return;
-	if (result.kind === "invalid") {
-		if (strict) throw new SyntaxError(result.reason);
-		return;
-	}
+	if (result.kind === "invalid") throw new SyntaxError(result.reason);
 	if (strict && result.strictError !== void 0) throw new SyntaxError(result.strictError);
 	return {
 		header: result.header,
@@ -1098,7 +1075,6 @@ function* yieldObjectFromFields(fields, primitives) {
 	function* walkFieldGroup(nodes) {
 		yield { type: "startObject" };
 		for (const node of nodes) {
-			if (!node.children && cellIndex >= primitives.length) continue;
 			yield {
 				type: "key",
 				key: node.name
@@ -1209,17 +1185,15 @@ function applyEvent(state, event) {
 			parent.currentKey = event.key;
 			break;
 		}
-		case "primitive":
-			if (stack.length === 0) state.root = event.value;
-			else {
-				const parent = stack[stack.length - 1];
-				if (parent.type === "object") {
-					if (parent.currentKey === void 0) throw new Error("Primitive event without preceding key in object");
-					setOwnProperty(parent.obj, parent.currentKey, event.value);
-					parent.currentKey = void 0;
-				} else if (parent.type === "array") parent.arr.push(event.value);
-			}
-			break;
+		case "primitive": if (stack.length === 0) state.root = event.value;
+		else {
+			const parent = stack[stack.length - 1];
+			if (parent.type === "object") {
+				if (parent.currentKey === void 0) throw new Error("Primitive event without preceding key in object");
+				setOwnProperty(parent.obj, parent.currentKey, event.value);
+				parent.currentKey = void 0;
+			} else if (parent.type === "array") parent.arr.push(event.value);
+		}
 	}
 }
 function finalizeState(state) {
@@ -1290,7 +1264,7 @@ function normalizeValue(value) {
 		return value.toString();
 	}
 	if (value instanceof Date) return value.toISOString();
-	if (Array.isArray(value)) return value.map(normalizeValue);
+	if (Array.isArray(value)) return Array.from(value, normalizeValue);
 	if (value instanceof Set) return Array.from(value).map(normalizeValue);
 	if (value instanceof Map) return Object.fromEntries(Array.from(value, ([k, v]) => [String(k), normalizeValue(v)]));
 	if (isPlainObject(value)) {
@@ -1363,21 +1337,7 @@ function assertValidDelimiter(delimiter) {
 function isValidUnquotedKey(key) {
 	return /^[A-Z_][\w.]*$/i.test(key);
 }
-/**
-* Determines if a string value can be safely encoded without quotes.
-*
-* @remarks
-* A string needs quoting if it:
-* - Is empty
-* - Has leading or trailing whitespace
-* - Could be confused with a literal (boolean, null, number)
-* - Contains structural characters (colons, brackets, braces)
-* - Contains quotes or backslashes (need escaping)
-* - Contains control characters (newlines, tabs, etc.)
-* - Contains the active delimiter
-* - Starts with a list marker (hyphen)
-* - Starts with a comment marker (#)
-*/
+/** Determines if a string value can be safely encoded without quotes. */
 function isSafeUnquoted(value, delimiter = DEFAULT_DELIMITER) {
 	if (!value) return false;
 	if (/^[ \t]|[ \t]$/.test(value)) return false;
@@ -1481,7 +1441,7 @@ function collectLeafValues(row, fields, leaves) {
 //#region src/encode/encoders.ts
 function* encodeJsonValue(value, options, depth) {
 	if (isEncodablePrimitive(value)) {
-		const encodedPrimitive = encodePrimitive(value, options.delimiter);
+		const encodedPrimitive = typeof value === "string" && value.startsWith("") ? `"${escapeString(value)}"` : encodePrimitive(value, options.delimiter);
 		if (encodedPrimitive !== "") yield encodedPrimitive;
 		return;
 	}
@@ -1626,13 +1586,14 @@ function* encodeObjectAsListItemLines(obj, depth, options) {
 	}
 	const encodedKey = encodeKey(firstKey);
 	if (isEncodablePrimitive(firstValue)) yield indentedListItem(depth, `${encodedKey}: ${encodePrimitive(firstValue, options.delimiter)}`, options.indentSize);
-	else if (isJsonArray(firstValue)) if (firstValue.length === 0) yield indentedListItem(depth, `${encodedKey}: []`, options.indentSize);
-	else if (isArrayOfPrimitives(firstValue)) yield indentedListItem(depth, `${encodedKey}${encodeInlineArrayLine(firstValue, options.delimiter)}`, options.indentSize);
-	else {
-		yield indentedListItem(depth, `${encodedKey}${formatHeader(firstValue.length, { delimiter: options.delimiter })}`, options.indentSize);
-		for (const item of firstValue) yield* encodeListItemValueLines(item, depth + 2, options);
-	}
-	else if (isJsonObject(firstValue)) {
+	else if (isJsonArray(firstValue)) {
+		if (firstValue.length === 0) yield indentedListItem(depth, `${encodedKey}: []`, options.indentSize);
+		else if (isArrayOfPrimitives(firstValue)) yield indentedListItem(depth, `${encodedKey}${encodeInlineArrayLine(firstValue, options.delimiter)}`, options.indentSize);
+		else {
+			yield indentedListItem(depth, `${encodedKey}${formatHeader(firstValue.length, { delimiter: options.delimiter })}`, options.indentSize);
+			for (const item of firstValue) yield* encodeListItemValueLines(item, depth + 2, options);
+		}
+	} else if (isJsonObject(firstValue)) {
 		yield indentedListItem(depth, `${encodedKey}:`, options.indentSize);
 		if (!isEmptyObject(firstValue)) yield* encodeObjectLines(firstValue, depth + 2, options);
 	}
@@ -1640,12 +1601,13 @@ function* encodeObjectAsListItemLines(obj, depth, options) {
 }
 function* encodeListItemValueLines(value, depth, options) {
 	if (isEncodablePrimitive(value)) yield indentedListItem(depth, encodePrimitive(value, options.delimiter), options.indentSize);
-	else if (isJsonArray(value)) if (isArrayOfPrimitives(value)) yield indentedListItem(depth, encodeInlineArrayLine(value, options.delimiter), options.indentSize);
-	else {
-		yield indentedListItem(depth, formatHeader(value.length, { delimiter: options.delimiter }), options.indentSize);
-		for (const item of value) yield* encodeListItemValueLines(item, depth + 1, options);
-	}
-	else if (isJsonObject(value)) yield* encodeObjectAsListItemLines(value, depth, options);
+	else if (isJsonArray(value)) {
+		if (isArrayOfPrimitives(value)) yield indentedListItem(depth, encodeInlineArrayLine(value, options.delimiter), options.indentSize);
+		else {
+			yield indentedListItem(depth, formatHeader(value.length, { delimiter: options.delimiter }), options.indentSize);
+			for (const item of value) yield* encodeListItemValueLines(item, depth + 1, options);
+		}
+	} else if (isJsonObject(value)) yield* encodeObjectAsListItemLines(value, depth, options);
 }
 function indentedLine(depth, content, indentSize) {
 	return " ".repeat(indentSize * depth) + content;
@@ -1707,10 +1669,6 @@ function transformArray(arr, replacer, path) {
 /**
 * Encodes a JavaScript value into TOON format string.
 *
-* @param input Any JavaScript value (objects, arrays, primitives)
-* @param options Optional encoding configuration
-* @returns TOON formatted string
-*
 * @example
 * ```ts
 * encode({ name: 'Ada', age: 30 })
@@ -1734,10 +1692,6 @@ function encode(input, options) {
 /**
 * Decodes a TOON format string into a JavaScript value.
 *
-* @param input TOON formatted string
-* @param options Optional decoding configuration
-* @returns Parsed JavaScript value (object, array, or primitive)
-*
 * @example
 * ```ts
 * decode('name: Ada\nage: 30')
@@ -1761,10 +1715,6 @@ function decode(input, options) {
 * This function yields TOON lines one at a time without building the full string,
 * making it suitable for streaming large outputs to files, HTTP responses, or process stdout.
 *
-* @param input Any JavaScript value (objects, arrays, primitives)
-* @param options Optional encoding configuration
-* @returns Iterable of TOON lines (without trailing newlines)
-*
 * @example
 * ```ts
 * // Stream to stdout
@@ -1790,10 +1740,6 @@ function encodeLines(input, options) {
 * Convenience wrapper around the streaming decoder that builds the full
 * value in memory.
 *
-* @param lines Iterable of TOON lines (without newlines)
-* @param options Optional decoding configuration
-* @returns Parsed JavaScript value (object, array, or primitive)
-*
 * @example
 * ```ts
 * const lines = ['name: Ada', 'age: 30']
@@ -1802,7 +1748,7 @@ function encodeLines(input, options) {
 * ```
 */
 function decodeFromLines(lines, options) {
-	return buildValueFromEvents(decodeStreamSync$1(lines, resolveDecodeOptions(options)));
+	return buildValueFromEvents(decodeStreamSync$1(lines, options));
 }
 /**
 * Synchronously decodes TOON lines into a stream of JSON events.
@@ -1810,10 +1756,6 @@ function decodeFromLines(lines, options) {
 * Yields structured events (startObject, endObject, startArray, endArray, key,
 * primitive) that represent the JSON data model without building the full value tree.
 *
-* @param lines Iterable of TOON lines (without newlines)
-* @param options Optional decoding configuration
-* @returns Iterable of JSON stream events
-*
 * @example
 * ```ts
 * const lines = ['name: Ada', 'age: 30']
@@ -1836,10 +1778,6 @@ function decodeStreamSync(lines, options) {
 * primitive) that represent the JSON data model without building the full value tree.
 * Supports both sync and async iterables.
 *
-* @param source Async or sync iterable of TOON lines (without newlines)
-* @param options Optional decoding configuration
-* @returns Async iterable of JSON stream events
-*
 * @example
 * ```ts
 * const fileStream = createReadStream('data.toon', 'utf-8')
@@ -1866,11 +1804,5 @@ function resolveOptions(options) {
 		replacer: options?.replacer
 	};
 }
-function resolveDecodeOptions(options) {
-	return {
-		indentSize: options?.indentSize ?? options?.indent ?? 2,
-		strict: options?.strict ?? true
-	};
-}
 //#endregion
 export { DEFAULT_DELIMITER, DELIMITERS, ToonDecodeError, decode, decodeFromLines, decodeStream, decodeStreamSync, encode, encodeLines, escapeString, rawString };