yaml 2.8.4 → 3.0.0-1

package/dist/directives-CiM56lHW.js

@@ -0,0 +1,2963 @@
+//#region src/nodes/Scalar.ts
+var Scalar = class {
+	static BLOCK_FOLDED = "BLOCK_FOLDED";
+	static BLOCK_LITERAL = "BLOCK_LITERAL";
+	static PLAIN = "PLAIN";
+	static QUOTE_DOUBLE = "QUOTE_DOUBLE";
+	static QUOTE_SINGLE = "QUOTE_SINGLE";
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+	/** Create a copy of this node.  */
+	clone() {
+		const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+		if (this.range) copy.range = [...this.range];
+		return copy;
+	}
+	/** A plain JavaScript representation of this node. */
+	toJS(_doc, ctx) {
+		if (ctx && this.anchor) ctx.anchors.set(this, {
+			aliasCount: 0,
+			count: 1,
+			res: this.value
+		});
+		return this.value;
+	}
+	toString() {
+		return String(this.value);
+	}
+};
+//#endregion
+//#region src/stringify/foldFlowLines.ts
+const FOLD_FLOW = "flow";
+const FOLD_BLOCK = "block";
+const FOLD_QUOTED = "quoted";
+/**
+* Tries to keep input at up to `lineWidth` characters, splitting only on spaces
+* not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are
+* terminated with `\n` and started with `indent`.
+*/
+function foldFlowLines(text, indent, mode = "flow", { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {
+	if (!lineWidth || lineWidth < 0) return text;
+	if (lineWidth < minContentWidth) minContentWidth = 0;
+	const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);
+	if (text.length <= endStep) return text;
+	const folds = [];
+	const escapedFolds = {};
+	let end = lineWidth - indent.length;
+	if (typeof indentAtStart === "number") if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) folds.push(0);
+	else end = lineWidth - indentAtStart;
+	let split = void 0;
+	let prev = void 0;
+	let overflow = false;
+	let i = -1;
+	let escStart = -1;
+	let escEnd = -1;
+	if (mode === "block") {
+		i = consumeMoreIndentedLines(text, i, indent.length);
+		if (i !== -1) end = i + endStep;
+	}
+	for (let ch; ch = text[i += 1];) {
+		if (mode === "quoted" && ch === "\\") {
+			escStart = i;
+			switch (text[i + 1]) {
+				case "x":
+					i += 3;
+					break;
+				case "u":
+					i += 5;
+					break;
+				case "U":
+					i += 9;
+					break;
+				default: i += 1;
+			}
+			escEnd = i;
+		}
+		if (ch === "\n") {
+			if (mode === "block") i = consumeMoreIndentedLines(text, i, indent.length);
+			end = i + indent.length + endStep;
+			split = void 0;
+		} else {
+			if (ch === " " && prev && prev !== " " && prev !== "\n" && prev !== "	") {
+				const next = text[i + 1];
+				if (next && next !== " " && next !== "\n" && next !== "	") split = i;
+			}
+			if (i >= end) if (split) {
+				folds.push(split);
+				end = split + endStep;
+				split = void 0;
+			} else if (mode === "quoted") {
+				while (prev === " " || prev === "	") {
+					prev = ch;
+					ch = text[i += 1];
+					overflow = true;
+				}
+				const j = i > escEnd + 1 ? i - 2 : escStart - 1;
+				if (escapedFolds[j]) return text;
+				folds.push(j);
+				escapedFolds[j] = true;
+				end = j + endStep;
+				split = void 0;
+			} else overflow = true;
+		}
+		prev = ch;
+	}
+	if (overflow && onOverflow) onOverflow();
+	if (folds.length === 0) return text;
+	if (onFold) onFold();
+	let res = text.slice(0, folds[0]);
+	for (let i = 0; i < folds.length; ++i) {
+		const fold = folds[i];
+		const end = folds[i + 1] || text.length;
+		if (fold === 0) res = `\n${indent}${text.slice(0, end)}`;
+		else {
+			if (mode === "quoted" && escapedFolds[fold]) res += `${text[fold]}\\`;
+			res += `\n${indent}${text.slice(fold + 1, end)}`;
+		}
+	}
+	return res;
+}
+/**
+* Presumes `i + 1` is at the start of a line
+* @returns index of last newline in more-indented block
+*/
+function consumeMoreIndentedLines(text, i, indent) {
+	let end = i;
+	let start = i + 1;
+	let ch = text[start];
+	while (ch === " " || ch === "	") if (i < start + indent) ch = text[++i];
+	else {
+		do
+			ch = text[++i];
+		while (ch && ch !== "\n");
+		end = i;
+		start = i + 1;
+		ch = text[start];
+	}
+	return end;
+}
+//#endregion
+//#region src/stringify/stringifyString.ts
+const getFoldOptions = (ctx, isBlock) => ({
+	indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart,
+	lineWidth: ctx.options.lineWidth,
+	minContentWidth: ctx.options.minContentWidth
+});
+const containsDocumentMarker = (str) => /^(%|---|\.\.\.)/m.test(str);
+function lineLengthOverLimit(str, lineWidth, indentLength) {
+	if (!lineWidth || lineWidth < 0) return false;
+	const limit = lineWidth - indentLength;
+	const strLen = str.length;
+	if (strLen <= limit) return false;
+	for (let i = 0, start = 0; i < strLen; ++i) if (str[i] === "\n") {
+		if (i - start > limit) return true;
+		start = i + 1;
+		if (strLen - start <= limit) return false;
+	}
+	return true;
+}
+function doubleQuotedString(value, ctx) {
+	const json = JSON.stringify(value);
+	if (ctx.options.doubleQuotedAsJSON) return json;
+	const { implicitKey } = ctx;
+	const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;
+	const indent = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
+	let str = "";
+	let start = 0;
+	for (let i = 0, ch = json[i]; ch; ch = json[++i]) {
+		if (ch === " " && json[i + 1] === "\\" && json[i + 2] === "n") {
+			str += json.slice(start, i) + "\\ ";
+			i += 1;
+			start = i;
+			ch = "\\";
+		}
+		if (ch === "\\") switch (json[i + 1]) {
+			case "u":
+				{
+					str += json.slice(start, i);
+					const code = json.substr(i + 2, 4);
+					switch (code) {
+						case "0000":
+							str += "\\0";
+							break;
+						case "0007":
+							str += "\\a";
+							break;
+						case "000b":
+							str += "\\v";
+							break;
+						case "001b":
+							str += "\\e";
+							break;
+						case "0085":
+							str += "\\N";
+							break;
+						case "00a0":
+							str += "\\_";
+							break;
+						case "2028":
+							str += "\\L";
+							break;
+						case "2029":
+							str += "\\P";
+							break;
+						default: if (code.substr(0, 2) === "00") str += "\\x" + code.substr(2);
+						else str += json.substr(i, 6);
+					}
+					i += 5;
+					start = i + 1;
+				}
+				break;
+			case "n":
+				if (implicitKey || json[i + 2] === "\"" || json.length < minMultiLineLength) i += 1;
+				else {
+					str += json.slice(start, i) + "\n\n";
+					while (json[i + 2] === "\\" && json[i + 3] === "n" && json[i + 4] !== "\"") {
+						str += "\n";
+						i += 2;
+					}
+					str += indent;
+					if (json[i + 2] === " ") str += "\\";
+					i += 1;
+					start = i + 1;
+				}
+				break;
+			default: i += 1;
+		}
+	}
+	str = start ? str + json.slice(start) : json;
+	return implicitKey ? str : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx, false));
+}
+function singleQuotedString(value, ctx) {
+	if (ctx.options.singleQuote === false || ctx.implicitKey && value.includes("\n") || /[ \t]\n|\n[ \t]/.test(value)) return doubleQuotedString(value, ctx);
+	const indent = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
+	const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&\n${indent}`) + "'";
+	return ctx.implicitKey ? res : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx, false));
+}
+function quotedString(value, ctx) {
+	const { singleQuote } = ctx.options;
+	let qs;
+	if (singleQuote === false) qs = doubleQuotedString;
+	else {
+		const hasDouble = value.includes("\"");
+		const hasSingle = value.includes("'");
+		if (hasDouble && !hasSingle) qs = singleQuotedString;
+		else if (hasSingle && !hasDouble) qs = doubleQuotedString;
+		else qs = singleQuote ? singleQuotedString : doubleQuotedString;
+	}
+	return qs(value, ctx);
+}
+let blockEndNewlines;
+try {
+	blockEndNewlines = /* @__PURE__ */ new RegExp("(^|(?<!\n))\n+(?!\n|$)", "g");
+} catch {
+	blockEndNewlines = /\n+(?!\n|$)/g;
+}
+function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
+	const { blockQuote, commentString, lineWidth } = ctx.options;
+	if (!blockQuote || /\n[\t ]+$/.test(value)) return quotedString(value, ctx);
+	const indent = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value) ? "  " : "");
+	const literal = blockQuote === "literal" ? true : blockQuote === "folded" || type === Scalar.BLOCK_FOLDED ? false : type === Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, lineWidth, indent.length);
+	if (!value) return literal ? "|\n" : ">\n";
+	let chomp;
+	let endStart;
+	for (endStart = value.length; endStart > 0; --endStart) {
+		const ch = value[endStart - 1];
+		if (ch !== "\n" && ch !== "	" && ch !== " ") break;
+	}
+	let end = value.substring(endStart);
+	const endNlPos = end.indexOf("\n");
+	if (endNlPos === -1) chomp = "-";
+	else if (value === end || endNlPos !== end.length - 1) {
+		chomp = "+";
+		if (onChompKeep) onChompKeep();
+	} else chomp = "";
+	if (end) {
+		value = value.slice(0, -end.length);
+		if (end[end.length - 1] === "\n") end = end.slice(0, -1);
+		end = end.replace(blockEndNewlines, `$&${indent}`);
+	}
+	let startWithSpace = false;
+	let startEnd;
+	let startNlPos = -1;
+	for (startEnd = 0; startEnd < value.length; ++startEnd) {
+		const ch = value[startEnd];
+		if (ch === " ") startWithSpace = true;
+		else if (ch === "\n") startNlPos = startEnd;
+		else break;
+	}
+	let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);
+	if (start) {
+		value = value.substring(start.length);
+		start = start.replace(/\n+/g, `$&${indent}`);
+	}
+	let header = (startWithSpace ? indent ? "2" : "1" : "") + chomp;
+	if (comment) {
+		header += " " + commentString(comment.replace(/ ?[\r\n]+/g, " "));
+		if (onComment) onComment();
+	}
+	if (!literal) {
+		const foldedValue = value.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent}`);
+		let literalFallback = false;
+		const foldOptions = getFoldOptions(ctx, true);
+		if (blockQuote !== "folded" && type !== Scalar.BLOCK_FOLDED) foldOptions.onOverflow = () => {
+			literalFallback = true;
+		};
+		const body = foldFlowLines(`${start}${foldedValue}${end}`, indent, FOLD_BLOCK, foldOptions);
+		if (!literalFallback) return `>${header}\n${indent}${body}`;
+	}
+	value = value.replace(/\n+/g, `$&${indent}`);
+	return `|${header}\n${indent}${start}${value}${end}`;
+}
+function plainString(item, ctx, onComment, onChompKeep) {
+	const { type, value } = item;
+	const { actualString, implicitKey, indent, indentStep, inFlow } = ctx;
+	if (implicitKey && value.includes("\n") || inFlow && /[[\]{},]/.test(value)) return quotedString(value, ctx);
+	if (/^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) return implicitKey || inFlow || !value.includes("\n") ? quotedString(value, ctx) : blockString(item, ctx, onComment, onChompKeep);
+	if (!implicitKey && !inFlow && type !== Scalar.PLAIN && value.includes("\n")) return blockString(item, ctx, onComment, onChompKeep);
+	if (containsDocumentMarker(value)) {
+		if (indent === "") {
+			ctx.forceBlockIndent = true;
+			return blockString(item, ctx, onComment, onChompKeep);
+		} else if (implicitKey && indent === indentStep) return quotedString(value, ctx);
+	}
+	const str = value.replace(/\n+/g, `$&\n${indent}`);
+	if (actualString) {
+		const test = (tag) => tag.default && tag.tag !== "tag:yaml.org,2002:str" && tag.test?.test(str);
+		const { compat, tags } = ctx.doc.schema;
+		if (tags.some(test) || compat?.some(test)) return quotedString(value, ctx);
+	}
+	return implicitKey ? str : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx, false));
+}
+function stringifyString(item, ctx, onComment, onChompKeep) {
+	const { implicitKey, inFlow } = ctx;
+	const ss = typeof item.value === "string" ? item : Object.assign({}, item, { value: String(item.value) });
+	let { type } = item;
+	if (type !== Scalar.QUOTE_DOUBLE) {
+		if (/[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(ss.value)) type = Scalar.QUOTE_DOUBLE;
+	}
+	const _stringify = (_type) => {
+		switch (_type) {
+			case Scalar.BLOCK_FOLDED:
+			case Scalar.BLOCK_LITERAL: return implicitKey || inFlow ? quotedString(ss.value, ctx) : blockString(ss, ctx, onComment, onChompKeep);
+			case Scalar.QUOTE_DOUBLE: return doubleQuotedString(ss.value, ctx);
+			case Scalar.QUOTE_SINGLE: return singleQuotedString(ss.value, ctx);
+			case Scalar.PLAIN: return plainString(ss, ctx, onComment, onChompKeep);
+			default: return null;
+		}
+	};
+	let res = _stringify(type);
+	if (res === null) {
+		const { defaultKeyType, defaultStringType } = ctx.options;
+		const t = implicitKey && defaultKeyType || defaultStringType;
+		res = _stringify(t);
+		if (res === null) throw new Error(`Unsupported default string type ${t}`);
+	}
+	return res;
+}
+//#endregion
+//#region src/doc/anchors.ts
+/**
+* Verify that the input string is a valid anchor.
+*
+* Will throw on errors.
+*/
+function anchorIsValid(anchor) {
+	if (/[\x00-\x19\s,[\]{}]/.test(anchor)) {
+		const msg = `Anchor must not contain whitespace or control characters: ${JSON.stringify(anchor)}`;
+		throw new Error(msg);
+	}
+	return true;
+}
+function anchorNames(root) {
+	const anchors = /* @__PURE__ */ new Set();
+	visit(root, { Value(_key, node) {
+		if (node.anchor) anchors.add(node.anchor);
+	} });
+	return anchors;
+}
+/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */
+function findNewAnchor(prefix, exclude) {
+	for (let i = 1;; ++i) {
+		const name = `${prefix}${i}`;
+		if (!exclude.has(name)) return name;
+	}
+}
+//#endregion
+//#region src/doc/NodeCreator.ts
+const defaultTagPrefix = "tag:yaml.org,2002:";
+var NodeCreator = class {
+	keepUndefined;
+	replacer;
+	schema;
+	#anchorPrefix;
+	#aliasObjects = [];
+	#doc;
+	#flow;
+	#onTagObj;
+	#prevAnchors = null;
+	#sourceObjects = /* @__PURE__ */ new Map();
+	constructor(docOrSchema, options = {}, replacer) {
+		this.keepUndefined = options.keepUndefined ?? false;
+		this.replacer = replacer;
+		this.#flow = options.flow ?? false;
+		this.#onTagObj = options.onTagObj;
+		this.#anchorPrefix = options.anchorPrefix || "a";
+		if (docOrSchema instanceof Document) {
+			if (options.aliasDuplicateObjects ?? true) this.#doc = docOrSchema;
+			this.schema = docOrSchema.schema;
+		} else this.schema = docOrSchema;
+	}
+	create(value, tagName) {
+		if (value instanceof Document) value = value.value;
+		if (isNode(value)) return value;
+		if (value instanceof Pair) return this.schema.map.createNode(this, null).set(value);
+		if (value instanceof String || value instanceof Number || value instanceof Boolean || typeof BigInt !== "undefined" && value instanceof BigInt) value = value.valueOf();
+		let ref = void 0;
+		if (this.#doc && value && typeof value === "object") {
+			ref = this.#sourceObjects.get(value);
+			if (ref) {
+				if (!ref.anchor) {
+					this.#aliasObjects.push(value);
+					this.#prevAnchors ??= anchorNames(this.#doc);
+					ref.anchor = findNewAnchor(this.#anchorPrefix, this.#prevAnchors);
+					this.#prevAnchors.add(ref.anchor);
+				}
+				return new Alias(ref.anchor);
+			} else {
+				ref = {
+					anchor: null,
+					node: null
+				};
+				this.#sourceObjects.set(value, ref);
+			}
+		}
+		let tagObj;
+		if (tagName) {
+			if (tagName.startsWith("!!")) tagName = defaultTagPrefix + tagName.slice(2);
+			const match = this.schema.tags.filter((t) => t.tag === tagName);
+			tagObj = match.find((t) => !t.format) ?? match[0];
+			if (!tagObj) throw new Error(`Tag ${tagName} not found`);
+		} else tagObj = this.schema.tags.find((t) => t.identify?.(value) && !t.format);
+		if (!tagObj) {
+			if (value && typeof value.toJSON === "function") value = value.toJSON();
+			if (!value || typeof value !== "object") {
+				const node = new Scalar(value);
+				if (ref) ref.node = node;
+				return node;
+			}
+			tagObj = value instanceof Map ? this.schema.map : Symbol.iterator in Object(value) ? this.schema.seq : this.schema.map;
+		}
+		if (this.#onTagObj) {
+			this.#onTagObj(tagObj);
+			this.#onTagObj = void 0;
+		}
+		const node = tagObj?.createNode?.(this, value) ?? new Scalar(value);
+		if (tagName) node.tag = tagName;
+		else if (!tagObj.default) node.tag = tagObj.tag;
+		if (ref) ref.node = node;
+		if (this.#flow && isCollection(node)) node.flow = true;
+		return node;
+	}
+	createPair(key, value) {
+		return new Pair(this.create(key), value == null ? null : this.create(value));
+	}
+	/**
+	* With circular references, the source node is only resolved after all
+	* of its child nodes are. This is why anchors are set only after all of
+	* the nodes have been created.
+	*/
+	setAnchors() {
+		for (const source of this.#aliasObjects) {
+			const ref = this.#sourceObjects.get(source);
+			if (typeof ref === "object" && ref.anchor && (ref.node instanceof Scalar || isCollection(ref.node))) ref.node.anchor = ref.anchor;
+			else throw Object.assign(/* @__PURE__ */ new Error("Failed to resolve repeated object (this should not happen)"), { source });
+		}
+	}
+};
+//#endregion
+//#region src/stringify/stringifyComment.ts
+/**
+* Stringifies a comment.
+*
+* Empty comment lines are left empty,
+* lines consisting of a single space are replaced by `#`,
+* and all other lines are prefixed with a `#`.
+*/
+const stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, "#");
+function indentComment(comment, indent) {
+	if (/^\n+$/.test(comment)) return comment.substring(1);
+	return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;
+}
+const lineComment = (str, indent, comment) => str.endsWith("\n") ? indentComment(comment, indent) : comment.includes("\n") ? "\n" + indentComment(comment, indent) : (str.endsWith(" ") ? "" : " ") + comment;
+//#endregion
+//#region src/log.ts
+function debug(logLevel, ...messages) {
+	if (logLevel === "debug") console.log(...messages);
+}
+function warn(logLevel, warning) {
+	if (logLevel === "debug" || logLevel === "warn") if (typeof process !== "undefined" && typeof process.emitWarning === "function") process.emitWarning(warning);
+	else console.warn(warning);
+}
+//#endregion
+//#region src/schema/yaml-1.1/merge.ts
+const MERGE_KEY = "<<";
+const merge = {
+	identify: (value) => value === MERGE_KEY || typeof value === "symbol" && value.description === MERGE_KEY,
+	default: "key",
+	tag: "tag:yaml.org,2002:merge",
+	test: /^<<$/,
+	resolve: () => Object.assign(new Scalar(Symbol(MERGE_KEY)), { addToJSMap: addMergeToJSMap }),
+	stringify: () => MERGE_KEY
+};
+const isMergeKey = (doc, key) => (merge.identify(key) || key instanceof Scalar && (!key.type || key.type === Scalar.PLAIN) && merge.identify(key.value)) && Boolean(doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default));
+function addMergeToJSMap(doc, ctx, map, value) {
+	value = ctx && value instanceof Alias ? value.resolve(doc, ctx) : value;
+	if (Array.isArray(value) && !(value instanceof YAMLMap)) for (const it of value) mergeValue(doc, ctx, map, it);
+	else mergeValue(doc, ctx, map, value);
+}
+function mergeValue(doc, ctx, map, value) {
+	const srcMap = (value instanceof Alias ? value.resolve(doc, ctx) : value).toJS(doc, ctx, Map);
+	if (!(srcMap instanceof Map)) throw new Error("Merge sources must be maps or map aliases");
+	for (const [key, value] of srcMap) if (map instanceof Map) {
+		if (!map.has(key)) map.set(key, value);
+	} else if (map instanceof Set) map.add(key);
+	else if (!Object.prototype.hasOwnProperty.call(map, key)) Object.defineProperty(map, key, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+	return map;
+}
+//#endregion
+//#region src/stringify/stringify.ts
+const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+function createStringifyContext(doc, options) {
+	const opt = Object.assign({
+		blockQuote: true,
+		commentString: stringifyComment,
+		defaultKeyType: null,
+		defaultStringType: "PLAIN",
+		directives: null,
+		doubleQuotedAsJSON: false,
+		doubleQuotedMinMultiLineLength: 40,
+		falseStr: "false",
+		flowCollectionPadding: true,
+		indentSeq: true,
+		lineWidth: 80,
+		minContentWidth: 20,
+		nullStr: "null",
+		simpleKeys: false,
+		singleQuote: null,
+		sortMapEntries: false,
+		trailingComma: false,
+		trueStr: "true",
+		verifyAliasOrder: true
+	}, doc.schema.toStringOptions, options);
+	let inFlow;
+	switch (opt.collectionStyle) {
+		case "block":
+			inFlow = false;
+			break;
+		case "flow":
+			inFlow = true;
+			break;
+		default: inFlow = null;
+	}
+	const sortMapEntries = typeof opt.sortMapEntries === "function" ? opt.sortMapEntries : opt.sortMapEntries === true ? sortMapEntriesByKey : null;
+	return {
+		anchors: /* @__PURE__ */ new Set(),
+		doc,
+		flowCollectionPadding: opt.flowCollectionPadding ? " " : "",
+		indent: "",
+		indentStep: typeof opt.indent === "number" ? " ".repeat(opt.indent) : "  ",
+		inFlow,
+		options: opt,
+		sortMapEntries
+	};
+}
+function getTagObject(tags, item) {
+	if (item.tag) {
+		const match = tags.filter((t) => t.tag === item.tag);
+		if (match.length > 0) return match.find((t) => t.format === item.format) ?? match[0];
+	}
+	let tagObj = void 0;
+	let obj;
+	if (item instanceof Scalar) {
+		obj = item.value;
+		let match = tags.filter((t) => t.identify?.(obj));
+		if (match.length > 1) {
+			const testMatch = match.filter((t) => t.test);
+			if (testMatch.length > 0) match = testMatch;
+		}
+		tagObj = match.find((t) => t.format === item.format) ?? match.find((t) => !t.format);
+	} else {
+		obj = item;
+		tagObj = tags.find((t) => t.nodeClass && obj instanceof t.nodeClass);
+	}
+	if (!tagObj) {
+		const name = obj?.constructor?.name ?? (obj === null ? "null" : typeof obj);
+		throw new Error(`Tag not resolved for ${name} value`);
+	}
+	return tagObj;
+}
+function stringifyProps(node, tagObj, { anchors, doc }) {
+	if (!doc.directives) return "";
+	const props = [];
+	const anchor = node.anchor;
+	if (anchor && anchorIsValid(anchor)) {
+		anchors.add(anchor);
+		props.push(`&${anchor}`);
+	}
+	const tag = node.tag ?? (tagObj.default ? null : tagObj.tag);
+	if (tag) props.push(doc.directives.tagString(tag));
+	return props.join(" ");
+}
+function stringify(node, ctx, onComment, onChompKeep) {
+	if (node instanceof Pair) return node.toString(ctx, onComment, onChompKeep);
+	if (node instanceof Alias) {
+		if (ctx.doc.directives) return node.toString(ctx);
+		if (ctx.resolvedAliases?.has(node)) throw new TypeError("Cannot stringify circular structure without alias nodes");
+		if (ctx.resolvedAliases) ctx.resolvedAliases.add(node);
+		else ctx.resolvedAliases = new Set([node]);
+		node = node.resolve(ctx.doc) ?? null;
+	}
+	let tagObj = void 0;
+	node ??= ctx.doc.createNode(null, { onTagObj: (o) => tagObj = o });
+	tagObj ??= getTagObject(ctx.doc.schema.tags, node);
+	const props = stringifyProps(node, tagObj, ctx);
+	if (props.length > 0) ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;
+	const str = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : node instanceof Scalar ? stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep);
+	if (!props) return str;
+	return node instanceof Scalar || str[0] === "{" || str[0] === "[" ? `${props} ${str}` : `${props}\n${ctx.indent}${str}`;
+}
+//#endregion
+//#region src/nodes/addPairToJSMap.ts
+function addPairToJSMap(doc, ctx, map, { key, value }) {
+	if ("addToJSMap" in key) key.addToJSMap?.(doc, ctx, map, value);
+	else if (isMergeKey(doc, key)) addMergeToJSMap(doc, ctx, map, value);
+	else {
+		const jsKey = key.toJS(doc, ctx);
+		if (map instanceof Map) map.set(jsKey, value ? value.toJS(doc, ctx) : value);
+		else if (map instanceof Set) map.add(jsKey);
+		else {
+			const stringKey = stringifyKey(doc, ctx, key, jsKey);
+			const jsValue = value ? value.toJS(doc, ctx) : value;
+			if (stringKey in map) Object.defineProperty(map, stringKey, {
+				value: jsValue,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+			else map[stringKey] = jsValue;
+		}
+	}
+	return map;
+}
+function stringifyKey(doc, ctx, key, jsKey) {
+	if (jsKey === null) return "";
+	if (typeof jsKey !== "object") return String(jsKey);
+	const strCtx = createStringifyContext(doc, {});
+	strCtx.anchors = /* @__PURE__ */ new Set();
+	for (const node of ctx.anchors.keys()) strCtx.anchors.add(node.anchor);
+	strCtx.inFlow = true;
+	strCtx.inStringifyKey = true;
+	const strKey = key.toString(strCtx);
+	if (!ctx.mapKeyWarned) {
+		let jsonStr = JSON.stringify(strKey);
+		if (jsonStr.length > 40) jsonStr = jsonStr.substring(0, 36) + "...\"";
+		const msg = `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use a Map instead.`;
+		warn(doc.options.logLevel, msg);
+		ctx.mapKeyWarned = true;
+	}
+	return strKey;
+}
+//#endregion
+//#region src/nodes/toJS.ts
+/** A context used in `node.toJS()` implementations */
+var ToJSContext = class {
+	anchors = /* @__PURE__ */ new Map();
+	/** Cached anchor and alias nodes in the order they occur in the document */
+	aliasResolveCache;
+	mapAsMap;
+	mapKeyWarned = false;
+	maxAliasCount;
+	constructor(opt) {
+		this.mapAsMap = opt?.mapAsMap === true;
+		this.maxAliasCount = opt?.maxAliasCount ?? 100;
+	}
+	setAnchor(node, res) {
+		this.anchors.set(node, {
+			aliasCount: 0,
+			count: 1,
+			res
+		});
+	}
+};
+//#endregion
+//#region src/nodes/util-clone-map-or-set.ts
+function cloneMapOrSet(coll, schema) {
+	schema ??= coll.schema;
+	const copy = new coll.constructor(schema);
+	for (const [key, value] of coll.values) copy.values.set(key, value.clone(schema));
+	if (coll.range) copy.range = [...coll.range];
+	const propDesc = Object.getOwnPropertyDescriptors(coll);
+	for (const [name, prop] of Object.entries(propDesc)) if (!(name in copy)) Object.defineProperty(copy, name, prop);
+	return copy;
+}
+//#endregion
+//#region src/nodes/YAMLMap.ts
+var YAMLMap = class {
+	static tagName = "tag:yaml.org,2002:map";
+	values = /* @__PURE__ */ new Map();
+	/**
+	* A generic collection factory method that can be used
+	* by other node classes that inherit from YAMLMap
+	*/
+	static create(nc, obj) {
+		const { replacer } = nc;
+		const map = new this(nc.schema);
+		if (obj && typeof obj === "object") {
+			const iter = obj instanceof Map ? obj : Object.entries(obj);
+			for (let [key, value] of iter) {
+				if (replacer) {
+					if (typeof replacer === "function") value = replacer.call(obj, key, value);
+					else if (Array.isArray(replacer) && !replacer.includes(key)) continue;
+				}
+				if (value !== void 0 || nc.keepUndefined) {
+					const mk = nc.schema.mapKey(key);
+					const pair = nc.createPair(key, value);
+					map.values.set(mk, pair);
+				}
+			}
+		}
+		return map;
+	}
+	constructor(schema, elements) {
+		Object.defineProperty(this, "schema", {
+			value: schema,
+			configurable: true,
+			enumerable: false,
+			writable: true
+		});
+		this.values = new Map(elements?.map((pair) => [this.schema.mapKey(pair), pair]));
+	}
+	get size() {
+		return this.values.size;
+	}
+	/**
+	* Create a copy of this map.
+	*
+	* @param schema - If defined, overwrites the original's schema
+	*/
+	clone(schema) {
+		return cloneMapOrSet(this, schema);
+	}
+	/**
+	* Remove a value from the mapping.
+	* @returns `true` if the item was found and removed.
+	*/
+	delete(key) {
+		let mk = this.schema.mapKey(key);
+		if (this.values.delete(mk)) return true;
+		mk = key instanceof Pair ? key.key : isNode(key) ? key : null;
+		if (mk) {
+			for (const [k, p] of this.values) if (p.key === mk) return this.values.delete(k);
+		}
+		return false;
+	}
+	/** Return value at `key`, or `undefined` if not found.  */
+	get(key) {
+		return this.getPair(key)?.value;
+	}
+	/** Return pair at `key`, or `undefined` if not found.  */
+	getPair(key) {
+		let mk = this.schema.mapKey(key);
+		const pair = this.values.get(mk);
+		if (pair) return pair;
+		mk = key instanceof Pair ? key.key : isNode(key) ? key : null;
+		if (mk) {
+			for (const p of this.values.values()) if (p.key === mk) return p;
+		}
+	}
+	/** Check if the mapping includes a value with the key `key`.  */
+	has(key) {
+		let mk = this.schema.mapKey(key);
+		if (this.values.has(mk)) return true;
+		mk = key instanceof Pair ? key.key : isNode(key) ? key : null;
+		if (mk) {
+			for (const p of this.values.values()) if (p.key === mk) return true;
+		}
+		return false;
+	}
+	/**
+	* Return the internal Map key matching `key`, or `undefined` if not found.
+	*
+	* @param allowMissing - If `true`, a key is always returned,
+	*                       even if the key is not in the map.
+	*/
+	keyOf(key, allowMissing = false) {
+		let mk = this.schema.mapKey(key);
+		if (allowMissing || this.values.has(mk)) return mk;
+		mk = key instanceof Pair ? key.key : isNode(key) ? key : null;
+		if (mk) {
+			for (const [k, v] of this.values) if (v.key === mk) return k;
+		}
+	}
+	pairs() {
+		return this.values.values();
+	}
+	set(keyOrPair, value, options) {
+		const mk = this.schema.mapKey(keyOrPair);
+		let pair;
+		if (keyOrPair instanceof Pair) pair = keyOrPair;
+		else if (isNode(keyOrPair) && (value == null || isNode(value))) pair = new Pair(keyOrPair, value ?? null);
+		else pair = new NodeCreator(this.schema, options).createPair(keyOrPair, value);
+		if (pair.value instanceof Scalar) {
+			const prev = this.values.get(mk);
+			if (prev) {
+				if (!prev.value) {
+					prev.value = pair.value;
+					return this;
+				}
+				if (prev.value instanceof Scalar) {
+					Object.assign(prev.value, pair.value);
+					return this;
+				}
+			}
+		}
+		this.values.set(mk, pair);
+		return this;
+	}
+	toJS(doc, ctx, Type) {
+		ctx ??= new ToJSContext();
+		const map = Type ? new Type() : ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {};
+		if (this.anchor) ctx.setAnchor(this, map);
+		for (const pair of this.values.values()) addPairToJSMap(doc, ctx, map, pair);
+		return map;
+	}
+	toString(ctx, onComment, onChompKeep) {
+		if (!ctx) return JSON.stringify(this);
+		let pairs = this.values.values();
+		if (ctx.sortMapEntries) pairs = Array.from(pairs).sort(ctx.sortMapEntries);
+		return ctx.inFlow ?? this.flow ? this.#stringifyFlowMap(ctx, pairs) : this.#stringifyBlockMap(ctx, pairs, onComment, onChompKeep);
+	}
+	#stringifyBlockMap(ctx, pairs, onComment, onChompKeep) {
+		const { indent, options: { commentString } } = ctx;
+		let chompKeep = false;
+		const lines = [];
+		for (const pair of pairs) {
+			let comment = null;
+			if (!chompKeep && pair.key.spaceBefore) lines.push("");
+			let cb = pair.key.commentBefore;
+			if (cb && chompKeep) cb = cb.replace(/^\n+/, "");
+			if (cb) {
+				const ic = indentComment(commentString(cb), indent).trimStart();
+				lines.push(ic);
+			}
+			chompKeep = false;
+			let str = stringifyPair(pair, ctx, () => comment = null, () => chompKeep = true);
+			if (comment) str += lineComment(str, indent, commentString(comment));
+			if (chompKeep && comment) chompKeep = false;
+			lines.push(str);
+		}
+		let str;
+		if (lines.length === 0) str = "{}";
+		else {
+			str = lines[0];
+			for (let i = 1; i < lines.length; ++i) {
+				const line = lines[i];
+				str += line ? `\n${indent}${line}` : "\n";
+			}
+		}
+		if (this.comment) {
+			str += "\n" + indentComment(commentString(this.comment), indent);
+			onComment?.();
+		} else if (chompKeep) onChompKeep?.();
+		return str;
+	}
+	#stringifyFlowMap(ctx, pairs) {
+		const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString, lineWidth, trailingComma } } = ctx;
+		const itemIndent = indent + indentStep;
+		const itemCtx = {
+			...ctx,
+			indent: itemIndent,
+			inFlow: true
+		};
+		let reqNewline = false;
+		let linesAtValue = 0;
+		const lines = [];
+		let itemsLeft = this.values.size;
+		for (const pair of pairs) {
+			itemsLeft -= 1;
+			let comment = null;
+			const ik = pair.key;
+			if (ik.spaceBefore) {
+				lines.push("");
+				reqNewline = true;
+			}
+			if (ik.commentBefore) {
+				const ic = indentComment(commentString(ik.commentBefore), indent);
+				lines.push(ic.trimStart());
+				reqNewline = true;
+			}
+			if (ik.comment) reqNewline = true;
+			const iv = pair.value;
+			if (iv) {
+				if (iv.comment) comment = iv.comment;
+				if (iv.commentBefore) reqNewline = true;
+			} else if (ik?.comment) comment = ik.comment;
+			if (comment) reqNewline = true;
+			let str = stringifyPair(pair, itemCtx, () => comment = null);
+			reqNewline ||= lines.length > linesAtValue || str.includes("\n");
+			if (itemsLeft > 0) str += ",";
+			else if (trailingComma) {
+				if (!reqNewline && lineWidth > 0) reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str.length + 2) > lineWidth;
+				if (reqNewline) str += ",";
+			}
+			if (comment) str += lineComment(str, itemIndent, commentString(comment));
+			lines.push(str);
+			linesAtValue = lines.length;
+		}
+		if (lines.length === 0) return "{}";
+		if (!reqNewline) {
+			const len = lines.reduce((sum, line) => sum + line.length + 2, 2);
+			reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;
+		}
+		if (reqNewline) {
+			let str = "{";
+			for (const line of lines) str += line ? `\n${indentStep}${indent}${line}` : "\n";
+			return `${str}\n${indent}}`;
+		}
+		return `{${fcPadding}${lines.join(" ")}${fcPadding}}`;
+	}
+};
+//#endregion
+//#region src/nodes/YAMLSeq.ts
+const isScalarValue = (value) => !value || typeof value !== "function" && typeof value !== "object";
+var YAMLSeq = class extends Array {
+	static get tagName() {
+		return "tag:yaml.org,2002:seq";
+	}
+	/**
+	* A generic collection factory method that can be extended
+	* to other node classes that inherit from YAMLSeq
+	*/
+	static create(nc, obj) {
+		const seq = new this(nc.schema);
+		if (obj && Symbol.iterator in Object(obj)) {
+			let i = 0;
+			for (let it of obj) {
+				if (typeof nc.replacer === "function") {
+					const key = obj instanceof Set ? it : String(i++);
+					it = nc.replacer.call(obj, key, it);
+				}
+				seq.push(nc.create(it));
+			}
+		}
+		return seq;
+	}
+	constructor(schema, elements = []) {
+		super(...nodeValues(schema, elements));
+		Object.defineProperty(this, "schema", {
+			value: schema,
+			configurable: true,
+			enumerable: false,
+			writable: true
+		});
+	}
+	get size() {
+		return this.length;
+	}
+	/**
+	* Create a copy of this collection.
+	*
+	* @param schema - If defined, overwrites the original's schema
+	*/
+	clone(schema) {
+		const copy = this.constructor.from(this, (it) => it.clone(schema));
+		if (this.range) copy.range = [...this.range];
+		const propDesc = Object.getOwnPropertyDescriptors(this);
+		for (const [name, prop] of Object.entries(propDesc)) if (!(name in copy)) Object.defineProperty(copy, name, prop);
+		if (schema) copy.schema = schema;
+		return copy;
+	}
+	/**
+	* Change all elements within a range of indices in this sequence to a static value.
+	*
+	* Non-node values are converted to Node values.
+	*/
+	fill(value, start, end) {
+		return super.fill(nodeValue(this.schema, value), start, end);
+	}
+	/** @private */
+	_push(item) {
+		super.push(item);
+	}
+	/**
+	* Append new elements to this sequence, and return its new length.
+	*
+	* Non-node values are converted to Node values.
+	*/
+	push(...values) {
+		return super.push(...nodeValues(this.schema, values));
+	}
+	/**
+	* Set a value in this sequence.
+	*
+	* Non-node values are converted to Node values.
+	*/
+	set(idx, value, options) {
+		if (!Number.isInteger(idx)) throw new TypeError(`Expected an integer, not ${JSON.stringify(idx)}.`);
+		const prev = this.at(idx);
+		if (prev instanceof Scalar && isScalarValue(value)) prev.value = value;
+		else {
+			if (idx < 0) {
+				if (idx < -this.length) throw new RangeError(`Invalid index ${idx}`);
+				idx += this.length;
+			}
+			this[idx] = nodeValue(this.schema, value, options);
+		}
+	}
+	/**
+	* Changes the contents of this sequence by removing or replacing existing elements
+	* and/or adding new elements in place.
+	*
+	* Non-node values are converted to Node values.
+	*/
+	splice(start, deleteCount, ...values) {
+		const nv = nodeValues(this.schema, values);
+		return arguments.length < 2 ? super.splice(start) : super.splice(start, Number(deleteCount), ...nv);
+	}
+	/**
+	* Prepend new elements to this sequence, and return its new length.
+	*
+	* Non-node values are converted to Node values.
+	*/
+	unshift(...values) {
+		return super.unshift(...nodeValues(this.schema, values));
+	}
+	/** A plain JavaScript representation of this node. */
+	toJS(doc, ctx) {
+		ctx ??= new ToJSContext();
+		if (this.anchor) {
+			const res = [];
+			if (this.anchor) ctx.setAnchor(this, res);
+			for (const item of this) res.push(item.toJS(doc, ctx));
+			return res;
+		}
+		return Array.from(this, (item) => item.toJS(doc, ctx));
+	}
+	toString(ctx, onComment, onChompKeep) {
+		if (!ctx) return JSON.stringify(this);
+		return ctx.inFlow ?? this.flow ? this.#stringifyFlowSeq(ctx) : this.#stringifyBlockSeq(ctx, onComment, onChompKeep);
+	}
+	#stringifyBlockSeq(ctx, onComment, onChompKeep) {
+		const { indent, options: { commentString } } = ctx;
+		const itemIndent = indent + "  ";
+		const itemCtx = {
+			...ctx,
+			indent: itemIndent
+		};
+		let chompKeep = false;
+		const lines = [];
+		for (let i = 0; i < this.length; ++i) {
+			const item = this[i];
+			let comment = null;
+			if (item instanceof Pair) {
+				if (!chompKeep && item.key.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, item.key.commentBefore, chompKeep);
+			} else if (item) {
+				if (!chompKeep && item.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, item.commentBefore, chompKeep);
+				if (item.comment) comment = item.comment;
+			}
+			chompKeep = false;
+			let str = stringify(item, itemCtx, () => comment = null, () => chompKeep = true);
+			if (comment) str += lineComment(str, itemIndent, commentString(comment));
+			if (chompKeep && comment) chompKeep = false;
+			lines.push(`- ${str}`);
+		}
+		let str;
+		if (lines.length === 0) str = "[]";
+		else {
+			str = lines[0];
+			for (let i = 1; i < lines.length; ++i) {
+				const line = lines[i];
+				str += line ? `\n${indent}${line}` : "\n";
+			}
+		}
+		if (this.comment) {
+			str += "\n" + indentComment(commentString(this.comment), indent);
+			onComment?.();
+		} else if (chompKeep) onChompKeep?.();
+		return str;
+	}
+	#stringifyFlowSeq(ctx) {
+		const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;
+		const itemIndent = indent + "  " + indentStep;
+		const itemCtx = {
+			...ctx,
+			indent: itemIndent,
+			inFlow: true
+		};
+		let reqNewline = false;
+		let linesAtValue = 0;
+		const lines = [];
+		for (let i = 0; i < this.length; ++i) {
+			const item = this[i];
+			let comment = null;
+			if (item instanceof Pair) {
+				const ik = item.key;
+				if (ik.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, ik.commentBefore, false);
+				if (ik.comment) reqNewline = true;
+				const iv = item.value;
+				if (iv) {
+					if (iv.comment) comment = iv.comment;
+					if (iv.commentBefore) reqNewline = true;
+				} else if (ik?.comment) comment = ik.comment;
+			} else if (item) {
+				if (item.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, item.commentBefore, false);
+				if (item.comment) comment = item.comment;
+			}
+			if (comment) reqNewline = true;
+			let str = stringify(item, itemCtx, () => comment = null);
+			reqNewline ||= lines.length > linesAtValue || str.includes("\n");
+			if (i < this.length - 1) str += ",";
+			else if (ctx.options.trailingComma) {
+				if (ctx.options.lineWidth > 0) reqNewline ||= lines.reduce((sum, line) => sum + line.length + 2, 2) + (str.length + 2) > ctx.options.lineWidth;
+				if (reqNewline) str += ",";
+			}
+			if (comment) str += lineComment(str, itemIndent, commentString(comment));
+			lines.push(str);
+			linesAtValue = lines.length;
+		}
+		if (lines.length === 0) return "[]";
+		if (!reqNewline) {
+			const len = lines.reduce((sum, line) => sum + line.length + 2, 2);
+			reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;
+		}
+		if (reqNewline) {
+			let str = "[";
+			for (const line of lines) str += line ? `\n${indentStep}${indent}${line}` : "\n";
+			return `${str}\n${indent}]`;
+		}
+		return `[${fcPadding}${lines.join(" ")}${fcPadding}]`;
+	}
+};
+function nodeValue(schema, value, options) {
+	if (isNode(value) || value instanceof Pair) return value;
+	return new NodeCreator(schema, options).create(value);
+}
+function nodeValues(schema, values) {
+	let nc;
+	return values.map((value) => {
+		if (isNode(value) || value instanceof Pair) return value;
+		nc ??= new NodeCreator(schema);
+		return nc.create(value);
+	});
+}
+function addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {
+	if (comment && chompKeep) comment = comment.replace(/^\n+/, "");
+	if (comment) {
+		const ic = indentComment(commentString(comment), indent);
+		lines.push(ic.trimStart());
+	}
+}
+//#endregion
+//#region src/nodes/YAMLSet.ts
+var YAMLSet = class {
+	static tagName = "tag:yaml.org,2002:set";
+	/** A fully qualified tag */
+	tag = "tag:yaml.org,2002:set";
+	values = /* @__PURE__ */ new Map();
+	constructor(schema) {
+		Object.defineProperty(this, "schema", {
+			value: schema,
+			configurable: true,
+			enumerable: false,
+			writable: true
+		});
+	}
+	get size() {
+		return this.values.size;
+	}
+	add(value, options) {
+		if (this.has(value)) return this;
+		const mk = this.schema.mapKey(value);
+		const node = isNode(value) ? value : new NodeCreator(this.schema, options).create(value);
+		this.values.set(mk, node);
+		return this;
+	}
+	/**
+	* Create a copy of this set.
+	*
+	* @param schema - If defined, overwrites the original's schema
+	*/
+	clone(schema) {
+		return cloneMapOrSet(this, schema);
+	}
+	/**
+	* Remove `value` from the set.
+	* @returns `true` if the item was found and removed.
+	*/
+	delete(value) {
+		const mk = this.schema.mapKey(value);
+		if (this.values.delete(mk)) return true;
+		if (isNode(value)) {
+			for (const [k, v] of this.values) if (v === value) return this.values.delete(k);
+		}
+		return false;
+	}
+	/** Return the node matching `value`, if the set includes it.  */
+	get(value) {
+		const mk = this.schema.mapKey(value);
+		const node = this.values.get(mk);
+		if (node) return node;
+		if (isNode(value)) {
+			for (const v of this.values.values()) if (v === value) return v;
+		}
+	}
+	/** Check if the set includes `value`.  */
+	has(value) {
+		const mk = this.schema.mapKey(value);
+		if (this.values.has(mk)) return true;
+		if (isNode(value)) {
+			for (const v of this.values.values()) if (v === value) return true;
+		}
+		return false;
+	}
+	/**
+	* Return the internal Map key matching `value`, or `undefined` if not found.
+	*
+	* @param allowMissing - If `true`, a key is always returned,
+	*                       even if the value is not in the set.
+	*/
+	keyOf(value, allowMissing = false) {
+		const mk = this.schema.mapKey(value);
+		if (allowMissing || this.values.has(mk)) return mk;
+		if (isNode(value)) {
+			for (const [k, v] of this.values) if (v === value) return k;
+		}
+	}
+	/** A plain JavaScript representation of this set. */
+	toJS(doc, ctx) {
+		ctx ??= new ToJSContext();
+		const set = /* @__PURE__ */ new Set();
+		if (this.anchor) ctx.setAnchor(this, set);
+		for (const item of this.values.values()) set.add(item.toJS(doc, ctx));
+		return set;
+	}
+	toString(ctx, onComment, onChompKeep) {
+		if (!ctx) return JSON.stringify(this);
+		let items = this.values.values();
+		if (ctx.sortMapEntries) items = Array.from(items, (item) => new Pair(item)).sort(ctx.sortMapEntries).map((pair) => pair.key);
+		if (ctx.inFlow ?? this.flow) return this.#stringifyFlowSet(ctx, items);
+		else return this.#stringifyBlockSet(ctx, items, onComment, onChompKeep);
+	}
+	#stringifyBlockSet(ctx, items, onComment, onChompKeep) {
+		const { indent, indentStep, options: { commentString } } = ctx;
+		const itemCtx = {
+			...ctx,
+			implicitKey: false,
+			indent: indent + indentStep
+		};
+		let chompKeep = false;
+		let res = null;
+		for (const item of items) {
+			if (!chompKeep && item.spaceBefore) if (typeof res === "string") res += "\n";
+			else res = "";
+			let cb = item.commentBefore;
+			if (cb && chompKeep) cb = cb.replace(/^\n+/, "");
+			if (cb) {
+				const ic = indentComment(commentString(cb), indent).trimStart();
+				if (typeof res === "string") res += `\n${indent}${ic}`;
+				else res = ic;
+			}
+			chompKeep = false;
+			let comment = item.comment;
+			let str = stringify(item, itemCtx, () => comment = null, () => chompKeep = true);
+			str = str ? `? ${str}` : "?";
+			if (comment) {
+				str += lineComment(str, itemCtx.indent, commentString(comment));
+				chompKeep = false;
+			}
+			if (typeof res === "string") res += `\n${indent}${str}`;
+			else res = str;
+		}
+		if (this.comment) {
+			const cs = commentString(this.comment);
+			if (typeof res === "string") res += "\n" + indentComment(cs, indent);
+			else res = "{}" + lineComment("", indent, cs);
+			onComment?.();
+		} else if (chompKeep) onChompKeep?.();
+		return res ?? "{}";
+	}
+	#stringifyFlowSet(ctx, items) {
+		const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString, lineWidth, trailingComma } } = ctx;
+		const itemCtx = {
+			...ctx,
+			indent: indent + indentStep + indentStep,
+			inFlow: true
+		};
+		let reqNewline = false;
+		const lines = [];
+		let itemsLeft = this.values.size;
+		let singleLineWidth = 2 * fcPadding.length;
+		for (const item of items) {
+			itemsLeft -= 1;
+			if (item.spaceBefore) {
+				lines.push("");
+				reqNewline = true;
+			}
+			if (item.commentBefore) {
+				const ic = indentComment(commentString(item.commentBefore), indent);
+				lines.push(ic.trimStart());
+				reqNewline = true;
+			}
+			let comment = item.comment;
+			if (comment) reqNewline = true;
+			itemCtx.implicitKey = !isCollection(item);
+			let str = stringify(item, itemCtx, () => comment = null) || "?";
+			if (isCollection(item)) str = `? ${str}`;
+			reqNewline ||= str.includes("\n");
+			if (!reqNewline && lineWidth > 0) {
+				singleLineWidth += str.length + 2;
+				if (singleLineWidth > lineWidth) reqNewline = true;
+			}
+			if (itemsLeft > 0 || trailingComma && reqNewline) str += ",";
+			if (comment) str += lineComment(str, indent + indentStep, commentString(comment));
+			lines.push(str);
+		}
+		if (lines.length === 0) return "{}";
+		if (!reqNewline) return `{${fcPadding}${lines.join(" ")}${fcPadding}}`;
+		let str = "{";
+		for (const line of lines) str += line ? `\n${indentStep}${indent}${line}` : "\n";
+		return `${str}\n${indent}}`;
+	}
+};
+//#endregion
+//#region src/nodes/identity.ts
+/** Type predicate for collections */
+const isCollection = (node) => node instanceof YAMLMap || node instanceof YAMLSeq || node instanceof YAMLSet;
+/** Type predicate for `Node` values */
+const isNode = (node) => node instanceof Scalar || node instanceof Alias || node instanceof YAMLMap || node instanceof YAMLSeq || node instanceof YAMLSet;
+//#endregion
+//#region src/stringify/stringifyPair.ts
+function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
+	const { indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
+	if (simpleKeys) {
+		if (key.comment) throw new Error("With simple keys, key nodes cannot have comments");
+		if (isCollection(key)) throw new Error("With simple keys, collection cannot be used as a key value");
+	}
+	let explicitKey = !simpleKeys && (!(key instanceof Scalar) || key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL);
+	ctx = {
+		...ctx,
+		implicitKey: !explicitKey,
+		indent: indent + indentStep
+	};
+	let keyComment = key.comment;
+	let keyCommentDone = false;
+	let chompKeep = false;
+	let str = stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true);
+	if (!explicitKey && !ctx.inFlow && str.length > 1024) {
+		if (simpleKeys) throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
+		explicitKey = true;
+	}
+	if (ctx.inFlow) {
+		if (value == null) {
+			if (keyCommentDone && onComment) onComment();
+			return str === "" ? "?" : explicitKey ? `? ${str}` : `${str}:`;
+		}
+	} else if (value == null && explicitKey) {
+		str = `? ${str}`;
+		if (keyComment && !keyCommentDone) str += lineComment(str, ctx.indent, commentString(keyComment));
+		else if (chompKeep && onChompKeep) onChompKeep();
+		return str;
+	}
+	if (keyCommentDone) keyComment = null;
+	if (explicitKey) {
+		if (keyComment) str += lineComment(str, ctx.indent, commentString(keyComment));
+		str = `? ${str}\n${indent}:`;
+	} else {
+		str = `${str}:`;
+		if (keyComment) str += lineComment(str, ctx.indent, commentString(keyComment));
+	}
+	let vsb, vcb, valueComment;
+	if (value) {
+		vsb = !!value.spaceBefore;
+		vcb = value.commentBefore;
+		valueComment = value.comment;
+	} else {
+		vsb = false;
+		vcb = null;
+		valueComment = null;
+	}
+	ctx.implicitKey = false;
+	if (!explicitKey && !keyComment && value instanceof Scalar) ctx.indentAtStart = str.length + 1;
+	chompKeep = false;
+	if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && value instanceof YAMLSeq && !value.flow && !value.tag && !value.anchor) ctx.indent = ctx.indent.substring(2);
+	let valueCommentDone = false;
+	const valueStr = stringify(value, ctx, () => valueCommentDone = true, () => chompKeep = true);
+	let ws = " ";
+	if (keyComment || vsb || vcb) {
+		ws = vsb ? "\n" : "";
+		if (vcb) {
+			const cs = commentString(vcb);
+			ws += `\n${indentComment(cs, ctx.indent)}`;
+		}
+		if (valueStr === "" && !ctx.inFlow) {
+			if (ws === "\n" && valueComment) ws = "\n\n";
+		} else ws += `\n${ctx.indent}`;
+	} else if (!explicitKey && isCollection(value)) {
+		const vs0 = valueStr[0];
+		const nl0 = valueStr.indexOf("\n");
+		const hasNewline = nl0 !== -1;
+		const flow = ctx.inFlow ?? value.flow ?? value.size === 0;
+		if (hasNewline || !flow) {
+			let hasPropsLine = false;
+			if (hasNewline && (vs0 === "&" || vs0 === "!")) {
+				let sp0 = valueStr.indexOf(" ");
+				if (vs0 === "&" && sp0 !== -1 && sp0 < nl0 && valueStr[sp0 + 1] === "!") sp0 = valueStr.indexOf(" ", sp0 + 1);
+				if (sp0 === -1 || nl0 < sp0) hasPropsLine = true;
+			}
+			if (!hasPropsLine) ws = `\n${ctx.indent}`;
+		}
+	} else if (valueStr === "" || valueStr[0] === "\n") ws = "";
+	str += ws + valueStr;
+	if (ctx.inFlow) {
+		if (valueCommentDone && onComment) onComment();
+	} else if (valueComment && !valueCommentDone) str += lineComment(str, ctx.indent, commentString(valueComment));
+	else if (chompKeep && onChompKeep) onChompKeep();
+	return str;
+}
+//#endregion
+//#region src/nodes/Pair.ts
+var Pair = class Pair {
+	key;
+	value;
+	constructor(key, value = null) {
+		this.key = key;
+		this.value = value;
+	}
+	clone(schema) {
+		return new Pair(this.key.clone(schema), this.value?.clone(schema) ?? null);
+	}
+	toJS(doc, ctx) {
+		return addPairToJSMap(doc, ctx, ctx.mapAsMap ? /* @__PURE__ */ new Map() : {}, this);
+	}
+	toString(ctx, onComment, onChompKeep) {
+		return ctx?.doc ? stringifyPair(this, ctx, onComment, onChompKeep) : JSON.stringify(this);
+	}
+};
+//#endregion
+//#region src/nodes/Alias.ts
+var Alias = class Alias {
+	source;
+	constructor(source) {
+		this.source = source;
+		Object.defineProperty(this, "tag", { set() {
+			throw new Error("Alias nodes cannot have tags");
+		} });
+	}
+	/** Create a copy of this node.  */
+	clone() {
+		const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+		if (this.range) copy.range = [...this.range];
+		return copy;
+	}
+	/**
+	* Resolve the value of this alias within `doc`, finding the last
+	* instance of the `source` anchor before this node.
+	*/
+	resolve(doc, ctx) {
+		if (ctx?.maxAliasCount === 0) throw new ReferenceError("Alias resolution is disabled");
+		let nodes;
+		if (ctx?.aliasResolveCache) nodes = ctx.aliasResolveCache;
+		else {
+			nodes = [];
+			visit(doc, { Node: (_key, node) => {
+				if (node instanceof Alias || node.anchor) nodes.push(node);
+			} });
+			if (ctx) ctx.aliasResolveCache = nodes;
+		}
+		let found = void 0;
+		for (const node of nodes) {
+			if (node === this) break;
+			if (node.anchor === this.source) found = node;
+		}
+		return found;
+	}
+	/** A plain JavaScript representation of the resolved value of this alias. */
+	toJS(doc, ctx) {
+		if (!doc?.schema) throw new TypeError("A document argument is required");
+		ctx ??= new ToJSContext();
+		const { anchors, maxAliasCount } = ctx;
+		const source = this.resolve(doc, ctx);
+		if (!source) {
+			const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+			throw new ReferenceError(msg);
+		}
+		let data = anchors.get(source);
+		if (!data) {
+			source.toJS(doc, ctx);
+			data = anchors.get(source);
+		}
+		/* istanbul ignore if */
+		if (data?.res === void 0) throw new ReferenceError("This should not happen: Alias anchor was not resolved?");
+		if (maxAliasCount >= 0) {
+			data.count += 1;
+			data.aliasCount ||= getAliasCount(doc, ctx, source, anchors);
+			if (data.count * data.aliasCount > maxAliasCount) throw new ReferenceError("Excessive alias count indicates a resource exhaustion attack");
+		}
+		return data.res;
+	}
+	toString(ctx, _onComment, _onChompKeep) {
+		const src = `*${this.source}`;
+		if (ctx) {
+			anchorIsValid(this.source);
+			if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
+				const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+				throw new Error(msg);
+			}
+			if (ctx.implicitKey) return `${src} `;
+		}
+		return src;
+	}
+};
+function getAliasCount(doc, ctx, node, anchors) {
+	if (node instanceof Alias) {
+		const source = node.resolve(doc, ctx);
+		const anchor = anchors && source && anchors.get(source);
+		return anchor ? anchor.count * anchor.aliasCount : 0;
+	} else if (node instanceof Pair) {
+		const kc = getAliasCount(doc, ctx, node.key, anchors);
+		const vc = getAliasCount(doc, ctx, node.value, anchors);
+		return Math.max(kc, vc);
+	} else if (Array.isArray(node)) {
+		let count = 0;
+		for (const item of node) {
+			const c = getAliasCount(doc, ctx, item, anchors);
+			if (c > count) count = c;
+		}
+		return count;
+	}
+	return 1;
+}
+//#endregion
+//#region src/schema/common/map.ts
+const map = {
+	collection: "map",
+	default: true,
+	nodeClass: YAMLMap,
+	tag: "tag:yaml.org,2002:map",
+	createNode(nc, obj) {
+		return YAMLMap.create(nc, obj);
+	},
+	resolve(map, onError) {
+		if (!(map instanceof YAMLMap)) onError("Expected a mapping for this tag");
+		return map;
+	}
+};
+//#endregion
+//#region src/schema/common/seq.ts
+const seq = {
+	collection: "seq",
+	default: true,
+	nodeClass: YAMLSeq,
+	tag: "tag:yaml.org,2002:seq",
+	createNode(nc, obj) {
+		return YAMLSeq.create(nc, obj);
+	},
+	resolve(seq, onError) {
+		if (!(seq instanceof YAMLSeq)) onError("Expected a sequence for this tag");
+		return seq;
+	}
+};
+//#endregion
+//#region src/schema/common/string.ts
+const string = {
+	identify: (value) => typeof value === "string",
+	default: true,
+	tag: "tag:yaml.org,2002:str",
+	resolve: (str) => str,
+	stringify(item, ctx, onComment, onChompKeep) {
+		ctx = Object.assign({ actualString: true }, ctx);
+		return stringifyString(item, ctx, onComment, onChompKeep);
+	}
+};
+//#endregion
+//#region src/schema/common/null.ts
+const nullTag = {
+	identify: (value) => value == null,
+	createNode: () => new Scalar(null),
+	default: true,
+	tag: "tag:yaml.org,2002:null",
+	test: /^(?:~|[Nn]ull|NULL)?$/,
+	resolve: () => new Scalar(null),
+	stringify: ({ source }, ctx) => typeof source === "string" && nullTag.test.test(source) ? source : ctx.options.nullStr
+};
+//#endregion
+//#region src/schema/core/bool.ts
+const boolTag = {
+	identify: (value) => typeof value === "boolean",
+	default: true,
+	tag: "tag:yaml.org,2002:bool",
+	test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
+	resolve: (str) => new Scalar(str[0] === "t" || str[0] === "T"),
+	stringify({ source, value }, ctx) {
+		if (source && boolTag.test.test(source)) {
+			if (value === (source[0] === "t" || source[0] === "T")) return source;
+		}
+		return value ? ctx.options.trueStr : ctx.options.falseStr;
+	}
+};
+//#endregion
+//#region src/stringify/stringifyNumber.ts
+function stringifyNumber({ format, minFractionDigits, tag, value }) {
+	if (typeof value === "bigint") return String(value);
+	const num = typeof value === "number" ? value : Number(value);
+	if (!isFinite(num)) return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf";
+	let n = Object.is(value, -0) ? "-0" : JSON.stringify(value);
+	if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^-?\d/.test(n) && !n.includes("e")) {
+		let i = n.indexOf(".");
+		if (i < 0) {
+			i = n.length;
+			n += ".";
+		}
+		let d = minFractionDigits - (n.length - i - 1);
+		while (d-- > 0) n += "0";
+	}
+	return n;
+}
+//#endregion
+//#region src/schema/core/float.ts
+const floatNaN$1 = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
+	resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
+	stringify: stringifyNumber
+};
+const floatExp$1 = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	format: "EXP",
+	test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
+	resolve: (str) => parseFloat(str),
+	stringify(node) {
+		const num = Number(node.value);
+		return isFinite(num) ? num.toExponential() : stringifyNumber(node);
+	}
+};
+const float$1 = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
+	resolve(str) {
+		const node = new Scalar(parseFloat(str));
+		const dot = str.indexOf(".");
+		if (dot !== -1 && str[str.length - 1] === "0") node.minFractionDigits = str.length - dot - 1;
+		return node;
+	},
+	stringify: stringifyNumber
+};
+//#endregion
+//#region src/schema/core/int.ts
+const intIdentify$2 = (value) => typeof value === "bigint" || Number.isInteger(value);
+const intResolve$1 = (str, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix);
+function intStringify$1(node, radix, prefix) {
+	const { value } = node;
+	if (intIdentify$2(value) && value >= 0) return prefix + value.toString(radix);
+	return stringifyNumber(node);
+}
+const intOct$1 = {
+	identify: (value) => intIdentify$2(value) && value >= 0,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	format: "OCT",
+	test: /^0o[0-7]+$/,
+	resolve: (str, _onError, opt) => intResolve$1(str, 2, 8, opt),
+	stringify: (node) => intStringify$1(node, 8, "0o")
+};
+const int$1 = {
+	identify: intIdentify$2,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	test: /^[-+]?[0-9]+$/,
+	resolve: (str, _onError, opt) => intResolve$1(str, 0, 10, opt),
+	stringify: stringifyNumber
+};
+const intHex$1 = {
+	identify: (value) => intIdentify$2(value) && value >= 0,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	format: "HEX",
+	test: /^0x[0-9a-fA-F]+$/,
+	resolve: (str, _onError, opt) => intResolve$1(str, 2, 16, opt),
+	stringify: (node) => intStringify$1(node, 16, "0x")
+};
+//#endregion
+//#region src/schema/core/schema.ts
+const schema$2 = [
+	map,
+	seq,
+	string,
+	nullTag,
+	boolTag,
+	intOct$1,
+	int$1,
+	intHex$1,
+	floatNaN$1,
+	floatExp$1,
+	float$1
+];
+//#endregion
+//#region src/schema/json/schema.ts
+function intIdentify$1(value) {
+	return typeof value === "bigint" || Number.isInteger(value);
+}
+const stringifyJSON = ({ value }) => JSON.stringify(value);
+const jsonScalars = [
+	{
+		identify: (value) => typeof value === "string",
+		default: true,
+		tag: "tag:yaml.org,2002:str",
+		resolve: (str) => str,
+		stringify: stringifyJSON
+	},
+	{
+		identify: (value) => value == null,
+		createNode: () => new Scalar(null),
+		default: true,
+		tag: "tag:yaml.org,2002:null",
+		test: /^null$/,
+		resolve: () => null,
+		stringify: stringifyJSON
+	},
+	{
+		identify: (value) => typeof value === "boolean",
+		default: true,
+		tag: "tag:yaml.org,2002:bool",
+		test: /^true$|^false$/,
+		resolve: (str) => str === "true",
+		stringify: stringifyJSON
+	},
+	{
+		identify: intIdentify$1,
+		default: true,
+		tag: "tag:yaml.org,2002:int",
+		test: /^-?(?:0|[1-9][0-9]*)$/,
+		resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),
+		stringify: ({ value }) => intIdentify$1(value) ? value.toString() : JSON.stringify(value)
+	},
+	{
+		identify: (value) => typeof value === "number",
+		default: true,
+		tag: "tag:yaml.org,2002:float",
+		test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
+		resolve: (str) => parseFloat(str),
+		stringify: stringifyJSON
+	}
+];
+const jsonError = {
+	default: true,
+	tag: "",
+	test: /^/,
+	resolve(str, onError) {
+		onError(`Unresolved plain scalar ${JSON.stringify(str)}`);
+		return str;
+	}
+};
+const schema$1 = [
+	map,
+	seq,
+	...jsonScalars,
+	jsonError
+];
+//#endregion
+//#region src/schema/yaml-1.1/binary.ts
+const binary = {
+	identify: (value) => value instanceof Uint8Array,
+	default: false,
+	tag: "tag:yaml.org,2002:binary",
+	resolve(src, onError) {
+		if (typeof Buffer === "function") return Buffer.from(src, "base64");
+		else if (typeof Uint8Array.fromBase64 === "function") return Uint8Array.fromBase64(src);
+		else if (typeof atob === "function") {
+			const str = atob(src.replace(/[\n\r]/g, ""));
+			const buffer = new Uint8Array(str.length);
+			for (let i = 0; i < str.length; ++i) buffer[i] = str.charCodeAt(i);
+			return buffer;
+		} else {
+			onError("This environment does not support reading binary tags; either Buffer or atob is required");
+			return src;
+		}
+	},
+	stringify({ comment, type, value }, ctx, onComment, onChompKeep) {
+		if (!value) return "";
+		const buf = value;
+		let str;
+		if (typeof buf.toBase64 === "function") str = buf.toBase64();
+		else if (typeof Buffer === "function") str = buf instanceof Buffer ? buf.toString("base64") : Buffer.from(buf.buffer).toString("base64");
+		else if (typeof btoa === "function") {
+			let s = "";
+			for (let i = 0; i < buf.length; ++i) s += String.fromCharCode(buf[i]);
+			str = btoa(s);
+		} else throw new Error("This environment does not support writing binary tags; either Buffer or btoa is required");
+		type ??= Scalar.BLOCK_LITERAL;
+		if (type !== Scalar.QUOTE_DOUBLE) {
+			const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);
+			const n = Math.ceil(str.length / lineWidth);
+			const lines = new Array(n);
+			for (let i = 0, o = 0; i < n; ++i, o += lineWidth) lines[i] = str.substr(o, lineWidth);
+			str = lines.join(type === Scalar.BLOCK_LITERAL ? "\n" : " ");
+		}
+		return stringifyString({
+			comment,
+			type,
+			value: str
+		}, ctx, onComment, onChompKeep);
+	}
+};
+//#endregion
+//#region src/schema/yaml-1.1/pairs.ts
+function resolvePairs(seq, onError) {
+	if (seq instanceof YAMLSeq) for (let i = 0; i < seq.length; ++i) {
+		const item = seq[i];
+		if (item instanceof Pair) continue;
+		if (item instanceof YAMLMap) {
+			if (item.size > 1) onError("Each pair must have its own sequence indicator");
+			const pair = item.values.values().next().value ?? new Pair(new Scalar(null));
+			if (item.commentBefore) pair.key.commentBefore = pair.key.commentBefore ? `${item.commentBefore}\n${pair.key.commentBefore}` : item.commentBefore;
+			if (item.comment) {
+				const cn = pair.value ?? pair.key;
+				cn.comment = cn.comment ? `${item.comment}\n${cn.comment}` : item.comment;
+			}
+			seq[i] = pair;
+		} else seq[i] = new Pair(item, null);
+	}
+	else onError("Expected a sequence for this tag");
+	return seq;
+}
+function createPairs(nc, iterable) {
+	const pairs = new YAMLSeq(nc.schema);
+	pairs.tag = "tag:yaml.org,2002:pairs";
+	let i = 0;
+	if (iterable && Symbol.iterator in Object(iterable)) for (let it of iterable) {
+		if (typeof nc.replacer === "function") it = nc.replacer.call(iterable, String(i++), it);
+		let key, value;
+		if (Array.isArray(it)) if (it.length === 2) {
+			key = it[0];
+			value = it[1];
+		} else throw new TypeError(`Expected [key, value] tuple: ${it}`);
+		else if (it && it instanceof Object) {
+			const keys = Object.keys(it);
+			if (keys.length === 1) {
+				key = keys[0];
+				value = it[key];
+			} else throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);
+		} else key = it;
+		pairs.push(nc.createPair(key, value));
+	}
+	return pairs;
+}
+const pairs = {
+	collection: "seq",
+	default: false,
+	tag: "tag:yaml.org,2002:pairs",
+	resolve: resolvePairs,
+	createNode: createPairs
+};
+//#endregion
+//#region src/schema/yaml-1.1/omap.ts
+var YAMLOMap = class extends YAMLSeq {
+	constructor(schema, elements) {
+		super(schema, elements);
+		this.tag = omap.tag;
+	}
+	/**
+	* Append new pairs to the omap, and return its new length.
+	*/
+	push(...pairs) {
+		for (const pair of pairs) if (pair instanceof Pair) super.push(pair);
+		else throw new Error("Omap only supports Pair values");
+		return this.length;
+	}
+	/**
+	* Set a pair in this omap.
+	*
+	* Throws if `idx` is not an integer.
+	*/
+	set(idx, pair) {
+		if (!Number.isInteger(idx)) throw new TypeError(`Expected an integer, not ${JSON.stringify(idx)}.`);
+		if (idx < 0) {
+			if (idx < -this.length) throw new RangeError(`Invalid index ${idx}`);
+			idx += this.length;
+		}
+		this[idx] = pair;
+	}
+	/**
+	* The returned value actually has type `Map<unknown, unknown>`,
+	* but TypeScript won't allow widening the signature of a child method.
+	*/
+	toJS(doc, ctx) {
+		if (!ctx) return super.toJS(doc);
+		const map = /* @__PURE__ */ new Map();
+		if (this.anchor) ctx.anchors.set(this, {
+			aliasCount: 0,
+			count: 1,
+			res: map
+		});
+		for (const pair of this) {
+			const key = pair.key.toJS(doc, ctx);
+			const value = pair.value ? pair.value.toJS(doc, ctx) : null;
+			if (map.has(key)) throw new Error("Ordered maps must not include duplicate keys");
+			map.set(key, value);
+		}
+		return map;
+	}
+	toString(ctx, onComment, onChompKeep) {
+		const keys = /* @__PURE__ */ new Set();
+		for (const pair of this) {
+			const key = this.schema.mapKey(pair);
+			if (keys.has(key)) throw new Error("Ordered maps must not include duplicate keys");
+			keys.add(key);
+		}
+		return super.toString(ctx, onComment, onChompKeep);
+	}
+};
+const omap = {
+	collection: "seq",
+	identify: (value) => value instanceof Map,
+	nodeClass: YAMLOMap,
+	default: false,
+	tag: "tag:yaml.org,2002:omap",
+	createNode(nc, iterable) {
+		const pairs = createPairs(nc, iterable);
+		return new YAMLOMap(nc.schema, pairs);
+	},
+	resolve(seq, onError) {
+		const pairs = resolvePairs(seq, onError);
+		const seenKeys = [];
+		for (const { key } of pairs) if (key instanceof Scalar) if (seenKeys.includes(key.value)) onError(`Ordered maps must not include duplicate keys: ${key.value}`);
+		else seenKeys.push(key.value);
+		return Object.assign(new YAMLOMap(seq.schema), pairs);
+	}
+};
+//#endregion
+//#region src/schema/yaml-1.1/bool.ts
+function boolStringify({ value, source }, ctx) {
+	if (source && (value ? trueTag : falseTag).test.test(source)) return source;
+	return value ? ctx.options.trueStr : ctx.options.falseStr;
+}
+const trueTag = {
+	identify: (value) => value === true,
+	default: true,
+	tag: "tag:yaml.org,2002:bool",
+	test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
+	resolve: () => new Scalar(true),
+	stringify: boolStringify
+};
+const falseTag = {
+	identify: (value) => value === false,
+	default: true,
+	tag: "tag:yaml.org,2002:bool",
+	test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,
+	resolve: () => new Scalar(false),
+	stringify: boolStringify
+};
+//#endregion
+//#region src/schema/yaml-1.1/float.ts
+const floatNaN = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
+	resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
+	stringify: stringifyNumber
+};
+const floatExp = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	format: "EXP",
+	test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/,
+	resolve: (str) => parseFloat(str.replace(/_/g, "")),
+	stringify(node) {
+		const num = Number(node.value);
+		return isFinite(num) ? num.toExponential() : stringifyNumber(node);
+	}
+};
+const float = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
+	resolve(str) {
+		const node = new Scalar(parseFloat(str.replace(/_/g, "")));
+		const dot = str.indexOf(".");
+		if (dot !== -1) {
+			const f = str.substring(dot + 1).replace(/_/g, "");
+			if (f[f.length - 1] === "0") node.minFractionDigits = f.length;
+		}
+		return node;
+	},
+	stringify: stringifyNumber
+};
+//#endregion
+//#region src/schema/yaml-1.1/int.ts
+const intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
+function intResolve(str, offset, radix, { intAsBigInt }) {
+	const sign = str[0];
+	if (sign === "-" || sign === "+") offset += 1;
+	str = str.substring(offset).replace(/_/g, "");
+	if (intAsBigInt) {
+		switch (radix) {
+			case 2:
+				str = `0b${str}`;
+				break;
+			case 8:
+				str = `0o${str}`;
+				break;
+			case 16:
+				str = `0x${str}`;
+				break;
+		}
+		const n = BigInt(str);
+		return sign === "-" ? BigInt(-1) * n : n;
+	}
+	const n = parseInt(str, radix);
+	return sign === "-" ? -1 * n : n;
+}
+function intStringify(node, radix, prefix) {
+	const { value } = node;
+	if (intIdentify(value)) {
+		const str = value.toString(radix);
+		return value < 0 ? "-" + prefix + str.substr(1) : prefix + str;
+	}
+	return stringifyNumber(node);
+}
+const intBin = {
+	identify: intIdentify,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	format: "BIN",
+	test: /^[-+]?0b[0-1_]+$/,
+	resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),
+	stringify: (node) => intStringify(node, 2, "0b")
+};
+const intOct = {
+	identify: intIdentify,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	format: "OCT",
+	test: /^[-+]?0[0-7_]+$/,
+	resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),
+	stringify: (node) => intStringify(node, 8, "0")
+};
+const int = {
+	identify: intIdentify,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	test: /^[-+]?[0-9][0-9_]*$/,
+	resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
+	stringify: stringifyNumber
+};
+const intHex = {
+	identify: intIdentify,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	format: "HEX",
+	test: /^[-+]?0x[0-9a-fA-F_]+$/,
+	resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
+	stringify: (node) => intStringify(node, 16, "0x")
+};
+//#endregion
+//#region src/schema/yaml-1.1/set.ts
+const set = {
+	collection: "map",
+	identify: (value) => value instanceof Set,
+	nodeClass: YAMLSet,
+	default: false,
+	tag: "tag:yaml.org,2002:set",
+	createNode(nc, iterable) {
+		const set = new YAMLSet(nc.schema);
+		if (iterable && Symbol.iterator in Object(iterable)) for (let value of iterable) {
+			if (typeof nc.replacer === "function") value = nc.replacer.call(iterable, value, value);
+			const mk = nc.schema.mapKey(value);
+			set.values.set(mk, nc.create(value));
+		}
+		return set;
+	},
+	resolve(set, onError) {
+		if (!(set instanceof YAMLSet)) onError("Expected a set for this tag");
+		return set;
+	}
+};
+//#endregion
+//#region src/schema/yaml-1.1/timestamp.ts
+/** Internal types handle bigint as number, because TS can't figure it out. */
+function parseSexagesimal(str, asBigInt) {
+	const sign = str[0];
+	const parts = sign === "-" || sign === "+" ? str.substring(1) : str;
+	const num = (n) => asBigInt ? BigInt(n) : Number(n);
+	const res = parts.replace(/_/g, "").split(":").reduce((res, p) => res * num(60) + num(p), num(0));
+	return sign === "-" ? num(-1) * res : res;
+}
+/**
+* hhhh:mm:ss.sss
+*
+* Internal types handle bigint as number, because TS can't figure it out.
+*/
+function stringifySexagesimal(node) {
+	let { value } = node;
+	let num = (n) => n;
+	if (typeof value === "bigint") num = (n) => BigInt(n);
+	else if (isNaN(value) || !isFinite(value)) return stringifyNumber(node);
+	let sign = "";
+	if (value < 0) {
+		sign = "-";
+		value *= num(-1);
+	}
+	const _60 = num(60);
+	const parts = [value % _60];
+	if (value < 60) parts.unshift(0);
+	else {
+		value = (value - parts[0]) / _60;
+		parts.unshift(value % _60);
+		if (value >= 60) {
+			value = (value - parts[0]) / _60;
+			parts.unshift(value);
+		}
+	}
+	return sign + parts.map((n) => String(n).padStart(2, "0")).join(":").replace(/000000\d*$/, "");
+}
+const intTime = {
+	identify: (value) => typeof value === "bigint" || Number.isInteger(value),
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	format: "TIME",
+	test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,
+	resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt),
+	stringify: stringifySexagesimal
+};
+const floatTime = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	format: "TIME",
+	test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/,
+	resolve: (str) => parseSexagesimal(str, false),
+	stringify: stringifySexagesimal
+};
+const timestamp = {
+	identify: (value) => value instanceof Date,
+	default: true,
+	tag: "tag:yaml.org,2002:timestamp",
+	test: RegExp("^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?$"),
+	resolve(str) {
+		const match = str.match(timestamp.test);
+		if (!match) throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd");
+		const [, year, month, day, hour, minute, second] = match.map(Number);
+		const millisec = match[7] ? Number((match[7] + "00").substr(1, 3)) : 0;
+		let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);
+		const tz = match[8];
+		if (tz && tz !== "Z") {
+			let d = parseSexagesimal(tz, false);
+			if (Math.abs(d) < 30) d *= 60;
+			date -= 6e4 * d;
+		}
+		return new Date(date);
+	},
+	stringify: ({ value }) => value?.toISOString().replace(/(T00:00:00)?\.000Z$/, "") ?? ""
+};
+//#endregion
+//#region src/schema/yaml-1.1/schema.ts
+const schema = [
+	map,
+	seq,
+	string,
+	nullTag,
+	trueTag,
+	falseTag,
+	intBin,
+	intOct,
+	int,
+	intHex,
+	floatNaN,
+	floatExp,
+	float,
+	binary,
+	merge,
+	omap,
+	pairs,
+	set,
+	intTime,
+	floatTime,
+	timestamp
+];
+//#endregion
+//#region src/schema/tags.ts
+const schemas = new Map([
+	["core", schema$2],
+	["failsafe", [
+		map,
+		seq,
+		string
+	]],
+	["json", schema$1],
+	["yaml11", schema],
+	["yaml-1.1", schema]
+]);
+const tagsByName = {
+	binary,
+	bool: boolTag,
+	float: float$1,
+	floatExp: floatExp$1,
+	floatNaN: floatNaN$1,
+	floatTime,
+	int: int$1,
+	intHex: intHex$1,
+	intOct: intOct$1,
+	intTime,
+	map,
+	merge,
+	null: nullTag,
+	omap,
+	pairs,
+	seq,
+	set,
+	timestamp
+};
+const coreKnownTags = {
+	"tag:yaml.org,2002:binary": binary,
+	"tag:yaml.org,2002:merge": merge,
+	"tag:yaml.org,2002:omap": omap,
+	"tag:yaml.org,2002:pairs": pairs,
+	"tag:yaml.org,2002:set": set,
+	"tag:yaml.org,2002:timestamp": timestamp
+};
+function getTags(customTags, schemaName, addMergeTag) {
+	const schemaTags = schemas.get(schemaName);
+	if (schemaTags && !customTags) return addMergeTag && !schemaTags.includes(merge) ? [...schemaTags, merge] : schemaTags.slice();
+	let tags = schemaTags;
+	if (!tags) if (Array.isArray(customTags)) tags = [];
+	else {
+		const keys = Array.from(schemas.keys()).filter((key) => key !== "yaml11").map((key) => JSON.stringify(key)).join(", ");
+		throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
+	}
+	if (Array.isArray(customTags)) for (const tag of customTags) tags = tags.concat(tag);
+	else if (typeof customTags === "function") tags = customTags(tags.slice());
+	if (addMergeTag) tags = [...tags, merge];
+	return tags.reduce((tags, tag) => {
+		const tagObj = typeof tag === "string" ? tagsByName[tag] : tag;
+		if (!tagObj) {
+			const tagName = JSON.stringify(tag);
+			const keys = Object.keys(tagsByName).map((key) => JSON.stringify(key)).join(", ");
+			throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);
+		}
+		if (!tags.includes(tagObj)) tags.push(tagObj);
+		return tags;
+	}, []);
+}
+//#endregion
+//#region src/schema/Schema.ts
+var Schema = class Schema {
+	compat;
+	knownTags;
+	mapKey;
+	name;
+	tags;
+	toStringOptions;
+	constructor({ compat, customTags, mapKey, merge, resolveKnownTags, schema, toStringDefaults }) {
+		this.compat = Array.isArray(compat) ? getTags(compat, "compat") : compat ? getTags(null, compat) : null;
+		this.mapKey = mapKey ?? defaultMapKey;
+		this.name = typeof schema === "string" && schema || "core";
+		this.knownTags = resolveKnownTags ? coreKnownTags : {};
+		this.tags = getTags(customTags, this.name, merge);
+		this.toStringOptions = toStringDefaults ?? null;
+		Object.defineProperty(this, "map", { value: map });
+		Object.defineProperty(this, "scalar", { value: string });
+		Object.defineProperty(this, "seq", { value: seq });
+	}
+	clone() {
+		const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));
+		copy.tags = this.tags.slice();
+		return copy;
+	}
+};
+function defaultMapKey(value) {
+	if (value instanceof Pair) value = value.key;
+	if (value instanceof Scalar) value = value.value;
+	return value ?? null;
+}
+//#endregion
+//#region src/stringify/stringifyDocument.ts
+function stringifyDocument(doc, options) {
+	const lines = [];
+	let hasDirectives = options.directives === true;
+	if (options.directives !== false && doc.directives) {
+		const dir = doc.directives.toString(doc);
+		if (dir) {
+			lines.push(dir);
+			hasDirectives = true;
+		} else if (doc.directives.docStart) hasDirectives = true;
+	}
+	if (hasDirectives) lines.push("---");
+	const ctx = createStringifyContext(doc, options);
+	const { commentString } = ctx.options;
+	if (doc.commentBefore) {
+		if (lines.length !== 1) lines.unshift("");
+		const cs = commentString(doc.commentBefore);
+		lines.unshift(indentComment(cs, ""));
+	}
+	let chompKeep = false;
+	let contentComment = null;
+	if (doc.value.spaceBefore && hasDirectives) lines.push("");
+	if (doc.value.commentBefore) {
+		const cs = commentString(doc.value.commentBefore);
+		lines.push(indentComment(cs, ""));
+	}
+	ctx.forceBlockIndent = !!doc.comment;
+	contentComment = doc.value.comment;
+	const onChompKeep = contentComment ? void 0 : () => chompKeep = true;
+	let body = stringify(doc.value, ctx, () => contentComment = null, onChompKeep);
+	if (contentComment) body += lineComment(body, "", commentString(contentComment));
+	if ((body[0] === "|" || body[0] === ">") && lines[lines.length - 1] === "---") lines[lines.length - 1] = `--- ${body}`;
+	else lines.push(body);
+	if (doc.directives?.docEnd) if (doc.comment) {
+		const cs = commentString(doc.comment);
+		if (cs.includes("\n")) {
+			lines.push("...");
+			lines.push(indentComment(cs, ""));
+		} else lines.push(`... ${cs}`);
+	} else lines.push("...");
+	else {
+		let dc = doc.comment;
+		if (dc && chompKeep) dc = dc.replace(/^\n+/, "");
+		if (dc) {
+			if ((!chompKeep || contentComment) && lines[lines.length - 1] !== "") lines.push("");
+			lines.push(indentComment(commentString(dc), ""));
+		}
+	}
+	return lines.join("\n") + "\n";
+}
+//#endregion
+//#region src/doc/applyReviver.ts
+function applyReviver(reviver, obj, key, val) {
+	if (val && typeof val === "object") if (Array.isArray(val)) for (let i = 0, len = val.length; i < len; ++i) {
+		const v0 = val[i];
+		const v1 = applyReviver(reviver, val, String(i), v0);
+		if (v1 === void 0) delete val[i];
+		else if (v1 !== v0) val[i] = v1;
+	}
+	else if (val instanceof Map) for (const k of Array.from(val.keys())) {
+		const v0 = val.get(k);
+		const v1 = applyReviver(reviver, val, k, v0);
+		if (v1 === void 0) val.delete(k);
+		else if (v1 !== v0) val.set(k, v1);
+	}
+	else if (val instanceof Set) for (const v0 of Array.from(val)) {
+		const v1 = applyReviver(reviver, val, v0, v0);
+		if (v1 === void 0) val.delete(v0);
+		else if (v1 !== v0) {
+			val.delete(v0);
+			val.add(v1);
+		}
+	}
+	else for (const [k, v0] of Object.entries(val)) {
+		const v1 = applyReviver(reviver, val, k, v0);
+		if (v1 === void 0) delete val[k];
+		else if (v1 !== v0) val[k] = v1;
+	}
+	return reviver.call(obj, key, val);
+}
+//#endregion
+//#region src/doc/Document.ts
+var Document = class Document {
+	/** A comment before this Document */
+	commentBefore = null;
+	/** A comment immediately after this Document */
+	comment = null;
+	/** The document value. */
+	value;
+	directives;
+	/** Errors encountered during parsing. */
+	errors = [];
+	options;
+	/** Warnings encountered during parsing. */
+	warnings = [];
+	constructor(value, replacer, options) {
+		let _replacer = null;
+		if (typeof replacer === "function" || Array.isArray(replacer)) _replacer = replacer;
+		else if (options === void 0 && replacer) {
+			options = replacer;
+			replacer = void 0;
+		}
+		const opt = Object.assign({
+			intAsBigInt: false,
+			keepSourceTokens: false,
+			logLevel: "warn",
+			prettyErrors: true,
+			strict: true,
+			stringKeys: false,
+			version: "1.2"
+		}, options);
+		this.options = opt;
+		let { version } = opt;
+		if (options?._directives) {
+			this.directives = options._directives.atDocument();
+			if (this.directives.yaml.explicit) version = this.directives.yaml.version;
+		} else this.directives = new Directives({ version });
+		this.setSchema(version, options);
+		this.value = this.createNode(value, _replacer, options);
+	}
+	/**
+	* Create a deep copy of this Document and its value.
+	*
+	* Custom Node values that inherit from `Object` still refer to their original instances.
+	*/
+	clone() {
+		const copy = Object.create(Document.prototype);
+		copy.commentBefore = this.commentBefore;
+		copy.comment = this.comment;
+		copy.errors = this.errors.slice();
+		copy.warnings = this.warnings.slice();
+		copy.options = Object.assign({}, this.options);
+		if (this.directives) copy.directives = this.directives.clone();
+		copy.schema = this.schema.clone();
+		copy.value = this.value.clone(copy.schema);
+		if (this.range) copy.range = this.range.slice();
+		return copy;
+	}
+	/**
+	* Create a new `Alias` node, ensuring that the target `node` has the required anchor.
+	*
+	* If `node` already has an anchor, `name` is ignored.
+	* Otherwise, the `node.anchor` value will be set to `name`,
+	* or if an anchor with that name is already present in the document,
+	* `name` will be used as a prefix for a new unique anchor.
+	* If `name` is undefined, the generated anchor will use 'a' as a prefix.
+	*/
+	createAlias(node, name) {
+		if (!node.anchor) {
+			const prev = anchorNames(this);
+			node.anchor = !name || prev.has(name) ? findNewAnchor(name || "a", prev) : name;
+		}
+		return new Alias(node.anchor);
+	}
+	createNode(value, replacer, options) {
+		let nc;
+		if (typeof replacer === "function") {
+			value = replacer.call({ "": value }, "", value);
+			nc = new NodeCreator(this, options, replacer);
+		} else if (Array.isArray(replacer)) {
+			const keyToStr = (v) => typeof v === "number" || v instanceof String || v instanceof Number;
+			const asStr = replacer.filter(keyToStr).map(String);
+			if (asStr.length > 0) replacer = [...replacer, ...asStr];
+			nc = new NodeCreator(this, options, replacer);
+		} else {
+			options ??= replacer ?? void 0;
+			nc = new NodeCreator(this, options);
+		}
+		const node = nc.create(value, options?.tag);
+		nc.setAnchors();
+		return node;
+	}
+	/**
+	* Convert a key and a value into a `Pair` using the current schema,
+	* recursively wrapping all values as `Scalar` or `Collection` nodes.
+	*/
+	createPair(key, value, options = {}) {
+		const nc = new NodeCreator(this, options);
+		const pair = nc.createPair(key, value);
+		nc.setAnchors();
+		return pair;
+	}
+	/**
+	* Returns item at `key`, or `undefined` if not found.
+	*/
+	get(key) {
+		if (this.value instanceof YAMLMap || this.value instanceof YAMLSet) return this.value.get(key);
+		if (this.value instanceof YAMLSeq) {
+			if (Number.isInteger(key)) return this.value.at(key);
+			throw new TypeError(`Expected an integer, not ${JSON.stringify(key)}.`);
+		}
+	}
+	/**
+	* Returns pair at `key`, or `undefined` if not found.
+	*/
+	getPair(key) {
+		if (this.value instanceof YAMLMap) return this.value.getPair(key);
+		if (this.value instanceof YAMLSeq) {
+			if (!Number.isInteger(key)) throw new TypeError(`Expected an integer, not ${JSON.stringify(key)}.`);
+			const pair = this.value.at(key);
+			if (pair instanceof Pair) return pair;
+			throw new TypeError(`Value at ${key} is not a Pair`);
+		}
+	}
+	/**
+	* Sets a value in this document's top-level collection. For `!!set`, `value` is ignored.
+	*/
+	set(key, value) {
+		if (this.value instanceof YAMLSet) this.value.add(key);
+		else if (this.value instanceof YAMLMap || this.value instanceof YAMLSeq) this.value.set(key, value);
+		else throw new Error("Expected a YAML collection as document value");
+	}
+	/**
+	* Change the YAML version and schema used by the document.
+	* A `null` version disables support for directives, explicit tags, anchors, and aliases.
+	* It also requires the `schema` option to be given as a `Schema` instance value.
+	*
+	* Overrides all previously set schema options.
+	*/
+	setSchema(version, options = {}) {
+		if (typeof version === "number") version = String(version);
+		let opt;
+		switch (version) {
+			case "1.1":
+				if (this.directives) this.directives.yaml.version = "1.1";
+				else this.directives = new Directives({ version: "1.1" });
+				opt = {
+					resolveKnownTags: false,
+					schema: "yaml-1.1"
+				};
+				break;
+			case "1.2":
+			case "next":
+				if (this.directives) this.directives.yaml.version = version;
+				else this.directives = new Directives({ version });
+				opt = {
+					resolveKnownTags: true,
+					schema: "core"
+				};
+				break;
+			case null:
+				if (this.directives) delete this.directives;
+				opt = null;
+				break;
+			default: {
+				const sv = JSON.stringify(version);
+				throw new Error(`Expected '1.1', '1.2' or null as first argument, but found: ${sv}`);
+			}
+		}
+		if (options.schema instanceof Object) this.schema = options.schema;
+		else if (opt) this.schema = new Schema(Object.assign(opt, options));
+		else throw new Error(`With a null YAML version, the { schema: Schema } option is required`);
+	}
+	/** A plain JavaScript representation of the document `value`. */
+	toJS(opt = {}) {
+		const { onAnchor, reviver } = opt;
+		const ctx = new ToJSContext(opt);
+		const res = this.value.toJS(this, ctx);
+		if (typeof onAnchor === "function") for (const { count, res } of ctx.anchors.values()) onAnchor(res, count);
+		return typeof reviver === "function" ? applyReviver(reviver, { "": res }, "", res) : res;
+	}
+	/** A JSON representation of the document `value`.  */
+	toJSON() {
+		return this.toJS({ mapAsMap: false });
+	}
+	/** A YAML representation of the document. */
+	toString(options = {}) {
+		if (this.errors.length > 0) throw new Error("Document with errors cannot be stringified");
+		if ("indent" in options && (!Number.isInteger(options.indent) || Number(options.indent) <= 0)) {
+			const s = JSON.stringify(options.indent);
+			throw new Error(`"indent" option must be a positive integer, not ${s}`);
+		}
+		return stringifyDocument(this, options);
+	}
+};
+//#endregion
+//#region src/visit.ts
+const BREAK = Symbol("break visit");
+const SKIP = Symbol("skip children");
+const REMOVE = Symbol("remove node");
+/**
+* Apply a visitor to an AST node or document.
+*
+* Walks through the tree (depth-first) starting from `node`, calling a
+* `visitor` function with three arguments:
+*   - `key`: For sequence values and map `Pair`, the node's index in the
+*     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+*     `null` for the root node.
+*   - `node`: The current node.
+*   - `path`: The ancestry of the current node.
+*
+* 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 node, continue with next
+*     sibling
+*   - `visit.BREAK`: Terminate traversal completely
+*   - `visit.REMOVE`: Remove the current node, then continue with the next one
+*   - `Node`: Replace the current node, then continue by visiting it
+*   - `number`: While iterating the items of a sequence or map, set the index
+*     of the next step. This is useful especially if the index of the current
+*     node has changed.
+*
+* If `visitor` is a single function, it will be called with all values
+* encountered in the tree, including e.g. `null` values. Alternatively,
+* separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+* `Alias` and `Scalar` node. To define the same visitor function for more than
+* one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+* and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+* specific defined one will be used for each node.
+*/
+const visit = function visit(node, visitor) {
+	const visitor_ = initVisitor(visitor);
+	if (node instanceof Document) {
+		if (visit_(null, node.value, visitor_, [node]) === REMOVE) node.value = new Scalar(null);
+	} else visit_(null, node, visitor_, []);
+};
+visit.BREAK = BREAK;
+visit.SKIP = SKIP;
+visit.REMOVE = REMOVE;
+function visit_(key, node, visitor, path) {
+	const ctrl = callVisitor(key, node, visitor, path);
+	if (isNode(ctrl) || ctrl instanceof Pair) {
+		replaceNode(key, path, ctrl);
+		return visit_(key, ctrl, visitor, path);
+	}
+	if (typeof ctrl !== "symbol") {
+		if (node instanceof YAMLSeq) {
+			path = [...path, node];
+			for (let i = 0; i < node.length; ++i) {
+				const ci = visit_(i, node[i], visitor, path);
+				if (typeof ci === "number") i = ci - 1;
+				else if (ci === BREAK) return BREAK;
+				else if (ci === REMOVE) {
+					node.splice(i, 1);
+					i -= 1;
+				}
+			}
+		} else if (node instanceof YAMLMap || node instanceof YAMLSet) {
+			path = [...path, node];
+			const entries = Array.from(node.values);
+			const delKeys = [];
+			for (let i = 0; i < entries.length; ++i) {
+				const ci = visit_(i, entries[i][1], visitor, path);
+				if (typeof ci === "number") i = ci - 1;
+				else if (ci === BREAK) return BREAK;
+				else if (ci === REMOVE) delKeys.push(entries[i][0]);
+			}
+			for (const dk of delKeys) node.values.delete(dk);
+		} else if (node instanceof Pair) {
+			path = [...path, node];
+			const ck = visit_("key", node.key, visitor, path);
+			if (ck === BREAK) return BREAK;
+			else if (ck === REMOVE) node.key = new Scalar(null);
+			const cv = visit_("value", node.value, visitor, path);
+			if (cv === BREAK) return BREAK;
+			else if (cv === REMOVE) node.value = null;
+		}
+	}
+	return ctrl;
+}
+/**
+* Apply an async visitor to an AST node or document.
+*
+* Walks through the tree (depth-first) starting from `node`, calling a
+* `visitor` function with three arguments:
+*   - `key`: For sequence values and map `Pair`, the node's index in the
+*     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+*     `null` for the root node.
+*   - `node`: The current node.
+*   - `path`: The ancestry of the current node.
+*
+* The return value of the visitor may be used to control the traversal:
+*   - `Promise`: Must resolve to one of the following values
+*   - `undefined` (default): Do nothing and continue
+*   - `visitAsync.SKIP`: Do not visit the children of this node,
+*     continue with next sibling
+*   - `visitAsync.BREAK`: Terminate traversal completely
+*   - `visitAsync.REMOVE`: Remove the current node,
+*     then continue with the next one
+*   - `Node`: Replace the current node, then continue by visiting it
+*   - `number`: While iterating the items of a sequence or map, set the index
+*     of the next step. This is useful especially if the index of the current
+*     node has changed.
+*
+* If `visitor` is a single function, it will be called with all values
+* encountered in the tree, including e.g. `null` values. Alternatively,
+* separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+* `Alias` and `Scalar` node. To define the same visitor function for more than
+* one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+* and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+* specific defined one will be used for each node.
+*/
+const visitAsync = async function visitAsync(node, visitor) {
+	const visitor_ = initVisitor(visitor);
+	if (node instanceof Document) {
+		if (await visitAsync_(null, node.value, visitor_, [node]) === REMOVE) node.value = new Scalar(null);
+	} else await visitAsync_(null, node, visitor_, []);
+};
+visitAsync.BREAK = BREAK;
+visitAsync.SKIP = SKIP;
+visitAsync.REMOVE = REMOVE;
+async function visitAsync_(key, node, visitor, path) {
+	const ctrl = await callVisitor(key, node, visitor, path);
+	if (isNode(ctrl) || ctrl instanceof Pair) {
+		replaceNode(key, path, ctrl);
+		return visitAsync_(key, ctrl, visitor, path);
+	}
+	if (typeof ctrl !== "symbol") {
+		if (node instanceof YAMLSeq) {
+			path = [...path, node];
+			for (let i = 0; i < node.length; ++i) {
+				const ci = await visitAsync_(i, node[i], visitor, path);
+				if (typeof ci === "number") i = ci - 1;
+				else if (ci === BREAK) return BREAK;
+				else if (ci === REMOVE) {
+					node.splice(i, 1);
+					i -= 1;
+				}
+			}
+		} else if (node instanceof YAMLMap || node instanceof YAMLSet) {
+			path = [...path, node];
+			const entries = Array.from(node.values);
+			const delKeys = [];
+			for (let i = 0; i < entries.length; ++i) {
+				const ci = await visitAsync_(i, entries[i][1], visitor, path);
+				if (typeof ci === "number") i = ci - 1;
+				else if (ci === BREAK) return BREAK;
+				else if (ci === REMOVE) delKeys.push(entries[i][0]);
+			}
+			for (const dk of delKeys) node.values.delete(dk);
+		} else if (node instanceof Pair) {
+			path = [...path, node];
+			const ck = await visitAsync_("key", node.key, visitor, path);
+			if (ck === BREAK) return BREAK;
+			else if (ck === REMOVE) node.key = new Scalar(null);
+			const cv = await visitAsync_("value", node.value, visitor, path);
+			if (cv === BREAK) return BREAK;
+			else if (cv === REMOVE) node.value = null;
+		}
+	}
+	return ctrl;
+}
+function initVisitor(visitor) {
+	if (typeof visitor === "object" && (visitor.Collection || visitor.Node || visitor.Value)) return Object.assign({
+		Alias: visitor.Node,
+		Map: visitor.Node,
+		Scalar: visitor.Node,
+		Seq: visitor.Node
+	}, visitor.Value && {
+		Map: visitor.Value,
+		Scalar: visitor.Value,
+		Seq: visitor.Value
+	}, visitor.Collection && {
+		Map: visitor.Collection,
+		Seq: visitor.Collection
+	}, visitor);
+	return visitor;
+}
+function callVisitor(key, node, visitor, path) {
+	if (typeof visitor === "function") return visitor(key, node, path);
+	if (node instanceof YAMLMap || node instanceof YAMLSet) return visitor.Map?.(key, node, path);
+	if (node instanceof YAMLSeq) return visitor.Seq?.(key, node, path);
+	if (node instanceof Pair) return visitor.Pair?.(key, node, path);
+	if (node instanceof Scalar) return visitor.Scalar?.(key, node, path);
+	if (node instanceof Alias) return visitor.Alias?.(key, node, path);
+}
+function replaceNode(key, path, node) {
+	const parent = path[path.length - 1];
+	if (parent instanceof YAMLSeq) parent[key] = node;
+	else if (parent instanceof YAMLMap) if (node instanceof Pair) {
+		const entries = Array.from(parent.values);
+		entries[key] = [parent.keyOf(node, true), node];
+		parent.values = new Map(entries);
+	} else throw new Error("Cannot replace map pair with non-pair value");
+	else if (parent instanceof YAMLSet) if (isNode(node)) {
+		const entries = Array.from(parent.values);
+		entries[key] = [parent.keyOf(node, true), node];
+		parent.values = new Map(entries);
+	} else throw new Error("Cannot replace set value with non-node value");
+	else if (parent instanceof Pair) if (isNode(node)) if (key === "key") parent.key = node;
+	else parent.value = node;
+	else throw new Error(`Cannot replace pair ${key} with non-node value`);
+	else if (parent instanceof Document) if (node instanceof Scalar || isCollection(node)) parent.value = node;
+	else throw new Error("Cannot replace Document value with non-node value");
+	else {
+		const pt = parent instanceof Alias ? "alias" : "scalar";
+		throw new Error(`Cannot replace node with ${pt} parent`);
+	}
+}
+//#endregion
+//#region src/doc/directives.ts
+const escapeChars = {
+	"!": "%21",
+	",": "%2C",
+	"[": "%5B",
+	"]": "%5D",
+	"{": "%7B",
+	"}": "%7D"
+};
+const escapeTagName = (tn) => tn.replace(/[!,[\]{}]/g, (ch) => escapeChars[ch]);
+var Directives = class Directives {
+	static defaultYaml = {
+		explicit: false,
+		version: "1.2"
+	};
+	static defaultTags = { "!!": "tag:yaml.org,2002:" };
+	yaml;
+	tags;
+	/**
+	* The directives-end/doc-start marker `---`. If `null`, a marker may still be
+	* included in the document's stringified representation.
+	*/
+	docStart = null;
+	/** The doc-end marker `...`.  */
+	docEnd = false;
+	/**
+	* Used when parsing YAML 1.1, where:
+	* > If the document specifies no directives, it is parsed using the same
+	* > settings as the previous document. If the document does specify any
+	* > directives, all directives of previous documents, if any, are ignored.
+	*/
+	atNextDocument;
+	constructor(yaml, tags) {
+		this.yaml = Object.assign({}, Directives.defaultYaml, yaml);
+		this.tags = Object.assign({}, Directives.defaultTags, tags);
+	}
+	clone() {
+		const copy = new Directives(this.yaml, this.tags);
+		copy.docStart = this.docStart;
+		return copy;
+	}
+	/**
+	* During parsing, get a Directives instance for the current document and
+	* update the stream state according to the current version's spec.
+	*/
+	atDocument() {
+		const res = new Directives(this.yaml, this.tags);
+		switch (this.yaml.version) {
+			case "1.1":
+				this.atNextDocument = true;
+				break;
+			case "1.2":
+				this.atNextDocument = false;
+				this.yaml = {
+					explicit: Directives.defaultYaml.explicit,
+					version: "1.2"
+				};
+				this.tags = Object.assign({}, Directives.defaultTags);
+				break;
+		}
+		return res;
+	}
+	/**
+	* @param onError - May be called even if the action was successful
+	* @returns `true` on success
+	*/
+	add(line, onError) {
+		if (this.atNextDocument) {
+			this.yaml = {
+				explicit: Directives.defaultYaml.explicit,
+				version: "1.1"
+			};
+			this.tags = Object.assign({}, Directives.defaultTags);
+			this.atNextDocument = false;
+		}
+		const parts = line.trim().split(/[ \t]+/);
+		const name = parts.shift();
+		switch (name) {
+			case "%TAG": {
+				if (parts.length !== 2) {
+					onError(0, "%TAG directive should contain exactly two parts");
+					if (parts.length < 2) return false;
+				}
+				const [handle, prefix] = parts;
+				this.tags[handle] = prefix;
+				return true;
+			}
+			case "%YAML": {
+				this.yaml.explicit = true;
+				if (parts.length !== 1) {
+					onError(0, "%YAML directive should contain exactly one part");
+					return false;
+				}
+				const [version] = parts;
+				if (version === "1.1" || version === "1.2") {
+					this.yaml.version = version;
+					return true;
+				} else {
+					const isValid = /^\d+\.\d+$/.test(version);
+					onError(6, `Unsupported YAML version ${version}`, isValid);
+					return false;
+				}
+			}
+			default:
+				onError(0, `Unknown directive ${name}`, true);
+				return false;
+		}
+	}
+	/**
+	* Resolves a tag, matching handles to those defined in %TAG directives.
+	*
+	* @returns Resolved tag, which may also be the non-specific tag `'!'` or a
+	*   `'!local'` tag, or `null` if unresolvable.
+	*/
+	tagName(source, onError) {
+		if (source === "!") return "!";
+		if (source[0] !== "!") {
+			onError(`Not a valid tag: ${source}`);
+			return null;
+		}
+		if (source[1] === "<") {
+			const verbatim = source.slice(2, -1);
+			if (verbatim === "!" || verbatim === "!!") {
+				onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);
+				return null;
+			}
+			if (source[source.length - 1] !== ">") onError("Verbatim tags must end with a >");
+			return verbatim;
+		}
+		const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);
+		if (!suffix) onError(`The ${source} tag has no suffix`);
+		const prefix = this.tags[handle];
+		if (prefix) try {
+			return prefix + decodeURIComponent(suffix);
+		} catch (error) {
+			onError(String(error));
+			return null;
+		}
+		if (handle === "!") return source;
+		onError(`Could not resolve tag: ${source}`);
+		return null;
+	}
+	/**
+	* Given a fully resolved tag, returns its printable string form,
+	* taking into account current tag prefixes and defaults.
+	*/
+	tagString(tag) {
+		for (const [handle, prefix] of Object.entries(this.tags)) if (tag.startsWith(prefix)) return handle + escapeTagName(tag.substring(prefix.length));
+		return tag[0] === "!" ? tag : `!<${tag}>`;
+	}
+	toString(doc) {
+		const lines = this.yaml.explicit ? [`%YAML ${this.yaml.version || "1.2"}`] : [];
+		const tagEntries = Object.entries(this.tags);
+		let tagNames;
+		if (doc && tagEntries.length > 0) {
+			const tags = {};
+			visit(doc.value, (_key, node) => {
+				if (node?.tag) tags[node.tag] = true;
+			});
+			tagNames = Object.keys(tags);
+		} else tagNames = [];
+		for (const [handle, prefix] of tagEntries) {
+			if (handle === "!!" && prefix === "tag:yaml.org,2002:") continue;
+			if (!doc || tagNames.some((tn) => tn.startsWith(prefix))) lines.push(`%TAG ${handle} ${prefix}`);
+		}
+		return lines.join("\n");
+	}
+};
+//#endregion
+export { Scalar as S, ToJSContext as _, Schema as a, stringifyString as b, seq as c, Pair as d, isCollection as f, YAMLMap as g, YAMLSeq as h, Document as i, map as l, YAMLSet as m, visit as n, stringifyNumber as o, isNode as p, visitAsync as r, string as s, Directives as t, Alias as u, debug as v, foldFlowLines as x, warn as y };