@effected/yaml 0.1.0

package/internal/composer/scalars.js

@@ -0,0 +1,885 @@
+import { YamlScalar } from "../../YamlNode.js";
+import { registerAnchor } from "./anchors.js";
+import { lineCol } from "./state.js";
+import { resolveTagHandle } from "./tags.js";
+
+//#region src/internal/composer/scalars.ts
+const NULL_RE = /^(?:null|Null|NULL|~)$/;
+const TRUE_RE = /^(?:true|True|TRUE)$/;
+const FALSE_RE = /^(?:false|False|FALSE)$/;
+const INT_RE = /^[-+]?[0-9]+$/;
+const OCT_RE = /^0o[0-7]+$/;
+const HEX_RE = /^0x[\dA-Fa-f]+$/;
+const FLOAT_RE = /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)(?:[eE][-+]?[0-9]+)?$/;
+const INF_RE = /^[-+]?\.(?:inf|Inf|INF)$/;
+const NAN_RE = /^\.(?:nan|NaN|NAN)$/;
+/**
+* Parses an integer string, returning `bigint` when the value exceeds
+* `Number.MAX_SAFE_INTEGER` to avoid silent precision loss.
+*/
+function safeParseInt(value, radix) {
+	const n = Number.parseInt(value, radix);
+	if (Number.isSafeInteger(n)) return n;
+	return BigInt(`${radix === 16 ? "0x" : radix === 8 ? "0o" : ""}${value}`);
+}
+/**
+* Classify a plain scalar's numeric form for duplicate-key identity. `1` is an
+* `!!int` and `1.0` an `!!float` even though both resolve to the JS number `1`,
+* so they are distinct mapping keys; `1` and `0x1` are both `!!int 1` and so
+* are the same key. Returns `null` for non-numeric plain text. Uses the same
+* regexes as {@link resolvePlainScalar} so the classification always agrees
+* with how the value was resolved.
+*/
+function classifyPlainNumeric(raw) {
+	const t = raw.trim();
+	if (OCT_RE.test(t) || HEX_RE.test(t) || INT_RE.test(t)) return "int";
+	if (INF_RE.test(t) || NAN_RE.test(t) || FLOAT_RE.test(t)) return "float";
+	return null;
+}
+function resolvePlainScalar(value) {
+	if (value === "" || NULL_RE.test(value)) return null;
+	if (TRUE_RE.test(value)) return true;
+	if (FALSE_RE.test(value)) return false;
+	if (OCT_RE.test(value)) return safeParseInt(value.slice(2), 8);
+	if (HEX_RE.test(value)) return safeParseInt(value.slice(2), 16);
+	if (INT_RE.test(value)) return safeParseInt(value, 10);
+	if (INF_RE.test(value)) return value.startsWith("-") ? -Number.POSITIVE_INFINITY : Number.POSITIVE_INFINITY;
+	if (NAN_RE.test(value)) return NaN;
+	if (FLOAT_RE.test(value)) {
+		const n = Number.parseFloat(value);
+		if (!Number.isNaN(n)) return n;
+	}
+	return value;
+}
+function resolveTaggedScalar(rawValue, tag) {
+	switch (tag) {
+		case "!!str":
+		case "tag:yaml.org,2002:str": return rawValue;
+		case "!!int":
+		case "tag:yaml.org,2002:int": {
+			if (OCT_RE.test(rawValue)) return Number.parseInt(rawValue.slice(2), 8);
+			if (HEX_RE.test(rawValue)) return Number.parseInt(rawValue.slice(2), 16);
+			const n = Number.parseInt(rawValue, 10);
+			return Number.isNaN(n) ? rawValue : n;
+		}
+		case "!!float":
+		case "tag:yaml.org,2002:float": {
+			if (INF_RE.test(rawValue)) return rawValue.startsWith("-") ? -Number.POSITIVE_INFINITY : Number.POSITIVE_INFINITY;
+			if (NAN_RE.test(rawValue)) return NaN;
+			const n = Number.parseFloat(rawValue);
+			return Number.isNaN(n) ? rawValue : n;
+		}
+		case "!!bool":
+		case "tag:yaml.org,2002:bool":
+			if (TRUE_RE.test(rawValue)) return true;
+			if (FALSE_RE.test(rawValue)) return false;
+			return rawValue;
+		case "!!null":
+		case "tag:yaml.org,2002:null": return null;
+		default: return rawValue;
+	}
+}
+function resolveScalar(rawValue, style, tag, state) {
+	if (tag) return resolveTaggedScalar(rawValue, state ? resolveTagHandle(tag, state) : tag);
+	if (style !== "plain") return rawValue;
+	return resolvePlainScalar(rawValue);
+}
+function getScalarStyle(node) {
+	if (node.type === "block-scalar") return node.source.trimStart()[0] === ">" ? "block-folded" : "block-literal";
+	const first = node.source[0];
+	if (first === "'") return "single-quoted";
+	if (first === "\"") return "double-quoted";
+	return "plain";
+}
+/**
+* Extracts the chomp indicator from a block scalar's header.
+* Returns "strip" for `-`, "keep" for `+`, "clip" otherwise (default).
+* Returns undefined for non-block scalars.
+*/
+function getBlockChomp(node) {
+	if (node.type !== "block-scalar") return void 0;
+	const src = node.source.trimStart();
+	const headerEnd = src.indexOf("\n");
+	const header = headerEnd === -1 ? src : src.slice(0, headerEnd);
+	if (header.includes("+")) return "keep";
+	if (header.includes("-")) return "strip";
+	return "clip";
+}
+function getScalarValue(node, fullText) {
+	if (node.type === "block-scalar") return decodeBlockScalar(node.source, fullText, node.offset);
+	const style = getScalarStyle(node);
+	if (style === "single-quoted") return decodeSingleQuoted(node.source);
+	if (style === "double-quoted") return decodeDoubleQuoted(node.source);
+	return decodePlainScalar(node.source);
+}
+/**
+* YAML 1.2 §6.5 flow line folding for plain scalars.
+* - Bare newline between non-empty lines becomes a space (fold)
+* - Empty line(s) preserved as newline characters
+* - Leading whitespace on continuation lines trimmed
+* - Trailing whitespace before newlines trimmed
+*/
+function decodePlainScalar(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed.includes("\n")) return trimmed;
+	return foldFlowLines(trimmed);
+}
+/**
+* Decode single-quoted scalar with flow folding.
+* Only escape: '' → '
+* Bare newlines follow flow folding rules.
+*/
+function decodeSingleQuoted(raw) {
+	const unescaped = raw.slice(1, -1).replace(/''/g, "'");
+	if (!unescaped.includes("\n")) return unescaped;
+	return foldFlowLines(unescaped);
+}
+function decodeDoubleQuoted(raw) {
+	const inner = raw.slice(1, -1);
+	let result = "";
+	let significantEnd = 0;
+	let i = 0;
+	while (i < inner.length) {
+		const ch = inner[i];
+		if (ch === "\\") {
+			i++;
+			const esc = inner[i];
+			switch (esc) {
+				case "\\":
+					result += "\\";
+					break;
+				case "\"":
+					result += "\"";
+					break;
+				case "/":
+					result += "/";
+					break;
+				case "b":
+					result += "\b";
+					break;
+				case "f":
+					result += "\f";
+					break;
+				case "n":
+					result += "\n";
+					break;
+				case "r":
+					result += "\r";
+					break;
+				case "t":
+					result += "	";
+					break;
+				case "0":
+					result += "\0";
+					break;
+				case "a":
+					result += "\x07";
+					break;
+				case "e":
+					result += "\x1B";
+					break;
+				case "v":
+					result += "\v";
+					break;
+				case " ":
+					result += " ";
+					break;
+				case "N":
+					result += "…";
+					break;
+				case "_":
+					result += "\xA0";
+					break;
+				case "L":
+					result += "\u2028";
+					break;
+				case "P":
+					result += "\u2029";
+					break;
+				case "x": {
+					const hex = inner.slice(i + 1, i + 3);
+					result += String.fromCharCode(Number.parseInt(hex, 16));
+					i += 2;
+					break;
+				}
+				case "u": {
+					const hex = inner.slice(i + 1, i + 5);
+					result += String.fromCodePoint(Number.parseInt(hex, 16));
+					i += 4;
+					break;
+				}
+				case "U": {
+					const hex = inner.slice(i + 1, i + 9);
+					const cp = Number.parseInt(hex, 16);
+					result += cp <= 1114111 ? String.fromCodePoint(cp) : "�";
+					i += 8;
+					break;
+				}
+				case "\n":
+					i++;
+					while (i < inner.length && (inner[i] === " " || inner[i] === "	")) i++;
+					continue;
+				case "\r":
+					i++;
+					if (i < inner.length && inner[i] === "\n") i++;
+					while (i < inner.length && (inner[i] === " " || inner[i] === "	")) i++;
+					continue;
+				default: result += esc === void 0 ? "\\" : esc;
+			}
+			significantEnd = result.length;
+			i++;
+		} else if (ch === "\n" || ch === "\r" && inner[i + 1] === "\n") {
+			result = result.slice(0, significantEnd);
+			i += ch === "\r" ? 2 : 1;
+			while (i < inner.length && (inner[i] === " " || inner[i] === "	")) i++;
+			if (i < inner.length && (inner[i] === "\n" || inner[i] === "\r")) while (i < inner.length && (inner[i] === "\n" || inner[i] === "\r")) {
+				result += "\n";
+				i += inner[i] === "\r" && inner[i + 1] === "\n" ? 2 : 1;
+				while (i < inner.length && (inner[i] === " " || inner[i] === "	")) i++;
+			}
+			else result += " ";
+			significantEnd = result.length;
+		} else {
+			result += ch;
+			if (ch !== " " && ch !== "	") significantEnd = result.length;
+			i++;
+		}
+	}
+	return result;
+}
+/**
+* Apply YAML 1.2 §6.5 flow line folding to a string.
+* - Split into lines, trim trailing whitespace from each
+* - Newline between non-empty lines becomes a space
+* - Empty line preserved as newline in output
+* - Leading whitespace (indentation) on continuation lines trimmed
+*/
+function foldFlowLines(text) {
+	const lines = text.split("\n");
+	let result = "";
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i] ?? "";
+		if (i === 0) {
+			result += line.replace(/[ \t]+$/, "");
+			continue;
+		}
+		const isLast = i === lines.length - 1;
+		const trimmed = isLast ? line.trimStart() : line.trim();
+		if (trimmed === "") if (isLast) {
+			if (result.length === 0 || result[result.length - 1] !== "\n") result += " ";
+		} else result += "\n";
+		else {
+			if (result.length > 0 && result[result.length - 1] !== "\n") result += " ";
+			result += trimmed;
+		}
+	}
+	return result;
+}
+/**
+* Collect a multi-line plain scalar key from consecutive CST children.
+* Like `collectMultilinePlainScalar`, but for keys: collects plain scalars
+* up until the `:` value separator, merging them with flow line folding.
+* Returns the folded key text and the index after the last consumed child.
+*/
+function collectMultilineKey(children, startIdx) {
+	const first = children[startIdx];
+	if (first?.type !== "flow-scalar") return {
+		value: first?.source.trim() ?? "",
+		nextIdx: startIdx + 1
+	};
+	const parts = [first.source.trim()];
+	let idx = startIdx + 1;
+	while (idx < children.length) {
+		const child = children[idx];
+		if (!child) break;
+		if (child.type === "newline" || child.type === "whitespace" && child.source.trim() === "") {
+			idx++;
+			continue;
+		}
+		if (child.type === "whitespace" && (child.source === ":" || child.source === ",")) break;
+		if (child.type === "flow-scalar" && getScalarStyle(child) === "plain") {
+			parts.push(child.source.trim());
+			idx++;
+			continue;
+		}
+		break;
+	}
+	if (parts.length === 1) return {
+		value: parts[0] ?? "",
+		nextIdx: idx
+	};
+	return {
+		value: foldFlowLines(parts.join("\n")),
+		nextIdx: idx
+	};
+}
+/**
+* Extract the trimmed content of the line at `offset` in `text`.
+* Returns the trimmed text and the offset of the next line (or EOF).
+*/
+function extractLineContent(text, offset) {
+	let lineStart = offset;
+	while (lineStart > 0 && text[lineStart - 1] !== "\n") lineStart--;
+	let lineEnd = offset;
+	while (lineEnd < text.length && text[lineEnd] !== "\n" && text[lineEnd] !== "\r") lineEnd++;
+	return {
+		lineText: text.slice(lineStart, lineEnd).trim(),
+		lineEndOffset: lineEnd
+	};
+}
+/**
+* Skip all children whose offset falls on the same line as `lineOffset`.
+* Returns the index of the first child that is past the line end.
+*/
+function skipChildrenOnLine(children, startIdx, lineEndOffset) {
+	let idx = startIdx;
+	while (idx < children.length) {
+		const c = children[idx];
+		if (!c) break;
+		if (c.type === "newline" && c.offset >= lineEndOffset) break;
+		if (c.offset > lineEndOffset) break;
+		idx++;
+	}
+	return idx;
+}
+/**
+* Collect a multi-line plain scalar from consecutive CST children.
+* Starting from a plain flow-scalar at `startIdx`, look ahead through
+* newlines and whitespace for more plain flow-scalars that continue the
+* same value. Returns the folded scalar text and the index after the last
+* consumed child.
+*
+* A continuation scalar must:
+* - Be a plain flow-scalar (not quoted)
+* - NOT be followed by a value-sep (`:`) — that makes it a mapping key
+* - Be separated from the previous scalar only by newlines/whitespace
+*
+* When the lexer mis-tokenizes continuation line content as anchors, tags,
+* aliases, directives, or block-seq entries, this function detects such
+* lines and extracts the raw source text as continuation parts (3MYT, FBC9,
+* XLQ9, AB8U).
+*
+* `endOffset` is the source end of the last consumed fragment, so callers
+* can span the composed scalar node across the whole folded value (the
+* sourceMultiline decoration pass then stamps it from the span).
+*/
+function collectMultilinePlainScalar(children, startIdx, minContinuationColumn, sourceText) {
+	const first = children[startIdx];
+	if (first?.type !== "flow-scalar") return {
+		value: first?.source.trim() ?? "",
+		nextIdx: startIdx + 1,
+		partsCount: 1,
+		endOffset: first === void 0 ? 0 : first.offset + first.length
+	};
+	if (getScalarStyle(first) !== "plain") return {
+		value: getScalarValue(first),
+		nextIdx: startIdx + 1,
+		partsCount: 1,
+		endOffset: first.offset + first.length
+	};
+	const parts = [first.source.trim()];
+	let endOffset = first.offset + first.length;
+	let emptyLines = 0;
+	let idx = startIdx + 1;
+	let sawNewline = false;
+	while (idx < children.length) {
+		const child = children[idx];
+		if (!child) break;
+		if (child.type === "newline") {
+			emptyLines++;
+			sawNewline = true;
+			idx++;
+			continue;
+		}
+		if (child.type === "whitespace") {
+			if (child.source === ":" || child.source === "?" || child.source === "-") break;
+			idx++;
+			continue;
+		}
+		if (child.type === "comment") break;
+		if (child.type === "flow-scalar" && getScalarStyle(child) === "plain") {
+			if (hasValueSepAfterInList(children, idx + 1)) break;
+			if (hasBlockMapAfterInList(children, idx + 1)) break;
+			if (minContinuationColumn !== void 0 && sourceText) {
+				if (lineCol(sourceText, child.offset).column < minContinuationColumn) break;
+			}
+			if (emptyLines > 1) for (let e = 0; e < emptyLines - 1; e++) parts.push("");
+			parts.push(child.source.trim());
+			endOffset = child.offset + child.length;
+			emptyLines = 0;
+			sawNewline = false;
+			idx++;
+			continue;
+		}
+		if (sawNewline && sourceText && child.type !== "flow-scalar" && child.type !== "block-scalar") {
+			const childCol = lineCol(sourceText, child.offset).column;
+			const isDirectiveContinuation = child.type === "directive";
+			if (minContinuationColumn !== void 0 && !isDirectiveContinuation && childCol < minContinuationColumn) break;
+			if (childCol > 0 || isDirectiveContinuation) {
+				const { lineText, lineEndOffset } = extractLineContent(sourceText, child.offset);
+				if (lineText.length > 0) {
+					if (emptyLines > 1) for (let e = 0; e < emptyLines - 1; e++) parts.push("");
+					parts.push(lineText);
+					let contentEnd = lineEndOffset;
+					while (contentEnd > 0 && (sourceText[contentEnd - 1] === " " || sourceText[contentEnd - 1] === "	")) contentEnd--;
+					endOffset = contentEnd;
+					emptyLines = 0;
+					sawNewline = false;
+					idx = skipChildrenOnLine(children, idx, lineEndOffset);
+					continue;
+				}
+			}
+		}
+		break;
+	}
+	if (parts.length === 1) return {
+		value: parts[0] ?? "",
+		nextIdx: idx,
+		partsCount: 1,
+		endOffset
+	};
+	return {
+		value: foldFlowLines(parts.join("\n")),
+		nextIdx: idx,
+		partsCount: parts.length,
+		endOffset
+	};
+}
+/**
+* Find the index of the next non-trivia child (skips newline, whitespace, comment).
+* If `stopAtDash` is true, returns null when a `-` indicator is encountered before
+* any significant child (used to avoid merging across sequence entry boundaries).
+*/
+function findNextSignificantChild(children, startIdx, stopAtDash = false) {
+	for (let j = startIdx; j < children.length; j++) {
+		const c = children[j];
+		if (!c) continue;
+		if (c.type === "newline" || c.type === "comment") continue;
+		if (c.type === "whitespace") {
+			if (stopAtDash && c.source.trim() === "-") return null;
+			continue;
+		}
+		return j;
+	}
+	return null;
+}
+/**
+* Check if a value separator (`:`) follows in a CST children list,
+* skipping whitespace and newlines.
+*/
+function hasValueSepAfterInList(children, startIdx) {
+	return findValueSepOffset(children, startIdx) >= 0;
+}
+/**
+* Check if the next non-trivia child is a block-map (indicating that the
+* preceding scalar is the first key of a nested implicit mapping). Returns
+* false if a sibling `:` value-sep is encountered first, since that means
+* the scalar is a key at the current level (not a nested mapping start).
+*/
+function hasBlockMapAfterInList(children, startIdx) {
+	for (let j = startIdx; j < children.length; j++) {
+		const c = children[j];
+		if (!c) continue;
+		if (c.type === "newline" || c.type === "comment") continue;
+		if (c.type === "whitespace") {
+			if (c.source === ":") return false;
+			continue;
+		}
+		return c.type === "block-map";
+	}
+	return false;
+}
+/** Find the offset of the next ":" value separator in a CST children list, or -1 if none. */
+function findValueSepOffset(children, startIdx) {
+	for (let j = startIdx; j < children.length; j++) {
+		const c = children[j];
+		if (!c) continue;
+		if (c.type === "newline" || c.type === "comment") continue;
+		if (c.type === "whitespace") {
+			if (c.source === ":") return c.offset;
+			continue;
+		}
+		return -1;
+	}
+	return -1;
+}
+/** Check if a ":" value-sep exists between startIdx (inclusive) and endIdx (exclusive). */
+function hasValueSepBetween(children, startIdx, endIdx) {
+	for (let j = startIdx; j < endIdx; j++) {
+		const c = children[j];
+		if (!c) continue;
+		if (c.type === "whitespace" && c.source === ":") return true;
+	}
+	return false;
+}
+/**
+* Returns true when the first non-trivia child of a block-map CST node is a
+* `:` value separator (i.e., the block map begins with an implicit empty key
+* followed by a value indicator). Used to decide whether a pending anchor/tag
+* belongs to that empty key rather than to the block map itself.
+*/
+function blockMapStartsWithValueSep(blockMap) {
+	for (const c of blockMap.children ?? []) {
+		if (!c) continue;
+		if (c.type === "newline" || c.type === "comment") continue;
+		if (c.type === "whitespace") {
+			if (c.source === ":") return true;
+			if (c.source.trim() === "") continue;
+			return false;
+		}
+		return false;
+	}
+	return false;
+}
+/**
+* Like `hasValueSepAfterInList`, but also skips over plain flow-scalars
+* that appear after a newline. Used to detect multi-line keys:
+* `multi\n  line: value` where `:` comes after continuation plain scalars.
+* Only allows skipping plain scalars that were preceded by a newline,
+* preventing false matches across comma-delimited entries on the same line.
+*/
+function hasValueSepThroughPlainScalars(children, startIdx) {
+	let sawNewline = false;
+	for (let j = startIdx; j < children.length; j++) {
+		const c = children[j];
+		if (!c) continue;
+		if (c.type === "newline") {
+			sawNewline = true;
+			continue;
+		}
+		if (c.type === "comment") continue;
+		if (c.type === "whitespace") {
+			if (c.source === ":") return true;
+			if (c.source === ",") return false;
+			continue;
+		}
+		if (sawNewline && c.type === "flow-scalar" && getScalarStyle(c) === "plain") continue;
+		return false;
+	}
+	return false;
+}
+/** Find the next non-trivia CST child in a list, returning the node and its index. */
+function findNextContentInList(children, startIdx) {
+	for (let j = startIdx; j < children.length; j++) {
+		const c = children[j];
+		if (!c) continue;
+		if (c.type === "whitespace" || c.type === "newline" || c.type === "comment") continue;
+		return {
+			node: c,
+			idx: j
+		};
+	}
+	return null;
+}
+function findFirstContent(children) {
+	for (const c of children) {
+		if (!c) continue;
+		if (c.type === "whitespace" && c.source.trim() === "") continue;
+		if (c.type === "newline") continue;
+		return c;
+	}
+}
+function findLastContent(children) {
+	for (let i = children.length - 1; i >= 0; i--) {
+		const c = children[i];
+		if (!c) continue;
+		if (c.type === "whitespace" && c.source.trim() === "") continue;
+		if (c.type === "newline") continue;
+		return c;
+	}
+}
+/**
+* Find the next content child (skipping trivia AND anchor/tag properties),
+* or null. Used at the document level where properties precede content.
+*/
+function findNextContentChild(children, startIdx) {
+	for (let i = startIdx; i < children.length; i++) {
+		const c = children[i];
+		if (!c) continue;
+		if (c.type === "whitespace" || c.type === "newline" || c.type === "comment" || c.type === "anchor" || c.type === "tag") continue;
+		return c;
+	}
+	return null;
+}
+function indexOfChild(children, target) {
+	for (let i = 0; i < children.length; i++) if (children[i] === target) return i;
+	return -1;
+}
+/** Check if there's a value separator ":" after startIdx (skipping only whitespace). */
+function hasValueSepAfter(children, startIdx) {
+	for (let j = startIdx; j < children.length; j++) {
+		const c = children[j];
+		if (!c) continue;
+		if (c.type === "whitespace" && c.source === ":") return true;
+		if (c.type === "whitespace" && c.source !== ":") continue;
+		if (c.type === "newline") continue;
+		break;
+	}
+	return false;
+}
+/**
+* Scan backward in the full document text from a block scalar indicator's
+* position to find the parent context indentation level n. This handles:
+* - Same-line ":" (mapping value): n = key's column indent
+* - Same-line "-" (seq entry): n = column of "-"
+* - Own-line (preceded by newline, tag, anchor): scan further back across
+*   lines to find the ":" or "-" that introduced this value
+*/
+function findParentIndent(fullText, indicatorOffset) {
+	let scanBack = indicatorOffset - 1;
+	while (scanBack >= 0 && (fullText[scanBack] === " " || fullText[scanBack] === "	")) scanBack--;
+	if (scanBack >= 0 && fullText[scanBack] === ":") return findKeyIndent(fullText, scanBack);
+	if (scanBack >= 0 && fullText[scanBack] === "-") return findColOnLine(fullText, scanBack);
+	while (scanBack >= 0) {
+		const ch = fullText[scanBack];
+		if (ch === ":") return findKeyIndent(fullText, scanBack);
+		if (ch === "-") {
+			const afterDash = scanBack + 1;
+			if (afterDash >= fullText.length || fullText[afterDash] === " " || fullText[afterDash] === "	" || fullText[afterDash] === "\n" || fullText[afterDash] === "\r") return findColOnLine(fullText, scanBack);
+		}
+		scanBack--;
+	}
+	return 0;
+}
+/** Find the column of a character on its line. */
+function findColOnLine(text, pos) {
+	let lineStart = pos;
+	while (lineStart > 0 && text[lineStart - 1] !== "\n" && text[lineStart - 1] !== "\r") lineStart--;
+	return pos - lineStart;
+}
+/** Find the key indentation for a mapping ":" at the given position. */
+function findKeyIndent(text, colonPos) {
+	let lineStart = colonPos;
+	while (lineStart > 0 && text[lineStart - 1] !== "\n" && text[lineStart - 1] !== "\r") lineStart--;
+	let spaces = 0;
+	while (lineStart + spaces < text.length && text[lineStart + spaces] === " ") spaces++;
+	if (lineStart + spaces < text.length && text[lineStart + spaces] === "-") {
+		const afterDash = lineStart + spaces + 1;
+		if (afterDash < text.length && (text[afterDash] === " " || text[afterDash] === "	")) return spaces + 2;
+	}
+	return spaces;
+}
+function decodeBlockScalar(raw, fullText, nodeOffset) {
+	const firstChar = raw.trimStart()[0];
+	const isFolded = firstChar === ">";
+	let i = raw.indexOf(firstChar === ">" ? ">" : "|");
+	if (i < 0) return "";
+	i++;
+	let chomp = "clip";
+	let explicitIndent = 0;
+	for (let hc = 0; hc < 2 && i < raw.length && raw[i] !== "\n" && raw[i] !== "\r"; hc++) {
+		const ch = raw[i];
+		if (ch === "-") {
+			chomp = "strip";
+			i++;
+		} else if (ch === "+") {
+			chomp = "keep";
+			i++;
+		} else if (ch !== void 0 && ch >= "1" && ch <= "9") {
+			explicitIndent = Number.parseInt(ch, 10);
+			i++;
+		} else break;
+	}
+	while (i < raw.length && raw[i] !== "\n" && raw[i] !== "\r") i++;
+	if (i < raw.length) if (raw[i] === "\r" && raw[i + 1] === "\n") i += 2;
+	else i++;
+	let contentIndent = explicitIndent;
+	let foundContent = explicitIndent > 0;
+	if (explicitIndent > 0 && fullText !== void 0 && nodeOffset !== void 0) {
+		contentIndent = findParentIndent(fullText, nodeOffset) + explicitIndent;
+		foundContent = true;
+	} else if (contentIndent === 0) {
+		let scanAhead = i;
+		while (scanAhead < raw.length) {
+			let spaces = 0;
+			while (scanAhead < raw.length && raw[scanAhead] === " ") {
+				spaces++;
+				scanAhead++;
+			}
+			if (scanAhead >= raw.length || raw[scanAhead] === "\n" || raw[scanAhead] === "\r") {
+				if (scanAhead < raw.length) {
+					scanAhead++;
+					if (raw[scanAhead - 1] === "\r" && scanAhead < raw.length && raw[scanAhead] === "\n") scanAhead++;
+				}
+				continue;
+			}
+			contentIndent = spaces;
+			foundContent = true;
+			break;
+		}
+	}
+	if (!foundContent) {
+		if (chomp === "keep") {
+			let count = 0;
+			let j = i;
+			while (j < raw.length) {
+				while (j < raw.length && (raw[j] === " " || raw[j] === "	")) j++;
+				if (j >= raw.length) {
+					if (count === 0) count = 1;
+					break;
+				}
+				if (raw[j] === "\n") {
+					count++;
+					j++;
+				} else if (raw[j] === "\r") {
+					count++;
+					j++;
+					if (j < raw.length && raw[j] === "\n") j++;
+				} else break;
+			}
+			return "\n".repeat(count);
+		}
+		return "";
+	}
+	const lines = [];
+	const trailingNewlines = [];
+	while (i < raw.length) {
+		let spaces = 0;
+		while (i < raw.length && raw[i] === " ") {
+			spaces++;
+			i++;
+		}
+		if (i >= raw.length || raw[i] === "\n" || raw[i] === "\r") {
+			if (spaces > contentIndent) {
+				for (const nl of trailingNewlines) lines.push(nl);
+				trailingNewlines.length = 0;
+				lines.push(" ".repeat(spaces - contentIndent));
+			} else trailingNewlines.push("");
+			if (i < raw.length) if (raw[i] === "\r" && i + 1 < raw.length && raw[i + 1] === "\n") i += 2;
+			else i++;
+			continue;
+		}
+		if (spaces < contentIndent) break;
+		for (const _nl of trailingNewlines) lines.push("");
+		trailingNewlines.length = 0;
+		const extra = " ".repeat(spaces - contentIndent);
+		const contentStart = i;
+		while (i < raw.length && raw[i] !== "\n" && raw[i] !== "\r") i++;
+		lines.push(extra + raw.slice(contentStart, i));
+		if (i < raw.length) if (raw[i] === "\r" && i + 1 < raw.length && raw[i + 1] === "\n") i += 2;
+		else i++;
+	}
+	let value;
+	if (isFolded) {
+		let result = "";
+		let prevMoreIndented = false;
+		let hadContent = false;
+		for (let li = 0; li < lines.length; li++) {
+			const ln = lines[li] ?? "";
+			const isMoreIndented = ln.length > 0 && (ln[0] === " " || ln[0] === "	");
+			if (ln === "") result += "\n";
+			else if (!hadContent) {
+				result += ln;
+				prevMoreIndented = isMoreIndented;
+				hadContent = true;
+			} else {
+				if (result[result.length - 1] === "\n") if (isMoreIndented || prevMoreIndented) result += `\n${ln}`;
+				else result += ln;
+				else if (isMoreIndented || prevMoreIndented) result += `\n${ln}`;
+				else result += ` ${ln}`;
+				prevMoreIndented = isMoreIndented;
+			}
+		}
+		if (hadContent || trailingNewlines.length > 0) {
+			if (chomp === "keep") {
+				result += "\n";
+				for (const _nl of trailingNewlines) result += "\n";
+			} else if (chomp !== "strip") result += "\n";
+		}
+		value = result;
+	} else {
+		value = lines.join("\n");
+		if (lines.length > 0 || trailingNewlines.length > 0) {
+			if (chomp === "keep") {
+				value += "\n";
+				for (const _nl of trailingNewlines) value += "\n";
+			} else if (chomp !== "strip") value += "\n";
+		}
+	}
+	return value;
+}
+/**
+* 5LLU, S98Z, W9L4: per YAML 1.2 §8.1.1, leading empty lines preceding the
+* first content line in a block scalar must satisfy l-empty(n,c) — at most
+* n leading spaces, where n is the content indent. When the indent indicator
+* is auto-detected from the first non-empty line, that line establishes n;
+* any preceding empty line with more than n spaces is malformed.
+*/
+function validateBlockScalarLeadingEmpties(cst, state) {
+	const raw = cst.source;
+	let i = 0;
+	while (i < raw.length && raw[i] !== "\n" && raw[i] !== "\r") i++;
+	if (i < raw.length) if (raw[i] === "\r" && raw[i + 1] === "\n") i += 2;
+	else i++;
+	const emptyIndents = [];
+	while (i < raw.length) {
+		const lineStart = i;
+		let spaces = 0;
+		while (i < raw.length && raw[i] === " ") {
+			spaces++;
+			i++;
+		}
+		if (i >= raw.length || raw[i] === "\n" || raw[i] === "\r") {
+			emptyIndents.push({
+				indent: spaces,
+				offsetInRaw: lineStart
+			});
+			if (i < raw.length) if (raw[i] === "\r" && raw[i + 1] === "\n") i += 2;
+			else i++;
+			continue;
+		}
+		const contentIndent = spaces;
+		for (const empty of emptyIndents) if (empty.indent > contentIndent) {
+			const offset = cst.offset + empty.offsetInRaw;
+			state.errors.push({
+				code: "InvalidIndentation",
+				message: "Block scalar leading empty line cannot be more indented than the first content line",
+				offset,
+				length: empty.indent
+			});
+			return;
+		}
+		return;
+	}
+}
+function makeScalar(cst, state, meta) {
+	const style = getScalarStyle(cst);
+	if (style === "block-literal" || style === "block-folded") validateBlockScalarLeadingEmpties(cst, state);
+	const rawValue = getScalarValue(cst, state.text);
+	const value = resolveScalar(rawValue, style, meta?.tag, state);
+	const chomp = getBlockChomp(cst);
+	const needsRaw = style === "plain" && typeof value !== "string" && value !== void 0 && shouldPreserveRaw(rawValue, value);
+	const scalar = new YamlScalar({
+		value,
+		style,
+		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 } : {},
+		...chomp !== void 0 ? { chomp } : {},
+		...needsRaw ? { raw: rawValue } : {}
+	});
+	if (meta?.anchor) registerAnchor(scalar, meta.anchor, state, cst.offset);
+	return scalar;
+}
+/**
+* Returns true when the scalar's source representation should be preserved
+* for canonical round-trip — i.e. the source form differs from `String(value)`
+* but resolves to the same value.
+*
+* Special-float values (NaN, +/-Infinity) are excluded: their canonical YAML
+* spelling is the lowercase `.inf` / `.nan` form per spec §10.3, so source
+* variants like `.INF` or `.NaN` should normalize on round-trip rather than
+* preserve.
+*/
+function shouldPreserveRaw(rawValue, value) {
+	if (typeof value === "number") {
+		if (Number.isNaN(value) || !Number.isFinite(value)) return false;
+		return rawValue !== String(value);
+	}
+	return false;
+}
+
+//#endregion
+export { blockMapStartsWithValueSep, classifyPlainNumeric, collectMultilineKey, collectMultilinePlainScalar, findFirstContent, findLastContent, findNextContentChild, findNextContentInList, findNextSignificantChild, findValueSepOffset, foldFlowLines, getBlockChomp, getScalarStyle, getScalarValue, hasBlockMapAfterInList, hasValueSepAfter, hasValueSepAfterInList, hasValueSepBetween, hasValueSepThroughPlainScalars, indexOfChild, makeScalar, resolveScalar, shouldPreserveRaw };