@effected/yaml 0.1.0

package/internal/composer/block.js

@@ -0,0 +1,1155 @@
+import { YamlMap, YamlPair, YamlScalar, YamlSeq } from "../../YamlNode.js";
+import { checkAnchorOnAlias, getAnchorName, makeAlias, registerAnchor } from "./anchors.js";
+import { enterNesting, exitNesting, hasMeta, hasNonWhitespaceBeforeOnLine, lineCol, lineIndentColumn, sameLine } from "./state.js";
+import { blockMapStartsWithValueSep, classifyPlainNumeric, collectMultilineKey, collectMultilinePlainScalar, findFirstContent, findLastContent, findNextContentInList, findNextSignificantChild, findValueSepOffset, getScalarStyle, hasValueSepAfterInList, hasValueSepBetween, hasValueSepThroughPlainScalars, makeScalar, resolveScalar, shouldPreserveRaw } from "./scalars.js";
+
+//#region src/internal/composer/block.ts
+/**
+* Compose a block map from its CST children, with an optional external first key.
+*
+* CST pattern for `a: 1, b: true`:
+*   `[flow-scalar("a"), block-map(children: [":"," ","1","\\n","b",":"," ","true"])]`
+*
+* The first key is external (sibling before block-map in document/parent).
+* Subsequent keys are inside the block-map children.
+*/
+function composeBlockMap(blockMapCst, state, externalFirstKey, meta) {
+	if (!enterNesting(state, blockMapCst)) return new YamlMap({
+		items: [],
+		style: "block",
+		offset: blockMapCst.offset,
+		length: blockMapCst.length
+	});
+	try {
+		return composeBlockMapInner(blockMapCst, state, externalFirstKey, meta);
+	} finally {
+		exitNesting(state);
+	}
+}
+function composeBlockMapInner(blockMapCst, state, externalFirstKey, meta) {
+	const children = blockMapCst.children ?? [];
+	const pairs = [];
+	const extKeyOffset = externalFirstKey && "offset" in externalFirstKey ? externalFirstKey.offset : void 0;
+	const items = flattenBlockMapChildren(children, state, extKeyOffset !== void 0 ? lineIndentColumn(state.text, extKeyOffset) : void 0, extKeyOffset);
+	if (externalFirstKey) items.unshift({
+		kind: "key",
+		node: externalFirstKey
+	});
+	buildPairs(items, pairs, state.text);
+	if (state.options.uniqueKeys) checkDuplicateKeys(pairs, state);
+	checkMultilineImplicitKeys(pairs, state);
+	const offset = externalFirstKey ? "offset" in externalFirstKey ? externalFirstKey.offset : blockMapCst.offset : blockMapCst.offset;
+	const map = new YamlMap({
+		items: pairs,
+		style: "block",
+		offset,
+		length: blockMapCst.offset + blockMapCst.length - offset,
+		...meta?.tag !== void 0 ? { tag: meta.tag } : {},
+		...meta?.anchor !== void 0 ? { anchor: meta.anchor } : {},
+		...meta?.comment !== void 0 ? { comment: meta.comment } : {}
+	});
+	if (meta?.anchor) registerAnchor(map, meta.anchor, state, offset);
+	return map;
+}
+function flattenBlockMapChildren(children, state, externalKeyColumn, externalKeyOffset) {
+	const items = [];
+	let pendingMeta = {};
+	let outerMeta = {};
+	let sawNewlineSincePending = false;
+	let afterValueSep = false;
+	let lastValueSepOffset = -1;
+	let lastKeyColumn = externalKeyColumn ?? -1;
+	let lastKeyOffset = externalKeyOffset ?? -1;
+	const hasExternalKeyColumn = externalKeyColumn !== void 0;
+	let pendingExplicitKeyCol = -1;
+	function commitOuterIfNewlineSeen() {
+		if (sawNewlineSincePending && hasMeta(pendingMeta)) {
+			outerMeta = hasMeta(outerMeta) ? {
+				...outerMeta,
+				...pendingMeta
+			} : pendingMeta;
+			pendingMeta = {};
+		}
+		sawNewlineSincePending = false;
+	}
+	function combinedPending() {
+		if (!hasMeta(outerMeta)) return pendingMeta;
+		if (!hasMeta(pendingMeta)) return outerMeta;
+		return {
+			...outerMeta,
+			...pendingMeta
+		};
+	}
+	function resetAllMeta() {
+		pendingMeta = {};
+		outerMeta = {};
+		sawNewlineSincePending = false;
+	}
+	function validateKeyColumn(col, offset, length) {
+		if (lastKeyColumn >= 0 && col !== lastKeyColumn) state.errors.push({
+			code: "InvalidIndentation",
+			message: "Bad indentation in block mapping",
+			offset,
+			length
+		});
+	}
+	function pushNode(node, nodeOffset) {
+		if (!afterValueSep && nodeOffset !== void 0 && nodeOffset >= 0) {
+			lastKeyColumn = pendingExplicitKeyCol >= 0 ? pendingExplicitKeyCol : lineCol(state.text, nodeOffset).column;
+			lastKeyOffset = nodeOffset;
+		}
+		pendingExplicitKeyCol = -1;
+		items.push({
+			kind: "node",
+			node
+		});
+		afterValueSep = false;
+	}
+	for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		if (!child) continue;
+		if (child.type === "error") {
+			state.errors.push({
+				code: "UnexpectedToken",
+				message: `Unexpected content: ${child.source.trim() || "(empty)"}`,
+				offset: child.offset,
+				length: child.length
+			});
+			continue;
+		}
+		if (child.type === "newline") {
+			if (hasMeta(pendingMeta)) sawNewlineSincePending = true;
+			continue;
+		}
+		if (child.type === "whitespace") {
+			if (child.source === "?") {
+				const qCol = lineCol(state.text, child.offset).column;
+				pendingExplicitKeyCol = qCol;
+				afterValueSep = false;
+				const lookahead = scanExplicitKeyShape(children, i, qCol, state.text);
+				if (lookahead.kind === "inline-implicit-map") {
+					const sliceChildren = children.slice(i + 1, lookahead.endIdx);
+					const innerItems = flattenBlockMapChildren(sliceChildren, state);
+					const innerPairs = [];
+					buildPairs(innerItems, innerPairs, state.text);
+					const firstC = findFirstContent(sliceChildren);
+					const lastC = findLastContent(sliceChildren);
+					const innerOffset = firstC ? firstC.offset : child.offset;
+					pushNode(new YamlMap({
+						items: innerPairs,
+						style: "block",
+						offset: innerOffset,
+						length: (lastC ? lastC.offset + lastC.length : child.offset + child.length) - innerOffset
+					}), innerOffset);
+					i = lookahead.endIdx - 1;
+					continue;
+				}
+				continue;
+			}
+			if (child.source === ":") {
+				validateNoTabAfterContinuationValueSep(child, children, i, state);
+				const flushMeta = combinedPending();
+				if (hasMeta(flushMeta)) {
+					const scalar = new YamlScalar({
+						value: resolveScalar("", "plain", flushMeta.tag, state),
+						style: "plain",
+						offset: child.offset,
+						length: 0,
+						...flushMeta.tag !== void 0 ? { tag: flushMeta.tag } : {},
+						...flushMeta.anchor !== void 0 ? { anchor: flushMeta.anchor } : {}
+					});
+					if (flushMeta.anchor) registerAnchor(scalar, flushMeta.anchor, state, child.offset);
+					resetAllMeta();
+					pushNode(scalar);
+				}
+				items.push({
+					kind: "value-sep",
+					offset: child.offset
+				});
+				afterValueSep = true;
+				lastValueSepOffset = child.offset;
+			}
+			if (child.source === "-" && lastValueSepOffset >= 0 && sameLine(state.text, lastValueSepOffset, child.offset) && hasNonWhitespaceBeforeOnLine(state.text, lastValueSepOffset)) state.errors.push({
+				code: "UnexpectedToken",
+				message: "Sequence entry on same line as mapping value indicator",
+				offset: child.offset,
+				length: child.length
+			});
+			else if (child.source === "-" && lastValueSepOffset >= 0 && !sameLine(state.text, lastValueSepOffset, child.offset) && pendingExplicitKeyCol < 0 && !precededByExplicitKeyMarker(children, i)) state.errors.push({
+				code: "InvalidIndentation",
+				message: "Block sequence entry indicator outside any sequence",
+				offset: child.offset,
+				length: child.length
+			});
+			continue;
+		}
+		if (child.type === "comment") {
+			const text = child.source.startsWith("#") ? child.source.slice(1).trim() : child.source;
+			items.push({
+				kind: "comment",
+				comment: text
+			});
+			continue;
+		}
+		if (child.type === "anchor") {
+			validatePropertyContinuationColumn(child, state, afterValueSep, lastValueSepOffset, lastKeyColumn);
+			commitOuterIfNewlineSeen();
+			pendingMeta.anchor = getAnchorName(child, state.text);
+			continue;
+		}
+		if (child.type === "tag") {
+			validatePropertyContinuationColumn(child, state, afterValueSep, lastValueSepOffset, lastKeyColumn);
+			commitOuterIfNewlineSeen();
+			pendingMeta.tag = child.source;
+			continue;
+		}
+		if (child.type === "flow-scalar" || child.type === "block-scalar") {
+			commitOuterIfNewlineSeen();
+			validateNoDoubleAnchorOnScalar(child, children, i, outerMeta, pendingMeta, state);
+			const valueSepOffset = findValueSepOffset(children, i + 1);
+			const sepOnSameLine = valueSepOffset >= 0 && lineCol(state.text, child.offset).line === lineCol(state.text, valueSepOffset).line;
+			if (afterValueSep && sepOnSameLine) {
+				const flushMeta = combinedPending();
+				if (hasMeta(flushMeta)) {
+					const scalar = new YamlScalar({
+						value: resolveScalar("", "plain", flushMeta.tag, state),
+						style: "plain",
+						offset: child.offset,
+						length: 0,
+						...flushMeta.tag !== void 0 ? { tag: flushMeta.tag } : {},
+						...flushMeta.anchor !== void 0 ? { anchor: flushMeta.anchor } : {}
+					});
+					if (flushMeta.anchor) registerAnchor(scalar, flushMeta.anchor, state, child.offset);
+					resetAllMeta();
+					pushNode(scalar);
+				}
+			}
+			const nextValueSepOffset = findValueSepOffset(children, i + 1);
+			if (afterValueSep && lastValueSepOffset >= 0 && hasNonWhitespaceBeforeOnLine(state.text, lastValueSepOffset) && child.type === "flow-scalar" && nextValueSepOffset >= 0 && sameLine(state.text, lastValueSepOffset, child.offset) && sameLine(state.text, child.offset, nextValueSepOffset)) state.errors.push({
+				code: "UnexpectedToken",
+				message: "Implicit mapping key on same line as previous value indicator",
+				offset: child.offset,
+				length: child.length
+			});
+			const nextContent = findNextContentInList(children, i + 1);
+			if (nextContent?.node.type === "block-map" && !hasValueSepBetween(children, i + 1, nextContent.idx)) {
+				if (!afterValueSep && hasExternalKeyColumn) validateKeyColumn(pendingExplicitKeyCol >= 0 ? pendingExplicitKeyCol : lineCol(state.text, child.offset).column, child.offset, child.length);
+				const keyMeta = hasMeta(pendingMeta) ? pendingMeta : void 0;
+				const mapMeta = hasMeta(outerMeta) ? outerMeta : void 0;
+				const key = makeScalar(child, state, keyMeta);
+				const map = composeBlockMap(nextContent.node, state, key, mapMeta);
+				resetAllMeta();
+				pushNode(map);
+				i = nextContent.idx;
+				continue;
+			}
+			if (!afterValueSep && child.type === "flow-scalar" && getScalarStyle(child) === "plain" && !hasValueSepAfterInList(children, i + 1) && hasValueSepThroughPlainScalars(children, i + 1)) {
+				let isExplicitKey = false;
+				let explicitKeyCol = -1;
+				for (let p = i - 1; p >= 0; p--) {
+					const prev = children[p];
+					if (!prev) continue;
+					if (prev.type === "whitespace" && prev.source === "?") {
+						explicitKeyCol = lineCol(state.text, prev.offset).column;
+						isExplicitKey = true;
+						break;
+					}
+					if (prev.type === "whitespace" && prev.source.trim() === "") continue;
+					if (prev.type === "newline") continue;
+					break;
+				}
+				if (isExplicitKey) {
+					let nextScalarIndented = false;
+					let sawNl = false;
+					for (let j = i + 1; j < children.length; j++) {
+						const c = children[j];
+						if (!c) continue;
+						if (c.type === "newline") {
+							sawNl = true;
+							continue;
+						}
+						if (c.type === "whitespace" && c.source.trim() === "") continue;
+						if (sawNl && c.type === "flow-scalar") nextScalarIndented = lineCol(state.text, c.offset).column > explicitKeyCol;
+						break;
+					}
+					isExplicitKey = nextScalarIndented;
+				}
+				if (isExplicitKey) {
+					const { value: keyValue, nextIdx: keyNextIdx } = collectMultilineKey(children, i);
+					const keyMeta = combinedPending();
+					const scalar = new YamlScalar({
+						value: resolveScalar(keyValue, "plain", keyMeta.tag, state),
+						style: "plain",
+						offset: child.offset,
+						length: child.length,
+						...keyMeta.tag !== void 0 ? { tag: keyMeta.tag } : {},
+						...keyMeta.anchor !== void 0 ? { anchor: keyMeta.anchor } : {}
+					});
+					if (keyMeta.anchor) registerAnchor(scalar, keyMeta.anchor, state, child.offset);
+					resetAllMeta();
+					pushNode(scalar, child.offset);
+					i = keyNextIdx - 1;
+					continue;
+				}
+			}
+			if (child.type === "flow-scalar" && getScalarStyle(child) === "plain" && !hasValueSepAfterInList(children, i + 1)) {
+				const isValuePosition = afterValueSep;
+				if (!isValuePosition) {
+					let isLineStart = true;
+					for (let k = child.offset - 1; k >= 0; k--) {
+						const ch = state.text[k];
+						if (ch === "\n") break;
+						if (ch === " " || ch === "	") continue;
+						isLineStart = false;
+						break;
+					}
+					if (isLineStart) {
+						let precededByIndicator = false;
+						for (let p = i - 1; p >= 0; p--) {
+							const prev = children[p];
+							if (!prev) continue;
+							if (prev.type === "whitespace" && (prev.source === "-" || prev.source === "?")) {
+								precededByIndicator = true;
+								break;
+							}
+							if (prev.type === "whitespace" && prev.source.trim() === "") continue;
+							if (prev.type === "newline") continue;
+							break;
+						}
+						if (!precededByIndicator) state.errors.push({
+							code: "UnexpectedToken",
+							message: "Trailing content in block mapping",
+							offset: child.offset,
+							length: child.length
+						});
+					}
+				}
+				const minContCol = isValuePosition && lastKeyColumn >= 0 && lastKeyOffset >= 0 && lastValueSepOffset >= 0 && sameLine(state.text, lastKeyOffset, lastValueSepOffset) ? lastKeyColumn + 1 : void 0;
+				const { value, nextIdx, partsCount, endOffset } = collectMultilinePlainScalar(children, i, minContCol, minContCol !== void 0 ? state.text : void 0);
+				const plainMeta = combinedPending();
+				const resolved = resolveScalar(value, "plain", plainMeta.tag, state);
+				const needsRaw = typeof resolved !== "string" && resolved !== void 0 && shouldPreserveRaw(value, resolved);
+				const scalar = new YamlScalar({
+					value: resolved,
+					style: "plain",
+					offset: child.offset,
+					length: partsCount > 1 ? endOffset - child.offset : child.length,
+					...plainMeta.tag !== void 0 ? { tag: plainMeta.tag } : {},
+					...plainMeta.anchor !== void 0 ? { anchor: plainMeta.anchor } : {},
+					...needsRaw ? { raw: value } : {}
+				});
+				if (plainMeta.anchor) registerAnchor(scalar, plainMeta.anchor, state, child.offset);
+				resetAllMeta();
+				pushNode(scalar, child.offset);
+				if (isValuePosition && partsCount > 1) {
+					const stoppedAtContent = findNextContentInList(children, nextIdx);
+					if (stoppedAtContent) {
+						const sn = stoppedAtContent.node;
+						const valueCol = lineCol(state.text, child.offset).column;
+						if (lineCol(state.text, sn.offset).column >= valueCol) {
+							if (sn.type === "flow-scalar" && getScalarStyle(sn) === "plain" && hasValueSepAfterInList(children, stoppedAtContent.idx + 1) || sn.type === "flow-scalar" && getScalarStyle(sn) === "plain" && (() => {
+								const after = findNextContentInList(children, stoppedAtContent.idx + 1);
+								return after !== null && after.node.type === "block-map";
+							})() || sn.type === "block-map") state.errors.push({
+								code: "UnexpectedToken",
+								message: "Mapping key after multiline plain scalar value",
+								offset: sn.offset,
+								length: sn.length
+							});
+						}
+					}
+				}
+				i = nextIdx - 1;
+				continue;
+			}
+			const style = getScalarStyle(child);
+			const isValuePosition = afterValueSep;
+			const scalarMeta = combinedPending();
+			const scalar = makeScalar(child, state, hasMeta(scalarMeta) ? scalarMeta : void 0);
+			resetAllMeta();
+			pushNode(scalar, child.offset);
+			if (isValuePosition && (style === "single-quoted" || style === "double-quoted")) {
+				checkTrailingContentOnSameLine(children, i + 1, child, state);
+				validateQuotedScalarContinuationIndent(child, state, lastKeyColumn);
+			}
+			continue;
+		}
+		if (child.type === "alias") {
+			commitOuterIfNewlineSeen();
+			const nextAlias = findNextContentInList(children, i + 1);
+			if (nextAlias?.node.type === "block-map") {
+				const alias = makeAlias(child, state);
+				const aliasMapMeta = hasMeta(outerMeta) ? outerMeta : void 0;
+				const map = composeBlockMap(nextAlias.node, state, alias, aliasMapMeta);
+				resetAllMeta();
+				pushNode(map);
+				i = nextAlias.idx;
+				continue;
+			}
+			checkAnchorOnAlias(combinedPending(), child, state);
+			const alias = makeAlias(child, state);
+			resetAllMeta();
+			pushNode(alias);
+			continue;
+		}
+		if (child.type === "block-map") {
+			commitOuterIfNewlineSeen();
+			const mapMeta = combinedPending();
+			if (hasMeta(pendingMeta) && blockMapStartsWithValueSep(child)) {
+				const emptyKey = new YamlScalar({
+					value: null,
+					style: "plain",
+					offset: child.offset,
+					length: 0,
+					...pendingMeta.tag !== void 0 ? { tag: pendingMeta.tag } : {},
+					...pendingMeta.anchor !== void 0 ? { anchor: pendingMeta.anchor } : {}
+				});
+				if (pendingMeta.anchor) registerAnchor(emptyKey, pendingMeta.anchor, state, child.offset);
+				const map = composeBlockMap(child, state, emptyKey, hasMeta(outerMeta) ? outerMeta : void 0);
+				resetAllMeta();
+				pushNode(map);
+				continue;
+			}
+			const map = composeBlockMap(child, state, void 0, hasMeta(mapMeta) ? mapMeta : void 0);
+			resetAllMeta();
+			pushNode(map);
+			continue;
+		}
+		if (child.type === "block-seq") {
+			commitOuterIfNewlineSeen();
+			const seqMeta = combinedPending();
+			if (!afterValueSep && pendingExplicitKeyCol < 0 && child.length > 0) state.errors.push({
+				code: "InvalidIndentation",
+				message: "Sequence in mapping key position",
+				offset: child.offset,
+				length: child.length
+			});
+			const seq = composeBlockSeq(child, state, hasMeta(seqMeta) ? seqMeta : void 0);
+			resetAllMeta();
+			pushNode(seq);
+			continue;
+		}
+		if (child.type === "flow-map") {
+			commitOuterIfNewlineSeen();
+			const isValue = afterValueSep;
+			const flowMapMeta = combinedPending();
+			const map = state.flow.composeFlowMap(child, state, hasMeta(flowMapMeta) ? flowMapMeta : void 0, lastKeyColumn);
+			resetAllMeta();
+			pushNode(map);
+			if (isValue) checkTrailingContentOnSameLine(children, i + 1, child, state);
+			continue;
+		}
+		if (child.type === "flow-seq") {
+			commitOuterIfNewlineSeen();
+			const isValue = afterValueSep;
+			const flowSeqMeta = combinedPending();
+			const seq = state.flow.composeFlowSeq(child, state, hasMeta(flowSeqMeta) ? flowSeqMeta : void 0, lastKeyColumn);
+			resetAllMeta();
+			pushNode(seq);
+			if (isValue) checkTrailingContentOnSameLine(children, i + 1, child, state);
+		}
+	}
+	const trailingMeta = combinedPending();
+	if (hasMeta(trailingMeta)) {
+		const scalar = new YamlScalar({
+			value: resolveScalar("", "plain", trailingMeta.tag, state),
+			style: "plain",
+			offset: 0,
+			length: 0,
+			...trailingMeta.tag !== void 0 ? { tag: trailingMeta.tag } : {},
+			...trailingMeta.anchor !== void 0 ? { anchor: trailingMeta.anchor } : {}
+		});
+		if (trailingMeta.anchor) registerAnchor(scalar, trailingMeta.anchor, state, 0);
+		items.push({
+			kind: "node",
+			node: scalar
+		});
+	}
+	return items;
+}
+/**
+* Build pairs from a semantic item stream.
+* Pattern: node, value-sep, node produces a key:value pair.
+* Pattern: node, value-sep (no node) produces a key:null pair.
+* Pattern: value-sep, node produces a null:value pair.
+*/
+function buildPairs(items, pairs, text) {
+	let i = 0;
+	while (i < items.length) {
+		const item = items[i];
+		if (!item) {
+			i++;
+			continue;
+		}
+		if (item.kind === "comment") {
+			if (pairs.length > 0) {
+				const last = pairs[pairs.length - 1];
+				if (last) pairs[pairs.length - 1] = new YamlPair({
+					key: last.key,
+					value: last.value,
+					...item.comment !== void 0 ? { comment: item.comment } : {}
+				});
+			}
+			i++;
+			continue;
+		}
+		if (item.kind === "value-sep") {
+			const valueSepOffset = item.offset ?? 0;
+			i++;
+			const valueNode = consumeValueNodeForNullKey(items, i, text, valueSepOffset);
+			if (valueNode) {
+				const nullKey = new YamlScalar({
+					value: null,
+					style: "plain",
+					offset: 0,
+					length: 0
+				});
+				pairs.push(new YamlPair({
+					key: nullKey,
+					value: valueNode.node ?? null
+				}));
+				i = valueNode.nextIdx;
+			} else {
+				const nullKey = new YamlScalar({
+					value: null,
+					style: "plain",
+					offset: 0,
+					length: 0
+				});
+				pairs.push(new YamlPair({
+					key: nullKey,
+					value: null
+				}));
+			}
+			continue;
+		}
+		if (item.kind === "node" || item.kind === "key") {
+			let keyNode = item.node;
+			i++;
+			if (item.kind === "key" && !keyNode) {
+				while (i < items.length && items[i]?.kind === "comment") i++;
+				if (i < items.length && items[i]?.kind === "node") {
+					keyNode = items[i]?.node;
+					i++;
+				}
+			}
+			while (i < items.length && items[i]?.kind === "comment") i++;
+			if (i < items.length && items[i]?.kind === "value-sep") {
+				i++;
+				const valueResult = consumeValueNode(items, i);
+				if (valueResult) {
+					pairs.push(new YamlPair({
+						key: keyNode ?? new YamlScalar({
+							value: null,
+							style: "plain",
+							offset: 0,
+							length: 0
+						}),
+						value: valueResult.node ?? null
+					}));
+					i = valueResult.nextIdx;
+				} else pairs.push(new YamlPair({
+					key: keyNode ?? new YamlScalar({
+						value: null,
+						style: "plain",
+						offset: 0,
+						length: 0
+					}),
+					value: null
+				}));
+			} else pairs.push(new YamlPair({
+				key: keyNode ?? new YamlScalar({
+					value: null,
+					style: "plain",
+					offset: 0,
+					length: 0
+				}),
+				value: null
+			}));
+			continue;
+		}
+		i++;
+	}
+}
+function consumeValueNode(items, startIdx) {
+	let i = startIdx;
+	while (i < items.length) {
+		const item = items[i];
+		if (!item) break;
+		if (item.kind === "comment") {
+			i++;
+			continue;
+		}
+		if (item.kind === "node") return {
+			node: item.node ?? null,
+			nextIdx: i + 1
+		};
+		break;
+	}
+	return i > startIdx ? {
+		node: null,
+		nextIdx: i
+	} : null;
+}
+/**
+* Like consumeValueNode but for implicit null-key entries (`: value`).
+* If the next non-comment node is immediately followed by a value-sep
+* AND is on a different line from the null key's `:`, it's actually a
+* KEY for the next pair, not our value — return null so the null key
+* gets a null value. When on the same line (e.g. `a: b: c: d`), consume
+* normally to preserve the original pairing (which may produce duplicate
+* keys that get rejected).
+*/
+function consumeValueNodeForNullKey(items, startIdx, text, valueSepOffset) {
+	let i = startIdx;
+	while (i < items.length) {
+		const item = items[i];
+		if (!item) break;
+		if (item.kind === "comment") {
+			i++;
+			continue;
+		}
+		if (item.kind === "node") {
+			if (i + 1 < items.length && items[i + 1]?.kind === "value-sep") {
+				const nodeOffset = item.node && "offset" in item.node ? item.node.offset : 0;
+				if (text.slice(valueSepOffset, nodeOffset).includes("\n")) break;
+			}
+			return {
+				node: item.node ?? null,
+				nextIdx: i + 1
+			};
+		}
+		break;
+	}
+	return i > startIdx ? {
+		node: null,
+		nextIdx: i
+	} : null;
+}
+/**
+* Canonical duplicate-key identity for a scalar key. Two keys collide only if
+* they are the same YAML node: same type *and* value. Resolved JS values alone
+* are ambiguous for numbers — `!!int 1` and `!!float 1.0` both become the JS
+* number `1` yet are distinct keys — so the number branch disambiguates int
+* from float via the source form (or an explicit tag). String/bool/null keys
+* are distinguished by their type prefix, so `1` (int) never collides with
+* `"1"` (string) or `true`.
+*/
+function keyIdentity(key, text) {
+	const v = key.value;
+	if (v === null) return "null";
+	switch (typeof v) {
+		case "boolean": return `b:${v}`;
+		case "string": return `s:${v}`;
+		case "bigint": return `i:${v.toString()}`;
+		case "number": {
+			let kind = classifyPlainNumeric(text.slice(key.offset, key.offset + key.length).trim());
+			if (key.tag !== void 0) {
+				if (key.tag.includes("float")) kind = "float";
+				else if (key.tag.includes("int")) kind = "int";
+			}
+			return `${kind === "float" ? "f" : "i"}:${v}`;
+		}
+		default: return `o:${String(v)}`;
+	}
+}
+function checkDuplicateKeys(pairs, state) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const pair of pairs) if (pair.key instanceof YamlScalar) {
+		const id = keyIdentity(pair.key, state.text);
+		if (seen.has(id)) state.warnings.push({
+			code: "DuplicateKey",
+			message: `Duplicate key: ${String(pair.key.value)}`,
+			offset: pair.key.offset,
+			length: pair.key.length
+		});
+		seen.add(id);
+	}
+}
+/**
+* Inspect the slice of children after a `?` indicator to decide how the
+* explicit key should be composed.
+*
+* - `terminated` — found a matching `:` at `qCol`; the key is the slice
+*   between `?` and that `:`. Existing per-node logic handles this.
+* - `inline-implicit-map` — no matching `:` at `qCol`, but the slice
+*   contains a `:` at a deeper column. The whole slice is a compact
+*   inline implicit-map key (M2N8/00, M2N8/01).
+* - `simple` — no internal `:` at all; the next content node is the
+*   single key (KK5P, M5DY block-seq keys; plain scalar keys).
+*/
+function scanExplicitKeyShape(children, qIdx, qCol, text) {
+	const qChild = children[qIdx];
+	const qLine = qChild ? lineCol(text, qChild.offset).line : -1;
+	let inlineColonOnQLine = false;
+	let endIdx = children.length;
+	for (let j = qIdx + 1; j < children.length; j++) {
+		const c = children[j];
+		if (!c) continue;
+		if (c.type === "whitespace" && c.source === ":") {
+			if (lineCol(text, c.offset).column === qCol) return {
+				kind: "terminated",
+				matchIdx: j
+			};
+			if (lineCol(text, c.offset).line === qLine) inlineColonOnQLine = true;
+		}
+		if (c.type === "whitespace" && c.source === "?") {
+			if (lineCol(text, c.offset).column === qCol) {
+				endIdx = j;
+				break;
+			}
+		}
+	}
+	if (inlineColonOnQLine) return {
+		kind: "inline-implicit-map",
+		endIdx
+	};
+	return { kind: "simple" };
+}
+/**
+* Returns true if a value at the given offset was introduced by a `?`
+* explicit-key indicator. Scans backward through whitespace and newlines
+* looking for a `?` at the start of a line (not part of a scalar).
+*
+* Named verbosely to avoid colliding with the local `isExplicitKey`
+* boolean in `flattenBlockMapChildren` (used for multi-line key
+* continuation detection — different concept).
+*/
+function wasIntroducedByExplicitKeyIndicator(text, offset) {
+	let i = offset - 1;
+	while (i >= 0) {
+		const ch = text[i];
+		if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+			i--;
+			continue;
+		}
+		if (ch === "?") {
+			if (i === 0) return true;
+			const prev = text[i - 1];
+			return prev === " " || prev === "	" || prev === "\n" || prev === "\r";
+		}
+		return false;
+	}
+	return false;
+}
+/**
+* Validate that implicit mapping keys do not span multiple lines.
+* YAML 1.2 §7.4.2 requires implicit keys to fit on a single line.
+*/
+function checkMultilineImplicitKeys(pairs, state, items) {
+	for (const pair of pairs) {
+		const key = pair.key;
+		if (key.length === 0) continue;
+		if (key._tag === "YamlScalar") {
+			const s = key.style;
+			if (s !== "single-quoted" && s !== "double-quoted") continue;
+			const keySource = state.text.slice(key.offset, key.offset + key.length);
+			if (keySource.includes("\n") || keySource.includes("\r")) state.errors.push({
+				code: "UnexpectedToken",
+				message: "Implicit mapping key must not span multiple lines",
+				offset: key.offset,
+				length: key.length
+			});
+			continue;
+		}
+		if (key._tag === "YamlMap" || key._tag === "YamlSeq") {
+			if (key.style !== "flow") continue;
+			if (wasIntroducedByExplicitKeyIndicator(state.text, key.offset)) continue;
+			const keySource = state.text.slice(key.offset, key.offset + key.length);
+			if (keySource.includes("\n") || keySource.includes("\r")) state.errors.push({
+				code: "UnexpectedToken",
+				message: "Implicit mapping key must not span multiple lines",
+				offset: key.offset,
+				length: key.length
+			});
+		}
+	}
+	if (!items) return;
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i];
+		if (!item) continue;
+		if (item.kind !== "node" && item.kind !== "key") continue;
+		const node = item.node;
+		if (node?._tag !== "YamlScalar" || node.length === 0) continue;
+		let j = i + 1;
+		while (j < items.length && items[j]?.kind === "comment") j++;
+		const next = items[j];
+		if (next?.kind !== "value-sep" || next.offset === void 0) continue;
+		if (lineCol(state.text, node.offset + node.length - 1).line !== lineCol(state.text, next.offset).line) state.errors.push({
+			code: "UnexpectedToken",
+			message: "Implicit mapping key and value indicator must be on the same line",
+			offset: node.offset,
+			length: node.length
+		});
+	}
+}
+/**
+* Check for non-trivial CST content on the same line after a completed value node.
+* Used to detect trailing content after quoted scalars and flow collections.
+* Skips if the next non-trivia content is a ":" (value-sep), since that means
+* this node is actually a key, not a value.
+*/
+function checkTrailingContentOnSameLine(children, startIdx, valueNode, state) {
+	const valueEnd = valueNode.offset + valueNode.length;
+	for (let j = startIdx; j < children.length; j++) {
+		const next = children[j];
+		if (!next) continue;
+		if (next.type === "newline") break;
+		if (next.type === "comment") break;
+		if (next.type === "whitespace") {
+			if (next.source === ":") break;
+			if (next.source.trim() === "") continue;
+		}
+		if (sameLine(state.text, valueEnd - 1, next.offset)) state.errors.push({
+			code: "UnexpectedToken",
+			message: "Trailing content after value on same line",
+			offset: next.offset,
+			length: next.length
+		});
+		break;
+	}
+}
+/**
+* QB6E: continuation lines of a multi-line quoted scalar in value position
+* must be indented past the parent key column.
+*/
+function validateQuotedScalarContinuationIndent(scalar, state, parentKeyColumn) {
+	if (parentKeyColumn < 0) return;
+	const text = state.text;
+	const start = scalar.offset;
+	const end = scalar.offset + scalar.length;
+	let i = start;
+	let inLineStart = false;
+	let lineStart = -1;
+	while (i < end && i < text.length) {
+		const ch = text[i];
+		if (ch === "\n") {
+			inLineStart = true;
+			lineStart = i + 1;
+			i++;
+			continue;
+		}
+		if (inLineStart) {
+			if (ch === " " || ch === "	") {
+				i++;
+				continue;
+			}
+			if (i - lineStart <= parentKeyColumn) {
+				state.errors.push({
+					code: "InvalidIndentation",
+					message: "Multi-line quoted scalar continuation must be indented past the parent key",
+					offset: i,
+					length: 1
+				});
+				return;
+			}
+			inLineStart = false;
+		}
+		i++;
+	}
+}
+/**
+* 4JVG: a single scalar cannot have two anchor declarations. When the
+* outer-meta slot and the pending-meta slot both carry an anchor, AND the
+* scalar is being consumed as a plain value (not as a key for a nested
+* block-map, not followed by `:`), both anchors would collapse onto the
+* scalar — that's invalid YAML.
+*/
+function validateNoDoubleAnchorOnScalar(scalar, children, idx, outerMeta, pendingMeta, state) {
+	if (outerMeta.anchor === void 0 || pendingMeta.anchor === void 0) return;
+	if (hasValueSepAfterInList(children, idx + 1)) return;
+	const nextContent = findNextContentInList(children, idx + 1);
+	if (nextContent?.node.type === "block-map" && !hasValueSepBetween(children, idx + 1, nextContent.idx)) return;
+	state.errors.push({
+		code: "UnexpectedToken",
+		message: "Scalar cannot have two anchor declarations",
+		offset: scalar.offset,
+		length: scalar.length
+	});
+}
+/**
+* Y79Y/009: when a `:` value-sep is at the start of a line (continuation
+* line, not on the same line as a key) and is immediately followed by a
+* tab and same-line content, the tab is being used as block indentation
+* for the upcoming content — invalid per YAML 1.2 §6.1.
+*/
+function validateNoTabAfterContinuationValueSep(colonChild, children, idx, state) {
+	if (lineCol(state.text, colonChild.offset).column !== lineIndentColumn(state.text, colonChild.offset)) return;
+	let sawTab = false;
+	for (let j = idx + 1; j < children.length; j++) {
+		const c = children[j];
+		if (!c) continue;
+		if (c.type === "newline") return;
+		if (c.type === "whitespace") {
+			if (c.source.includes("	")) sawTab = true;
+			continue;
+		}
+		if (sawTab && sameLine(state.text, colonChild.offset, c.offset)) state.errors.push({
+			code: "TabIndentation",
+			message: "Tab character cannot be used as indentation after a value indicator",
+			offset: colonChild.offset,
+			length: colonChild.length
+		});
+		return;
+	}
+}
+/**
+* Returns true when the upcoming "-" indicator is preceded (after only
+* whitespace/newlines) by either an empty block-seq placeholder or a
+* `?`-only block-map. The parser uses both shapes to mark "explicit key
+* with a sequence as the key" (KK5P fixture).
+*/
+function precededByExplicitKeyMarker(children, idx) {
+	for (let j = idx - 1; j >= 0; j--) {
+		const c = children[j];
+		if (!c) continue;
+		if (c.type === "whitespace" || c.type === "newline" || c.type === "comment") continue;
+		if (c.type === "block-seq" && c.length === 0) return true;
+		if (c.type === "block-map" && c.source.trimEnd() === "?") return true;
+		return false;
+	}
+	return false;
+}
+/**
+* G9HC, H7J7: anchor/tag in value position on a continuation line (not on
+* the same line as `:`) must be at a column strictly greater than the
+* parent key's column. Per YAML 1.2 §8.1.2, properties before a block
+* collection must be at indent n+1, where n is the parent key column.
+*/
+function validatePropertyContinuationColumn(property, state, afterValueSep, lastValueSepOffset, parentKeyColumn) {
+	if (!afterValueSep) return;
+	if (parentKeyColumn < 0) return;
+	if (lastValueSepOffset >= 0 && sameLine(state.text, lastValueSepOffset, property.offset)) return;
+	if (lineCol(state.text, property.offset).column <= parentKeyColumn) state.errors.push({
+		code: "InvalidIndentation",
+		message: "Property (anchor or tag) must be indented past the parent key",
+		offset: property.offset,
+		length: property.length
+	});
+}
+function composeBlockSeq(cst, state, meta) {
+	if (!enterNesting(state, cst)) return new YamlSeq({
+		items: [],
+		style: "block",
+		offset: cst.offset,
+		length: cst.length
+	});
+	try {
+		return composeBlockSeqInner(cst, state, meta);
+	} finally {
+		exitNesting(state);
+	}
+}
+function composeBlockSeqInner(cst, state, meta) {
+	const children = cst.children ?? [];
+	const items = [];
+	let pendingMeta = {};
+	let sawEntry = false;
+	const seqIndent = lineIndentColumn(state.text, cst.offset);
+	let sawNewlineSincePending = false;
+	for (let ci = 0; ci < children.length; ci++) {
+		const child = children[ci];
+		if (!child) continue;
+		if (child.type === "newline") {
+			if (hasMeta(pendingMeta)) sawNewlineSincePending = true;
+			continue;
+		}
+		if (child.type === "comment") continue;
+		if (child.type === "whitespace") {
+			if (child.source.trim() === "-") {
+				if (sawEntry) {
+					const emptyScalar = new YamlScalar({
+						value: null,
+						style: "plain",
+						offset: child.offset,
+						length: 0,
+						...pendingMeta.tag !== void 0 ? { tag: pendingMeta.tag } : {},
+						...pendingMeta.anchor !== void 0 ? { anchor: pendingMeta.anchor } : {}
+					});
+					if (pendingMeta.anchor) registerAnchor(emptyScalar, pendingMeta.anchor, state, child.offset);
+					pendingMeta = {};
+					items.push(emptyScalar);
+				}
+				sawEntry = true;
+			}
+			continue;
+		}
+		if (child.type === "error") {
+			state.errors.push({
+				code: "UnexpectedToken",
+				message: `Unexpected content: ${child.source.trim() || "(empty)"}`,
+				offset: child.offset,
+				length: child.length
+			});
+			continue;
+		}
+		if (child.type === "anchor") {
+			pendingMeta.anchor = getAnchorName(child, state.text);
+			continue;
+		}
+		if (child.type === "tag") {
+			pendingMeta.tag = child.source;
+			continue;
+		}
+		if (child.type === "flow-scalar" || child.type === "block-scalar") {
+			const nextSig = findNextSignificantChild(children, ci + 1, true);
+			const nextSigChild = nextSig !== null ? children[nextSig] : void 0;
+			if (nextSig !== null && nextSigChild && nextSigChild.type === "block-map") {
+				let keyMeta = hasMeta(pendingMeta) ? pendingMeta : void 0;
+				let mapMeta;
+				if (sawNewlineSincePending && hasMeta(pendingMeta)) {
+					mapMeta = pendingMeta;
+					keyMeta = void 0;
+				}
+				const map = composeBlockMap(nextSigChild, state, makeScalar(child, state, keyMeta), mapMeta);
+				pendingMeta = {};
+				sawNewlineSincePending = false;
+				sawEntry = false;
+				items.push(map);
+				ci = nextSig;
+				continue;
+			}
+			if (child.type === "flow-scalar" && getScalarStyle(child) === "plain") {
+				const { value: merged, nextIdx: mergeEnd, partsCount, endOffset } = collectMultilinePlainScalar(children, ci, void 0, state.text);
+				if (partsCount > 1) {
+					const scalar = new YamlScalar({
+						value: resolveScalar(merged, "plain", pendingMeta.tag, state),
+						style: "plain",
+						offset: child.offset,
+						length: endOffset - child.offset,
+						...pendingMeta.tag !== void 0 ? { tag: pendingMeta.tag } : {},
+						...pendingMeta.anchor !== void 0 ? { anchor: pendingMeta.anchor } : {}
+					});
+					if (pendingMeta.anchor) registerAnchor(scalar, pendingMeta.anchor, state, child.offset);
+					pendingMeta = {};
+					sawEntry = false;
+					items.push(scalar);
+					ci = mergeEnd - 1;
+					continue;
+				}
+			}
+			const scalar = makeScalar(child, state, hasMeta(pendingMeta) ? pendingMeta : void 0);
+			pendingMeta = {};
+			sawNewlineSincePending = false;
+			sawEntry = false;
+			items.push(scalar);
+			continue;
+		}
+		if (child.type === "alias") {
+			checkAnchorOnAlias(pendingMeta, child, state);
+			const alias = makeAlias(child, state);
+			pendingMeta = {};
+			sawNewlineSincePending = false;
+			sawEntry = false;
+			items.push(alias);
+			continue;
+		}
+		if (child.type === "block-map") {
+			if (hasMeta(pendingMeta) && blockMapStartsWithValueSep(child)) {
+				const emptyKey = new YamlScalar({
+					value: null,
+					style: "plain",
+					offset: child.offset,
+					length: 0,
+					...pendingMeta.tag !== void 0 ? { tag: pendingMeta.tag } : {},
+					...pendingMeta.anchor !== void 0 ? { anchor: pendingMeta.anchor } : {}
+				});
+				if (pendingMeta.anchor) registerAnchor(emptyKey, pendingMeta.anchor, state, child.offset);
+				pendingMeta = {};
+				sawNewlineSincePending = false;
+				const map = composeBlockMap(child, state, emptyKey, void 0);
+				sawEntry = false;
+				items.push(map);
+				continue;
+			}
+			const map = composeBlockMap(child, state, void 0, hasMeta(pendingMeta) ? pendingMeta : void 0);
+			pendingMeta = {};
+			sawNewlineSincePending = false;
+			sawEntry = false;
+			items.push(map);
+			continue;
+		}
+		if (child.type === "block-seq") {
+			const seq = composeBlockSeq(child, state, hasMeta(pendingMeta) ? pendingMeta : void 0);
+			pendingMeta = {};
+			sawNewlineSincePending = false;
+			sawEntry = false;
+			items.push(seq);
+			continue;
+		}
+		if (child.type === "flow-map") {
+			const map = state.flow.composeFlowMap(child, state, hasMeta(pendingMeta) ? pendingMeta : void 0, seqIndent);
+			pendingMeta = {};
+			sawEntry = false;
+			items.push(map);
+			checkTrailingContentOnSameLine(children, ci + 1, child, state);
+			continue;
+		}
+		if (child.type === "flow-seq") {
+			const seq = state.flow.composeFlowSeq(child, state, hasMeta(pendingMeta) ? pendingMeta : void 0, seqIndent);
+			pendingMeta = {};
+			sawEntry = false;
+			items.push(seq);
+			checkTrailingContentOnSameLine(children, ci + 1, child, state);
+		}
+	}
+	if (sawEntry && !hasMeta(pendingMeta)) items.push(new YamlScalar({
+		value: null,
+		style: "plain",
+		offset: cst.offset + cst.length,
+		length: 0
+	}));
+	if (hasMeta(pendingMeta)) {
+		const scalar = new YamlScalar({
+			value: resolveScalar("", "plain", pendingMeta.tag, state),
+			style: "plain",
+			offset: 0,
+			length: 0,
+			...pendingMeta.tag !== void 0 ? { tag: pendingMeta.tag } : {},
+			...pendingMeta.anchor !== void 0 ? { anchor: pendingMeta.anchor } : {}
+		});
+		if (pendingMeta.anchor) registerAnchor(scalar, pendingMeta.anchor, state, 0);
+		items.push(scalar);
+	}
+	const seq = new YamlSeq({
+		items,
+		style: "block",
+		offset: cst.offset,
+		length: cst.length,
+		...meta?.tag !== void 0 ? { tag: meta.tag } : {},
+		...meta?.anchor !== void 0 ? { anchor: meta.anchor } : {},
+		...meta?.comment !== void 0 ? { comment: meta.comment } : {}
+	});
+	if (meta?.anchor) registerAnchor(seq, meta.anchor, state, cst.offset);
+	return seq;
+}
+/**
+* Compose a block map from flat document children (no block-map wrapper node).
+* This happens in multi-document scenarios where the parser doesn't create a block-map node.
+*/
+function composeFlatBlockMap(children, startIdx, parentCst, state, externalFirstKey, meta) {
+	const items = flattenBlockMapChildren(children.slice(startIdx), state);
+	items.unshift({
+		kind: "key",
+		node: externalFirstKey
+	});
+	const pairs = [];
+	buildPairs(items, pairs, state.text);
+	if (state.options.uniqueKeys) checkDuplicateKeys(pairs, state);
+	checkMultilineImplicitKeys(pairs, state);
+	const offset = "offset" in externalFirstKey ? externalFirstKey.offset : parentCst.offset;
+	const map = new YamlMap({
+		items: pairs,
+		style: "block",
+		offset,
+		length: parentCst.offset + parentCst.length - offset,
+		...meta?.tag !== void 0 ? { tag: meta.tag } : {},
+		...meta?.anchor !== void 0 ? { anchor: meta.anchor } : {},
+		...meta?.comment !== void 0 ? { comment: meta.comment } : {}
+	});
+	if (meta?.anchor) registerAnchor(map, meta.anchor, state, offset);
+	return map;
+}
+
+//#endregion
+export { buildPairs, checkDuplicateKeys, checkMultilineImplicitKeys, checkTrailingContentOnSameLine, composeBlockMap, composeBlockSeq, composeFlatBlockMap, flattenBlockMapChildren };