yaml 2.8.2 → 3.0.0-0

package/dist/line-counter-TFl552k_.js

@@ -0,0 +1,3098 @@
+import { t as __exportAll } from "./chunk-BYypO7fO.js";
+import { _ as Collection, b as Scalar, f as Alias, g as YAMLSeq, i as Document, p as Pair, t as Directives, u as YAMLMap, v as stringifyString, x as NodeBase } from "./directives-CG6n4xSM.js";
+
+//#region src/compose/resolve-block-scalar.ts
+function resolveBlockScalar(ctx, scalar, onError) {
+	const start = scalar.offset;
+	const header = parseBlockScalarHeader(scalar, ctx.options.strict, onError);
+	if (!header) return {
+		value: "",
+		type: null,
+		comment: "",
+		range: [
+			start,
+			start,
+			start
+		]
+	};
+	const type = header.mode === ">" ? Scalar.BLOCK_FOLDED : Scalar.BLOCK_LITERAL;
+	const lines = scalar.source ? splitLines(scalar.source) : [];
+	let chompStart = lines.length;
+	for (let i = lines.length - 1; i >= 0; --i) {
+		const content = lines[i][1];
+		if (content === "" || content === "\r") chompStart = i;
+		else break;
+	}
+	if (chompStart === 0) {
+		const value = header.chomp === "+" && lines.length > 0 ? "\n".repeat(Math.max(1, lines.length - 1)) : "";
+		let end = start + header.length;
+		if (scalar.source) end += scalar.source.length;
+		return {
+			value,
+			type,
+			comment: header.comment,
+			range: [
+				start,
+				end,
+				end
+			]
+		};
+	}
+	let trimIndent = scalar.indent + header.indent;
+	let offset = scalar.offset + header.length;
+	let contentStart = 0;
+	for (let i = 0; i < chompStart; ++i) {
+		const [indent, content] = lines[i];
+		if (content === "" || content === "\r") {
+			if (header.indent === 0 && indent.length > trimIndent) trimIndent = indent.length;
+		} else {
+			if (indent.length < trimIndent) onError(offset + indent.length, "MISSING_CHAR", "Block scalars with more-indented leading empty lines must use an explicit indentation indicator");
+			if (header.indent === 0) trimIndent = indent.length;
+			contentStart = i;
+			if (trimIndent === 0 && !ctx.atRoot) onError(offset, "BAD_INDENT", "Block scalar values in collections must be indented");
+			break;
+		}
+		offset += indent.length + content.length + 1;
+	}
+	for (let i = lines.length - 1; i >= chompStart; --i) if (lines[i][0].length > trimIndent) chompStart = i + 1;
+	let value = "";
+	let sep = "";
+	let prevMoreIndented = false;
+	for (let i = 0; i < contentStart; ++i) value += lines[i][0].slice(trimIndent) + "\n";
+	for (let i = contentStart; i < chompStart; ++i) {
+		let [indent, content] = lines[i];
+		offset += indent.length + content.length + 1;
+		const crlf = content[content.length - 1] === "\r";
+		if (crlf) content = content.slice(0, -1);
+		/* istanbul ignore if already caught in lexer */
+		if (content && indent.length < trimIndent) {
+			const message = `Block scalar lines must not be less indented than their ${header.indent ? "explicit indentation indicator" : "first line"}`;
+			onError(offset - content.length - (crlf ? 2 : 1), "BAD_INDENT", message);
+			indent = "";
+		}
+		if (type === Scalar.BLOCK_LITERAL) {
+			value += sep + indent.slice(trimIndent) + content;
+			sep = "\n";
+		} else if (indent.length > trimIndent || content[0] === "	") {
+			if (sep === " ") sep = "\n";
+			else if (!prevMoreIndented && sep === "\n") sep = "\n\n";
+			value += sep + indent.slice(trimIndent) + content;
+			sep = "\n";
+			prevMoreIndented = true;
+		} else if (content === "") if (sep === "\n") value += "\n";
+		else sep = "\n";
+		else {
+			value += sep + content;
+			sep = " ";
+			prevMoreIndented = false;
+		}
+	}
+	switch (header.chomp) {
+		case "-": break;
+		case "+":
+			for (let i = chompStart; i < lines.length; ++i) value += "\n" + lines[i][0].slice(trimIndent);
+			if (value[value.length - 1] !== "\n") value += "\n";
+			break;
+		default: value += "\n";
+	}
+	const end = start + header.length + scalar.source.length;
+	return {
+		value,
+		type,
+		comment: header.comment,
+		range: [
+			start,
+			end,
+			end
+		]
+	};
+}
+function parseBlockScalarHeader({ offset, props }, strict, onError) {
+	/* istanbul ignore if should not happen */
+	if (props[0].type !== "block-scalar-header") {
+		onError(props[0], "IMPOSSIBLE", "Block scalar header not found");
+		return null;
+	}
+	const { source } = props[0];
+	const mode = source[0];
+	let indent = 0;
+	let chomp = "";
+	let error = -1;
+	for (let i = 1; i < source.length; ++i) {
+		const ch = source[i];
+		if (!chomp && (ch === "-" || ch === "+")) chomp = ch;
+		else {
+			const n = Number(ch);
+			if (!indent && n) indent = n;
+			else if (error === -1) error = offset + i;
+		}
+	}
+	if (error !== -1) onError(error, "UNEXPECTED_TOKEN", `Block scalar header includes extra characters: ${source}`);
+	let hasSpace = false;
+	let comment = "";
+	let length = source.length;
+	for (let i = 1; i < props.length; ++i) {
+		const token = props[i];
+		switch (token.type) {
+			case "space": hasSpace = true;
+			case "newline":
+				length += token.source.length;
+				break;
+			case "comment":
+				if (strict && !hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
+				length += token.source.length;
+				comment = token.source.substring(1);
+				break;
+			case "error":
+				onError(token, "UNEXPECTED_TOKEN", token.message);
+				length += token.source.length;
+				break;
+			default: {
+				onError(token, "UNEXPECTED_TOKEN", `Unexpected token in block scalar header: ${token.type}`);
+				const ts = token.source;
+				if (ts && typeof ts === "string") length += ts.length;
+			}
+		}
+	}
+	return {
+		mode,
+		indent,
+		chomp,
+		comment,
+		length
+	};
+}
+/** @returns Array of lines split up as `[indent, content]` */
+function splitLines(source) {
+	const split = source.split(/\n( *)/);
+	const first = split[0];
+	const m = first.match(/^( *)/);
+	const lines = [m?.[1] ? [m[1], first.slice(m[1].length)] : ["", first]];
+	for (let i = 1; i < split.length; i += 2) lines.push([split[i], split[i + 1]]);
+	return lines;
+}
+
+//#endregion
+//#region src/compose/resolve-end.ts
+function resolveEnd(end, offset, reqSpace, onError) {
+	let comment = "";
+	if (end) {
+		let hasSpace = false;
+		let sep = "";
+		for (const token of end) {
+			const { source, type } = token;
+			switch (type) {
+				case "space":
+					hasSpace = true;
+					break;
+				case "comment": {
+					if (reqSpace && !hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
+					const cb = source.substring(1) || " ";
+					if (!comment) comment = cb;
+					else comment += sep + cb;
+					sep = "";
+					break;
+				}
+				case "newline":
+					if (comment) sep += source;
+					hasSpace = true;
+					break;
+				default: onError(token, "UNEXPECTED_TOKEN", `Unexpected ${type} at node end`);
+			}
+			offset += source.length;
+		}
+	}
+	return {
+		comment,
+		offset
+	};
+}
+
+//#endregion
+//#region src/compose/resolve-flow-scalar.ts
+function resolveFlowScalar(scalar, strict, onError) {
+	const { offset, type, source, end } = scalar;
+	let _type;
+	let value;
+	const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
+	switch (type) {
+		case "scalar":
+			_type = Scalar.PLAIN;
+			value = plainValue(source, _onError);
+			break;
+		case "single-quoted-scalar":
+			_type = Scalar.QUOTE_SINGLE;
+			value = singleQuotedValue(source, _onError);
+			break;
+		case "double-quoted-scalar":
+			_type = Scalar.QUOTE_DOUBLE;
+			value = doubleQuotedValue(source, _onError);
+			break;
+		default:
+			onError(scalar, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
+			return {
+				value: "",
+				type: null,
+				comment: "",
+				range: [
+					offset,
+					offset + source.length,
+					offset + source.length
+				]
+			};
+	}
+	const valueEnd = offset + source.length;
+	const re = resolveEnd(end, valueEnd, strict, onError);
+	return {
+		value,
+		type: _type,
+		comment: re.comment,
+		range: [
+			offset,
+			valueEnd,
+			re.offset
+		]
+	};
+}
+function plainValue(source, onError) {
+	let badChar = "";
+	switch (source[0]) {
+		case "	":
+			badChar = "a tab character";
+			break;
+		case ",":
+			badChar = "flow indicator character ,";
+			break;
+		case "%":
+			badChar = "directive indicator character %";
+			break;
+		case "|":
+		case ">":
+			badChar = `block scalar indicator ${source[0]}`;
+			break;
+		case "@":
+		case "`":
+			badChar = `reserved character ${source[0]}`;
+			break;
+	}
+	if (badChar) onError(0, "BAD_SCALAR_START", `Plain value cannot start with ${badChar}`);
+	return foldLines(source);
+}
+function singleQuotedValue(source, onError) {
+	if (source[source.length - 1] !== "'" || source.length === 1) onError(source.length, "MISSING_CHAR", "Missing closing 'quote");
+	return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+}
+function foldLines(source) {
+	/**
+	* The negative lookbehind here and in the `re` RegExp is to
+	* prevent causing a polynomial search time in certain cases.
+	*
+	* The try-catch is for Safari, which doesn't support this yet:
+	* https://caniuse.com/js-regexp-lookbehind
+	*/
+	let first, line;
+	try {
+		first = /* @__PURE__ */ new RegExp("(.*?)(?<![ 	])[ 	]*\r?\n", "sy");
+		line = /* @__PURE__ */ new RegExp("[ 	]*(.*?)(?:(?<![ 	])[ 	]*)?\r?\n", "sy");
+	} catch {
+		first = /(.*?)[ \t]*\r?\n/sy;
+		line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+	}
+	let match = first.exec(source);
+	if (!match) return source;
+	let res = match[1];
+	let sep = " ";
+	let pos = first.lastIndex;
+	line.lastIndex = pos;
+	while (match = line.exec(source)) {
+		if (match[1] === "") if (sep === "\n") res += sep;
+		else sep = "\n";
+		else {
+			res += sep + match[1];
+			sep = " ";
+		}
+		pos = line.lastIndex;
+	}
+	const last = /[ \t]*(.*)/sy;
+	last.lastIndex = pos;
+	match = last.exec(source);
+	return res + sep + (match?.[1] ?? "");
+}
+function doubleQuotedValue(source, onError) {
+	let res = "";
+	for (let i = 1; i < source.length - 1; ++i) {
+		const ch = source[i];
+		if (ch === "\r" && source[i + 1] === "\n") continue;
+		if (ch === "\n") {
+			const { fold, offset } = foldNewline(source, i);
+			res += fold;
+			i = offset;
+		} else if (ch === "\\") {
+			let next = source[++i];
+			const cc = escapeCodes[next];
+			if (cc) res += cc;
+			else if (next === "\n") {
+				next = source[i + 1];
+				while (next === " " || next === "	") next = source[++i + 1];
+			} else if (next === "\r" && source[i + 1] === "\n") {
+				next = source[++i + 1];
+				while (next === " " || next === "	") next = source[++i + 1];
+			} else if (next === "x" || next === "u" || next === "U") {
+				const length = {
+					x: 2,
+					u: 4,
+					U: 8
+				}[next];
+				res += parseCharCode(source, i + 1, length, onError);
+				i += length;
+			} else {
+				const raw = source.substr(i - 1, 2);
+				onError(i - 1, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
+				res += raw;
+			}
+		} else if (ch === " " || ch === "	") {
+			const wsStart = i;
+			let next = source[i + 1];
+			while (next === " " || next === "	") next = source[++i + 1];
+			if (next !== "\n" && !(next === "\r" && source[i + 2] === "\n")) res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
+		} else res += ch;
+	}
+	if (source[source.length - 1] !== "\"" || source.length === 1) onError(source.length, "MISSING_CHAR", "Missing closing \"quote");
+	return res;
+}
+/**
+* Fold a single newline into a space, multiple newlines to N - 1 newlines.
+* Presumes `source[offset] === '\n'`
+*/
+function foldNewline(source, offset) {
+	let fold = "";
+	let ch = source[offset + 1];
+	while (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+		if (ch === "\r" && source[offset + 2] !== "\n") break;
+		if (ch === "\n") fold += "\n";
+		offset += 1;
+		ch = source[offset + 1];
+	}
+	if (!fold) fold = " ";
+	return {
+		fold,
+		offset
+	};
+}
+const escapeCodes = {
+	"0": "\0",
+	a: "\x07",
+	b: "\b",
+	e: "\x1B",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	",
+	v: "\v",
+	N: "…",
+	_: "\xA0",
+	L: "\u2028",
+	P: "\u2029",
+	" ": " ",
+	"\"": "\"",
+	"/": "/",
+	"\\": "\\",
+	"	": "	"
+};
+function parseCharCode(source, offset, length, onError) {
+	const cc = source.substr(offset, length);
+	const code = cc.length === length && /^[0-9a-fA-F]+$/.test(cc) ? parseInt(cc, 16) : NaN;
+	if (isNaN(code)) {
+		const raw = source.substr(offset - 2, length + 2);
+		onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
+		return raw;
+	}
+	return String.fromCodePoint(code);
+}
+
+//#endregion
+//#region src/errors.ts
+var YAMLError = class extends Error {
+	name;
+	code;
+	message;
+	pos;
+	linePos;
+	constructor(name, pos, code, message) {
+		super();
+		this.name = name;
+		this.code = code;
+		this.message = message;
+		this.pos = pos;
+	}
+};
+var YAMLParseError = class extends YAMLError {
+	constructor(pos, code, message) {
+		super("YAMLParseError", pos, code, message);
+	}
+};
+var YAMLWarning = class extends YAMLError {
+	constructor(pos, code, message) {
+		super("YAMLWarning", pos, code, message);
+	}
+};
+const prettifyError = (src, lc) => (error) => {
+	if (error.pos[0] === -1) return;
+	error.linePos = error.pos.map((pos) => lc.linePos(pos));
+	const { line, col } = error.linePos[0];
+	error.message += ` at line ${line}, column ${col}`;
+	let ci = col - 1;
+	let lineStr = src.substring(lc.lineStarts[line - 1], lc.lineStarts[line]).replace(/[\n\r]+$/, "");
+	if (ci >= 60 && lineStr.length > 80) {
+		const trimStart = Math.min(ci - 39, lineStr.length - 79);
+		lineStr = "…" + lineStr.substring(trimStart);
+		ci -= trimStart - 1;
+	}
+	if (lineStr.length > 80) lineStr = lineStr.substring(0, 79) + "…";
+	if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {
+		let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);
+		if (prev.length > 80) prev = prev.substring(0, 79) + "…\n";
+		lineStr = prev + lineStr;
+	}
+	if (/[^ ]/.test(lineStr)) {
+		let count = 1;
+		const end = error.linePos[1];
+		if (end?.line === line && end.col > col) count = Math.max(1, Math.min(end.col - col, 80 - ci));
+		const pointer = " ".repeat(ci) + "^".repeat(count);
+		error.message += `:\n\n${lineStr}\n${pointer}\n`;
+	}
+};
+
+//#endregion
+//#region src/parse/cst-scalar.ts
+function resolveAsScalar(token, strict = true, onError) {
+	if (token) {
+		const _onError = (pos, code, message) => {
+			const offset = typeof pos === "number" ? pos : Array.isArray(pos) ? pos[0] : pos.offset;
+			if (onError) onError(offset, code, message);
+			else throw new YAMLParseError([offset, offset + 1], code, message);
+		};
+		switch (token.type) {
+			case "scalar":
+			case "single-quoted-scalar":
+			case "double-quoted-scalar": return resolveFlowScalar(token, strict, _onError);
+			case "block-scalar": return resolveBlockScalar({ options: { strict } }, token, _onError);
+		}
+	}
+	return null;
+}
+/**
+* Create a new scalar token with `value`
+*
+* Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
+* as this function does not support any schema operations and won't check for such conflicts.
+*
+* @param value The string representation of the value, which will have its content properly indented.
+* @param context.end Comments and whitespace after the end of the value, or after the block scalar header. If undefined, a newline will be added.
+* @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
+* @param context.indent The indent level of the token.
+* @param context.inFlow Is this scalar within a flow collection? This may affect the resolved type of the token's value.
+* @param context.offset The offset position of the token.
+* @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
+*/
+function createScalarToken(value, context) {
+	const { implicitKey = false, indent, inFlow = false, offset = -1, type = "PLAIN" } = context;
+	const source = stringifyString({
+		type,
+		value
+	}, {
+		implicitKey,
+		indent: indent > 0 ? " ".repeat(indent) : "",
+		inFlow,
+		options: {
+			blockQuote: true,
+			lineWidth: -1
+		}
+	});
+	const end = context.end ?? [{
+		type: "newline",
+		offset: -1,
+		indent,
+		source: "\n"
+	}];
+	switch (source[0]) {
+		case "|":
+		case ">": {
+			const he = source.indexOf("\n");
+			const head = source.substring(0, he);
+			const body = source.substring(he + 1) + "\n";
+			const props = [{
+				type: "block-scalar-header",
+				offset,
+				indent,
+				source: head
+			}];
+			if (!addEndtoBlockProps(props, end)) props.push({
+				type: "newline",
+				offset: -1,
+				indent,
+				source: "\n"
+			});
+			return {
+				type: "block-scalar",
+				offset,
+				indent,
+				props,
+				source: body
+			};
+		}
+		case "\"": return {
+			type: "double-quoted-scalar",
+			offset,
+			indent,
+			source,
+			end
+		};
+		case "'": return {
+			type: "single-quoted-scalar",
+			offset,
+			indent,
+			source,
+			end
+		};
+		default: return {
+			type: "scalar",
+			offset,
+			indent,
+			source,
+			end
+		};
+	}
+}
+/**
+* Set the value of `token` to the given string `value`, overwriting any previous contents and type that it may have.
+*
+* Best efforts are made to retain any comments previously associated with the `token`,
+* though all contents within a collection's `items` will be overwritten.
+*
+* Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
+* as this function does not support any schema operations and won't check for such conflicts.
+*
+* @param token Any token. If it does not include an `indent` value, the value will be stringified as if it were an implicit key.
+* @param value The string representation of the value, which will have its content properly indented.
+* @param context.afterKey In most cases, values after a key should have an additional level of indentation.
+* @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
+* @param context.inFlow Being within a flow collection may affect the resolved type of the token's value.
+* @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
+*/
+function setScalarValue(token, value, context = {}) {
+	let { afterKey = false, implicitKey = false, inFlow = false, type } = context;
+	let indent = "indent" in token ? token.indent : null;
+	if (afterKey && typeof indent === "number") indent += 2;
+	if (!type) switch (token.type) {
+		case "single-quoted-scalar":
+			type = "QUOTE_SINGLE";
+			break;
+		case "double-quoted-scalar":
+			type = "QUOTE_DOUBLE";
+			break;
+		case "block-scalar": {
+			const header = token.props[0];
+			if (header.type !== "block-scalar-header") throw new Error("Invalid block scalar header");
+			type = header.source[0] === ">" ? "BLOCK_FOLDED" : "BLOCK_LITERAL";
+			break;
+		}
+		default: type = "PLAIN";
+	}
+	const source = stringifyString({
+		type,
+		value
+	}, {
+		implicitKey: implicitKey || indent === null,
+		indent: indent !== null && indent > 0 ? " ".repeat(indent) : "",
+		inFlow,
+		options: {
+			blockQuote: true,
+			lineWidth: -1
+		}
+	});
+	switch (source[0]) {
+		case "|":
+		case ">":
+			setBlockScalarValue(token, source);
+			break;
+		case "\"":
+			setFlowScalarValue(token, source, "double-quoted-scalar");
+			break;
+		case "'":
+			setFlowScalarValue(token, source, "single-quoted-scalar");
+			break;
+		default: setFlowScalarValue(token, source, "scalar");
+	}
+}
+function setBlockScalarValue(token, source) {
+	const he = source.indexOf("\n");
+	const head = source.substring(0, he);
+	const body = source.substring(he + 1) + "\n";
+	if (token.type === "block-scalar") {
+		const header = token.props[0];
+		if (header.type !== "block-scalar-header") throw new Error("Invalid block scalar header");
+		header.source = head;
+		token.source = body;
+	} else {
+		const { offset } = token;
+		const indent = "indent" in token ? token.indent : -1;
+		const props = [{
+			type: "block-scalar-header",
+			offset,
+			indent,
+			source: head
+		}];
+		if (!addEndtoBlockProps(props, "end" in token ? token.end : void 0)) props.push({
+			type: "newline",
+			offset: -1,
+			indent,
+			source: "\n"
+		});
+		for (const key of Object.keys(token)) if (key !== "type" && key !== "offset") delete token[key];
+		Object.assign(token, {
+			type: "block-scalar",
+			indent,
+			props,
+			source: body
+		});
+	}
+}
+/** @returns `true` if last token is a newline */
+function addEndtoBlockProps(props, end) {
+	if (end) for (const st of end) switch (st.type) {
+		case "space":
+		case "comment":
+			props.push(st);
+			break;
+		case "newline":
+			props.push(st);
+			return true;
+	}
+	return false;
+}
+function setFlowScalarValue(token, source, type) {
+	switch (token.type) {
+		case "scalar":
+		case "double-quoted-scalar":
+		case "single-quoted-scalar":
+			token.type = type;
+			token.source = source;
+			break;
+		case "block-scalar": {
+			const end = token.props.slice(1);
+			let oa = source.length;
+			if (token.props[0].type === "block-scalar-header") oa -= token.props[0].source.length;
+			for (const tok of end) tok.offset += oa;
+			delete token.props;
+			Object.assign(token, {
+				type,
+				source,
+				end
+			});
+			break;
+		}
+		case "block-map":
+		case "block-seq": {
+			const nl = {
+				type: "newline",
+				offset: token.offset + source.length,
+				indent: token.indent,
+				source: "\n"
+			};
+			delete token.items;
+			Object.assign(token, {
+				type,
+				source,
+				end: [nl]
+			});
+			break;
+		}
+		default: {
+			const indent = "indent" in token ? token.indent : -1;
+			const end = "end" in token && Array.isArray(token.end) ? token.end.filter((st) => st.type === "space" || st.type === "comment" || st.type === "newline") : [];
+			for (const key of Object.keys(token)) if (key !== "type" && key !== "offset") delete token[key];
+			Object.assign(token, {
+				type,
+				indent,
+				source,
+				end
+			});
+		}
+	}
+}
+
+//#endregion
+//#region src/parse/cst-stringify.ts
+/**
+* Stringify a CST document, token, or collection item
+*
+* Fair warning: This applies no validation whatsoever, and
+* simply concatenates the sources in their logical order.
+*/
+const stringify = (cst) => "type" in cst ? stringifyToken(cst) : stringifyItem(cst);
+function stringifyToken(token) {
+	switch (token.type) {
+		case "block-scalar": {
+			let res = "";
+			for (const tok of token.props) res += stringifyToken(tok);
+			return res + token.source;
+		}
+		case "block-map":
+		case "block-seq": {
+			let res = "";
+			for (const item of token.items) res += stringifyItem(item);
+			return res;
+		}
+		case "flow-collection": {
+			let res = token.start.source;
+			for (const item of token.items) res += stringifyItem(item);
+			for (const st of token.end) res += st.source;
+			return res;
+		}
+		case "document": {
+			let res = stringifyItem(token);
+			if (token.end) for (const st of token.end) res += st.source;
+			return res;
+		}
+		default: {
+			let res = token.source;
+			if ("end" in token && token.end) for (const st of token.end) res += st.source;
+			return res;
+		}
+	}
+}
+function stringifyItem({ start, key, sep, value }) {
+	let res = "";
+	for (const st of start) res += st.source;
+	if (key) res += stringifyToken(key);
+	if (sep) for (const st of sep) res += st.source;
+	if (value) res += stringifyToken(value);
+	return res;
+}
+
+//#endregion
+//#region src/parse/cst-visit.ts
+const BREAK = Symbol("break visit");
+const SKIP = Symbol("skip children");
+const REMOVE = Symbol("remove item");
+/**
+* Apply a visitor to a CST document or item.
+*
+* Walks through the tree (depth-first) starting from the root, calling a
+* `visitor` function with two arguments when entering each item:
+*   - `item`: The current item, which included the following members:
+*     - `start: SourceToken[]` – Source tokens before the key or value,
+*       possibly including its anchor or tag.
+*     - `key?: Token | null` – Set for pair values. May then be `null`, if
+*       the key before the `:` separator is empty.
+*     - `sep?: SourceToken[]` – Source tokens between the key and the value,
+*       which should include the `:` map value indicator if `value` is set.
+*     - `value?: Token` – The value of a sequence item, or of a map pair.
+*   - `path`: The steps from the root to the current node, as an array of
+*     `['key' | 'value', number]` tuples.
+*
+* The return value of the visitor may be used to control the traversal:
+*   - `undefined` (default): Do nothing and continue
+*   - `visit.SKIP`: Do not visit the children of this token, continue with
+*      next sibling
+*   - `visit.BREAK`: Terminate traversal completely
+*   - `visit.REMOVE`: Remove the current item, then continue with the next one
+*   - `number`: Set the index of the next step. This is useful especially if
+*     the index of the current token has changed.
+*   - `function`: Define the next visitor for this item. After the original
+*     visitor is called on item entry, next visitors are called after handling
+*     a non-empty `key` and when exiting the item.
+*/
+const visit = function visit(cst, visitor) {
+	if ("type" in cst && cst.type === "document") cst = {
+		start: cst.start,
+		value: cst.value
+	};
+	_visit(Object.freeze([]), cst, visitor);
+};
+visit.BREAK = BREAK;
+visit.SKIP = SKIP;
+visit.REMOVE = REMOVE;
+visit.itemAtPath = (cst, path) => {
+	let item = cst;
+	for (const [field, index] of path) {
+		const tok = item?.[field];
+		if (tok && "items" in tok) item = tok.items[index];
+		else return void 0;
+	}
+	return item;
+};
+visit.parentCollection = (cst, path) => {
+	const parent = visit.itemAtPath(cst, path.slice(0, -1));
+	const field = path[path.length - 1][0];
+	const coll = parent?.[field];
+	if (coll && "items" in coll) return coll;
+	throw new Error("Parent collection not found");
+};
+function _visit(path, item, visitor) {
+	let ctrl = visitor(item, path);
+	if (typeof ctrl === "symbol") return ctrl;
+	for (const field of ["key", "value"]) {
+		const token = item[field];
+		if (token && "items" in token) {
+			for (let i = 0; i < token.items.length; ++i) {
+				const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
+				if (typeof ci === "number") i = ci - 1;
+				else if (ci === BREAK) return BREAK;
+				else if (ci === REMOVE) {
+					token.items.splice(i, 1);
+					i -= 1;
+				}
+			}
+			if (typeof ctrl === "function" && field === "key") ctrl = ctrl(item, path);
+		}
+	}
+	return typeof ctrl === "function" ? ctrl(item, path) : ctrl;
+}
+
+//#endregion
+//#region src/parse/cst.ts
+var cst_exports = /* @__PURE__ */ __exportAll({
+	BOM: () => BOM,
+	DOCUMENT: () => DOCUMENT,
+	FLOW_END: () => FLOW_END,
+	SCALAR: () => SCALAR,
+	createScalarToken: () => createScalarToken,
+	isCollection: () => isCollection,
+	isScalar: () => isScalar,
+	prettyToken: () => prettyToken,
+	resolveAsScalar: () => resolveAsScalar,
+	setScalarValue: () => setScalarValue,
+	stringify: () => stringify,
+	tokenType: () => tokenType,
+	visit: () => visit
+});
+/** The byte order mark */
+const BOM = "";
+/** Start of doc-mode */
+const DOCUMENT = "";
+/** Unexpected end of flow-mode */
+const FLOW_END = "";
+/** Next token is a scalar value */
+const SCALAR = "";
+/** @returns `true` if `token` is a flow or block collection */
+const isCollection = (token) => !!token && "items" in token;
+/** @returns `true` if `token` is a flow or block scalar; not an alias */
+const isScalar = (token) => !!token && (token.type === "scalar" || token.type === "single-quoted-scalar" || token.type === "double-quoted-scalar" || token.type === "block-scalar");
+/* istanbul ignore next */
+/** Get a printable representation of a lexer token */
+function prettyToken(token) {
+	switch (token) {
+		case BOM: return "<BOM>";
+		case DOCUMENT: return "<DOC>";
+		case FLOW_END: return "<FLOW_END>";
+		case SCALAR: return "<SCALAR>";
+		default: return JSON.stringify(token);
+	}
+}
+/** Identify the type of a lexer token. May return `null` for unknown tokens. */
+function tokenType(source) {
+	switch (source) {
+		case BOM: return "byte-order-mark";
+		case DOCUMENT: return "doc-mode";
+		case FLOW_END: return "flow-error-end";
+		case SCALAR: return "scalar";
+		case "---": return "doc-start";
+		case "...": return "doc-end";
+		case "":
+		case "\n":
+		case "\r\n": return "newline";
+		case "-": return "seq-item-ind";
+		case "?": return "explicit-key-ind";
+		case ":": return "map-value-ind";
+		case "{": return "flow-map-start";
+		case "}": return "flow-map-end";
+		case "[": return "flow-seq-start";
+		case "]": return "flow-seq-end";
+		case ",": return "comma";
+	}
+	switch (source[0]) {
+		case " ":
+		case "	": return "space";
+		case "#": return "comment";
+		case "%": return "directive-line";
+		case "*": return "alias";
+		case "&": return "anchor";
+		case "!": return "tag";
+		case "'": return "single-quoted-scalar";
+		case "\"": return "double-quoted-scalar";
+		case "|":
+		case ">": return "block-scalar-header";
+	}
+	return null;
+}
+
+//#endregion
+//#region src/parse/lexer.ts
+function isEmpty(ch) {
+	switch (ch) {
+		case void 0:
+		case " ":
+		case "\n":
+		case "\r":
+		case "	": return true;
+		default: return false;
+	}
+}
+const flowIndicatorChars = /* @__PURE__ */ new Set(",[]{}");
+const invalidAnchorChars = /* @__PURE__ */ new Set(" ,[]{}\n\r	");
+const isNotAnchorChar = (ch) => !ch || invalidAnchorChars.has(ch);
+const blockScalarHeader = /([|>][^\s#]*)([ \t]*)((?:.|\r(?!\n))*)$/my;
+const blockStart = /([-?:])(?=[ \n\r\t]|$)([ \t]*)/y;
+const directiveLine = /(%.*?)(?:([ \t]+)(#.*)?)?$/my;
+const docMarker = /[-.]{3}(?=[ \n\r\t]|$)(?:([ \t]+)(#.*)?)?/y;
+const emptyLineOrComment = /([ \t]*)(#.*)?$/my;
+const indicator = /(?:(&[^\s,[\]{}]*|!<[^\s>]*>?|!(?:[0-9a-z-#;/?:@&=+$_.!~*'()]|%[0-9a-f]{2})*)|([-?:])(?=[ \n\r\t]|$)|([-?:])(?=[,[\]{}]|$))([ \t]*)/iy;
+/**
+* Splits an input `source` string into lexical YAML tokens,
+* i.e. smaller strings that are easily identifiable by `tokens.tokenType()`.
+*
+* Lexing starts always in a "stream" context.
+*
+* In addition to slices of the original input, the following control characters
+* may also be emitted:
+*
+* - `\x02` (Start of Text): A document starts with the next token
+* - `\x18` (Cancel): Unexpected end of flow-mode (indicates an error)
+* - `\x1f` (Unit Separator): Next token is a scalar value
+* - `\u{FEFF}` (Byte order mark): Emitted separately outside documents
+*/
+function lex(source) {
+	if (typeof source !== "string") throw TypeError("source is not a string");
+	const lexer = new Lexer(source);
+	const end = source.length;
+	let state = "stream";
+	while (lexer.pos < end) state = lexer[state]();
+	return lexer.tokens;
+}
+var Lexer = class {
+	/** Current input */
+	source = "";
+	/**
+	* Flag noting whether the map value indicator : can immediately follow this
+	* node within a flow context.
+	*/
+	flowKey = false;
+	/** Count of surrounding flow collection levels. */
+	flowLevel = 0;
+	/**
+	* Minimum level of indentation required for next lines to be parsed as a
+	* part of the current scalar value.
+	*/
+	indentNext = 0;
+	/** Indentation level of the current line. */
+	indentValue = 0;
+	/** A pointer to `source`; the current position of the lexer. */
+	pos = 0;
+	tokens = [];
+	constructor(source) {
+		this.source = source;
+	}
+	charAt(n) {
+		return this.source[this.pos + n];
+	}
+	continueScalar(offset) {
+		if (this.indentNext > 0) {
+			let ch = this.source[offset];
+			let indent = 0;
+			while (ch === " ") ch = this.source[++indent + offset];
+			if (ch === "\r") {
+				if (this.source[indent + offset + 1] === "\n") return offset + indent + 1;
+			}
+			return ch === "\n" || indent >= this.indentNext ? offset + indent : -1;
+		}
+		docMarker.lastIndex = offset;
+		return docMarker.test(this.source) ? -1 : offset;
+	}
+	stream() {
+		if (this.charAt(0) === BOM) {
+			this.count(1);
+			return "stream";
+		}
+		directiveLine.lastIndex = this.pos;
+		let m = directiveLine.exec(this.source);
+		if (m) {
+			const [line, directive, spaces, comment] = m;
+			this.tokens.push(directive);
+			if (spaces) this.tokens.push(spaces);
+			if (comment) this.tokens.push(comment);
+			this.pos += line.length;
+			this.newline();
+			return "stream";
+		}
+		emptyLineOrComment.lastIndex = this.pos;
+		m = emptyLineOrComment.exec(this.source);
+		if (m) {
+			const [line, spaces, comment] = m;
+			if (spaces) this.tokens.push(spaces);
+			if (comment) this.tokens.push(comment);
+			this.pos += line.length;
+			this.newline();
+			return "stream";
+		}
+		this.tokens.push(DOCUMENT);
+		return this.lineStart();
+	}
+	lineStart() {
+		docMarker.lastIndex = this.pos;
+		const dmm = docMarker.exec(this.source);
+		if (dmm) {
+			const [line, spaces, comment] = dmm;
+			this.count(3);
+			if (spaces) {
+				this.tokens.push(spaces);
+				this.pos += spaces.length;
+			}
+			if (comment) {
+				this.tokens.push(comment);
+				this.pos += comment.length;
+			}
+			this.newline();
+			this.indentValue = 0;
+			this.indentNext = 0;
+			return line.startsWith("-") ? this.lineStart() : "stream";
+		}
+		this.indentValue = this.spaces(false);
+		if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1))) this.indentNext = this.indentValue;
+		blockStart.lastIndex = this.pos;
+		let bsm;
+		while (bsm = blockStart.exec(this.source)) {
+			const [line, indicator, spaces] = bsm;
+			this.tokens.push(indicator);
+			if (spaces) this.tokens.push(spaces);
+			this.pos += line.length;
+			this.indentNext = this.indentValue + 1;
+			this.indentValue += line.length;
+		}
+		return "document";
+	}
+	document() {
+		this.spaces(true);
+		this.indicators();
+		switch (this.charAt(0)) {
+			case "#": this.toLineEnd();
+			case "\n":
+			case void 0:
+				this.newline();
+				return this.lineStart();
+			case "{":
+			case "[":
+				this.count(1);
+				this.flowKey = false;
+				this.flowLevel = 1;
+				return "flow";
+			case "}":
+			case "]":
+				this.count(1);
+				return "document";
+			case "*":
+				this.until(isNotAnchorChar);
+				return "document";
+			case "\"":
+			case "'":
+				this.quotedScalar();
+				return "document";
+			case "|":
+			case ">":
+				this.blockScalar();
+				return this.lineStart();
+			case "\r": if (this.charAt(1) === "\n") {
+				this.count(2);
+				return this.lineStart();
+			}
+			default:
+				this.plainScalar();
+				return "document";
+		}
+	}
+	flow() {
+		let nl, sp;
+		let indent = -1;
+		do {
+			nl = this.newline();
+			if (nl > 0) {
+				sp = this.spaces(false);
+				this.indentValue = indent = sp;
+			} else sp = 0;
+			sp += this.spaces(true);
+		} while (nl + sp > 0);
+		let ch = this.charAt(0);
+		if (indent !== -1 && indent < this.indentNext && ch !== "#" && !(indent === this.indentNext - 1 && this.flowLevel === 1 && (ch === "]" || ch === "}"))) {
+			this.flowLevel = 0;
+			this.tokens.push(FLOW_END);
+			return this.lineStart();
+		}
+		if (indent === 0) {
+			docMarker.lastIndex = this.pos;
+			if (docMarker.test(this.source)) {
+				this.flowLevel = 0;
+				this.tokens.push(FLOW_END);
+				return this.lineStart();
+			}
+		}
+		while (ch === ",") {
+			this.count(1);
+			this.spaces(true);
+			this.flowKey = false;
+			ch = this.charAt(0);
+		}
+		if (this.indicators()) ch = this.charAt(0);
+		switch (ch) {
+			case "\n":
+			case void 0: break;
+			case "#":
+				this.toLineEnd();
+				break;
+			case "{":
+			case "[":
+				this.count(1);
+				this.flowKey = false;
+				this.flowLevel += 1;
+				break;
+			case "}":
+			case "]":
+				this.count(1);
+				this.flowKey = true;
+				this.flowLevel -= 1;
+				return this.flowLevel ? "flow" : "document";
+			case "*":
+				this.until(isNotAnchorChar);
+				break;
+			case "\"":
+			case "'":
+				this.flowKey = true;
+				this.quotedScalar();
+				break;
+			case ":":
+				if (this.flowKey) {
+					this.flowKey = false;
+					this.count(1);
+					this.spaces(true);
+				} else {
+					const next = this.charAt(1);
+					if (isEmpty(next) || next === ",") {
+						this.count(1);
+						this.spaces(true);
+					} else this.plainScalar();
+				}
+				break;
+			case "\r": if (this.charAt(1) === "\n") break;
+			default:
+				this.flowKey = false;
+				this.plainScalar();
+		}
+		return "flow";
+	}
+	indicators() {
+		let hasIndicators = false;
+		indicator.lastIndex = this.pos;
+		let m;
+		while (m = indicator.exec(this.source)) {
+			hasIndicators ||= true;
+			const [fm, tagOrAnchor, bsEmpty, bsInFlow, spaces] = m;
+			if (tagOrAnchor) this.tokens.push(tagOrAnchor);
+			else if (this.flowLevel > 0) {
+				this.tokens.push(bsEmpty ?? bsInFlow);
+				this.flowKey &&= false;
+			} else if (bsEmpty) {
+				this.tokens.push(bsEmpty);
+				this.indentNext = this.indentValue + 1;
+			} else break;
+			if (spaces) this.tokens.push(spaces);
+			this.pos += fm.length;
+		}
+		return hasIndicators;
+	}
+	quotedScalar() {
+		const quote = this.charAt(0);
+		let end = this.source.indexOf(quote, this.pos + 1);
+		if (quote === "'") while (end !== -1 && this.source[end + 1] === "'") end = this.source.indexOf("'", end + 2);
+		else while (end !== -1) {
+			let n = 0;
+			while (this.source[end - 1 - n] === "\\") n += 1;
+			if (n % 2 === 0) break;
+			end = this.source.indexOf("\"", end + 1);
+		}
+		const qb = this.source.substring(0, end);
+		let nl = qb.indexOf("\n", this.pos);
+		if (nl !== -1) {
+			while (nl !== -1) {
+				const cs = this.continueScalar(nl + 1);
+				if (cs === -1) break;
+				nl = qb.indexOf("\n", cs);
+			}
+			if (nl !== -1) end = nl - (qb[nl - 1] === "\r" ? 2 : 1);
+		}
+		if (end === -1) end = this.source.length;
+		this.toIndex(end + 1, false);
+	}
+	blockScalar() {
+		let bsIndent = -1;
+		let bsKeep = false;
+		blockScalarHeader.lastIndex = this.pos;
+		const [line, header, spaces, comment] = blockScalarHeader.exec(this.source);
+		for (const ch of header) if (ch === "+") bsKeep = true;
+		else if (ch > "0" && ch <= "9") bsIndent = Number(ch) - 1;
+		this.tokens.push(header);
+		if (spaces) this.tokens.push(spaces);
+		if (comment) this.tokens.push(comment);
+		this.pos += line.length;
+		this.newline();
+		let nl = this.pos - 1;
+		let indent = 0;
+		let ch;
+		loop: for (let i = this.pos; ch = this.source[i]; ++i) switch (ch) {
+			case " ":
+				indent += 1;
+				break;
+			case "\n":
+				nl = i;
+				indent = 0;
+				break;
+			case "\r": if (this.source[i + 1] === "\n") break;
+			default: break loop;
+		}
+		if (indent >= this.indentNext) {
+			if (bsIndent === -1) this.indentNext = indent;
+			else this.indentNext = bsIndent + (this.indentNext === 0 ? 1 : this.indentNext);
+			do {
+				const cs = this.continueScalar(nl + 1);
+				if (cs === -1) break;
+				nl = this.source.indexOf("\n", cs);
+			} while (nl !== -1);
+			if (nl === -1) nl = this.source.length;
+		}
+		let i = nl + 1;
+		ch = this.source[i];
+		while (ch === " ") ch = this.source[++i];
+		if (ch === "	") {
+			while (ch === "	" || ch === " " || ch === "\r" || ch === "\n") ch = this.source[++i];
+			nl = i - 1;
+		} else if (!bsKeep) do {
+			let i = nl - 1;
+			let ch = this.source[i];
+			if (ch === "\r") ch = this.source[--i];
+			const lastChar = i;
+			while (ch === " ") ch = this.source[--i];
+			if (ch === "\n" && i >= this.pos && i + 1 + indent > lastChar) nl = i;
+			else break;
+		} while (true);
+		this.tokens.push(SCALAR);
+		this.toIndex(nl + 1, true);
+	}
+	plainScalar() {
+		const inFlow = this.flowLevel > 0;
+		let end = this.pos - 1;
+		let i = this.pos - 1;
+		let ch;
+		while (ch = this.source[++i]) if (ch === ":") {
+			const next = this.source[i + 1];
+			if (isEmpty(next) || inFlow && flowIndicatorChars.has(next)) break;
+			end = i;
+		} else if (isEmpty(ch)) {
+			let next = this.source[i + 1];
+			if (ch === "\r") if (next === "\n") {
+				i += 1;
+				ch = "\n";
+				next = this.source[i + 1];
+			} else end = i;
+			if (next === "#" || inFlow && flowIndicatorChars.has(next)) break;
+			if (ch === "\n") {
+				const cs = this.continueScalar(i + 1);
+				if (cs === -1) break;
+				i = Math.max(i, cs - 2);
+			}
+		} else {
+			if (inFlow && flowIndicatorChars.has(ch)) break;
+			end = i;
+		}
+		this.tokens.push(SCALAR);
+		this.toIndex(end + 1, true);
+	}
+	count(n) {
+		if (n > 0) {
+			const s = this.source.substr(this.pos, n);
+			this.tokens.push(s);
+			this.pos += n;
+			return n;
+		}
+		return 0;
+	}
+	toIndex(i, allowEmpty) {
+		const s = this.source.slice(this.pos, i);
+		if (s) {
+			this.tokens.push(s);
+			this.pos += s.length;
+		} else if (allowEmpty) this.tokens.push("");
+		return s.length;
+	}
+	toLineEnd() {
+		let i = this.pos;
+		let ch = this.source[i];
+		while (ch && ch !== "\n") ch = this.source[++i];
+		if (this.source[i - 1] === "\r") --i;
+		return this.toIndex(i, false);
+	}
+	newline() {
+		const ch = this.source[this.pos];
+		if (ch === "\n") return this.count(1);
+		else if (ch === "\r" && this.charAt(1) === "\n") return this.count(2);
+		else return 0;
+	}
+	spaces(allowTabs) {
+		let i = this.pos - 1;
+		let ch;
+		do
+			ch = this.source[++i];
+		while (ch === " " || allowTabs && ch === "	");
+		const n = i - this.pos;
+		if (n > 0) {
+			const s = this.source.substr(this.pos, n);
+			this.tokens.push(s);
+			this.pos = i;
+		}
+		return n;
+	}
+	until(test) {
+		let i = this.pos;
+		let ch = this.source[i];
+		while (!test(ch)) ch = this.source[++i];
+		return this.toIndex(i, false);
+	}
+};
+
+//#endregion
+//#region src/parse/parser.ts
+function includesToken(list, type) {
+	for (let i = 0; i < list.length; ++i) if (list[i].type === type) return true;
+	return false;
+}
+const logToken$1 = typeof process !== "undefined" && process.env?.LOG_TOKENS ? (token) => console.log("|", prettyToken(token)) : () => {};
+function findNonEmptyIndex(list) {
+	for (let i = 0; i < list.length; ++i) switch (list[i].type) {
+		case "space":
+		case "comment":
+		case "newline": break;
+		default: return i;
+	}
+	return -1;
+}
+function isFlowToken(token) {
+	switch (token?.type) {
+		case "alias":
+		case "scalar":
+		case "single-quoted-scalar":
+		case "double-quoted-scalar":
+		case "flow-collection": return true;
+		default: return false;
+	}
+}
+function getPrevProps(parent) {
+	switch (parent.type) {
+		case "document": return parent.start;
+		case "block-map": {
+			const it = parent.items[parent.items.length - 1];
+			return it.sep ?? it.start;
+		}
+		case "block-seq": return parent.items[parent.items.length - 1].start;
+		default: return [];
+	}
+}
+/** Note: May modify input array */
+function getFirstKeyStartProps(prev) {
+	if (prev.length === 0) return [];
+	let i = prev.length;
+	loop: while (--i >= 0) switch (prev[i].type) {
+		case "doc-start":
+		case "explicit-key-ind":
+		case "map-value-ind":
+		case "seq-item-ind":
+		case "newline": break loop;
+	}
+	while (prev[++i]?.type === "space");
+	return prev.splice(i, prev.length);
+}
+function fixFlowSeqItems(fc) {
+	if (fc.start.type === "flow-seq-start") {
+		for (const it of fc.items) if (it.sep && !it.value && !includesToken(it.start, "explicit-key-ind") && !includesToken(it.sep, "map-value-ind")) {
+			if (it.key) it.value = it.key;
+			delete it.key;
+			if (isFlowToken(it.value)) if (it.value.end) Array.prototype.push.apply(it.value.end, it.sep);
+			else it.value.end = it.sep;
+			else Array.prototype.push.apply(it.start, it.sep);
+			delete it.sep;
+		}
+	}
+}
+/**
+* A YAML concrete syntax tree (CST) parser
+*
+* ```ts
+* const src: string = ...
+* for (const token of new Parser().parse(src)) {
+*   // token: Token
+* }
+* ```
+*
+* To use the parser with a user-provided lexer:
+*
+* ```ts
+* function parse(source: string, lexTokens: string[]) {
+*   const parser = new Parser()
+*   for (const lexeme of lexTokens) parser.next(lexeme)
+*   return parser.end()
+* }
+*
+* const src: string = ...
+* for (const token of parse(src, lex(src))) {
+*   // token: Token
+* }
+* ```
+*/
+var Parser = class {
+	onNewLine;
+	/** If true, space and sequence indicators count as indentation */
+	atNewLine = true;
+	/** If true, next token is a scalar value */
+	atScalar = false;
+	/** Current indentation level */
+	indent = 0;
+	/** Current offset since the start of parsing */
+	offset = 0;
+	/** On the same line with a block map key */
+	onKeyLine = false;
+	/** Top indicates the node that's currently being built */
+	stack = [];
+	/** The source of the current token, set in parse() */
+	source = "";
+	/** The type of the current token, set in parse() */
+	type = "";
+	tokens = [];
+	/**
+	* @param onNewLine - If defined, called separately with the start position of
+	*   each new line (in `parse()`, including the start of input).
+	*/
+	constructor(onNewLine) {
+		this.onNewLine = onNewLine;
+	}
+	/**
+	* Parse `source` as a YAML stream.
+	*
+	* Errors are not thrown, but included in the result as `{ type: 'error', message }` tokens.
+	*
+	* @returns Tokens representing each directive, document, and other structure.
+	*/
+	parse(source) {
+		if (this.onNewLine && this.offset === 0) this.onNewLine(0);
+		for (const lexeme of lex(source)) this.next(lexeme);
+		return this.end();
+	}
+	/**
+	* Advance the parser by the `source` of one lexical token.
+	*/
+	next(source) {
+		this.source = source;
+		logToken$1(source);
+		if (this.atScalar) {
+			this.atScalar = false;
+			this.step();
+			this.offset += source.length;
+			return;
+		}
+		const type = tokenType(source);
+		if (!type) {
+			const message = `Not a YAML token: ${source}`;
+			this.pop({
+				type: "error",
+				offset: this.offset,
+				message,
+				source
+			});
+			this.offset += source.length;
+		} else if (type === "scalar") {
+			this.atNewLine = false;
+			this.atScalar = true;
+			this.type = "scalar";
+		} else {
+			this.type = type;
+			this.step();
+			switch (type) {
+				case "newline":
+					this.atNewLine = true;
+					this.indent = 0;
+					if (this.onNewLine) this.onNewLine(this.offset + source.length);
+					break;
+				case "space":
+					if (this.atNewLine && source[0] === " ") this.indent += source.length;
+					break;
+				case "explicit-key-ind":
+				case "map-value-ind":
+				case "seq-item-ind":
+					if (this.atNewLine) this.indent += source.length;
+					break;
+				case "doc-mode":
+				case "flow-error-end": return;
+				default: this.atNewLine = false;
+			}
+			this.offset += source.length;
+		}
+	}
+	/** Call at end of input to account for any remaining constructions */
+	end() {
+		while (this.stack.length > 0) this.pop();
+		return this.tokens;
+	}
+	get sourceToken() {
+		return {
+			type: this.type,
+			offset: this.offset,
+			indent: this.indent,
+			source: this.source
+		};
+	}
+	step() {
+		const top = this.peek(1);
+		if (this.type === "doc-end" && top?.type !== "doc-end") {
+			while (this.stack.length > 0) this.pop();
+			this.stack.push({
+				type: "doc-end",
+				offset: this.offset,
+				source: this.source
+			});
+			return;
+		}
+		if (!top) {
+			const token = this.stream();
+			if (token) this.tokens.push(token);
+			return;
+		}
+		switch (top.type) {
+			case "document": return this.document(top);
+			case "alias":
+			case "scalar":
+			case "single-quoted-scalar":
+			case "double-quoted-scalar": return this.scalar(top);
+			case "block-scalar": return this.blockScalar(top);
+			case "block-map": return this.blockMap(top);
+			case "block-seq": return this.blockSequence(top);
+			case "flow-collection": return this.flowCollection(top);
+			case "doc-end": return this.documentEnd(top);
+		}
+		/* istanbul ignore next should not happen */
+		this.pop();
+	}
+	peek(n) {
+		return this.stack[this.stack.length - n];
+	}
+	pop(error) {
+		const token = error ?? this.stack.pop();
+		/* istanbul ignore if should not happen */
+		if (!token) this.tokens.push({
+			type: "error",
+			offset: this.offset,
+			source: "",
+			message: "Tried to pop an empty stack"
+		});
+		else if (this.stack.length === 0) this.tokens.push(token);
+		else {
+			const top = this.peek(1);
+			if (token.type === "block-scalar") token.indent = "indent" in top ? top.indent : 0;
+			else if (token.type === "flow-collection" && top.type === "document") token.indent = 0;
+			if (token.type === "flow-collection") fixFlowSeqItems(token);
+			switch (top.type) {
+				case "document":
+					top.value = token;
+					break;
+				case "block-scalar":
+					top.props.push(token);
+					break;
+				case "block-map": {
+					const it = top.items[top.items.length - 1];
+					if (it.value) {
+						top.items.push({
+							start: [],
+							key: token,
+							sep: []
+						});
+						this.onKeyLine = true;
+						return;
+					} else if (it.sep) it.value = token;
+					else {
+						Object.assign(it, {
+							key: token,
+							sep: []
+						});
+						this.onKeyLine = !it.explicitKey;
+						return;
+					}
+					break;
+				}
+				case "block-seq": {
+					const it = top.items[top.items.length - 1];
+					if (it.value) top.items.push({
+						start: [],
+						value: token
+					});
+					else it.value = token;
+					break;
+				}
+				case "flow-collection": {
+					const it = top.items[top.items.length - 1];
+					if (!it || it.value) top.items.push({
+						start: [],
+						key: token,
+						sep: []
+					});
+					else if (it.sep) it.value = token;
+					else Object.assign(it, {
+						key: token,
+						sep: []
+					});
+					return;
+				}
+				default:
+					this.pop();
+					this.pop(token);
+			}
+			if ((top.type === "document" || top.type === "block-map" || top.type === "block-seq") && (token.type === "block-map" || token.type === "block-seq")) {
+				const last = token.items[token.items.length - 1];
+				if (last && !last.sep && !last.value && last.start.length > 0 && findNonEmptyIndex(last.start) === -1 && (token.indent === 0 || last.start.every((st) => st.type !== "comment" || st.indent < token.indent))) {
+					if (top.type === "document") top.end = last.start;
+					else top.items.push({ start: last.start });
+					token.items.splice(-1, 1);
+				}
+			}
+		}
+	}
+	stream() {
+		switch (this.type) {
+			case "directive-line": return {
+				type: "directive",
+				offset: this.offset,
+				source: this.source
+			};
+			case "byte-order-mark":
+			case "space":
+			case "comment":
+			case "newline": return this.sourceToken;
+			case "doc-mode":
+			case "doc-start": {
+				const doc = {
+					type: "document",
+					offset: this.offset,
+					start: []
+				};
+				if (this.type === "doc-start") doc.start.push(this.sourceToken);
+				this.stack.push(doc);
+				return null;
+			}
+		}
+		return {
+			type: "error",
+			offset: this.offset,
+			message: `Unexpected ${this.type} token in YAML stream`,
+			source: this.source
+		};
+	}
+	document(doc) {
+		if (doc.value) return this.lineEnd(doc);
+		switch (this.type) {
+			case "doc-start":
+				if (findNonEmptyIndex(doc.start) !== -1) {
+					this.pop();
+					this.step();
+				} else doc.start.push(this.sourceToken);
+				return;
+			case "anchor":
+			case "tag":
+			case "space":
+			case "comment":
+			case "newline":
+				doc.start.push(this.sourceToken);
+				return;
+		}
+		const bv = this.startBlockValue(doc);
+		if (bv) this.stack.push(bv);
+		else this.tokens.push({
+			type: "error",
+			offset: this.offset,
+			message: `Unexpected ${this.type} token in YAML document`,
+			source: this.source
+		});
+	}
+	scalar(scalar) {
+		if (this.type === "map-value-ind") {
+			const start = getFirstKeyStartProps(getPrevProps(this.peek(2)));
+			let sep;
+			if (scalar.end) {
+				sep = scalar.end;
+				sep.push(this.sourceToken);
+				delete scalar.end;
+			} else sep = [this.sourceToken];
+			const map = {
+				type: "block-map",
+				offset: scalar.offset,
+				indent: scalar.indent,
+				items: [{
+					start,
+					key: scalar,
+					sep
+				}]
+			};
+			this.onKeyLine = true;
+			this.stack[this.stack.length - 1] = map;
+		} else this.lineEnd(scalar);
+	}
+	blockScalar(scalar) {
+		switch (this.type) {
+			case "space":
+			case "comment":
+			case "newline":
+				scalar.props.push(this.sourceToken);
+				return;
+			case "scalar":
+				scalar.source = this.source;
+				this.atNewLine = true;
+				this.indent = 0;
+				if (this.onNewLine) {
+					let nl = this.source.indexOf("\n") + 1;
+					while (nl !== 0) {
+						this.onNewLine(this.offset + nl);
+						nl = this.source.indexOf("\n", nl) + 1;
+					}
+				}
+				this.pop();
+				break;
+			default:
+				this.pop();
+				this.step();
+		}
+	}
+	blockMap(map) {
+		const it = map.items[map.items.length - 1];
+		switch (this.type) {
+			case "newline":
+				this.onKeyLine = false;
+				if (it.value) {
+					const end = "end" in it.value ? it.value.end : void 0;
+					if ((Array.isArray(end) ? end[end.length - 1] : void 0)?.type === "comment") end?.push(this.sourceToken);
+					else map.items.push({ start: [this.sourceToken] });
+				} else if (it.sep) it.sep.push(this.sourceToken);
+				else it.start.push(this.sourceToken);
+				return;
+			case "space":
+			case "comment":
+				if (it.value) map.items.push({ start: [this.sourceToken] });
+				else if (it.sep) it.sep.push(this.sourceToken);
+				else {
+					if (this.atIndentedComment(it.start, map.indent)) {
+						const end = (map.items[map.items.length - 2]?.value)?.end;
+						if (Array.isArray(end)) {
+							Array.prototype.push.apply(end, it.start);
+							end.push(this.sourceToken);
+							map.items.pop();
+							return;
+						}
+					}
+					it.start.push(this.sourceToken);
+				}
+				return;
+		}
+		if (this.indent >= map.indent) {
+			const atMapIndent = !this.onKeyLine && this.indent === map.indent;
+			const atNextItem = atMapIndent && (it.sep || it.explicitKey) && this.type !== "seq-item-ind";
+			let start = [];
+			if (atNextItem && it.sep && !it.value) {
+				const nl = [];
+				for (let i = 0; i < it.sep.length; ++i) {
+					const st = it.sep[i];
+					switch (st.type) {
+						case "newline":
+							nl.push(i);
+							break;
+						case "space": break;
+						case "comment":
+							if (st.indent > map.indent) nl.length = 0;
+							break;
+						default: nl.length = 0;
+					}
+				}
+				if (nl.length >= 2) start = it.sep.splice(nl[1]);
+			}
+			switch (this.type) {
+				case "anchor":
+				case "tag":
+					if (atNextItem || it.value) {
+						start.push(this.sourceToken);
+						map.items.push({ start });
+						this.onKeyLine = true;
+					} else if (it.sep) it.sep.push(this.sourceToken);
+					else it.start.push(this.sourceToken);
+					return;
+				case "explicit-key-ind":
+					if (!it.sep && !it.explicitKey) {
+						it.start.push(this.sourceToken);
+						it.explicitKey = true;
+					} else if (atNextItem || it.value) {
+						start.push(this.sourceToken);
+						map.items.push({
+							start,
+							explicitKey: true
+						});
+					} else this.stack.push({
+						type: "block-map",
+						offset: this.offset,
+						indent: this.indent,
+						items: [{
+							start: [this.sourceToken],
+							explicitKey: true
+						}]
+					});
+					this.onKeyLine = true;
+					return;
+				case "map-value-ind":
+					if (it.explicitKey) if (!it.sep) if (includesToken(it.start, "newline")) Object.assign(it, {
+						key: null,
+						sep: [this.sourceToken]
+					});
+					else {
+						const start = getFirstKeyStartProps(it.start);
+						this.stack.push({
+							type: "block-map",
+							offset: this.offset,
+							indent: this.indent,
+							items: [{
+								start,
+								key: null,
+								sep: [this.sourceToken]
+							}]
+						});
+					}
+					else if (it.value) map.items.push({
+						start: [],
+						key: null,
+						sep: [this.sourceToken]
+					});
+					else if (includesToken(it.sep, "map-value-ind")) this.stack.push({
+						type: "block-map",
+						offset: this.offset,
+						indent: this.indent,
+						items: [{
+							start,
+							key: null,
+							sep: [this.sourceToken]
+						}]
+					});
+					else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
+						const start = getFirstKeyStartProps(it.start);
+						const key = it.key;
+						const sep = it.sep;
+						sep.push(this.sourceToken);
+						delete it.key;
+						delete it.sep;
+						this.stack.push({
+							type: "block-map",
+							offset: this.offset,
+							indent: this.indent,
+							items: [{
+								start,
+								key,
+								sep
+							}]
+						});
+					} else if (start.length > 0) it.sep = it.sep.concat(start, this.sourceToken);
+					else it.sep.push(this.sourceToken);
+					else if (!it.sep) Object.assign(it, {
+						key: null,
+						sep: [this.sourceToken]
+					});
+					else if (it.value || atNextItem) map.items.push({
+						start,
+						key: null,
+						sep: [this.sourceToken]
+					});
+					else if (includesToken(it.sep, "map-value-ind")) this.stack.push({
+						type: "block-map",
+						offset: this.offset,
+						indent: this.indent,
+						items: [{
+							start: [],
+							key: null,
+							sep: [this.sourceToken]
+						}]
+					});
+					else it.sep.push(this.sourceToken);
+					this.onKeyLine = true;
+					return;
+				case "alias":
+				case "scalar":
+				case "single-quoted-scalar":
+				case "double-quoted-scalar": {
+					const fs = this.flowScalar(this.type);
+					if (atNextItem || it.value) {
+						map.items.push({
+							start,
+							key: fs,
+							sep: []
+						});
+						this.onKeyLine = true;
+					} else if (it.sep) this.stack.push(fs);
+					else {
+						Object.assign(it, {
+							key: fs,
+							sep: []
+						});
+						this.onKeyLine = true;
+					}
+					return;
+				}
+				default: {
+					const bv = this.startBlockValue(map);
+					if (bv) {
+						if (bv.type === "block-seq") {
+							if (!it.explicitKey && it.sep && !includesToken(it.sep, "newline")) {
+								this.pop({
+									type: "error",
+									offset: this.offset,
+									message: "Unexpected block-seq-ind on same line with key",
+									source: this.source
+								});
+								return;
+							}
+						} else if (atMapIndent) map.items.push({ start });
+						this.stack.push(bv);
+						return;
+					}
+				}
+			}
+		}
+		this.pop();
+		this.step();
+	}
+	blockSequence(seq) {
+		const it = seq.items[seq.items.length - 1];
+		switch (this.type) {
+			case "newline":
+				if (it.value) {
+					const end = "end" in it.value ? it.value.end : void 0;
+					if ((Array.isArray(end) ? end[end.length - 1] : void 0)?.type === "comment") end?.push(this.sourceToken);
+					else seq.items.push({ start: [this.sourceToken] });
+				} else it.start.push(this.sourceToken);
+				return;
+			case "space":
+			case "comment":
+				if (it.value) seq.items.push({ start: [this.sourceToken] });
+				else {
+					if (this.atIndentedComment(it.start, seq.indent)) {
+						const end = (seq.items[seq.items.length - 2]?.value)?.end;
+						if (Array.isArray(end)) {
+							Array.prototype.push.apply(end, it.start);
+							end.push(this.sourceToken);
+							seq.items.pop();
+							return;
+						}
+					}
+					it.start.push(this.sourceToken);
+				}
+				return;
+			case "anchor":
+			case "tag":
+				if (it.value || this.indent <= seq.indent) break;
+				it.start.push(this.sourceToken);
+				return;
+			case "seq-item-ind":
+				if (this.indent !== seq.indent) break;
+				if (it.value || includesToken(it.start, "seq-item-ind")) seq.items.push({ start: [this.sourceToken] });
+				else it.start.push(this.sourceToken);
+				return;
+		}
+		if (this.indent > seq.indent) {
+			const bv = this.startBlockValue(seq);
+			if (bv) {
+				this.stack.push(bv);
+				return;
+			}
+		}
+		this.pop();
+		this.step();
+	}
+	flowCollection(fc) {
+		const it = fc.items[fc.items.length - 1];
+		if (this.type === "flow-error-end") {
+			let top;
+			do {
+				this.pop();
+				top = this.peek(1);
+			} while (top?.type === "flow-collection");
+		} else if (fc.end.length === 0) {
+			switch (this.type) {
+				case "comma":
+				case "explicit-key-ind":
+					if (!it || it.sep) fc.items.push({ start: [this.sourceToken] });
+					else it.start.push(this.sourceToken);
+					return;
+				case "map-value-ind":
+					if (!it || it.value) fc.items.push({
+						start: [],
+						key: null,
+						sep: [this.sourceToken]
+					});
+					else if (it.sep) it.sep.push(this.sourceToken);
+					else Object.assign(it, {
+						key: null,
+						sep: [this.sourceToken]
+					});
+					return;
+				case "space":
+				case "comment":
+				case "newline":
+				case "anchor":
+				case "tag":
+					if (!it || it.value) fc.items.push({ start: [this.sourceToken] });
+					else if (it.sep) it.sep.push(this.sourceToken);
+					else it.start.push(this.sourceToken);
+					return;
+				case "alias":
+				case "scalar":
+				case "single-quoted-scalar":
+				case "double-quoted-scalar": {
+					const fs = this.flowScalar(this.type);
+					if (!it || it.value) fc.items.push({
+						start: [],
+						key: fs,
+						sep: []
+					});
+					else if (it.sep) this.stack.push(fs);
+					else Object.assign(it, {
+						key: fs,
+						sep: []
+					});
+					return;
+				}
+				case "flow-map-end":
+				case "flow-seq-end":
+					fc.end.push(this.sourceToken);
+					return;
+			}
+			const bv = this.startBlockValue(fc);
+			/* istanbul ignore else should not happen */
+			if (bv) this.stack.push(bv);
+			else {
+				this.pop();
+				this.step();
+			}
+		} else {
+			const parent = this.peek(2);
+			if (parent.type === "block-map" && (this.type === "map-value-ind" && parent.indent === fc.indent || this.type === "newline" && !parent.items[parent.items.length - 1].sep)) {
+				this.pop();
+				this.step();
+			} else if (this.type === "map-value-ind" && parent.type !== "flow-collection") {
+				const start = getFirstKeyStartProps(getPrevProps(parent));
+				fixFlowSeqItems(fc);
+				const sep = fc.end.splice(1, fc.end.length);
+				sep.push(this.sourceToken);
+				const map = {
+					type: "block-map",
+					offset: fc.offset,
+					indent: fc.indent,
+					items: [{
+						start,
+						key: fc,
+						sep
+					}]
+				};
+				this.onKeyLine = true;
+				this.stack[this.stack.length - 1] = map;
+			} else this.lineEnd(fc);
+		}
+	}
+	flowScalar(type) {
+		if (this.onNewLine) {
+			let nl = this.source.indexOf("\n") + 1;
+			while (nl !== 0) {
+				this.onNewLine(this.offset + nl);
+				nl = this.source.indexOf("\n", nl) + 1;
+			}
+		}
+		return {
+			type,
+			offset: this.offset,
+			indent: this.indent,
+			source: this.source
+		};
+	}
+	startBlockValue(parent) {
+		switch (this.type) {
+			case "alias":
+			case "scalar":
+			case "single-quoted-scalar":
+			case "double-quoted-scalar": return this.flowScalar(this.type);
+			case "block-scalar-header": return {
+				type: "block-scalar",
+				offset: this.offset,
+				indent: this.indent,
+				props: [this.sourceToken],
+				source: ""
+			};
+			case "flow-map-start":
+			case "flow-seq-start": return {
+				type: "flow-collection",
+				offset: this.offset,
+				indent: this.indent,
+				start: this.sourceToken,
+				items: [],
+				end: []
+			};
+			case "seq-item-ind": return {
+				type: "block-seq",
+				offset: this.offset,
+				indent: this.indent,
+				items: [{ start: [this.sourceToken] }]
+			};
+			case "explicit-key-ind": {
+				this.onKeyLine = true;
+				const start = getFirstKeyStartProps(getPrevProps(parent));
+				start.push(this.sourceToken);
+				return {
+					type: "block-map",
+					offset: this.offset,
+					indent: this.indent,
+					items: [{
+						start,
+						explicitKey: true
+					}]
+				};
+			}
+			case "map-value-ind": {
+				this.onKeyLine = true;
+				const start = getFirstKeyStartProps(getPrevProps(parent));
+				return {
+					type: "block-map",
+					offset: this.offset,
+					indent: this.indent,
+					items: [{
+						start,
+						key: null,
+						sep: [this.sourceToken]
+					}]
+				};
+			}
+		}
+		return null;
+	}
+	atIndentedComment(start, indent) {
+		if (this.type !== "comment") return false;
+		if (this.indent <= indent) return false;
+		return start.every((st) => st.type === "newline" || st.type === "space");
+	}
+	documentEnd(docEnd) {
+		if (this.type !== "doc-mode") {
+			if (docEnd.end) docEnd.end.push(this.sourceToken);
+			else docEnd.end = [this.sourceToken];
+			if (this.type === "newline") this.pop();
+		}
+	}
+	lineEnd(token) {
+		switch (this.type) {
+			case "comma":
+			case "doc-start":
+			case "doc-end":
+			case "flow-seq-end":
+			case "flow-map-end":
+			case "map-value-ind":
+				this.pop();
+				this.step();
+				break;
+			case "newline": this.onKeyLine = false;
+			default:
+				if (token.end) token.end.push(this.sourceToken);
+				else token.end = [this.sourceToken];
+				if (this.type === "newline") this.pop();
+		}
+	}
+};
+
+//#endregion
+//#region src/compose/resolve-props.ts
+function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIndent, startOnNewline }) {
+	let spaceBefore = false;
+	let atNewline = startOnNewline;
+	let hasSpace = startOnNewline;
+	let comment = "";
+	let commentSep = "";
+	let hasNewline = false;
+	let reqSpace = false;
+	let tab = null;
+	let anchor = null;
+	let tag = null;
+	let newlineAfterProp = null;
+	let comma = null;
+	let found = null;
+	let start = null;
+	for (const token of tokens) {
+		if (reqSpace) {
+			if (token.type !== "space" && token.type !== "newline" && token.type !== "comma") onError(token.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
+			reqSpace = false;
+		}
+		if (tab) {
+			if (atNewline && token.type !== "comment" && token.type !== "newline") onError(tab, "TAB_AS_INDENT", "Tabs are not allowed as indentation");
+			tab = null;
+		}
+		switch (token.type) {
+			case "space":
+				if (!flow && (indicator !== "doc-start" || next?.type !== "flow-collection") && token.source.includes("	")) tab = token;
+				hasSpace = true;
+				break;
+			case "comment": {
+				if (!hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
+				const cb = token.source.substring(1) || " ";
+				if (!comment) comment = cb;
+				else comment += commentSep + cb;
+				commentSep = "";
+				atNewline = false;
+				break;
+			}
+			case "newline":
+				if (atNewline) {
+					if (comment) comment += token.source;
+					else if (!found || indicator !== "seq-item-ind") spaceBefore = true;
+				} else commentSep += token.source;
+				atNewline = true;
+				hasNewline = true;
+				if (anchor || tag) newlineAfterProp = token;
+				hasSpace = true;
+				break;
+			case "anchor":
+				if (anchor) onError(token, "MULTIPLE_ANCHORS", "A node can have at most one anchor");
+				if (token.source.endsWith(":")) onError(token.offset + token.source.length - 1, "BAD_ALIAS", "Anchor ending in : is ambiguous", true);
+				anchor = token;
+				start ??= token.offset;
+				atNewline = false;
+				hasSpace = false;
+				reqSpace = true;
+				break;
+			case "tag":
+				if (tag) onError(token, "MULTIPLE_TAGS", "A node can have at most one tag");
+				tag = token;
+				start ??= token.offset;
+				atNewline = false;
+				hasSpace = false;
+				reqSpace = true;
+				break;
+			case indicator:
+				if (anchor || tag) onError(token, "BAD_PROP_ORDER", `Anchors and tags must be after the ${token.source} indicator`);
+				if (found) onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.source} in ${flow ?? "collection"}`);
+				found = token;
+				atNewline = indicator === "seq-item-ind" || indicator === "explicit-key-ind";
+				hasSpace = false;
+				break;
+			case "comma": if (flow) {
+				if (comma) onError(token, "UNEXPECTED_TOKEN", `Unexpected , in ${flow}`);
+				comma = token;
+				atNewline = false;
+				hasSpace = false;
+				break;
+			}
+			default:
+				onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.type} token`);
+				atNewline = false;
+				hasSpace = false;
+		}
+	}
+	const last = tokens[tokens.length - 1];
+	const end = last ? last.offset + last.source.length : offset;
+	if (reqSpace && next && next.type !== "space" && next.type !== "newline" && next.type !== "comma" && (next.type !== "scalar" || next.source !== "")) onError(next.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
+	if (tab && (atNewline && tab.indent <= parentIndent || next?.type === "block-map" || next?.type === "block-seq")) onError(tab, "TAB_AS_INDENT", "Tabs are not allowed as indentation");
+	return {
+		comma,
+		found,
+		spaceBefore,
+		comment,
+		hasNewline,
+		anchor,
+		tag,
+		newlineAfterProp,
+		end,
+		start: start ?? end
+	};
+}
+
+//#endregion
+//#region src/compose/util-contains-newline.ts
+function containsNewline(key) {
+	if (!key) return null;
+	switch (key.type) {
+		case "alias":
+		case "scalar":
+		case "double-quoted-scalar":
+		case "single-quoted-scalar":
+			if (key.source.includes("\n")) return true;
+			if (key.end) {
+				for (const st of key.end) if (st.type === "newline") return true;
+			}
+			return false;
+		case "flow-collection":
+			for (const it of key.items) {
+				for (const st of it.start) if (st.type === "newline") return true;
+				if (it.sep) {
+					for (const st of it.sep) if (st.type === "newline") return true;
+				}
+				if (containsNewline(it.key) || containsNewline(it.value)) return true;
+			}
+			return false;
+		default: return true;
+	}
+}
+
+//#endregion
+//#region src/compose/util-flow-indent-check.ts
+function flowIndentCheck(indent, fc, onError) {
+	if (fc?.type === "flow-collection") {
+		const end = fc.end[0];
+		if (end.indent === indent && (end.source === "]" || end.source === "}") && containsNewline(fc)) onError(end, "BAD_INDENT", "Flow end indicator should be more indented than parent", true);
+	}
+}
+
+//#endregion
+//#region src/compose/util-map-includes.ts
+function mapIncludes(ctx, items, search) {
+	const { uniqueKeys } = ctx.options;
+	if (uniqueKeys === false) return false;
+	const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a, b) => a === b || a instanceof Scalar && b instanceof Scalar && a.value === b.value;
+	return items.some((pair) => isEqual(pair.key, search));
+}
+
+//#endregion
+//#region src/compose/resolve-block-map.ts
+const startColMsg = "All mapping items must start at the same column";
+function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, tag) {
+	const map = new (tag?.nodeClass ?? YAMLMap)(ctx.schema);
+	if (ctx.atRoot) ctx.atRoot = false;
+	let offset = bm.offset;
+	let commentEnd = null;
+	for (const collItem of bm.items) {
+		const { start, key, sep, value } = collItem;
+		const keyProps = resolveProps(start, {
+			indicator: "explicit-key-ind",
+			next: key ?? sep?.[0],
+			offset,
+			onError,
+			parentIndent: bm.indent,
+			startOnNewline: true
+		});
+		const implicitKey = !keyProps.found;
+		if (implicitKey) {
+			if (key) {
+				if (key.type === "block-seq") onError(offset, "BLOCK_AS_IMPLICIT_KEY", "A block sequence may not be used as an implicit map key");
+				else if ("indent" in key && key.indent !== bm.indent) onError(offset, "BAD_INDENT", startColMsg);
+			}
+			if (!keyProps.anchor && !keyProps.tag && !sep) {
+				commentEnd = keyProps.end;
+				if (keyProps.comment) if (map.comment) map.comment += "\n" + keyProps.comment;
+				else map.comment = keyProps.comment;
+				continue;
+			}
+			if (keyProps.newlineAfterProp || containsNewline(key)) onError(key ?? start[start.length - 1], "MULTILINE_IMPLICIT_KEY", "Implicit keys need to be on a single line");
+		} else if (keyProps.found?.indent !== bm.indent) onError(offset, "BAD_INDENT", startColMsg);
+		ctx.atKey = true;
+		const keyStart = keyProps.end;
+		const keyNode = key ? composeNode(ctx, key, keyProps, onError) : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
+		if (ctx.schema.compat) flowIndentCheck(bm.indent, key, onError);
+		ctx.atKey = false;
+		if (mapIncludes(ctx, map.items, keyNode)) onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
+		const valueProps = resolveProps(sep ?? [], {
+			indicator: "map-value-ind",
+			next: value,
+			offset: keyNode.range[2],
+			onError,
+			parentIndent: bm.indent,
+			startOnNewline: !key || key.type === "block-scalar"
+		});
+		offset = valueProps.end;
+		if (valueProps.found) {
+			if (implicitKey) {
+				if (value?.type === "block-map" && !valueProps.hasNewline) onError(offset, "BLOCK_AS_IMPLICIT_KEY", "Nested mappings are not allowed in compact mappings");
+				if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024) onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
+			}
+			const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
+			if (ctx.schema.compat) flowIndentCheck(bm.indent, value, onError);
+			offset = valueNode.range[2];
+			const pair = new Pair(keyNode, valueNode);
+			if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
+			map.items.push(pair);
+		} else {
+			if (implicitKey) onError(keyNode.range, "MISSING_CHAR", "Implicit map keys need to be followed by map values");
+			if (valueProps.comment) if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
+			else keyNode.comment = valueProps.comment;
+			const pair = new Pair(keyNode);
+			if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
+			map.items.push(pair);
+		}
+	}
+	if (commentEnd && commentEnd < offset) onError(commentEnd, "IMPOSSIBLE", "Map comment with trailing content");
+	map.range = [
+		bm.offset,
+		offset,
+		commentEnd ?? offset
+	];
+	return map;
+}
+
+//#endregion
+//#region src/compose/resolve-block-seq.ts
+function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, tag) {
+	const seq = new (tag?.nodeClass ?? YAMLSeq)(ctx.schema);
+	if (ctx.atRoot) ctx.atRoot = false;
+	if (ctx.atKey) ctx.atKey = false;
+	let offset = bs.offset;
+	let commentEnd = null;
+	for (const { start, value } of bs.items) {
+		const props = resolveProps(start, {
+			indicator: "seq-item-ind",
+			next: value,
+			offset,
+			onError,
+			parentIndent: bs.indent,
+			startOnNewline: true
+		});
+		if (!props.found) if (props.anchor || props.tag || value) if (value?.type === "block-seq") onError(props.end, "BAD_INDENT", "All sequence items must start at the same column");
+		else onError(offset, "MISSING_CHAR", "Sequence item without - indicator");
+		else {
+			commentEnd = props.end;
+			if (props.comment) seq.comment = props.comment;
+			continue;
+		}
+		const node = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, start, null, props, onError);
+		if (ctx.schema.compat) flowIndentCheck(bs.indent, value, onError);
+		offset = node.range[2];
+		seq.items.push(node);
+	}
+	seq.range = [
+		bs.offset,
+		offset,
+		commentEnd ?? offset
+	];
+	return seq;
+}
+
+//#endregion
+//#region src/compose/resolve-flow-collection.ts
+const blockMsg = "Block collections are not allowed within flow collections";
+const isBlock = (token) => token && (token.type === "block-map" || token.type === "block-seq");
+function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) {
+	const isMap = fc.start.source === "{";
+	const fcName = isMap ? "flow map" : "flow sequence";
+	const coll = new (tag?.nodeClass ?? (isMap ? YAMLMap : YAMLSeq))(ctx.schema);
+	coll.flow = true;
+	const atRoot = ctx.atRoot;
+	if (atRoot) ctx.atRoot = false;
+	if (ctx.atKey) ctx.atKey = false;
+	let offset = fc.offset + fc.start.source.length;
+	for (let i = 0; i < fc.items.length; ++i) {
+		const collItem = fc.items[i];
+		const { start, key, sep, value } = collItem;
+		const props = resolveProps(start, {
+			flow: fcName,
+			indicator: "explicit-key-ind",
+			next: key ?? sep?.[0],
+			offset,
+			onError,
+			parentIndent: fc.indent,
+			startOnNewline: false
+		});
+		if (!props.found) {
+			if (!props.anchor && !props.tag && !sep && !value) {
+				if (i === 0 && props.comma) onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
+				else if (i < fc.items.length - 1) onError(props.start, "UNEXPECTED_TOKEN", `Unexpected empty item in ${fcName}`);
+				if (props.comment) if (coll.comment) coll.comment += "\n" + props.comment;
+				else coll.comment = props.comment;
+				offset = props.end;
+				continue;
+			}
+			if (!isMap && ctx.options.strict && containsNewline(key)) onError(key, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
+		}
+		if (i === 0) {
+			if (props.comma) onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
+		} else {
+			if (!props.comma) onError(props.start, "MISSING_CHAR", `Missing , between ${fcName} items`);
+			if (props.comment) {
+				let prevItemComment = "";
+				loop: for (const st of start) switch (st.type) {
+					case "comma":
+					case "space": break;
+					case "comment":
+						prevItemComment = st.source.substring(1);
+						break loop;
+					default: break loop;
+				}
+				if (prevItemComment) {
+					let prev = coll.items[coll.items.length - 1];
+					if (prev instanceof Pair) prev = prev.value ?? prev.key;
+					if (prev.comment) prev.comment += "\n" + prevItemComment;
+					else prev.comment = prevItemComment;
+					props.comment = props.comment.substring(prevItemComment.length + 1);
+				}
+			}
+		}
+		if (!isMap && !sep && !props.found) {
+			const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep, null, props, onError);
+			coll.items.push(valueNode);
+			offset = valueNode.range[2];
+			if (isBlock(value)) onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
+		} else {
+			ctx.atKey = true;
+			const keyStart = props.end;
+			const keyNode = key ? composeNode(ctx, key, props, onError) : composeEmptyNode(ctx, keyStart, start, null, props, onError);
+			if (isBlock(key)) onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
+			ctx.atKey = false;
+			const valueProps = resolveProps(sep ?? [], {
+				flow: fcName,
+				indicator: "map-value-ind",
+				next: value,
+				offset: keyNode.range[2],
+				onError,
+				parentIndent: fc.indent,
+				startOnNewline: false
+			});
+			if (valueProps.found) {
+				if (!isMap && !props.found && ctx.options.strict) {
+					if (sep) for (const st of sep) {
+						if (st === valueProps.found) break;
+						if (st.type === "newline") {
+							onError(st, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
+							break;
+						}
+					}
+					if (props.start < valueProps.found.offset - 1024) onError(valueProps.found, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit flow sequence key");
+				}
+			} else if (value) if ("source" in value && value.source?.[0] === ":") onError(value, "MISSING_CHAR", `Missing space after : in ${fcName}`);
+			else onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
+			const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError) : null;
+			if (valueNode) {
+				if (isBlock(value)) onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
+			} else if (valueProps.comment) if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
+			else keyNode.comment = valueProps.comment;
+			const pair = new Pair(keyNode, valueNode);
+			if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
+			if (isMap) {
+				const map = coll;
+				if (mapIncludes(ctx, map.items, keyNode)) onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
+				map.items.push(pair);
+			} else {
+				const map = new YAMLMap(ctx.schema);
+				map.flow = true;
+				map.items.push(pair);
+				const endRange = (valueNode ?? keyNode).range;
+				map.range = [
+					keyNode.range[0],
+					endRange[1],
+					endRange[2]
+				];
+				coll.items.push(map);
+			}
+			offset = valueNode ? valueNode.range[2] : valueProps.end;
+		}
+	}
+	const expectedEnd = isMap ? "}" : "]";
+	const [ce, ...ee] = fc.end;
+	let cePos = offset;
+	if (ce?.source === expectedEnd) cePos = ce.offset + ce.source.length;
+	else {
+		const name = fcName[0].toUpperCase() + fcName.substring(1);
+		const msg = atRoot ? `${name} must end with a ${expectedEnd}` : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`;
+		onError(offset, atRoot ? "MISSING_CHAR" : "BAD_INDENT", msg);
+		if (ce && ce.source.length !== 1) ee.unshift(ce);
+	}
+	if (ee.length > 0) {
+		const end = resolveEnd(ee, cePos, ctx.options.strict, onError);
+		if (end.comment) if (coll.comment) coll.comment += "\n" + end.comment;
+		else coll.comment = end.comment;
+		coll.range = [
+			fc.offset,
+			cePos,
+			end.offset
+		];
+	} else coll.range = [
+		fc.offset,
+		cePos,
+		cePos
+	];
+	return coll;
+}
+
+//#endregion
+//#region src/compose/compose-collection.ts
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+	const coll = token.type === "block-map" ? resolveBlockMap(CN, ctx, token, onError, tag) : token.type === "block-seq" ? resolveBlockSeq(CN, ctx, token, onError, tag) : resolveFlowCollection(CN, ctx, token, onError, tag);
+	const Coll = coll.constructor;
+	if (tagName === "!" || tagName === Coll.tagName) {
+		coll.tag = Coll.tagName;
+		return coll;
+	}
+	if (tagName) coll.tag = tagName;
+	return coll;
+}
+function composeCollection(CN, ctx, token, props, onError) {
+	const tagToken = props.tag;
+	const tagName = !tagToken ? null : ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg));
+	if (token.type === "block-seq") {
+		const { anchor, newlineAfterProp: nl } = props;
+		const lastProp = anchor && tagToken ? anchor.offset > tagToken.offset ? anchor : tagToken : anchor ?? tagToken;
+		if (lastProp && (!nl || nl.offset < lastProp.offset)) onError(lastProp, "MISSING_CHAR", "Missing newline after block sequence props");
+	}
+	const expType = token.type === "block-map" ? "map" : token.type === "block-seq" ? "seq" : token.start.source === "{" ? "map" : "seq";
+	if (!tagToken || !tagName || tagName === "!" || tagName === YAMLMap.tagName && expType === "map" || tagName === YAMLSeq.tagName && expType === "seq") return resolveCollection(CN, ctx, token, onError, tagName);
+	let tag = ctx.schema.tags.find((t) => t.tag === tagName && t.collection === expType);
+	if (!tag) {
+		const kt = ctx.schema.knownTags[tagName];
+		if (kt?.collection === expType) {
+			ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
+			tag = kt;
+		} else {
+			if (kt) onError(tagToken, "BAD_COLLECTION_TYPE", `${kt.tag} used for ${expType} collection, but expects ${kt.collection ?? "scalar"}`, true);
+			else onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, true);
+			return resolveCollection(CN, ctx, token, onError, tagName);
+		}
+	}
+	const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+	const res = tag.resolve?.(coll, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg), ctx.options) ?? coll;
+	const node = res instanceof NodeBase ? res : new Scalar(res);
+	node.range = coll.range;
+	node.tag = tagName;
+	if (tag?.format) node.format = tag.format;
+	return node;
+}
+
+//#endregion
+//#region src/compose/compose-scalar.ts
+function composeScalar(ctx, token, tagToken, onError) {
+	const { value, type, comment, range } = token.type === "block-scalar" ? resolveBlockScalar(ctx, token, onError) : resolveFlowScalar(token, ctx.options.strict, onError);
+	const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null;
+	let tag;
+	if (ctx.options.stringKeys && ctx.atKey) tag = ctx.schema.scalar;
+	else if (tagName) tag = findScalarTagByName(ctx.schema, value, tagName, tagToken, onError);
+	else if (token.type === "scalar") tag = findScalarTagByTest(ctx, value, token, onError);
+	else tag = ctx.schema.scalar;
+	let scalar;
+	try {
+		const res = tag.resolve(value, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options);
+		scalar = res instanceof Scalar ? res : new Scalar(res);
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg);
+		scalar = new Scalar(value);
+	}
+	scalar.range = range;
+	scalar.source = value;
+	if (type) scalar.type = type;
+	if (tagName) scalar.tag = tagName;
+	if (tag.format) scalar.format = tag.format;
+	if (comment) scalar.comment = comment;
+	return scalar;
+}
+function findScalarTagByName(schema, value, tagName, tagToken, onError) {
+	if (tagName === "!") return schema.scalar;
+	const matchWithTest = [];
+	for (const tag of schema.tags) if (!tag.collection && tag.tag === tagName) if (tag.default && tag.test) matchWithTest.push(tag);
+	else return tag;
+	for (const tag of matchWithTest) if (tag.test?.test(value)) return tag;
+	const kt = schema.knownTags[tagName];
+	if (kt && !kt.collection) {
+		schema.tags.push(Object.assign({}, kt, {
+			default: false,
+			test: void 0
+		}));
+		return kt;
+	}
+	onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str");
+	return schema.scalar;
+}
+function findScalarTagByTest({ atKey, directives, schema }, value, token, onError) {
+	const tag = schema.tags.find((tag) => (tag.default === true || atKey && tag.default === "key") && tag.test?.test(value)) || schema.scalar;
+	if (schema.compat) {
+		const compat = schema.compat.find((tag) => tag.default && tag.test?.test(value)) ?? schema.scalar;
+		if (tag.tag !== compat.tag) onError(token, "TAG_RESOLVE_FAILED", `Value may be parsed as either ${directives.tagString(tag.tag)} or ${directives.tagString(compat.tag)}`, true);
+	}
+	return tag;
+}
+
+//#endregion
+//#region src/compose/util-empty-scalar-position.ts
+function emptyScalarPosition(offset, before, pos) {
+	if (before) {
+		pos ??= before.length;
+		for (let i = pos - 1; i >= 0; --i) {
+			let st = before[i];
+			switch (st.type) {
+				case "space":
+				case "comment":
+				case "newline":
+					offset -= st.source.length;
+					continue;
+			}
+			st = before[++i];
+			while (st?.type === "space") {
+				offset += st.source.length;
+				st = before[++i];
+			}
+			break;
+		}
+	}
+	return offset;
+}
+
+//#endregion
+//#region src/compose/compose-node.ts
+const CN = {
+	composeNode,
+	composeEmptyNode
+};
+function composeNode(ctx, token, props, onError) {
+	const atKey = ctx.atKey;
+	const { spaceBefore, comment, anchor, tag } = props;
+	let node;
+	let isSrcToken = true;
+	switch (token.type) {
+		case "alias":
+			node = composeAlias(ctx, token, onError);
+			if (anchor || tag) onError(token, "ALIAS_PROPS", "An alias node must not specify any properties");
+			break;
+		case "scalar":
+		case "single-quoted-scalar":
+		case "double-quoted-scalar":
+		case "block-scalar":
+			node = composeScalar(ctx, token, tag, onError);
+			if (anchor) node.anchor = anchor.source.substring(1);
+			break;
+		case "block-map":
+		case "block-seq":
+		case "flow-collection":
+			node = composeCollection(CN, ctx, token, props, onError);
+			if (anchor) node.anchor = anchor.source.substring(1);
+			break;
+		default:
+			onError(token, "UNEXPECTED_TOKEN", token.type === "error" ? token.message : `Unsupported token (type: ${token.type})`);
+			node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError);
+			isSrcToken = false;
+	}
+	if (anchor && node.anchor === "") onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
+	if (atKey && ctx.options.stringKeys && (!(node instanceof Scalar) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) onError(tag ?? token, "NON_STRING_KEY", "With stringKeys, all keys must be strings");
+	if (spaceBefore) node.spaceBefore = true;
+	if (comment) if (token.type === "scalar" && token.source === "") node.comment = comment;
+	else node.commentBefore = comment;
+	if (ctx.options.keepSourceTokens && isSrcToken) node.srcToken = token;
+	return node;
+}
+function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) {
+	const node = composeScalar(ctx, {
+		type: "scalar",
+		offset: emptyScalarPosition(offset, before, pos),
+		indent: -1,
+		source: ""
+	}, tag, onError);
+	if (anchor) {
+		node.anchor = anchor.source.substring(1);
+		if (node.anchor === "") onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
+	}
+	if (spaceBefore) node.spaceBefore = true;
+	if (comment) {
+		node.comment = comment;
+		node.range[2] = end;
+	}
+	return node;
+}
+function composeAlias({ options }, { offset, source, end }, onError) {
+	const alias = new Alias(source.substring(1));
+	if (alias.source === "") onError(offset, "BAD_ALIAS", "Alias cannot be an empty string");
+	if (alias.source.endsWith(":")) onError(offset + source.length - 1, "BAD_ALIAS", "Alias ending in : is ambiguous", true);
+	const valueEnd = offset + source.length;
+	const re = resolveEnd(end, valueEnd, options.strict, onError);
+	alias.range = [
+		offset,
+		valueEnd,
+		re.offset
+	];
+	if (re.comment) alias.comment = re.comment;
+	return alias;
+}
+
+//#endregion
+//#region src/compose/compose-doc.ts
+function composeDoc(options, directives, { offset, start, value, end }, onError) {
+	const doc = new Document(void 0, Object.assign({ _directives: directives }, options));
+	const ctx = {
+		atKey: false,
+		atRoot: true,
+		directives: doc.directives,
+		options: doc.options,
+		schema: doc.schema
+	};
+	const props = resolveProps(start, {
+		indicator: "doc-start",
+		next: value ?? end?.[0],
+		offset,
+		onError,
+		parentIndent: 0,
+		startOnNewline: true
+	});
+	if (props.found) {
+		doc.directives.docStart = true;
+		if (value && (value.type === "block-map" || value.type === "block-seq") && !props.hasNewline) onError(props.end, "MISSING_CHAR", "Block collection cannot start on same line with directives-end marker");
+	}
+	doc.value = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, start, null, props, onError);
+	const contentEnd = doc.value.range[2];
+	const re = resolveEnd(end, contentEnd, false, onError);
+	if (re.comment) doc.comment = re.comment;
+	doc.range = [
+		offset,
+		contentEnd,
+		re.offset
+	];
+	return doc;
+}
+
+//#endregion
+//#region src/compose/composer.ts
+function getErrorPos(src) {
+	if (typeof src === "number") return [src, src + 1];
+	if (Array.isArray(src)) return src.length === 2 ? src : [src[0], src[1]];
+	const { offset, source } = src;
+	return [offset, offset + (typeof source === "string" ? source.length : 1)];
+}
+const logToken = typeof process !== "undefined" && process.env?.LOG_STREAM ? (token) => console.dir(token, { depth: null }) : () => {};
+function parsePrelude(prelude) {
+	let comment = "";
+	let atComment = false;
+	let afterEmptyLine = false;
+	for (let i = 0; i < prelude.length; ++i) {
+		const source = prelude[i];
+		switch (source[0]) {
+			case "#":
+				comment += (comment === "" ? "" : afterEmptyLine ? "\n\n" : "\n") + (source.substring(1) || " ");
+				atComment = true;
+				afterEmptyLine = false;
+				break;
+			case "%":
+				if (prelude[i + 1]?.[0] !== "#") i += 1;
+				atComment = false;
+				break;
+			default:
+				if (!atComment) afterEmptyLine = true;
+				atComment = false;
+		}
+	}
+	return {
+		comment,
+		afterEmptyLine
+	};
+}
+/**
+* Compose a stream of CST nodes into a stream of YAML Documents.
+*
+* ```ts
+* import { Composer, Parser } from 'yaml'
+*
+* const src: string = ...
+* const tokens = new Parser().parse(src)
+* const docs = new Composer().compose(tokens)
+* ```
+*/
+var Composer = class {
+	directives;
+	doc = null;
+	docs = [];
+	options;
+	atDirectives = false;
+	prelude = [];
+	errors = [];
+	warnings = [];
+	constructor(options = {}) {
+		this.directives = new Directives({ version: options.version || "1.2" });
+		this.options = options;
+	}
+	onError = (source, code, message, warning) => {
+		const pos = getErrorPos(source);
+		if (warning) this.warnings.push(new YAMLWarning(pos, code, message));
+		else this.errors.push(new YAMLParseError(pos, code, message));
+	};
+	decorate(doc, afterDoc) {
+		const { comment, afterEmptyLine } = parsePrelude(this.prelude);
+		if (comment) {
+			const dc = doc.value;
+			if (afterDoc) doc.comment = doc.comment ? `${doc.comment}\n${comment}` : comment;
+			else if (afterEmptyLine || doc.directives.docStart) doc.commentBefore = comment;
+			else if (dc instanceof Collection && !dc.flow && dc.items.length > 0) {
+				let it = dc.items[0];
+				if (it instanceof Pair) it = it.key;
+				const cb = it.commentBefore;
+				it.commentBefore = cb ? `${comment}\n${cb}` : comment;
+			} else {
+				const cb = dc.commentBefore;
+				dc.commentBefore = cb ? `${comment}\n${cb}` : comment;
+			}
+		}
+		if (afterDoc) {
+			Array.prototype.push.apply(doc.errors, this.errors);
+			Array.prototype.push.apply(doc.warnings, this.warnings);
+		} else {
+			doc.errors = this.errors;
+			doc.warnings = this.warnings;
+		}
+		this.prelude = [];
+		this.errors = [];
+		this.warnings = [];
+	}
+	/**
+	* Current stream status information.
+	*
+	* Mostly useful at the end of input for an empty stream.
+	*/
+	streamInfo() {
+		return {
+			comment: parsePrelude(this.prelude).comment,
+			directives: this.directives,
+			errors: this.errors,
+			warnings: this.warnings
+		};
+	}
+	/**
+	* Compose tokens into documents.
+	*
+	* @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+	* @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+	*/
+	compose(tokens, forceDoc = false, endOffset = -1) {
+		this.docs = [];
+		for (const token of tokens) this.next(token);
+		return this.end(forceDoc, endOffset);
+	}
+	/** Advance the composer by one CST token. */
+	next(token) {
+		logToken(token);
+		switch (token.type) {
+			case "directive":
+				this.directives.add(token.source, (offset, message, warning) => {
+					const pos = getErrorPos(token);
+					pos[0] += offset;
+					this.onError(pos, "BAD_DIRECTIVE", message, warning);
+				});
+				this.prelude.push(token.source);
+				this.atDirectives = true;
+				break;
+			case "document": {
+				const doc = composeDoc(this.options, this.directives, token, this.onError);
+				if (this.atDirectives && !doc.directives.docStart) this.onError(token, "MISSING_CHAR", "Missing directives-end/doc-start indicator line");
+				this.decorate(doc, false);
+				if (this.doc) this.docs.push(this.doc);
+				this.doc = doc;
+				this.atDirectives = false;
+				break;
+			}
+			case "byte-order-mark":
+			case "space": break;
+			case "comment":
+			case "newline":
+				this.prelude.push(token.source);
+				break;
+			case "error": {
+				const msg = token.source ? `${token.message}: ${JSON.stringify(token.source)}` : token.message;
+				const error = new YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg);
+				if (this.atDirectives || !this.doc) this.errors.push(error);
+				else this.doc.errors.push(error);
+				break;
+			}
+			case "doc-end": {
+				if (!this.doc) {
+					this.errors.push(new YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", "Unexpected doc-end without preceding document"));
+					break;
+				}
+				this.doc.directives.docEnd = true;
+				const end = resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError);
+				this.decorate(this.doc, true);
+				if (end.comment) {
+					const dc = this.doc.comment;
+					this.doc.comment = dc ? `${dc}\n${end.comment}` : end.comment;
+				}
+				this.doc.range[2] = end.offset;
+				break;
+			}
+			default: this.errors.push(new YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", `Unsupported token ${token.type}`));
+		}
+	}
+	/**
+	* Call at end of input to handle any remaining document.
+	*
+	* @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+	* @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+	*/
+	end(forceDoc = false, endOffset = -1) {
+		if (this.doc) {
+			this.decorate(this.doc, true);
+			this.docs.push(this.doc);
+			this.doc = null;
+		} else if (forceDoc) {
+			const doc = new Document(void 0, Object.assign({ _directives: this.directives }, this.options));
+			if (this.atDirectives) this.onError(endOffset, "MISSING_CHAR", "Missing directives-end indicator line");
+			doc.range = [
+				0,
+				endOffset,
+				endOffset
+			];
+			this.decorate(doc, false);
+			this.docs.push(doc);
+		}
+		return this.docs;
+	}
+};
+
+//#endregion
+//#region src/parse/line-counter.ts
+/**
+* Tracks newlines during parsing in order to provide an efficient API for
+* determining the one-indexed `{ line, col }` position for any offset
+* within the input.
+*/
+var LineCounter = class {
+	lineStarts = [];
+	/**
+	* Should be called in ascending order. Otherwise, call
+	* `lineCounter.lineStarts.sort()` before calling `linePos()`.
+	*/
+	addNewLine = (offset) => this.lineStarts.push(offset);
+	/**
+	* Performs a binary search and returns the 1-indexed { line, col }
+	* position of `offset`. If `line === 0`, `addNewLine` has never been
+	* called or `offset` is before the first known newline.
+	*/
+	linePos = (offset) => {
+		let low = 0;
+		let high = this.lineStarts.length;
+		while (low < high) {
+			const mid = low + high >> 1;
+			if (this.lineStarts[mid] < offset) low = mid + 1;
+			else high = mid;
+		}
+		if (this.lineStarts[low] === offset) return {
+			line: low + 1,
+			col: 1
+		};
+		if (low === 0) return {
+			line: 0,
+			col: offset
+		};
+		const start = this.lineStarts[low - 1];
+		return {
+			line: low,
+			col: offset - start + 1
+		};
+	};
+};
+
+//#endregion
+export { cst_exports as a, YAMLParseError as c, lex as i, YAMLWarning as l, Composer as n, prettyToken as o, Parser as r, YAMLError as s, LineCounter as t, prettifyError as u };