yaml 3.0.0-1 → 3.0.0-2

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

@@ -1,5 +1,5 @@
-import { t as __exportAll } from "./chunk-pbuEa-1d.js";
-import { S as Scalar, b as stringifyString, d as Pair, f as isCollection$1, g as YAMLMap, h as YAMLSeq, i as Document, m as YAMLSet, p as isNode, t as Directives, u as Alias } from "./directives-CiM56lHW.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;
@@ -78,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;
@@ -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 = "";
@@ -923,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;
@@ -951,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 {
@@ -978,17 +998,19 @@ 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;
@@ -1043,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:
@@ -1079,7 +1106,7 @@ var Lexer = class {
 				return "document";
 			case "\"":
 			case "'":
-				this.quotedScalar();
+				this.quotedScalar(ch);
 				return "document";
 			case "|":
 			case ">":
@@ -1150,7 +1177,7 @@ var Lexer = class {
 			case "\"":
 			case "'":
 				this.flowKey = true;
-				this.quotedScalar();
+				this.quotedScalar(ch);
 				break;
 			case ":":
 				if (this.flowKey) {
@@ -1192,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) {
@@ -1229,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) {
@@ -1252,18 +1278,18 @@ 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("");
@@ -1273,27 +1299,33 @@ var Lexer = class {
 		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("");
 		this.toIndex(end + 1, true);
@@ -1317,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() {
@@ -1329,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);
@@ -1406,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;
 		}
 	}
@@ -1607,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;
@@ -1633,10 +1667,10 @@ 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 */
@@ -1842,66 +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,
-						...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]
@@ -1933,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;
@@ -1954,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;
 					}
@@ -2033,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":
@@ -2058,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":
@@ -2223,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;
@@ -2293,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 {
@@ -2348,7 +2383,7 @@ function flowIndentCheck(indent, fc, onError) {
 //#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;
@@ -2370,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");
@@ -2414,8 +2451,10 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, ta
 			}
 		} 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;
+			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);
@@ -2435,7 +2474,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, ta
 //#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;
@@ -2449,12 +2488,15 @@ 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);
@@ -2499,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;
 			}
@@ -2562,13 +2606,17 @@ 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) {
@@ -2603,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,
@@ -2689,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, {
@@ -2703,10 +2755,16 @@ 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;
@@ -2776,8 +2834,10 @@ function composeNode(ctx, token, 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;
 }
@@ -2816,7 +2876,8 @@ function composeAlias({ options }, { offset, source, end }, onError) {
 //#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,
@@ -3027,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,