yaml 2.8.2 → 3.0.0-0

package/dist/directives-CG6n4xSM.js

@@ -0,0 +1,2856 @@
+//#region src/doc/applyReviver.ts
+/**
+* Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,
+* in section 24.5.1.1 "Runtime Semantics: InternalizeJSONProperty" of the
+* 2021 edition: https://tc39.es/ecma262/#sec-json.parse
+*
+* Includes extensions for handling Map and Set objects.
+*/
+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/nodes/toJS.ts
+/**
+* Recursively convert any node or its contents to native JavaScript
+*
+* @param value - The input value
+* @param arg - If `value` defines a `toJSON()` method, use this
+*   as its first argument
+* @param ctx - Conversion context, originally set in Document#toJS(). If
+*   `{ keep: true }` is not set, output should be suitable for JSON
+*   stringification.
+*/
+function toJS(value, arg, ctx) {
+	if (Array.isArray(value)) return value.map((v, i) => toJS(v, String(i), ctx));
+	if (value && typeof value.toJSON === "function") {
+		const node = value;
+		if (!ctx || !(node instanceof NodeBase) || !node.anchor) return value.toJSON(arg, ctx);
+		const data = {
+			aliasCount: 0,
+			count: 1,
+			res: void 0
+		};
+		ctx.anchors.set(node, data);
+		ctx.onCreate = (res) => {
+			data.res = res;
+			delete ctx.onCreate;
+		};
+		const res = node.toJSON(arg, ctx);
+		if (ctx.onCreate) ctx.onCreate(res);
+		return res;
+	}
+	if (typeof value === "bigint" && !ctx?.keep) return Number(value);
+	return value;
+}
+
+//#endregion
+//#region src/nodes/Node.ts
+var NodeBase = class {
+	/** Create a copy of this node.  */
+	clone(_schema) {
+		const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+		if (this.range) copy.range = this.range.slice();
+		return copy;
+	}
+	/** A plain JavaScript representation of this node. */
+	toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
+		if (!doc?.schema) throw new TypeError("A document argument is required");
+		const ctx = {
+			anchors: /* @__PURE__ */ new Map(),
+			doc,
+			keep: true,
+			mapAsMap: mapAsMap === true,
+			mapKeyWarned: false,
+			maxAliasCount: typeof maxAliasCount === "number" ? maxAliasCount : 100
+		};
+		const res = 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;
+	}
+};
+
+//#endregion
+//#region src/nodes/Scalar.ts
+var Scalar = class extends NodeBase {
+	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) {
+		super();
+		this.value = value;
+	}
+	toJSON(arg, ctx) {
+		return ctx?.keep ? this.value : toJS(this.value, arg, ctx);
+	}
+	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 === FOLD_BLOCK) {
+		i = consumeMoreIndentedLines(text, i, indent.length);
+		if (i !== -1) end = i + endStep;
+	}
+	for (let ch; ch = text[i += 1];) {
+		if (mode === FOLD_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 === FOLD_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 === FOLD_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 === FOLD_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;
+	#aliasDuplicateObjects;
+	#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.#aliasDuplicateObjects = options.aliasDuplicateObjects ?? true;
+		this.#anchorPrefix = options.anchorPrefix || "a";
+		if (docOrSchema instanceof Document) {
+			this.#doc = docOrSchema;
+			this.schema = docOrSchema.schema;
+		} else this.schema = docOrSchema;
+	}
+	create(value, tagName) {
+		if (value instanceof Document) value = value.value;
+		if (value instanceof NodeBase) return value;
+		if (value instanceof Pair) {
+			const map = this.schema.map.nodeClass.from(this, null);
+			map.items.push(value);
+			return map;
+		}
+		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.#aliasDuplicateObjects && 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) ?? tagObj?.nodeClass?.from?.(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 && node instanceof Collection) 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 || ref.node instanceof Collection)) ref.node.anchor = ref.anchor;
+			else throw Object.assign(new Error("Failed to resolve repeated object (this should not happen)"), { source });
+		}
+	}
+};
+
+//#endregion
+//#region src/nodes/Collection.ts
+function collectionFromPath(schema, path, value) {
+	let v = value;
+	for (let i = path.length - 1; i >= 0; --i) {
+		const k = path[i];
+		if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
+			const a = [];
+			a[k] = v;
+			v = a;
+		} else v = new Map([[k, v]]);
+	}
+	return new NodeCreator(schema, { aliasDuplicateObjects: false }).create(v);
+}
+var Collection = class Collection extends NodeBase {
+	schema;
+	constructor(schema) {
+		super();
+		Object.defineProperty(this, "schema", {
+			value: schema,
+			configurable: true,
+			enumerable: false,
+			writable: true
+		});
+	}
+	/**
+	* Create a copy of this collection.
+	*
+	* @param schema - If defined, overwrites the original's schema
+	*/
+	clone(schema) {
+		const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+		if (schema) copy.schema = schema;
+		copy.items = copy.items.map((it) => it.clone(schema));
+		if (this.range) copy.range = this.range.slice();
+		return copy;
+	}
+	/**
+	* Adds a value to the collection.
+	*
+	* For `!!map` and `!!omap` the value must be a Pair instance.
+	*/
+	addIn(path, value) {
+		if (!path.length) this.add(value);
+		else {
+			const [key, ...rest] = path;
+			const node = this.get(key);
+			if (node instanceof Collection) node.addIn(rest, value);
+			else if (node === void 0 && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));
+			else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+		}
+	}
+	/**
+	* Removes a value from the collection.
+	*
+	* @returns `true` if the item was found and removed.
+	*/
+	deleteIn(path) {
+		const [key, ...rest] = path;
+		if (rest.length === 0) return this.delete(key);
+		const node = this.get(key);
+		if (node instanceof Collection) return node.deleteIn(rest);
+		else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+	}
+	/**
+	* Returns item at `key`, or `undefined` if not found.
+	*/
+	getIn(path) {
+		const [key, ...rest] = path;
+		const node = this.get(key);
+		if (rest.length === 0) return node;
+		else return node instanceof Collection ? node.getIn(rest) : void 0;
+	}
+	/**
+	* Checks if the collection includes a value with the key `key`.
+	*/
+	hasIn(path) {
+		const [key, ...rest] = path;
+		if (rest.length === 0) return this.has(key);
+		const node = this.get(key);
+		return node instanceof Collection ? node.hasIn(rest) : false;
+	}
+	/**
+	* Sets a value in this collection.
+	*/
+	setIn(path, value) {
+		const [key, ...rest] = path;
+		if (rest.length === 0) this.set(key, value);
+		else {
+			const node = this.get(key);
+			if (node instanceof Collection) node.setIn(rest, value);
+			else if (node === void 0 && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));
+			else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+		}
+	}
+};
+
+//#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/stringify/stringify.ts
+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,
+		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;
+	}
+	return {
+		anchors: /* @__PURE__ */ new Set(),
+		doc,
+		flowCollectionPadding: opt.flowCollectionPadding ? " " : "",
+		indent: "",
+		indentStep: typeof opt.indent === "number" ? " ".repeat(opt.indent) : "  ",
+		inFlow,
+		options: opt
+	};
+}
+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 instanceof Scalar || node instanceof Collection) && 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(item, ctx, onComment, onChompKeep) {
+	if (item instanceof Pair) return item.toString(ctx, onComment, onChompKeep);
+	if (item instanceof Alias) {
+		if (ctx.doc.directives) return item.toString(ctx);
+		if (ctx.resolvedAliases?.has(item)) throw new TypeError(`Cannot stringify circular structure without alias nodes`);
+		else {
+			if (ctx.resolvedAliases) ctx.resolvedAliases.add(item);
+			else ctx.resolvedAliases = new Set([item]);
+			item = item.resolve(ctx.doc);
+		}
+	}
+	let tagObj = void 0;
+	const node = item instanceof NodeBase ? item : ctx.doc.createNode(item, { 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/stringify/stringifyCollection.ts
+function stringifyCollection(collection, ctx, options) {
+	return (ctx.inFlow ?? collection.flow ? stringifyFlowCollection : stringifyBlockCollection)(collection, ctx, options);
+}
+function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {
+	const { indent, options: { commentString } } = ctx;
+	const itemCtx = Object.assign({}, ctx, {
+		indent: itemIndent,
+		type: null
+	});
+	let chompKeep = false;
+	const lines = [];
+	for (let i = 0; i < items.length; ++i) {
+		const item = items[i];
+		let comment = null;
+		if (item instanceof NodeBase) {
+			if (!chompKeep && item.spaceBefore) lines.push("");
+			addCommentBefore(ctx, lines, item.commentBefore, chompKeep);
+			if (item.comment) comment = item.comment;
+		} else if (item instanceof Pair) {
+			const ik = item.key instanceof NodeBase ? item.key : null;
+			if (ik) {
+				if (!chompKeep && ik.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);
+			}
+		}
+		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(blockItemPrefix + str);
+	}
+	let str;
+	if (lines.length === 0) str = flowChars.start + flowChars.end;
+	else {
+		str = lines[0];
+		for (let i = 1; i < lines.length; ++i) {
+			const line = lines[i];
+			str += line ? `\n${indent}${line}` : "\n";
+		}
+	}
+	if (comment) {
+		str += "\n" + indentComment(commentString(comment), indent);
+		if (onComment) onComment();
+	} else if (chompKeep && onChompKeep) onChompKeep();
+	return str;
+}
+function stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) {
+	const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;
+	itemIndent += indentStep;
+	const itemCtx = Object.assign({}, ctx, {
+		indent: itemIndent,
+		inFlow: true,
+		type: null
+	});
+	let reqNewline = false;
+	let linesAtValue = 0;
+	const lines = [];
+	for (let i = 0; i < items.length; ++i) {
+		const item = items[i];
+		let comment = null;
+		if (item instanceof NodeBase) {
+			if (item.spaceBefore) lines.push("");
+			addCommentBefore(ctx, lines, item.commentBefore, false);
+			if (item.comment) comment = item.comment;
+		} else if (item instanceof Pair) {
+			const ik = item.key instanceof NodeBase ? item.key : null;
+			if (ik) {
+				if (ik.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, ik.commentBefore, false);
+				if (ik.comment) reqNewline = true;
+			}
+			const iv = item.value instanceof NodeBase ? item.value : null;
+			if (iv) {
+				if (iv.comment) comment = iv.comment;
+				if (iv.commentBefore) reqNewline = true;
+			} else if (item.value == null && ik?.comment) comment = ik.comment;
+		}
+		if (comment) reqNewline = true;
+		let str = stringify(item, itemCtx, () => comment = null);
+		if (i < items.length - 1) str += ",";
+		if (comment) str += lineComment(str, itemIndent, commentString(comment));
+		if (!reqNewline && (lines.length > linesAtValue || str.includes("\n"))) reqNewline = true;
+		lines.push(str);
+		linesAtValue = lines.length;
+	}
+	const { start, end } = flowChars;
+	if (lines.length === 0) return start + end;
+	else {
+		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 = start;
+			for (const line of lines) str += line ? `\n${indentStep}${indent}${line}` : "\n";
+			return `${str}\n${indent}${end}`;
+		} else return `${start}${fcPadding}${lines.join(" ")}${fcPadding}${end}`;
+	}
+}
+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/YAMLSeq.ts
+const isScalarValue = (value) => !value || typeof value !== "function" && typeof value !== "object";
+var YAMLSeq = class extends Collection {
+	static get tagName() {
+		return "tag:yaml.org,2002:seq";
+	}
+	items = [];
+	add(value, options) {
+		if (value instanceof NodeBase) this.items.push(value);
+		else if (!this.schema) throw new Error("Schema is required");
+		else {
+			const nc = new NodeCreator(this.schema, {
+				...options,
+				aliasDuplicateObjects: false
+			});
+			this.items.push(nc.create(value));
+			nc.setAnchors();
+		}
+	}
+	/**
+	* Removes a value from the collection.
+	*
+	* Throws if `idx` is not a non-negative integer.
+	*
+	* @returns `true` if the item was found and removed.
+	*/
+	delete(idx) {
+		if (!Number.isInteger(idx)) throw new TypeError(`Expected an integer, not ${idx}.`);
+		if (idx < 0) throw new RangeError(`Invalid negative index ${idx}`);
+		return this.items.splice(idx, 1).length > 0;
+	}
+	/**
+	* Returns item at `key`, or `undefined` if not found.
+	*
+	* Throws if `idx` is not a non-negative integer.
+	*/
+	get(idx) {
+		if (!Number.isInteger(idx)) throw new TypeError(`Expected an integer, not ${JSON.stringify(idx)}.`);
+		if (idx < 0) throw new RangeError(`Invalid negative index ${idx}`);
+		return this.items[idx];
+	}
+	/**
+	* Checks if the collection includes a value with the key `key`.
+	*
+	* Throws if `idx` is not a non-negative integer.
+	*/
+	has(idx) {
+		if (!Number.isInteger(idx)) throw new TypeError(`Expected an integer, not ${JSON.stringify(idx)}.`);
+		if (idx < 0) throw new RangeError(`Invalid negative index ${idx}`);
+		return idx < this.items.length;
+	}
+	/**
+	* Sets a value in this collection. For `!!set`, `value` needs to be a
+	* boolean to add/remove the item from the set.
+	*
+	* Throws if `idx` is not a non-negative integer.
+	*/
+	set(idx, value, options) {
+		if (!Number.isInteger(idx)) throw new TypeError(`Expected an integer, not ${JSON.stringify(idx)}.`);
+		if (idx < 0) throw new RangeError(`Invalid negative index ${idx}`);
+		const prev = this.items[idx];
+		if (prev instanceof Scalar && isScalarValue(value)) prev.value = value;
+		else if (value instanceof NodeBase) this.items[idx] = value;
+		else if (!this.schema) throw new Error("Schema is required");
+		else {
+			const nc = new NodeCreator(this.schema, {
+				...options,
+				aliasDuplicateObjects: false
+			});
+			this.items[idx] = nc.create(value);
+			nc.setAnchors();
+		}
+	}
+	toJSON(_, ctx) {
+		const seq = [];
+		if (ctx?.onCreate) ctx.onCreate(seq);
+		let i = 0;
+		for (const item of this.items) seq.push(toJS(item, String(i++), ctx));
+		return seq;
+	}
+	toString(ctx, onComment, onChompKeep) {
+		if (!ctx) return JSON.stringify(this);
+		return stringifyCollection(this, ctx, {
+			blockItemPrefix: "- ",
+			flowChars: {
+				start: "[",
+				end: "]"
+			},
+			itemIndent: (ctx.indent || "") + "  ",
+			onChompKeep,
+			onComment
+		});
+	}
+	static from(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.items.push(nc.create(it));
+			}
+		}
+		return seq;
+	}
+};
+
+//#endregion
+//#region src/stringify/stringifyPair.ts
+function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
+	const { doc, indent, indentStep, noValues, options: { commentString, indentSeq, simpleKeys } } = ctx;
+	let keyComment = key instanceof NodeBase && key.comment || null;
+	if (simpleKeys) {
+		if (keyComment) throw new Error("With simple keys, key nodes cannot have comments");
+		if (key instanceof Collection || !(key instanceof NodeBase) && typeof key === "object") throw new Error("With simple keys, collection cannot be used as a key value");
+	}
+	let explicitKey = !simpleKeys && (!key || !(key instanceof Scalar) || key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL);
+	ctx = {
+		...ctx,
+		implicitKey: !explicitKey && (simpleKeys || !noValues),
+		indent: indent + indentStep,
+		noValues: false
+	};
+	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 (noValues || value == null) {
+			if (keyCommentDone && onComment) onComment();
+			return str === "" ? "?" : explicitKey ? `? ${str}` : noValues ? str : `${str}:`;
+		}
+	} else if (noValues && !simpleKeys || 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 instanceof NodeBase) {
+		vsb = !!value.spaceBefore;
+		vcb = value.commentBefore;
+		valueComment = value.comment;
+	} else {
+		vsb = false;
+		vcb = null;
+		valueComment = null;
+		if (value && typeof value === "object") value = doc.createNode(value);
+	}
+	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 && value instanceof Collection) {
+		const vs0 = valueStr[0];
+		const nl0 = valueStr.indexOf("\n");
+		const hasNewline = nl0 !== -1;
+		const flow = ctx.inFlow ?? value.flow ?? value.items.length === 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/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 = (ctx, key) => (merge.identify(key) || key instanceof Scalar && (!key.type || key.type === Scalar.PLAIN) && merge.identify(key.value)) && Boolean(ctx?.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default));
+function addMergeToJSMap(ctx, map, value) {
+	value = ctx && value instanceof Alias ? value.resolve(ctx.doc) : value;
+	if (value instanceof YAMLSeq) for (const it of value.items) mergeValue(ctx, map, it);
+	else if (Array.isArray(value)) for (const it of value) mergeValue(ctx, map, it);
+	else mergeValue(ctx, map, value);
+}
+function mergeValue(ctx, map, value) {
+	const srcMap = (ctx && value instanceof Alias ? value.resolve(ctx.doc) : value).toJSON(null, 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/nodes/addPairToJSMap.ts
+function addPairToJSMap(ctx, map, { key, value }) {
+	if (key instanceof NodeBase && key.addToJSMap) key.addToJSMap(ctx, map, value);
+	else if (isMergeKey(ctx, key)) addMergeToJSMap(ctx, map, value);
+	else {
+		const jsKey = toJS(key, "", ctx);
+		if (map instanceof Map) map.set(jsKey, toJS(value, jsKey, ctx));
+		else if (map instanceof Set) map.add(jsKey);
+		else {
+			const stringKey = stringifyKey(key, jsKey, ctx);
+			const jsValue = toJS(value, stringKey, ctx);
+			if (stringKey in map) Object.defineProperty(map, stringKey, {
+				value: jsValue,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+			else map[stringKey] = jsValue;
+		}
+	}
+	return map;
+}
+function stringifyKey(key, jsKey, ctx) {
+	if (jsKey === null) return "";
+	if (typeof jsKey !== "object") return String(jsKey);
+	if (key instanceof NodeBase && ctx?.doc) {
+		const strCtx = createStringifyContext(ctx.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) + "...\"";
+			warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
+			ctx.mapKeyWarned = true;
+		}
+		return strKey;
+	}
+	return JSON.stringify(jsKey);
+}
+
+//#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);
+	}
+	toJSON(_, ctx) {
+		return addPairToJSMap(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 extends NodeBase {
+	source;
+	constructor(source) {
+		super();
+		this.source = source;
+		Object.defineProperty(this, "tag", { set() {
+			throw new Error("Alias nodes cannot have tags");
+		} });
+	}
+	/**
+	* Resolve the value of this alias within `doc`, finding the last
+	* instance of the `source` anchor before this node.
+	*/
+	resolve(doc, ctx) {
+		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;
+	}
+	toJSON(_arg, ctx) {
+		if (!ctx) return { source: this.source };
+		const { anchors, doc, 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) {
+			toJS(source, null, 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;
+			if (data.aliasCount === 0) data.aliasCount = getAliasCount(doc, 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, node, anchors) {
+	if (node instanceof Alias) {
+		const source = node.resolve(doc);
+		const anchor = anchors && source && anchors.get(source);
+		return anchor ? anchor.count * anchor.aliasCount : 0;
+	} else if (node instanceof NodeBase && "items" in node) {
+		const coll = node;
+		let count = 0;
+		for (const item of coll.items) {
+			const c = getAliasCount(doc, item, anchors);
+			if (c > count) count = c;
+		}
+		return count;
+	} else if (node instanceof Pair) {
+		const kc = getAliasCount(doc, node.key, anchors);
+		const vc = getAliasCount(doc, node.value, anchors);
+		return Math.max(kc, vc);
+	}
+	return 1;
+}
+
+//#endregion
+//#region src/nodes/YAMLMap.ts
+function findPair(items, key) {
+	const k = key instanceof Scalar ? key.value : key;
+	for (const it of items) {
+		if (it.key === key || it.key === k) return it;
+		if (it.key instanceof Scalar && it.key.value === k) return it;
+	}
+}
+var YAMLMap = class extends Collection {
+	static get tagName() {
+		return "tag:yaml.org,2002:map";
+	}
+	items = [];
+	/**
+	* A generic collection parsing method that can be extended
+	* to other node classes that inherit from YAMLMap
+	*/
+	static from(nc, obj) {
+		const { replacer } = nc;
+		const map = new this(nc.schema);
+		const add = (key, value) => {
+			if (typeof replacer === "function") value = replacer.call(obj, key, value);
+			else if (Array.isArray(replacer) && !replacer.includes(key)) return;
+			if (value !== void 0 || nc.keepUndefined) map.items.push(nc.createPair(key, value));
+		};
+		if (obj instanceof Map) for (const [key, value] of obj) add(key, value);
+		else if (obj && typeof obj === "object") for (const key of Object.keys(obj)) add(key, obj[key]);
+		if (typeof nc.schema.sortMapEntries === "function") map.items.sort(nc.schema.sortMapEntries);
+		return map;
+	}
+	/**
+	* Adds a key-value pair to the map.
+	*
+	* Using a key that is already in the collection overwrites the previous value.
+	*/
+	add(pair) {
+		if (!(pair instanceof Pair)) throw new TypeError("Expected a Pair");
+		const prev = findPair(this.items, pair.key);
+		const sortEntries = this.schema?.sortMapEntries;
+		if (prev) if (prev.value instanceof Scalar && pair.value instanceof Scalar) prev.value.value = pair.value.value;
+		else prev.value = pair.value;
+		else if (sortEntries) {
+			const i = this.items.findIndex((item) => sortEntries(pair, item) < 0);
+			if (i === -1) this.items.push(pair);
+			else this.items.splice(i, 0, pair);
+		} else this.items.push(pair);
+	}
+	delete(key) {
+		const it = findPair(this.items, key);
+		if (!it) return false;
+		return this.items.splice(this.items.indexOf(it), 1).length > 0;
+	}
+	get(key) {
+		return findPair(this.items, key)?.value ?? void 0;
+	}
+	has(key) {
+		return !!findPair(this.items, key);
+	}
+	set(key, value, options) {
+		let pair;
+		if (key instanceof NodeBase && (value instanceof NodeBase || value === null)) pair = new Pair(key, value);
+		else if (!this.schema) throw new Error("Schema is required");
+		else {
+			const nc = new NodeCreator(this.schema, {
+				...options,
+				aliasDuplicateObjects: false
+			});
+			pair = nc.createPair(key, value);
+			nc.setAnchors();
+		}
+		this.add(pair);
+	}
+	toJSON(_, ctx, Type) {
+		const map = Type ? new Type() : ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {};
+		if (ctx?.onCreate) ctx.onCreate(map);
+		for (const item of this.items) addPairToJSMap(ctx, map, item);
+		return map;
+	}
+	toString(ctx, onComment, onChompKeep) {
+		if (!ctx) return JSON.stringify(this);
+		for (const item of this.items) if (!(item instanceof Pair)) throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);
+		return stringifyCollection(this, ctx, {
+			blockItemPrefix: "",
+			flowChars: {
+				start: "{",
+				end: "}"
+			},
+			itemIndent: ctx.indent || "",
+			onChompKeep,
+			onComment
+		});
+	}
+};
+
+//#endregion
+//#region src/schema/common/map.ts
+const map = {
+	collection: "map",
+	default: true,
+	nodeClass: YAMLMap,
+	tag: "tag:yaml.org,2002:map",
+	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",
+	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)) {
+		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.items.length; ++i) {
+		const item = seq.items[i];
+		if (item instanceof Pair) continue;
+		else if (item instanceof YAMLMap) {
+			if (item.items.length > 1) onError("Each pair must have its own sequence indicator");
+			const pair = item.items[0] || 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.items[i] = pair;
+		} else seq.items[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.items.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 YAMLOMap extends YAMLSeq {
+	static tag = "tag:yaml.org,2002:omap";
+	constructor(schema) {
+		super(schema);
+		this.tag = YAMLOMap.tag;
+	}
+	add = YAMLMap.prototype.add.bind(this);
+	delete = YAMLMap.prototype.delete.bind(this);
+	get = YAMLMap.prototype.get.bind(this);
+	has = YAMLMap.prototype.has.bind(this);
+	set = YAMLMap.prototype.set.bind(this);
+	/**
+	* If `ctx` is given, the return type is actually `Map<unknown, unknown>`,
+	* but TypeScript won't allow widening the signature of a child method.
+	*/
+	toJSON(_, ctx) {
+		if (!ctx) return super.toJSON(_);
+		const map = /* @__PURE__ */ new Map();
+		if (ctx?.onCreate) ctx.onCreate(map);
+		for (const pair of this.items) {
+			let key, value;
+			if (pair instanceof Pair) {
+				key = toJS(pair.key, "", ctx);
+				value = toJS(pair.value, key, ctx);
+			} else key = toJS(pair, "", ctx);
+			if (map.has(key)) throw new Error("Ordered maps must not include duplicate keys");
+			map.set(key, value);
+		}
+		return map;
+	}
+	static from(nc, iterable) {
+		const pairs = createPairs(nc, iterable);
+		const omap = new this(nc.schema);
+		omap.items = pairs.items;
+		return omap;
+	}
+};
+const omap = {
+	collection: "seq",
+	identify: (value) => value instanceof Map,
+	nodeClass: YAMLOMap,
+	default: false,
+	tag: "tag:yaml.org,2002:omap",
+	resolve(seq, onError) {
+		const pairs = resolvePairs(seq, onError);
+		const seenKeys = [];
+		for (const { key } of pairs.items) 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(), 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
+var YAMLSet = class YAMLSet extends YAMLMap {
+	static tag = "tag:yaml.org,2002:set";
+	constructor(schema) {
+		super(schema);
+		this.tag = YAMLSet.tag;
+	}
+	/**
+	* Add a value to the set.
+	*
+	* If `value` is a Pair, its `.value` must be null and `options` is ignored.
+	*
+	* If the set already includes a matching value, no value is added.
+	*/
+	add(value, options) {
+		if (!(value instanceof Pair)) this.set(value, true, options);
+		else if (value.value !== null) throw new TypeError("set pair values must be null");
+		else if (!findPair(this.items, value.key)) this.items.push(value);
+	}
+	/**
+	* Returns the value matching `key`.
+	*/
+	get(key) {
+		return findPair(this.items, key)?.key;
+	}
+	/**
+	* `value` needs to be true/false to add/remove the item from the set.
+	*/
+	set(key, value, options) {
+		if (typeof value !== "boolean") throw new Error(`Expected a boolean value, not ${typeof value}`);
+		const prev = findPair(this.items, key);
+		if (prev && !value) this.items.splice(this.items.indexOf(prev), 1);
+		else if (!prev && value) {
+			let node;
+			if (key instanceof NodeBase) node = key;
+			else if (!this.schema) throw new Error("Schema is required");
+			else {
+				const nc = new NodeCreator(this.schema, {
+					...options,
+					aliasDuplicateObjects: false
+				});
+				node = nc.create(key);
+				nc.setAnchors();
+			}
+			this.items.push(new Pair(node));
+		}
+	}
+	toJSON(_, ctx) {
+		return super.toJSON(_, ctx, Set);
+	}
+	toString(ctx, onComment, onChompKeep) {
+		if (!ctx) return JSON.stringify(this);
+		return super.toString({
+			...ctx,
+			noValues: true
+		}, onComment, onChompKeep);
+	}
+	static from(nc, iterable) {
+		const set = new this(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);
+			set.items.push(nc.createPair(value, null));
+		}
+		return set;
+	}
+};
+const hasAllNullValues = (map) => map.items.every(({ value }) => value == null || value instanceof Scalar && value.value == null && !value.commentBefore && !value.comment && !value.tag);
+const set = {
+	collection: "map",
+	identify: (value) => value instanceof Set,
+	nodeClass: YAMLSet,
+	default: false,
+	tag: "tag:yaml.org,2002:set",
+	resolve(map, onError) {
+		if (!(map instanceof YAMLMap)) {
+			onError("Expected a mapping for this tag");
+			return map;
+		} else if (!hasAllNullValues(map)) {
+			onError("Set items must all have null values");
+			return map;
+		} else {
+			const set = Object.assign(new YAMLSet(), map);
+			for (const pair of map.items) pair.value &&= null;
+			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.concat(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.concat(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
+const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+var Schema = class Schema {
+	compat;
+	knownTags;
+	name;
+	sortMapEntries;
+	tags;
+	toStringOptions;
+	constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
+		this.compat = Array.isArray(compat) ? getTags(compat, "compat") : compat ? getTags(null, compat) : null;
+		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 });
+		this.sortMapEntries = typeof sortMapEntries === "function" ? sortMapEntries : sortMapEntries === true ? sortMapEntriesByKey : null;
+	}
+	clone() {
+		const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));
+		copy.tags = this.tags.slice();
+		return copy;
+	}
+};
+
+//#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/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,
+			uniqueKeys: true,
+			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;
+	}
+	/** Adds a value to the document. */
+	add(value) {
+		assertCollection(this.value).add(value);
+	}
+	/** Adds a value to the document. */
+	addIn(path, value) {
+		assertCollection(this.value).addIn(path, value);
+	}
+	/**
+	* 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.concat(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;
+	}
+	/**
+	* Removes a value from the document.
+	* @returns `true` if the item was found and removed.
+	*/
+	delete(key) {
+		return assertCollection(this.value).delete(key);
+	}
+	/**
+	* Removes a value from the document.
+	* @returns `true` if the item was found and removed.
+	*/
+	deleteIn(path) {
+		if (!path.length) {
+			this.value = new Scalar(null);
+			return true;
+		}
+		return assertCollection(this.value).deleteIn(path);
+	}
+	/**
+	* Returns item at `key`, or `undefined` if not found.
+	*/
+	get(key) {
+		return this.value instanceof Collection ? this.value.get(key) : void 0;
+	}
+	/**
+	* Returns item at `path`, or `undefined` if not found.
+	*/
+	getIn(path) {
+		if (!path.length) return this.value;
+		return this.value instanceof Collection ? this.value.getIn(path) : void 0;
+	}
+	/**
+	* Checks if the document includes a value with the key `key`.
+	*/
+	has(key) {
+		return this.value instanceof Collection ? this.value.has(key) : false;
+	}
+	/**
+	* Checks if the document includes a value at `path`.
+	*/
+	hasIn(path) {
+		if (!path.length) return true;
+		return this.value instanceof Collection ? this.value.hasIn(path) : false;
+	}
+	/**
+	* Sets a value in this document. For `!!set`, `value` needs to be a
+	* boolean to add/remove the item from the set.
+	*/
+	set(key, value) {
+		assertCollection(this.value).set(key, value);
+	}
+	/**
+	* Sets a value in this document. For `!!set`, `value` needs to be a
+	* boolean to add/remove the item from the set.
+	*/
+	setIn(path, value) {
+		if (!path.length) this.value = value;
+		else assertCollection(this.value).setIn(path, 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`);
+	}
+	toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
+		const ctx = {
+			anchors: /* @__PURE__ */ new Map(),
+			doc: this,
+			keep: !json,
+			mapAsMap: mapAsMap === true,
+			mapKeyWarned: false,
+			maxAliasCount: typeof maxAliasCount === "number" ? maxAliasCount : 100
+		};
+		const res = toJS(this.value, jsonArg ?? "", 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`.
+	*
+	* @param jsonArg Used by `JSON.stringify` to indicate the array index or
+	*   property name.
+	*/
+	toJSON(jsonArg, onAnchor) {
+		return this.toJS({
+			json: true,
+			jsonArg,
+			mapAsMap: false,
+			onAnchor
+		});
+	}
+	/** 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);
+	}
+};
+function assertCollection(value) {
+	if (value instanceof Collection) return value;
+	throw new Error("Expected a YAML collection as document value");
+}
+
+//#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_, Object.freeze([node])) === REMOVE) node.value = new Scalar(null);
+	} else visit_(null, node, visitor_, Object.freeze([]));
+};
+visit.BREAK = BREAK;
+visit.SKIP = SKIP;
+visit.REMOVE = REMOVE;
+function visit_(key, node, visitor, path) {
+	const ctrl = callVisitor(key, node, visitor, path);
+	if (ctrl instanceof NodeBase || ctrl instanceof Pair) {
+		replaceNode(key, path, ctrl);
+		return visit_(key, ctrl, visitor, path);
+	}
+	if (typeof ctrl !== "symbol") {
+		if (node instanceof YAMLMap || node instanceof YAMLSeq) {
+			path = Object.freeze(path.concat(node));
+			for (let i = 0; i < node.items.length; ++i) {
+				const ci = visit_(i, node.items[i], visitor, path);
+				if (typeof ci === "number") i = ci - 1;
+				else if (ci === BREAK) return BREAK;
+				else if (ci === REMOVE) {
+					node.items.splice(i, 1);
+					i -= 1;
+				}
+			}
+		} else if (node instanceof Pair) {
+			path = Object.freeze(path.concat(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_, Object.freeze([node])) === REMOVE) node.value = new Scalar(null);
+	} else await visitAsync_(null, node, visitor_, Object.freeze([]));
+};
+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 (ctrl instanceof NodeBase || ctrl instanceof Pair) {
+		replaceNode(key, path, ctrl);
+		return visitAsync_(key, ctrl, visitor, path);
+	}
+	if (typeof ctrl !== "symbol") {
+		if (node instanceof YAMLMap || node instanceof YAMLSeq) {
+			path = Object.freeze(path.concat(node));
+			for (let i = 0; i < node.items.length; ++i) {
+				const ci = await visitAsync_(i, node.items[i], visitor, path);
+				if (typeof ci === "number") i = ci - 1;
+				else if (ci === BREAK) return BREAK;
+				else if (ci === REMOVE) {
+					node.items.splice(i, 1);
+					i -= 1;
+				}
+			}
+		} else if (node instanceof Pair) {
+			path = Object.freeze(path.concat(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) 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 YAMLMap || parent instanceof YAMLSeq) parent.items[key] = node;
+	else if (parent instanceof Pair) if (node instanceof NodeBase) 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) parent.value = node;
+	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 instanceof NodeBase && 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 { toJS as S, Collection as _, Schema as a, Scalar as b, seq as c, findPair as d, Alias as f, YAMLSeq as g, warn as h, Document as i, map as l, debug as m, visit as n, stringifyNumber as o, Pair as p, visitAsync as r, string as s, Directives as t, YAMLMap as u, stringifyString as v, NodeBase as x, foldFlowLines as y };