yaml 3.0.0-0 → 3.0.0-2

package/dist/{line-counter-TFl552k_.js → line-counter-B2FjSv3E.js}

@@ -1,6 +1,5 @@
-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";
-
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { S as Scalar, _ as YAMLMap, b as stringifyString, f as Pair, g as YAMLSeq, h as YAMLSet, i as Document, m as isNode, p as isCollection$1, t as Directives, u as Alias } from "./directives-DqP9ea45.js";
 //#region src/compose/resolve-block-scalar.ts
 function resolveBlockScalar(ctx, scalar, onError) {
 	const start = scalar.offset;
@@ -79,9 +78,10 @@ function resolveBlockScalar(ctx, scalar, onError) {
 			value += sep + indent.slice(trimIndent) + content;
 			sep = "\n";
 			prevMoreIndented = true;
-		} else if (content === "") if (sep === "\n") value += "\n";
-		else sep = "\n";
-		else {
+		} else if (content === "") {
+			if (sep === "\n") value += "\n";
+			else sep = "\n";
+		} else {
 			value += sep + content;
 			sep = " ";
 			prevMoreIndented = false;
@@ -147,6 +147,7 @@ function parseBlockScalarHeader({ offset, props }, strict, onError) {
 				onError(token, "UNEXPECTED_TOKEN", token.message);
 				length += token.source.length;
 				break;
+			/* istanbul ignore next should not happen */
 			default: {
 				onError(token, "UNEXPECTED_TOKEN", `Unexpected token in block scalar header: ${token.type}`);
 				const ts = token.source;
@@ -171,7 +172,6 @@ function splitLines(source) {
 	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) {
@@ -207,7 +207,6 @@ function resolveEnd(end, offset, reqSpace, onError) {
 		offset
 	};
 }
-
 //#endregion
 //#region src/compose/resolve-flow-scalar.ts
 function resolveFlowScalar(scalar, strict, onError) {
@@ -228,6 +227,7 @@ function resolveFlowScalar(scalar, strict, onError) {
 			_type = Scalar.QUOTE_DOUBLE;
 			value = doubleQuotedValue(source, _onError);
 			break;
+		/* istanbul ignore next should not happen */
 		default:
 			onError(scalar, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
 			return {
@@ -257,6 +257,7 @@ function resolveFlowScalar(scalar, strict, onError) {
 function plainValue(source, onError) {
 	let badChar = "";
 	switch (source[0]) {
+		/* istanbul ignore next should not happen */
 		case "	":
 			badChar = "a tab character";
 			break;
@@ -271,9 +272,7 @@ function plainValue(source, onError) {
 			badChar = `block scalar indicator ${source[0]}`;
 			break;
 		case "@":
-		case "`":
-			badChar = `reserved character ${source[0]}`;
-			break;
+		case "`": badChar = `reserved character ${source[0]}`;
 	}
 	if (badChar) onError(0, "BAD_SCALAR_START", `Plain value cannot start with ${badChar}`);
 	return foldLines(source);
@@ -282,41 +281,40 @@ 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, "'");
 }
+const CHAR_CR$1 = 13;
+const CHAR_SPACE$1 = 32;
+const CHAR_TAB$1 = 9;
 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 newLineIndex = source.indexOf("\n");
+	if (newLineIndex === -1) return source;
+	let end = newLineIndex;
+	let cc = source.charCodeAt(end - 1);
+	if (cc === CHAR_CR$1) cc = source.charCodeAt(--end - 1);
+	while (end > 0 && (cc === CHAR_SPACE$1 || cc === CHAR_TAB$1)) cc = source.charCodeAt(--end - 1);
+	let res = source.slice(0, end);
 	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];
+	let pos = newLineIndex + 1;
+	while ((newLineIndex = source.indexOf("\n", pos)) !== -1) {
+		let start = pos;
+		cc = source.charCodeAt(start);
+		while (start < newLineIndex && (cc === CHAR_SPACE$1 || cc === CHAR_TAB$1)) cc = source.charCodeAt(++start);
+		end = newLineIndex;
+		cc = source.charCodeAt(end - 1);
+		if (cc === CHAR_CR$1) cc = source.charCodeAt(--end - 1);
+		while (end > start && (cc === CHAR_SPACE$1 || cc === CHAR_TAB$1)) cc = source.charCodeAt(--end - 1);
+		if (start === end) {
+			if (sep === "\n") res += sep;
+			else sep = "\n";
+		} else {
+			res += sep + source.slice(start, end);
 			sep = " ";
 		}
-		pos = line.lastIndex;
+		pos = newLineIndex + 1;
 	}
-	const last = /[ \t]*(.*)/sy;
-	last.lastIndex = pos;
-	match = last.exec(source);
-	return res + sep + (match?.[1] ?? "");
+	let start = pos;
+	cc = source.charCodeAt(start);
+	while (start < source.length && (cc === CHAR_SPACE$1 || cc === CHAR_TAB$1)) cc = source.charCodeAt(++start);
+	return res + sep + source.slice(start);
 }
 function doubleQuotedValue(source, onError) {
 	let res = "";
@@ -338,11 +336,7 @@ function doubleQuotedValue(source, onError) {
 				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];
+				const length = next === "x" ? 2 : next === "u" ? 4 : 8;
 				res += parseCharCode(source, i + 1, length, onError);
 				i += length;
 			} else {
@@ -402,14 +396,14 @@ const escapeCodes = {
 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)) {
+	try {
+		return String.fromCodePoint(code);
+	} catch {
 		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 {
@@ -462,7 +456,6 @@ const prettifyError = (src, lc) => (error) => {
 		error.message += `:\n\n${lineStr}\n${pointer}\n`;
 	}
 };
-
 //#endregion
 //#region src/parse/cst-scalar.ts
 function resolveAsScalar(token, strict = true, onError) {
@@ -721,7 +714,6 @@ function setFlowScalarValue(token, source, type) {
 		}
 	}
 }
-
 //#endregion
 //#region src/parse/cst-stringify.ts
 /**
@@ -770,7 +762,6 @@ function stringifyItem({ start, key, sep, value }) {
 	if (value) res += stringifyToken(value);
 	return res;
 }
-
 //#endregion
 //#region src/parse/cst-visit.ts
 const BREAK = Symbol("break visit");
@@ -809,7 +800,7 @@ const visit = function visit(cst, visitor) {
 		start: cst.start,
 		value: cst.value
 	};
-	_visit(Object.freeze([]), cst, visitor);
+	_visit([], cst, visitor);
 };
 visit.BREAK = BREAK;
 visit.SKIP = SKIP;
@@ -837,7 +828,7 @@ function _visit(path, item, visitor) {
 		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);
+				const ci = _visit([...path, [field, i]], token.items[i], visitor);
 				if (typeof ci === "number") i = ci - 1;
 				else if (ci === BREAK) return BREAK;
 				else if (ci === REMOVE) {
@@ -850,14 +841,13 @@ function _visit(path, item, visitor) {
 	}
 	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,
+	BOM: () => "",
+	DOCUMENT: () => "",
+	FLOW_END: () => "",
+	SCALAR: () => "",
 	createScalarToken: () => createScalarToken,
 	isCollection: () => isCollection,
 	isScalar: () => isScalar,
@@ -868,14 +858,6 @@ var cst_exports = /* @__PURE__ */ __exportAll({
 	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 */
@@ -884,20 +866,20 @@ const isScalar = (token) => !!token && (token.type === "scalar" || token.type ==
 /** 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>";
+		case "": return "<BOM>";
+		case "": return "<DOC>";
+		case "": return "<FLOW_END>";
+		case "": 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 "byte-order-mark";
+		case "": return "doc-mode";
+		case "": return "flow-error-end";
+		case "": return "scalar";
 		case "---": return "doc-start";
 		case "...": return "doc-end";
 		case "":
@@ -927,7 +909,6 @@ function tokenType(source) {
 	}
 	return null;
 }
-
 //#endregion
 //#region src/parse/lexer.ts
 function isEmpty(ch) {
@@ -940,12 +921,26 @@ function isEmpty(ch) {
 		default: return false;
 	}
 }
-const flowIndicatorChars = /* @__PURE__ */ new Set(",[]{}");
+const CHAR_TAB = 9;
+const CHAR_LF = 10;
+const CHAR_CR = 13;
+const CHAR_SPACE = 32;
+const CHAR_HASH = 35;
+const CHAR_COLON = 58;
+function isEmptyChar(ch) {
+	return Number.isNaN(ch) || ch === CHAR_SPACE || ch === CHAR_LF || ch === CHAR_CR || ch === CHAR_TAB;
+}
+const flowIndicatorCharCodes = /* @__PURE__ */ new Set([
+	44,
+	91,
+	93,
+	123,
+	125
+]);
 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 directiveLine = /(%(?:[^ \t\n\r]|[ \t](?![\n\r#]))*)([ \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;
@@ -968,7 +963,15 @@ function lex(source) {
 	const lexer = new Lexer(source);
 	const end = source.length;
 	let state = "stream";
-	while (lexer.pos < end) state = lexer[state]();
+	while (lexer.pos < end) switch (state) {
+		case "stream":
+			state = lexer.stream();
+			break;
+		case "document":
+			state = lexer.document();
+			break;
+		case "flow": state = lexer.flow();
+	}
 	return lexer.tokens;
 }
 var Lexer = class {
@@ -995,23 +998,25 @@ var Lexer = class {
 		this.source = source;
 	}
 	charAt(n) {
-		return this.source[this.pos + n];
+		const i = this.pos + n;
+		return i < this.source.length ? this.source[i] : void 0;
 	}
 	continueScalar(offset) {
 		if (this.indentNext > 0) {
-			let ch = this.source[offset];
+			const len = this.source.length;
 			let indent = 0;
-			while (ch === " ") ch = this.source[++indent + offset];
-			if (ch === "\r") {
-				if (this.source[indent + offset + 1] === "\n") return offset + indent + 1;
+			while (offset + indent < len && this.source.charCodeAt(offset + indent) === CHAR_SPACE) ++indent;
+			const cc = offset + indent < len ? this.source.charCodeAt(offset + indent) : NaN;
+			if (cc === CHAR_CR) {
+				if (this.source.charCodeAt(indent + offset + 1) === CHAR_LF) return offset + indent + 1;
 			}
-			return ch === "\n" || indent >= this.indentNext ? offset + indent : -1;
+			return cc === CHAR_LF || indent >= this.indentNext ? offset + indent : -1;
 		}
 		docMarker.lastIndex = offset;
 		return docMarker.test(this.source) ? -1 : offset;
 	}
 	stream() {
-		if (this.charAt(0) === BOM) {
+		if (this.charAt(0) === "") {
 			this.count(1);
 			return "stream";
 		}
@@ -1036,7 +1041,7 @@ var Lexer = class {
 			this.newline();
 			return "stream";
 		}
-		this.tokens.push(DOCUMENT);
+		this.tokens.push("");
 		return this.lineStart();
 	}
 	lineStart() {
@@ -1060,22 +1065,27 @@ var Lexer = class {
 		}
 		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;
+		while (true) {
+			const ch = this.source[this.pos];
+			if (ch !== "-" && ch !== "?" && ch !== ":") break;
+			const next = this.source[this.pos + 1];
+			if (next !== void 0 && next !== " " && next !== "\n" && next !== "\r" && next !== "	") break;
+			this.tokens.push(ch);
+			const start = this.pos;
+			this.pos += 1;
+			let sc = this.source.charCodeAt(this.pos);
+			while (sc === CHAR_SPACE || sc === CHAR_TAB) sc = this.source.charCodeAt(++this.pos);
+			if (this.pos > start + 1) this.tokens.push(this.source.slice(start + 1, this.pos));
 			this.indentNext = this.indentValue + 1;
-			this.indentValue += line.length;
+			this.indentValue += this.pos - start;
 		}
 		return "document";
 	}
 	document() {
 		this.spaces(true);
 		this.indicators();
-		switch (this.charAt(0)) {
+		const ch = this.charAt(0);
+		switch (ch) {
 			case "#": this.toLineEnd();
 			case "\n":
 			case void 0:
@@ -1096,7 +1106,7 @@ var Lexer = class {
 				return "document";
 			case "\"":
 			case "'":
-				this.quotedScalar();
+				this.quotedScalar(ch);
 				return "document";
 			case "|":
 			case ">":
@@ -1125,14 +1135,14 @@ var Lexer = class {
 		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);
+			this.tokens.push("");
 			return this.lineStart();
 		}
 		if (indent === 0) {
 			docMarker.lastIndex = this.pos;
 			if (docMarker.test(this.source)) {
 				this.flowLevel = 0;
-				this.tokens.push(FLOW_END);
+				this.tokens.push("");
 				return this.lineStart();
 			}
 		}
@@ -1167,7 +1177,7 @@ var Lexer = class {
 			case "\"":
 			case "'":
 				this.flowKey = true;
-				this.quotedScalar();
+				this.quotedScalar(ch);
 				break;
 			case ":":
 				if (this.flowKey) {
@@ -1209,8 +1219,7 @@ var Lexer = class {
 		}
 		return hasIndicators;
 	}
-	quotedScalar() {
-		const quote = this.charAt(0);
+	quotedScalar(quote) {
 		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) {
@@ -1246,16 +1255,16 @@ var Lexer = class {
 		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 " ":
+		let cc;
+		loop: for (let i = this.pos; cc = this.source.charCodeAt(i); ++i) switch (cc) {
+			case CHAR_SPACE:
 				indent += 1;
 				break;
-			case "\n":
+			case CHAR_LF:
 				nl = i;
 				indent = 0;
 				break;
-			case "\r": if (this.source[i + 1] === "\n") break;
+			case CHAR_CR: if (this.source.charCodeAt(i + 1) === CHAR_LF) break;
 			default: break loop;
 		}
 		if (indent >= this.indentNext) {
@@ -1269,50 +1278,56 @@ var Lexer = class {
 			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];
+		cc = this.source.charCodeAt(i);
+		while (cc === CHAR_SPACE) cc = this.source.charCodeAt(++i);
+		if (cc === CHAR_TAB) {
+			while (cc === CHAR_TAB || cc === CHAR_SPACE || cc === CHAR_CR || cc === CHAR_LF) cc = this.source.charCodeAt(++i);
 			nl = i - 1;
 		} else if (!bsKeep) do {
 			let i = nl - 1;
-			let ch = this.source[i];
-			if (ch === "\r") ch = this.source[--i];
+			let cc = this.source.charCodeAt(i);
+			if (cc === CHAR_CR) cc = this.source.charCodeAt(--i);
 			const lastChar = i;
-			while (ch === " ") ch = this.source[--i];
-			if (ch === "\n" && i >= this.pos && i + 1 + indent > lastChar) nl = i;
+			while (cc === CHAR_SPACE) cc = this.source.charCodeAt(--i);
+			if (cc === CHAR_LF && i >= this.pos && i + 1 + indent > lastChar) nl = i;
 			else break;
 		} while (true);
-		this.tokens.push(SCALAR);
+		this.tokens.push("");
 		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);
+		let cc;
+		const len = this.source.length;
+		while (++i < len) {
+			cc = this.source.charCodeAt(i);
+			if (cc === CHAR_COLON) {
+				const next = i + 1 < len ? this.source.charCodeAt(i + 1) : NaN;
+				if (isEmptyChar(next) || inFlow && flowIndicatorCharCodes.has(next)) break;
+				end = i;
+			} else if (isEmptyChar(cc)) {
+				let next = i + 1 < len ? this.source.charCodeAt(i + 1) : NaN;
+				if (cc === CHAR_CR) {
+					if (next === CHAR_LF) {
+						i += 1;
+						cc = CHAR_LF;
+						next = i + 1 < len ? this.source.charCodeAt(i + 1) : NaN;
+					} else end = i;
+				}
+				if (next === CHAR_HASH || inFlow && flowIndicatorCharCodes.has(next)) break;
+				if (cc === CHAR_LF) {
+					const cs = this.continueScalar(i + 1);
+					if (cs === -1) break;
+					i = Math.max(i, cs - 2);
+				}
+			} else {
+				if (inFlow && flowIndicatorCharCodes.has(cc)) break;
+				end = i;
 			}
-		} else {
-			if (inFlow && flowIndicatorChars.has(ch)) break;
-			end = i;
 		}
-		this.tokens.push(SCALAR);
+		this.tokens.push("");
 		this.toIndex(end + 1, true);
 	}
 	count(n) {
@@ -1334,9 +1349,9 @@ var Lexer = class {
 	}
 	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;
+		let ch = this.source.charCodeAt(i);
+		while (ch && ch !== CHAR_LF) ch = this.source.charCodeAt(++i);
+		if (this.source.charCodeAt(i - 1) === CHAR_CR) --i;
 		return this.toIndex(i, false);
 	}
 	newline() {
@@ -1346,11 +1361,13 @@ var Lexer = class {
 		else return 0;
 	}
 	spaces(allowTabs) {
-		let i = this.pos - 1;
-		let ch;
-		do
-			ch = this.source[++i];
-		while (ch === " " || allowTabs && ch === "	");
+		let i = this.pos;
+		const len = this.source.length;
+		while (i < len) {
+			const cc = this.source.charCodeAt(i);
+			if (cc !== CHAR_SPACE && !(allowTabs && cc === CHAR_TAB)) break;
+			++i;
+		}
 		const n = i - this.pos;
 		if (n > 0) {
 			const s = this.source.substr(this.pos, n);
@@ -1366,7 +1383,6 @@ var Lexer = class {
 		return this.toIndex(i, false);
 	}
 };
-
 //#endregion
 //#region src/parse/parser.ts
 function includesToken(list, type) {
@@ -1401,6 +1417,7 @@ function getPrevProps(parent) {
 			return it.sep ?? it.start;
 		}
 		case "block-seq": return parent.items[parent.items.length - 1].start;
+		/* istanbul ignore next should not happen */
 		default: return [];
 	}
 }
@@ -1423,9 +1440,10 @@ function fixFlowSeqItems(fc) {
 		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);
+			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;
 		}
 	}
@@ -1624,11 +1642,10 @@ var Parser = class {
 						return;
 					} else if (it.sep) it.value = token;
 					else {
-						Object.assign(it, {
-							key: token,
-							sep: []
-						});
-						this.onKeyLine = !it.explicitKey;
+						const item = it;
+						item.key = token;
+						item.sep = [];
+						this.onKeyLine = !item.explicitKey;
 						return;
 					}
 					break;
@@ -1650,12 +1667,13 @@ var Parser = class {
 						sep: []
 					});
 					else if (it.sep) it.value = token;
-					else Object.assign(it, {
-						key: token,
-						sep: []
-					});
+					else {
+						it.key = token;
+						it.sep = [];
+					}
 					return;
 				}
+				/* istanbul ignore next should not happen */
 				default:
 					this.pop();
 					this.pop(token);
@@ -1769,6 +1787,7 @@ var Parser = class {
 				}
 				this.pop();
 				break;
+			/* istanbul ignore next should not happen */
 			default:
 				this.pop();
 				this.step();
@@ -1857,62 +1876,68 @@ var Parser = class {
 					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,
+					if (it.explicitKey) {
+						if (!it.sep) {
+							if (includesToken(it.start, "newline")) {
+								const item = it;
+								item.key = null;
+								item.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 (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({
+						});
+						else if (includesToken(it.sep, "map-value-ind")) this.stack.push({
 							type: "block-map",
 							offset: this.offset,
 							indent: this.indent,
 							items: [{
 								start,
-								key,
-								sep
+								key: null,
+								sep: [this.sourceToken]
 							}]
 						});
-					} 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({
+						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,
+							...start,
+							this.sourceToken
+						];
+						else it.sep.push(this.sourceToken);
+					} else if (!it.sep) {
+						const item = it;
+						item.key = null;
+						item.sep = [this.sourceToken];
+					} else if (it.value || atNextItem) map.items.push({
 						start,
 						key: null,
 						sep: [this.sourceToken]
@@ -1944,10 +1969,9 @@ var Parser = class {
 						this.onKeyLine = true;
 					} else if (it.sep) this.stack.push(fs);
 					else {
-						Object.assign(it, {
-							key: fs,
-							sep: []
-						});
+						const item = it;
+						item.key = fs;
+						item.sep = [];
 						this.onKeyLine = true;
 					}
 					return;
@@ -1965,7 +1989,7 @@ var Parser = class {
 								});
 								return;
 							}
-						} else if (atMapIndent) map.items.push({ start });
+						} else if (atMapIndent && (it.sep || it.explicitKey || start.length > 0)) map.items.push({ start });
 						this.stack.push(bv);
 						return;
 					}
@@ -2044,10 +2068,10 @@ var Parser = class {
 						sep: [this.sourceToken]
 					});
 					else if (it.sep) it.sep.push(this.sourceToken);
-					else Object.assign(it, {
-						key: null,
-						sep: [this.sourceToken]
-					});
+					else {
+						it.key = null;
+						it.sep = [this.sourceToken];
+					}
 					return;
 				case "space":
 				case "comment":
@@ -2069,10 +2093,10 @@ var Parser = class {
 						sep: []
 					});
 					else if (it.sep) this.stack.push(fs);
-					else Object.assign(it, {
-						key: fs,
-						sep: []
-					});
+					else {
+						it.key = fs;
+						it.sep = [];
+					}
 					return;
 				}
 				case "flow-map-end":
@@ -2217,7 +2241,6 @@ var Parser = class {
 		}
 	}
 };
-
 //#endregion
 //#region src/compose/resolve-props.ts
 function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIndent, startOnNewline }) {
@@ -2235,7 +2258,8 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
 	let comma = null;
 	let found = null;
 	let start = null;
-	for (const token of tokens) {
+	let token;
+	for (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;
@@ -2305,8 +2329,7 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
 				hasSpace = false;
 		}
 	}
-	const last = tokens[tokens.length - 1];
-	const end = last ? last.offset + last.source.length : offset;
+	const end = token ? token.offset + token.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 {
@@ -2322,7 +2345,6 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
 		start: start ?? end
 	};
 }
-
 //#endregion
 //#region src/compose/util-contains-newline.ts
 function containsNewline(key) {
@@ -2349,7 +2371,6 @@ function containsNewline(key) {
 		default: return true;
 	}
 }
-
 //#endregion
 //#region src/compose/util-flow-indent-check.ts
 function flowIndentCheck(indent, fc, onError) {
@@ -2358,21 +2379,11 @@ function flowIndentCheck(indent, fc, onError) {
 		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);
+	const map = new ((tag?.nodeClass) ?? YAMLMap)(ctx.schema);
 	if (ctx.atRoot) ctx.atRoot = false;
 	let offset = bm.offset;
 	let commentEnd = null;
@@ -2394,8 +2405,10 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, ta
 			}
 			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;
+				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");
@@ -2405,7 +2418,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, ta
 		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");
+		if (map.has(keyNode)) onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
 		const valueProps = resolveProps(sep ?? [], {
 			indicator: "map-value-ind",
 			next: value,
@@ -2423,16 +2436,31 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, ta
 			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);
+			if (map instanceof YAMLSet) {
+				if (value || valueProps.anchor || valueProps.tag) onError(valueNode.range, "BAD_COLLECTION_TYPE", "Set items must not have non-empty values");
+				if (valueProps.comment) {
+					if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
+					else keyNode.comment = valueProps.comment;
+					keyNode.range[2] = valueProps.end;
+				}
+				map.add(keyNode);
+			} else {
+				const pair = new Pair(keyNode, valueNode);
+				if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
+				map.set(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 (valueProps.comment) {
+				if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
+				else keyNode.comment = valueProps.comment;
+			}
+			if (map instanceof YAMLSet) map.add(keyNode);
+			else {
+				const pair = new Pair(keyNode);
+				if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
+				map.set(pair);
+			}
 		}
 	}
 	if (commentEnd && commentEnd < offset) onError(commentEnd, "IMPOSSIBLE", "Map comment with trailing content");
@@ -2443,11 +2471,10 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, ta
 	];
 	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);
+	const seq = new ((tag?.nodeClass) ?? YAMLSeq)(ctx.schema);
 	if (ctx.atRoot) ctx.atRoot = false;
 	if (ctx.atKey) ctx.atKey = false;
 	let offset = bs.offset;
@@ -2461,17 +2488,20 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, ta
 			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;
+		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._push(node);
 	}
 	seq.range = [
 		bs.offset,
@@ -2480,7 +2510,6 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, ta
 	];
 	return seq;
 }
-
 //#endregion
 //#region src/compose/resolve-flow-collection.ts
 const blockMsg = "Block collections are not allowed within flow collections";
@@ -2488,7 +2517,9 @@ const isBlock = (token) => token && (token.type === "block-map" || token.type ==
 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);
+	let coll;
+	if (tag?.nodeClass) coll = new tag.nodeClass(ctx.schema);
+	else coll = isMap ? new YAMLMap(ctx.schema) : new YAMLSeq(ctx.schema);
 	coll.flow = true;
 	const atRoot = ctx.atRoot;
 	if (atRoot) ctx.atRoot = false;
@@ -2510,8 +2541,10 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
 			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;
+				if (props.comment) {
+					if (coll.comment) coll.comment += "\n" + props.comment;
+					else coll.comment = props.comment;
+				}
 				offset = props.end;
 				continue;
 			}
@@ -2532,7 +2565,9 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
 					default: break loop;
 				}
 				if (prevItemComment) {
-					let prev = coll.items[coll.items.length - 1];
+					let prev;
+					if (Array.isArray(coll)) prev = coll[coll.length - 1];
+					else for (const prev_ of coll.values.values()) prev = prev_;
 					if (prev instanceof Pair) prev = prev.value ?? prev.key;
 					if (prev.comment) prev.comment += "\n" + prevItemComment;
 					else prev.comment = prevItemComment;
@@ -2542,7 +2577,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
 		}
 		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);
+			coll._push(valueNode);
 			offset = valueNode.range[2];
 			if (isBlock(value)) onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
 		} else {
@@ -2571,30 +2606,35 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
 					}
 					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`);
+			} 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;
+			} 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);
+				if (map.has(keyNode)) onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
+				if (map instanceof YAMLSet) map.add(keyNode);
+				else map.set(pair);
 			} else {
 				const map = new YAMLMap(ctx.schema);
 				map.flow = true;
-				map.items.push(pair);
+				map.set(pair);
 				const endRange = (valueNode ?? keyNode).range;
 				map.range = [
 					keyNode.range[0],
 					endRange[1],
 					endRange[2]
 				];
-				coll.items.push(map);
+				coll._push(map);
 			}
 			offset = valueNode ? valueNode.range[2] : valueProps.end;
 		}
@@ -2611,8 +2651,10 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
 	}
 	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;
+		if (end.comment) {
+			if (coll.comment) coll.comment += "\n" + end.comment;
+			else coll.comment = end.comment;
+		}
 		coll.range = [
 			fc.offset,
 			cePos,
@@ -2625,7 +2667,6 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
 	];
 	return coll;
 }
-
 //#endregion
 //#region src/compose/compose-collection.ts
 function resolveCollection(CN, ctx, token, onError, tagName, tag) {
@@ -2662,13 +2703,12 @@ function composeCollection(CN, ctx, token, props, onError) {
 	}
 	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);
+	const node = isNode(res) ? 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) {
@@ -2699,9 +2739,11 @@ function composeScalar(ctx, token, tagToken, onError) {
 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;
+	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?.(value)) return tag;
 	const kt = schema.knownTags[tagName];
 	if (kt && !kt.collection) {
 		schema.tags.push(Object.assign({}, kt, {
@@ -2713,15 +2755,20 @@ function findScalarTagByName(schema, value, tagName, tagToken, onError) {
 	onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str");
 	return schema.scalar;
 }
+const schemaTagsWithTest = /* @__PURE__ */ new WeakMap();
 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;
+	let schemaTags = schemaTagsWithTest.get(schema);
+	if (!schemaTags) {
+		schemaTags = schema.tags.filter((t) => t.test !== void 0 && (t.default === true || t.default === "key"));
+		schemaTagsWithTest.set(schema, schemaTags);
+	}
+	const tag = schemaTags.find((t) => (t.default === true || atKey && t.default === "key") && t.test?.(value)) ?? schema.scalar;
 	if (schema.compat) {
-		const compat = schema.compat.find((tag) => tag.default && tag.test?.test(value)) ?? schema.scalar;
+		const compat = schema.compat.find((tag) => tag.default && tag.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) {
@@ -2746,7 +2793,6 @@ function emptyScalarPosition(offset, before, pos) {
 	}
 	return offset;
 }
-
 //#endregion
 //#region src/compose/compose-node.ts
 const CN = {
@@ -2773,19 +2819,25 @@ function composeNode(ctx, token, props, onError) {
 		case "block-map":
 		case "block-seq":
 		case "flow-collection":
-			node = composeCollection(CN, ctx, token, props, onError);
-			if (anchor) node.anchor = anchor.source.substring(1);
+			try {
+				node = composeCollection(CN, ctx, token, props, onError);
+				if (anchor) node.anchor = anchor.source.substring(1);
+			} catch (error) {
+				onError(token, "RESOURCE_EXHAUSTION", error instanceof Error ? error.message : String(error));
+			}
 			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;
 	}
+	node ??= composeEmptyNode(ctx, token.offset, void 0, null, props, onError);
 	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 (comment) {
+		if (token.type === "scalar" && token.source === "") node.comment = comment;
+		else node.commentBefore = comment;
+	}
 	if (ctx.options.keepSourceTokens && isSrcToken) node.srcToken = token;
 	return node;
 }
@@ -2821,11 +2873,11 @@ function composeAlias({ options }, { offset, source, end }, onError) {
 	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 opts = Object.assign({ _directives: directives }, options);
+	const doc = new Document(void 0, opts);
 	const ctx = {
 		atKey: false,
 		atRoot: true,
@@ -2856,7 +2908,6 @@ function composeDoc(options, directives, { offset, start, value, end }, onError)
 	];
 	return doc;
 }
-
 //#endregion
 //#region src/compose/composer.ts
 function getErrorPos(src) {
@@ -2927,8 +2978,8 @@ var Composer = class {
 			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];
+			else if (isCollection$1(dc) && !dc.flow && dc.size > 0) {
+				let it = Array.isArray(dc) ? dc[0] : dc.values.values().next().value;
 				if (it instanceof Pair) it = it.key;
 				const cb = it.commentBefore;
 				it.commentBefore = cb ? `${comment}\n${cb}` : comment;
@@ -3037,7 +3088,8 @@ var Composer = class {
 			this.docs.push(this.doc);
 			this.doc = null;
 		} else if (forceDoc) {
-			const doc = new Document(void 0, Object.assign({ _directives: this.directives }, this.options));
+			const opts = Object.assign({ _directives: this.directives }, this.options);
+			const doc = new Document(void 0, opts);
 			if (this.atDirectives) this.onError(endOffset, "MISSING_CHAR", "Missing directives-end indicator line");
 			doc.range = [
 				0,
@@ -3050,7 +3102,6 @@ var Composer = class {
 		return this.docs;
 	}
 };
-
 //#endregion
 //#region src/parse/line-counter.ts
 /**
@@ -3093,6 +3144,5 @@ var LineCounter = class {
 		};
 	};
 };
-
 //#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 };
+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 };