npm - yaml - Versions diffs - 3.0.0-0 → 3.0.0-2 - Mend

yaml 3.0.0-0 → 3.0.0-2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/dist/cli.js +4 -5
package/dist/directives-CGITitH5.d.ts +1377 -0
package/dist/{directives-CG6n4xSM.js → directives-DqP9ea45.js} +1252 -1010
package/dist/index.d.ts +201 -211
package/dist/index.js +4 -5
package/dist/{line-counter-TFl552k_.js → line-counter-B2FjSv3E.js} +346 -296
package/dist/{public-api-BE74JyVm.js → public-api-uicovB0N.js} +7 -7
package/dist/rolldown-runtime-D7D4PA-g.js +13 -0
package/dist/test-events.js +17 -12
package/dist/util.d.ts +2 -2
package/dist/util.js +2 -3
package/package.json +6 -6
package/dist/chunk-BYypO7fO.js +0 -18
package/dist/stringifyString-S_ITVLTO.d.ts +0 -1306

package/dist/{directives-CG6n4xSM.js → directives-DqP9ea45.js} RENAMED Viewed

@@ -1,104 +1,5 @@
-//#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 {
+var Scalar = class {
 	static BLOCK_FOLDED = "BLOCK_FOLDED";
 	static BLOCK_LITERAL = "BLOCK_LITERAL";
 	static PLAIN = "PLAIN";
@@ -106,17 +7,27 @@ var Scalar = class extends NodeBase {
 	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);
+	/** Create a copy of this node.  */
+	clone() {
+		const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+		if (this.range) copy.range = [...this.range];
+		return copy;
+	}
+	/** A plain JavaScript representation of this node. */
+	toJS(_doc, ctx) {
+		if (ctx && this.anchor) ctx.anchors.set(this, {
+			aliasCount: 0,
+			count: 1,
+			res: this.value
+		});
+		return this.value;
 	}
 	toString() {
 		return String(this.value);
 	}
 };
 //#endregion
 //#region src/stringify/foldFlowLines.ts
 const FOLD_FLOW = "flow";
@@ -135,20 +46,22 @@ function foldFlowLines(text, indent, mode = "flow", { indentAtStart, lineWidth =
 	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;
+	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) {
+	if (mode === "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 === "\\") {
+		if (mode === "quoted" && ch === "\\") {
 			escStart = i;
 			switch (text[i + 1]) {
 				case "x":
@@ -165,7 +78,7 @@ function foldFlowLines(text, indent, mode = "flow", { indentAtStart, lineWidth =
 			escEnd = i;
 		}
 		if (ch === "\n") {
-			if (mode === FOLD_BLOCK) i = consumeMoreIndentedLines(text, i, indent.length);
+			if (mode === "block") i = consumeMoreIndentedLines(text, i, indent.length);
 			end = i + indent.length + endStep;
 			split = void 0;
 		} else {
@@ -173,23 +86,25 @@ function foldFlowLines(text, indent, mode = "flow", { indentAtStart, lineWidth =
 				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;
+			if (i >= end) {
+				if (split) {
+					folds.push(split);
+					end = split + endStep;
+					split = void 0;
+				} else if (mode === "quoted") {
+					while (prev === " " || prev === "	") {
+						prev = ch;
+						ch = text[i += 1];
+						overflow = true;
+					}
+					const j = i > escEnd + 1 ? i - 2 : escStart - 1;
+					if (escapedFolds[j]) return text;
+					folds.push(j);
+					escapedFolds[j] = true;
+					end = j + endStep;
+					split = void 0;
+				} else overflow = true;
+			}
 		}
 		prev = ch;
 	}
@@ -202,7 +117,7 @@ function foldFlowLines(text, indent, mode = "flow", { indentAtStart, lineWidth =
 		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]}\\`;
+			if (mode === "quoted" && escapedFolds[fold]) res += `${text[fold]}\\`;
 			res += `\n${indent}${text.slice(fold + 1, end)}`;
 		}
 	}
@@ -227,7 +142,6 @@ function consumeMoreIndentedLines(text, i, indent) {
 	}
 	return end;
 }
 //#endregion
 //#region src/stringify/stringifyString.ts
 const getFoldOptions = (ctx, isBlock) => ({
@@ -341,7 +255,7 @@ function quotedString(value, ctx) {
 }
 let blockEndNewlines;
 try {
-	blockEndNewlines = /* @__PURE__ */ new RegExp("(^|(?<!\n))\n+(?!\n|$)", "g");
+	blockEndNewlines = new RegExp("(^|(?<!\n))\n+(?!\n|$)", "g");
 } catch {
 	blockEndNewlines = /\n+(?!\n|$)/g;
 }
@@ -415,7 +329,7 @@ function plainString(item, ctx, onComment, onChompKeep) {
 	}
 	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 test = (tag) => tag.default && tag.tag !== "tag:yaml.org,2002:str" && tag.test?.(str);
 		const { compat, tags } = ctx.doc.schema;
 		if (tags.some(test) || compat?.some(test)) return quotedString(value, ctx);
 	}
@@ -447,7 +361,6 @@ function stringifyString(item, ctx, onComment, onChompKeep) {
 	}
 	return res;
 }
 //#endregion
 //#region src/doc/anchors.ts
 /**
@@ -476,7 +389,6 @@ function findNewAnchor(prefix, exclude) {
 		if (!exclude.has(name)) return name;
 	}
 }
 //#endregion
 //#region src/doc/NodeCreator.ts
 const defaultTagPrefix = "tag:yaml.org,2002:";
@@ -484,7 +396,6 @@ var NodeCreator = class {
 	keepUndefined;
 	replacer;
 	schema;
-	#aliasDuplicateObjects;
 	#anchorPrefix;
 	#aliasObjects = [];
 	#doc;
@@ -497,24 +408,19 @@ var NodeCreator = class {
 		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;
+			if (options.aliasDuplicateObjects ?? true) this.#doc = docOrSchema;
 			this.schema = docOrSchema.schema;
 		} else this.schema = docOrSchema;
 	}
 	create(value, tagName) {
 		if (value instanceof Document) value = value.value;
-		if (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 (isNode(value)) return value;
+		if (value instanceof Pair) return this.schema.map.createNode(this, null).set(value);
 		if (value instanceof String || value instanceof Number || value instanceof Boolean || typeof BigInt !== "undefined" && value instanceof BigInt) value = value.valueOf();
 		let ref = void 0;
-		if (this.#aliasDuplicateObjects && value && typeof value === "object") {
+		if (this.#doc && value && typeof value === "object") {
 			ref = this.#sourceObjects.get(value);
 			if (ref) {
 				if (!ref.anchor) {
@@ -552,11 +458,11 @@ var NodeCreator = class {
 			this.#onTagObj(tagObj);
 			this.#onTagObj = void 0;
 		}
-		const node = tagObj?.createNode?.(this, value) ?? tagObj?.nodeClass?.from?.(this, value) ?? new Scalar(value);
+		const node = tagObj?.createNode?.(this, value) ?? new Scalar(value);
 		if (tagName) node.tag = tagName;
 		else if (!tagObj.default) node.tag = tagObj.tag;
 		if (ref) ref.node = node;
-		if (this.#flow && node instanceof Collection) node.flow = true;
+		if (this.#flow && isCollection(node)) node.flow = true;
 		return node;
 	}
 	createPair(key, value) {
@@ -570,109 +476,11 @@ var NodeCreator = class {
 	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}`);
+			if (typeof ref === "object" && ref.anchor && (ref.node instanceof Scalar || isCollection(ref.node))) ref.node.anchor = ref.anchor;
+			else throw Object.assign(/* @__PURE__ */ new Error("Failed to resolve repeated object (this should not happen)"), { source });
 		}
 	}
 };
 //#endregion
 //#region src/stringify/stringifyComment.ts
 /**
@@ -688,29 +496,104 @@ function indentComment(comment, indent) {
 	return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;
 }
 const lineComment = (str, indent, comment) => str.endsWith("\n") ? indentComment(comment, indent) : comment.includes("\n") ? "\n" + indentComment(comment, indent) : (str.endsWith(" ") ? "" : " ") + comment;
+//#endregion
+//#region src/log.ts
+function debug(logLevel, ...messages) {
+	if (logLevel === "debug") console.log(...messages);
+}
+function warn(logLevel, warning) {
+	if (logLevel === "debug" || logLevel === "warn") {
+		if (typeof process !== "undefined" && typeof process.emitWarning === "function") process.emitWarning(warning);
+		else console.warn(warning);
+	}
+}
+//#endregion
+//#region src/schema/yaml-1.1/merge.ts
+const MERGE_KEY = "<<";
+const merge = {
+	identify: (value) => value === MERGE_KEY || typeof value === "symbol" && value.description === MERGE_KEY,
+	default: "key",
+	tag: "tag:yaml.org,2002:merge",
+	test: (str) => str === MERGE_KEY,
+	resolve: () => Object.assign(new Scalar(Symbol(MERGE_KEY)), { addToJSMap: addMergeToJSMap }),
+	stringify: () => MERGE_KEY
+};
+const isMergeKey = (doc, key) => (merge.identify(key) || key instanceof Scalar && (!key.type || key.type === Scalar.PLAIN) && merge.identify(key.value)) && Boolean(doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default));
+function addMergeToJSMap(doc, ctx, map, value, isPlainObject) {
+	const source = getMergeSource(doc, ctx, value);
+	if (Array.isArray(source)) for (const it of source) mergeValue(doc, ctx, map, it, isPlainObject);
+	else mergeValue(doc, ctx, map, value, isPlainObject);
+}
+function mergeValue(doc, ctx, map, value, isPlainObject) {
+	const srcMap = getMergeSource(doc, ctx, value).toJS(doc, ctx, Map);
+	if (!(srcMap instanceof Map)) throw new Error("Merge sources must be maps or map aliases");
+	for (const [key, value] of srcMap) if (map instanceof Map) {
+		if (!map.has(key)) map.set(key, value);
+	} else if (map instanceof Set) map.add(key);
+	else if (!Object.prototype.hasOwnProperty.call(map, key)) {
+		if (!isPlainObject || key === "__proto__" || key === "constructor") Object.defineProperty(map, key, {
+			value,
+			writable: true,
+			enumerable: true,
+			configurable: true
+		});
+		else map[key] = value;
+	}
+	return map;
+}
+function getMergeSource(doc, ctx, value) {
+	if (!(value instanceof Alias)) return value;
+	const source = value.resolve(doc, ctx);
+	if (!source) {
+		const msg = `Unresolved alias (the anchor must be set before the alias): ${value.source}`;
+		throw new ReferenceError(msg);
+	}
+	ctx.resolveAlias(doc, source);
+	return source;
+}
 //#endregion
 //#region src/stringify/stringify.ts
+const defaultStringifyOptions = {
+	blockQuote: true,
+	commentString: stringifyComment,
+	defaultKeyType: null,
+	defaultStringType: "PLAIN",
+	directives: null,
+	doubleQuotedAsJSON: false,
+	doubleQuotedMinMultiLineLength: 40,
+	falseStr: "false",
+	flowCollectionPadding: true,
+	indentSeq: true,
+	lineWidth: 80,
+	minContentWidth: 20,
+	nullStr: "null",
+	simpleKeys: false,
+	singleQuote: null,
+	sortMapEntries: false,
+	trailingComma: false,
+	trueStr: "true",
+	verifyAliasOrder: true
+};
+const resolvedCache = /* @__PURE__ */ new WeakMap();
+function getResolvedOptions(schema) {
+	const key = schema.toStringOptions ?? defaultStringifyOptions;
+	let resolved = resolvedCache.get(key);
+	if (!resolved) {
+		resolved = schema.toStringOptions ? {
+			...defaultStringifyOptions,
+			...schema.toStringOptions
+		} : defaultStringifyOptions;
+		resolvedCache.set(key, resolved);
+	}
+	return resolved;
+}
+const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
 function createStringifyContext(doc, options) {
-	const opt = Object.assign({
-		blockQuote: true,
-		commentString: stringifyComment,
-		defaultKeyType: null,
-		defaultStringType: "PLAIN",
-		directives: null,
-		doubleQuotedAsJSON: false,
-		doubleQuotedMinMultiLineLength: 40,
-		falseStr: "false",
-		flowCollectionPadding: true,
-		indentSeq: true,
-		lineWidth: 80,
-		minContentWidth: 20,
-		nullStr: "null",
-		simpleKeys: false,
-		singleQuote: null,
-		trueStr: "true",
-		verifyAliasOrder: true
-	}, doc.schema.toStringOptions, options);
+	const resolved = getResolvedOptions(doc.schema);
+	const opt = options ? {
+		...resolved,
+		...options
+	} : resolved;
 	let inFlow;
 	switch (opt.collectionStyle) {
 		case "block":
@@ -721,6 +604,7 @@ function createStringifyContext(doc, options) {
 			break;
 		default: inFlow = null;
 	}
+	const sortMapEntries = typeof opt.sortMapEntries === "function" ? opt.sortMapEntries : opt.sortMapEntries === true ? sortMapEntriesByKey : null;
 	return {
 		anchors: /* @__PURE__ */ new Set(),
 		doc,
@@ -728,7 +612,8 @@ function createStringifyContext(doc, options) {
 		indent: "",
 		indentStep: typeof opt.indent === "number" ? " ".repeat(opt.indent) : "  ",
 		inFlow,
-		options: opt
+		options: opt,
+		sortMapEntries
 	};
 }
 function getTagObject(tags, item) {
@@ -736,7 +621,7 @@ function getTagObject(tags, item) {
 		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 tagObj;
 	let obj;
 	if (item instanceof Scalar) {
 		obj = item.value;
@@ -759,7 +644,7 @@ function getTagObject(tags, item) {
 function stringifyProps(node, tagObj, { anchors, doc }) {
 	if (!doc.directives) return "";
 	const props = [];
-	const anchor = (node instanceof Scalar || node instanceof Collection) && node.anchor;
+	const anchor = node.anchor;
 	if (anchor && anchorIsValid(anchor)) {
 		anchors.add(anchor);
 		props.push(`&${anchor}`);
@@ -768,19 +653,17 @@ function stringifyProps(node, tagObj, { anchors, doc }) {
 	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);
-		}
+function stringify(node, ctx, onComment, onChompKeep) {
+	if (node instanceof Pair) return node.toString(ctx, onComment, onChompKeep);
+	if (node instanceof Alias) {
+		if (ctx.doc.directives) return node.toString(ctx);
+		if (ctx.resolvedAliases?.has(node)) throw new TypeError("Cannot stringify circular structure without alias nodes");
+		if (ctx.resolvedAliases) ctx.resolvedAliases.add(node);
+		else ctx.resolvedAliases = /* @__PURE__ */ new Set([node]);
+		node = node.resolve(ctx.doc) ?? null;
 	}
 	let tagObj = void 0;
-	const node = item instanceof NodeBase ? item : ctx.doc.createNode(item, { onTagObj: (o) => tagObj = o });
+	node ??= ctx.doc.createNode(null, { onTagObj: (o) => tagObj = o });
 	tagObj ??= getTagObject(ctx.doc.schema.tags, node);
 	const props = stringifyProps(node, tagObj, ctx);
 	if (props.length > 0) ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;
@@ -788,242 +671,720 @@ function stringify(item, 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);
+//#region src/nodes/addPairToJSMap.ts
+function addPairToJSMap(doc, ctx, map, { key, value }, isPlainObject) {
+	if ("addToJSMap" in key) key.addToJSMap?.(doc, ctx, map, value, isPlainObject);
+	else if (isMergeKey(doc, key)) addMergeToJSMap(doc, ctx, map, value, isPlainObject);
+	else {
+		const jsKey = key.toJS(doc, ctx);
+		if (map instanceof Map) map.set(jsKey, value ? value.toJS(doc, ctx) : value);
+		else if (map instanceof Set) map.add(jsKey);
+		else {
+			const stringKey = stringifyKey(doc, ctx, key, jsKey);
+			const jsValue = value ? value.toJS(doc, ctx) : value;
+			if (!isPlainObject && stringKey in map || stringKey === "__proto__" || stringKey === "constructor") Object.defineProperty(map, stringKey, {
+				value: jsValue,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+			else map[stringKey] = jsValue;
+		}
+	}
+	return map;
 }
-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);
+function stringifyKey(doc, ctx, key, jsKey) {
+	if (jsKey === null) return "";
+	if (typeof jsKey !== "object") return String(jsKey);
+	const strCtx = createStringifyContext(doc, void 0);
+	for (const node of ctx.anchors.keys()) strCtx.anchors.add(node.anchor);
+	strCtx.inFlow = true;
+	strCtx.inStringifyKey = true;
+	const strKey = key.toString(strCtx);
+	if (!ctx.mapKeyWarned) {
+		let jsonStr = JSON.stringify(strKey);
+		if (jsonStr.length > 40) jsonStr = jsonStr.substring(0, 36) + "...\"";
+		const msg = `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use a Map instead.`;
+		warn(doc.options.logLevel, msg);
+		ctx.mapKeyWarned = true;
+	}
+	return strKey;
+}
+//#endregion
+//#region src/nodes/util-clone-map-or-set.ts
+function cloneMapOrSet(coll, schema) {
+	schema ??= coll.schema;
+	const copy = new coll.constructor(schema);
+	for (const [key, value] of coll.values) copy.values.set(key, value.clone(schema));
+	if (coll.range) copy.range = [...coll.range];
+	const propDesc = Object.getOwnPropertyDescriptors(coll);
+	for (const [name, prop] of Object.entries(propDesc)) if (!(name in copy)) Object.defineProperty(copy, name, prop);
+	return copy;
+}
+//#endregion
+//#region src/nodes/YAMLMap.ts
+var YAMLMap = class {
+	static tagName = "tag:yaml.org,2002:map";
+	values = /* @__PURE__ */ new Map();
+	/**
+	* A generic collection factory method that can be used
+	* by other node classes that inherit from YAMLMap
+	*/
+	static create(nc, obj) {
+		const { replacer } = nc;
+		const map = new this(nc.schema);
+		if (obj && typeof obj === "object") {
+			const iter = obj instanceof Map ? obj : Object.entries(obj);
+			for (let [key, value] of iter) {
+				if (replacer) {
+					if (typeof replacer === "function") value = replacer.call(obj, key, value);
+					else if (Array.isArray(replacer) && !replacer.includes(key)) continue;
+				}
+				if (value !== void 0 || nc.keepUndefined) {
+					const mk = nc.schema.mapKey(key);
+					const pair = nc.createPair(key, value);
+					map.values.set(mk, pair);
+				}
 			}
 		}
-		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);
+		return map;
 	}
-	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";
+	constructor(schema, elements) {
+		Object.defineProperty(this, "schema", {
+			value: schema,
+			configurable: true,
+			enumerable: false,
+			writable: true
+		});
+		this.values = new Map(elements?.map((pair) => [this.schema.mapKey(pair), pair]));
+	}
+	get size() {
+		return this.values.size;
+	}
+	/**
+	* Create a copy of this map.
+	*
+	* @param schema - If defined, overwrites the original's schema
+	*/
+	clone(schema) {
+		return cloneMapOrSet(this, schema);
+	}
+	/**
+	* Remove a value from the mapping.
+	* @returns `true` if the item was found and removed.
+	*/
+	delete(key) {
+		let mk = this.schema.mapKey(key);
+		if (this.values.delete(mk)) return true;
+		mk = key instanceof Pair ? key.key : isNode(key) ? key : null;
+		if (mk) {
+			for (const [k, p] of this.values) if (p.key === mk) return this.values.delete(k);
 		}
+		return false;
 	}
-	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;
+	/** Return value at `key`, or `undefined` if not found.  */
+	get(key) {
+		return this.getPair(key)?.value;
+	}
+	/** Return pair at `key`, or `undefined` if not found.  */
+	getPair(key) {
+		let mk = this.schema.mapKey(key);
+		const pair = this.values.get(mk);
+		if (pair) return pair;
+		mk = key instanceof Pair ? key.key : isNode(key) ? key : null;
+		if (mk) {
+			for (const p of this.values.values()) if (p.key === mk) return p;
+		}
+	}
+	/** Check if the mapping includes a value with the key `key`.  */
+	has(key) {
+		let mk = this.schema.mapKey(key);
+		if (this.values.has(mk)) return true;
+		mk = key instanceof Pair ? key.key : isNode(key) ? key : null;
+		if (mk) {
+			for (const p of this.values.values()) if (p.key === mk) return true;
+		}
+		return false;
+	}
+	/**
+	* Return the internal Map key matching `key`, or `undefined` if not found.
+	*
+	* @param allowMissing - If `true`, a key is always returned,
+	*                       even if the key is not in the map.
+	*/
+	keyOf(key, allowMissing = false) {
+		let mk = this.schema.mapKey(key);
+		if (allowMissing || this.values.has(mk)) return mk;
+		mk = key instanceof Pair ? key.key : isNode(key) ? key : null;
+		if (mk) {
+			for (const [k, v] of this.values) if (v.key === mk) return k;
+		}
+	}
+	pairs() {
+		return this.values.values();
+	}
+	set(keyOrPair, value, options) {
+		const mk = this.schema.mapKey(keyOrPair);
+		let pair;
+		if (keyOrPair instanceof Pair) pair = keyOrPair;
+		else if (isNode(keyOrPair) && (value == null || isNode(value))) pair = new Pair(keyOrPair, value ?? null);
+		else pair = new NodeCreator(this.schema, options).createPair(keyOrPair, value);
+		if (pair.value instanceof Scalar) {
+			const prev = this.values.get(mk);
+			if (prev) {
+				if (!prev.value) {
+					prev.value = pair.value;
+					return this;
+				}
+				if (prev.value instanceof Scalar) {
+					Object.assign(prev.value, pair.value);
+					return this;
+				}
+			}
+		}
+		this.values.set(mk, pair);
+		return this;
+	}
+	toJS(doc, ctx, Type) {
+		ctx ??= new ToJSContext();
+		let map;
+		let isPlainObject = false;
+		if (Type) map = new Type();
+		else if (ctx.mapAsMap) map = /* @__PURE__ */ new Map();
+		else {
+			map = {};
+			isPlainObject = true;
+		}
+		if (this.anchor) ctx.setAnchor(this, map);
+		for (const pair of this.values.values()) addPairToJSMap(doc, ctx, map, pair, isPlainObject);
+		return map;
+	}
+	toString(ctx, onComment, onChompKeep) {
+		if (!ctx) return JSON.stringify(this);
+		let pairs = this.values.values();
+		if (ctx.sortMapEntries) pairs = Array.from(pairs).sort(ctx.sortMapEntries);
+		return ctx.inFlow ?? this.flow ? this.#stringifyFlowMap(ctx, pairs) : this.#stringifyBlockMap(ctx, pairs, onComment, onChompKeep);
+	}
+	#stringifyBlockMap(ctx, pairs, onComment, onChompKeep) {
+		const { indent, options: { commentString } } = ctx;
+		let chompKeep = false;
+		const lines = [];
+		for (const pair of pairs) {
+			let comment = null;
+			if (!chompKeep && pair.key.spaceBefore) lines.push("");
+			let cb = pair.key.commentBefore;
+			if (cb && chompKeep) cb = cb.replace(/^\n+/, "");
+			if (cb) {
+				const ic = indentComment(commentString(cb), indent).trimStart();
+				lines.push(ic);
+			}
+			chompKeep = false;
+			let str = stringifyPair(pair, ctx, () => comment = null, () => chompKeep = true);
+			if (comment) str += lineComment(str, indent, commentString(comment));
+			if (chompKeep && comment) chompKeep = false;
+			lines.push(str);
+		}
+		let str;
+		if (lines.length === 0) str = "{}";
+		else {
+			str = lines[0];
+			for (let i = 1; i < lines.length; ++i) {
+				const line = lines[i];
+				str += line ? `\n${indent}${line}` : "\n";
 			}
-			const iv = item.value instanceof NodeBase ? item.value : null;
+		}
+		if (this.comment) {
+			str += "\n" + indentComment(commentString(this.comment), indent);
+			onComment?.();
+		} else if (chompKeep) onChompKeep?.();
+		return str;
+	}
+	#stringifyFlowMap(ctx, pairs) {
+		const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString, lineWidth, trailingComma } } = ctx;
+		const itemIndent = indent + indentStep;
+		const itemCtx = {
+			...ctx,
+			indent: itemIndent,
+			inFlow: true
+		};
+		let reqNewline = false;
+		let linesAtValue = 0;
+		const lines = [];
+		let itemsLeft = this.values.size;
+		for (const pair of pairs) {
+			itemsLeft -= 1;
+			let comment = null;
+			const ik = pair.key;
+			if (ik.spaceBefore) {
+				lines.push("");
+				reqNewline = true;
+			}
+			if (ik.commentBefore) {
+				const ic = indentComment(commentString(ik.commentBefore), indent);
+				lines.push(ic.trimStart());
+				reqNewline = true;
+			}
+			if (ik.comment) reqNewline = true;
+			const iv = pair.value;
 			if (iv) {
 				if (iv.comment) comment = iv.comment;
 				if (iv.commentBefore) reqNewline = true;
-			} else if (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 {
+			} else if (ik?.comment) comment = ik.comment;
+			if (comment) reqNewline = true;
+			let str = stringifyPair(pair, itemCtx, () => comment = null);
+			reqNewline ||= lines.length > linesAtValue || str.includes("\n");
+			if (itemsLeft > 0) str += ",";
+			else if (trailingComma) {
+				if (!reqNewline && lineWidth > 0) reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str.length + 2) > lineWidth;
+				if (reqNewline) str += ",";
+			}
+			if (comment) str += lineComment(str, itemIndent, commentString(comment));
+			lines.push(str);
+			linesAtValue = lines.length;
+		}
+		if (lines.length === 0) return "{}";
 		if (!reqNewline) {
 			const len = lines.reduce((sum, line) => sum + line.length + 2, 2);
 			reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;
 		}
 		if (reqNewline) {
-			let str = start;
+			let str = "{";
 			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());
+			return `${str}\n${indent}}`;
+		}
+		return `{${fcPadding}${lines.join(" ")}${fcPadding}}`;
 	}
-}
+};
 //#endregion
 //#region src/nodes/YAMLSeq.ts
 const isScalarValue = (value) => !value || typeof value !== "function" && typeof value !== "object";
-var YAMLSeq = class extends Collection {
+var YAMLSeq = class extends Array {
 	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();
+	/**
+	* A generic collection factory method that can be extended
+	* to other node classes that inherit from YAMLSeq
+	*/
+	static create(nc, obj) {
+		const seq = new this(nc.schema);
+		if (obj && Symbol.iterator in Object(obj)) {
+			let i = 0;
+			for (let it of obj) {
+				if (typeof nc.replacer === "function") {
+					const key = obj instanceof Set ? it : String(i++);
+					it = nc.replacer.call(obj, key, it);
+				}
+				seq.push(nc.create(it));
+			}
 		}
+		return seq;
+	}
+	constructor(schema, elements = []) {
+		super(...nodeValues(schema, elements));
+		Object.defineProperty(this, "schema", {
+			value: schema,
+			configurable: true,
+			enumerable: false,
+			writable: true
+		});
+	}
+	get size() {
+		return this.length;
 	}
 	/**
-	* Removes a value from the collection.
-	*
-	* Throws if `idx` is not a non-negative integer.
+	* Create a copy of this collection.
 	*
-	* @returns `true` if the item was found and removed.
+	* @param schema - If defined, overwrites the original's schema
 	*/
-	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;
+	clone(schema) {
+		const copy = this.constructor.from(this, (it) => it.clone(schema));
+		if (this.range) copy.range = [...this.range];
+		const propDesc = Object.getOwnPropertyDescriptors(this);
+		for (const [name, prop] of Object.entries(propDesc)) if (!(name in copy)) Object.defineProperty(copy, name, prop);
+		if (schema) copy.schema = schema;
+		return copy;
 	}
 	/**
-	* Returns item at `key`, or `undefined` if not found.
+	* Change all elements within a range of indices in this sequence to a static value.
 	*
-	* Throws if `idx` is not a non-negative integer.
+	* Non-node values are converted to Node values.
 	*/
-	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];
+	fill(value, start, end) {
+		return super.fill(nodeValue(this.schema, value), start, end);
+	}
+	/** @private */
+	_push(item) {
+		super.push(item);
 	}
 	/**
-	* Checks if the collection includes a value with the key `key`.
+	* Append new elements to this sequence, and return its new length.
 	*
-	* Throws if `idx` is not a non-negative integer.
+	* Non-node values are converted to Node values.
 	*/
-	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;
+	push(...values) {
+		return super.push(...nodeValues(this.schema, values));
 	}
 	/**
-	* Sets a value in this collection. For `!!set`, `value` needs to be a
-	* boolean to add/remove the item from the set.
+	* Set a value in this sequence.
 	*
-	* Throws if `idx` is not a non-negative integer.
+	* Non-node values are converted to Node values.
 	*/
 	set(idx, value, options) {
 		if (!Number.isInteger(idx)) throw new TypeError(`Expected an integer, not ${JSON.stringify(idx)}.`);
-		if (idx < 0) throw new RangeError(`Invalid negative index ${idx}`);
-		const prev = this.items[idx];
+		const prev = this.at(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();
+			if (idx < 0) {
+				if (idx < -this.length) throw new RangeError(`Invalid index ${idx}`);
+				idx += this.length;
+			}
+			this[idx] = nodeValue(this.schema, value, options);
 		}
 	}
-	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;
+	/**
+	* Changes the contents of this sequence by removing or replacing existing elements
+	* and/or adding new elements in place.
+	*
+	* Non-node values are converted to Node values.
+	*/
+	splice(start, deleteCount, ...values) {
+		const nv = nodeValues(this.schema, values);
+		return arguments.length < 2 ? super.splice(start) : super.splice(start, Number(deleteCount), ...nv);
+	}
+	/**
+	* Prepend new elements to this sequence, and return its new length.
+	*
+	* Non-node values are converted to Node values.
+	*/
+	unshift(...values) {
+		return super.unshift(...nodeValues(this.schema, values));
+	}
+	/** A plain JavaScript representation of this node. */
+	toJS(doc, ctx) {
+		ctx ??= new ToJSContext();
+		if (this.anchor) {
+			const res = [];
+			if (this.anchor) ctx.setAnchor(this, res);
+			for (const item of this) res.push(item.toJS(doc, ctx));
+			return res;
+		}
+		return Array.from(this, (item) => item.toJS(doc, ctx));
 	}
 	toString(ctx, onComment, onChompKeep) {
 		if (!ctx) return JSON.stringify(this);
-		return stringifyCollection(this, ctx, {
-			blockItemPrefix: "- ",
-			flowChars: {
-				start: "[",
-				end: "]"
-			},
-			itemIndent: (ctx.indent || "") + "  ",
-			onChompKeep,
-			onComment
+		return ctx.inFlow ?? this.flow ? this.#stringifyFlowSeq(ctx) : this.#stringifyBlockSeq(ctx, onComment, onChompKeep);
+	}
+	#stringifyBlockSeq(ctx, onComment, onChompKeep) {
+		const { indent, options: { commentString } } = ctx;
+		const itemIndent = indent + "  ";
+		const itemCtx = {
+			...ctx,
+			indent: itemIndent
+		};
+		let chompKeep = false;
+		const lines = [];
+		for (let i = 0; i < this.length; ++i) {
+			const item = this[i];
+			let comment = null;
+			if (item instanceof Pair) {
+				if (!chompKeep && item.key.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, item.key.commentBefore, chompKeep);
+			} else if (item) {
+				if (!chompKeep && item.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, item.commentBefore, chompKeep);
+				if (item.comment) comment = item.comment;
+			}
+			chompKeep = false;
+			let str = stringify(item, itemCtx, () => comment = null, () => chompKeep = true);
+			if (comment) str += lineComment(str, itemIndent, commentString(comment));
+			if (chompKeep && comment) chompKeep = false;
+			lines.push(`- ${str}`);
+		}
+		let str;
+		if (lines.length === 0) str = "[]";
+		else {
+			str = lines[0];
+			for (let i = 1; i < lines.length; ++i) {
+				const line = lines[i];
+				str += line ? `\n${indent}${line}` : "\n";
+			}
+		}
+		if (this.comment) {
+			str += "\n" + indentComment(commentString(this.comment), indent);
+			onComment?.();
+		} else if (chompKeep) onChompKeep?.();
+		return str;
+	}
+	#stringifyFlowSeq(ctx) {
+		const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;
+		const itemIndent = indent + "  " + indentStep;
+		const itemCtx = {
+			...ctx,
+			indent: itemIndent,
+			inFlow: true
+		};
+		let reqNewline = false;
+		let linesAtValue = 0;
+		const lines = [];
+		for (let i = 0; i < this.length; ++i) {
+			const item = this[i];
+			let comment = null;
+			if (item instanceof Pair) {
+				const ik = item.key;
+				if (ik.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, ik.commentBefore, false);
+				if (ik.comment) reqNewline = true;
+				const iv = item.value;
+				if (iv) {
+					if (iv.comment) comment = iv.comment;
+					if (iv.commentBefore) reqNewline = true;
+				} else if (ik?.comment) comment = ik.comment;
+			} else if (item) {
+				if (item.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, item.commentBefore, false);
+				if (item.comment) comment = item.comment;
+			}
+			if (comment) reqNewline = true;
+			let str = stringify(item, itemCtx, () => comment = null);
+			reqNewline ||= lines.length > linesAtValue || str.includes("\n");
+			if (i < this.length - 1) str += ",";
+			else if (ctx.options.trailingComma) {
+				if (ctx.options.lineWidth > 0) reqNewline ||= lines.reduce((sum, line) => sum + line.length + 2, 2) + (str.length + 2) > ctx.options.lineWidth;
+				if (reqNewline) str += ",";
+			}
+			if (comment) str += lineComment(str, itemIndent, commentString(comment));
+			lines.push(str);
+			linesAtValue = lines.length;
+		}
+		if (lines.length === 0) return "[]";
+		if (!reqNewline) {
+			const len = lines.reduce((sum, line) => sum + line.length + 2, 2);
+			reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;
+		}
+		if (reqNewline) {
+			let str = "[";
+			for (const line of lines) str += line ? `\n${indentStep}${indent}${line}` : "\n";
+			return `${str}\n${indent}]`;
+		}
+		return `[${fcPadding}${lines.join(" ")}${fcPadding}]`;
+	}
+};
+function nodeValue(schema, value, options) {
+	if (isNode(value) || value instanceof Pair) return value;
+	return new NodeCreator(schema, options).create(value);
+}
+function nodeValues(schema, values) {
+	let nc;
+	return values.map((value) => {
+		if (isNode(value) || value instanceof Pair) return value;
+		nc ??= new NodeCreator(schema);
+		return nc.create(value);
+	});
+}
+function addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {
+	if (comment && chompKeep) comment = comment.replace(/^\n+/, "");
+	if (comment) {
+		const ic = indentComment(commentString(comment), indent);
+		lines.push(ic.trimStart());
+	}
+}
+//#endregion
+//#region src/nodes/YAMLSet.ts
+var YAMLSet = class {
+	static tagName = "tag:yaml.org,2002:set";
+	/** A fully qualified tag */
+	tag = "tag:yaml.org,2002:set";
+	values = /* @__PURE__ */ new Map();
+	constructor(schema) {
+		Object.defineProperty(this, "schema", {
+			value: schema,
+			configurable: true,
+			enumerable: false,
+			writable: true
 		});
 	}
-	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));
+	get size() {
+		return this.values.size;
+	}
+	add(value, options) {
+		if (this.has(value)) return this;
+		const mk = this.schema.mapKey(value);
+		const node = isNode(value) ? value : new NodeCreator(this.schema, options).create(value);
+		this.values.set(mk, node);
+		return this;
+	}
+	/**
+	* Create a copy of this set.
+	*
+	* @param schema - If defined, overwrites the original's schema
+	*/
+	clone(schema) {
+		return cloneMapOrSet(this, schema);
+	}
+	/**
+	* Remove `value` from the set.
+	* @returns `true` if the item was found and removed.
+	*/
+	delete(value) {
+		const mk = this.schema.mapKey(value);
+		if (this.values.delete(mk)) return true;
+		if (isNode(value)) {
+			for (const [k, v] of this.values) if (v === value) return this.values.delete(k);
+		}
+		return false;
+	}
+	/** Return the node matching `value`, if the set includes it.  */
+	get(value) {
+		const mk = this.schema.mapKey(value);
+		const node = this.values.get(mk);
+		if (node) return node;
+		if (isNode(value)) {
+			for (const v of this.values.values()) if (v === value) return v;
+		}
+	}
+	/** Check if the set includes `value`.  */
+	has(value) {
+		const mk = this.schema.mapKey(value);
+		if (this.values.has(mk)) return true;
+		if (isNode(value)) {
+			for (const v of this.values.values()) if (v === value) return true;
+		}
+		return false;
+	}
+	/**
+	* Return the internal Map key matching `value`, or `undefined` if not found.
+	*
+	* @param allowMissing - If `true`, a key is always returned,
+	*                       even if the value is not in the set.
+	*/
+	keyOf(value, allowMissing = false) {
+		const mk = this.schema.mapKey(value);
+		if (allowMissing || this.values.has(mk)) return mk;
+		if (isNode(value)) {
+			for (const [k, v] of this.values) if (v === value) return k;
+		}
+	}
+	/** A plain JavaScript representation of this set. */
+	toJS(doc, ctx) {
+		ctx ??= new ToJSContext();
+		const set = /* @__PURE__ */ new Set();
+		if (this.anchor) ctx.setAnchor(this, set);
+		for (const item of this.values.values()) set.add(item.toJS(doc, ctx));
+		return set;
+	}
+	toString(ctx, onComment, onChompKeep) {
+		if (!ctx) return JSON.stringify(this);
+		let items = this.values.values();
+		if (ctx.sortMapEntries) items = Array.from(items, (item) => new Pair(item)).sort(ctx.sortMapEntries).map((pair) => pair.key);
+		if (ctx.inFlow ?? this.flow) return this.#stringifyFlowSet(ctx, items);
+		else return this.#stringifyBlockSet(ctx, items, onComment, onChompKeep);
+	}
+	#stringifyBlockSet(ctx, items, onComment, onChompKeep) {
+		const { indent, indentStep, options: { commentString } } = ctx;
+		const itemCtx = {
+			...ctx,
+			implicitKey: false,
+			indent: indent + indentStep
+		};
+		let chompKeep = false;
+		let res = null;
+		for (const item of items) {
+			if (!chompKeep && item.spaceBefore) {
+				if (typeof res === "string") res += "\n";
+				else res = "";
 			}
+			let cb = item.commentBefore;
+			if (cb && chompKeep) cb = cb.replace(/^\n+/, "");
+			if (cb) {
+				const ic = indentComment(commentString(cb), indent).trimStart();
+				if (typeof res === "string") res += `\n${indent}${ic}`;
+				else res = ic;
+			}
+			chompKeep = false;
+			let comment = item.comment;
+			let str = stringify(item, itemCtx, () => comment = null, () => chompKeep = true);
+			str = str ? `? ${str}` : "?";
+			if (comment) {
+				str += lineComment(str, itemCtx.indent, commentString(comment));
+				chompKeep = false;
+			}
+			if (typeof res === "string") res += `\n${indent}${str}`;
+			else res = str;
+		}
+		if (this.comment) {
+			const cs = commentString(this.comment);
+			if (typeof res === "string") res += "\n" + indentComment(cs, indent);
+			else res = "{}" + lineComment("", indent, cs);
+			onComment?.();
+		} else if (chompKeep) onChompKeep?.();
+		return res ?? "{}";
+	}
+	#stringifyFlowSet(ctx, items) {
+		const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString, lineWidth, trailingComma } } = ctx;
+		const itemCtx = {
+			...ctx,
+			indent: indent + indentStep + indentStep,
+			inFlow: true
+		};
+		let reqNewline = false;
+		const lines = [];
+		let itemsLeft = this.values.size;
+		let singleLineWidth = 2 * fcPadding.length;
+		for (const item of items) {
+			itemsLeft -= 1;
+			if (item.spaceBefore) {
+				lines.push("");
+				reqNewline = true;
+			}
+			if (item.commentBefore) {
+				const ic = indentComment(commentString(item.commentBefore), indent);
+				lines.push(ic.trimStart());
+				reqNewline = true;
+			}
+			let comment = item.comment;
+			if (comment) reqNewline = true;
+			itemCtx.implicitKey = !isCollection(item);
+			let str = stringify(item, itemCtx, () => comment = null) || "?";
+			if (isCollection(item)) str = `? ${str}`;
+			reqNewline ||= str.includes("\n");
+			if (!reqNewline && lineWidth > 0) {
+				singleLineWidth += str.length + 2;
+				if (singleLineWidth > lineWidth) reqNewline = true;
+			}
+			if (itemsLeft > 0 || trailingComma && reqNewline) str += ",";
+			if (comment) str += lineComment(str, indent + indentStep, commentString(comment));
+			lines.push(str);
 		}
-		return seq;
+		if (lines.length === 0) return "{}";
+		if (!reqNewline) return `{${fcPadding}${lines.join(" ")}${fcPadding}}`;
+		let str = "{";
+		for (const line of lines) str += line ? `\n${indentStep}${indent}${line}` : "\n";
+		return `${str}\n${indent}}`;
 	}
 };
+//#endregion
+//#region src/nodes/identity.ts
+/** Type predicate for collections */
+const isCollection = (node) => node instanceof YAMLMap || node instanceof YAMLSeq || node instanceof YAMLSet;
+/** Type predicate for `Node` values */
+const isNode = (node) => node instanceof Scalar || node instanceof Alias || node instanceof YAMLMap || node instanceof YAMLSeq || node instanceof YAMLSet;
 //#endregion
 //#region src/stringify/stringifyPair.ts
 function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
-	const { doc, indent, indentStep, noValues, options: { commentString, indentSeq, simpleKeys } } = ctx;
-	let keyComment = key instanceof NodeBase && key.comment || null;
+	const { indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
 	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");
+		if (key.comment) throw new Error("With simple keys, key nodes cannot have comments");
+		if (isCollection(key)) throw new Error("With simple keys, collection cannot be used as a key value");
 	}
-	let explicitKey = !simpleKeys && (!key || !(key instanceof Scalar) || key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL);
+	let explicitKey = !simpleKeys && (!(key instanceof Scalar) || key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL);
 	ctx = {
 		...ctx,
-		implicitKey: !explicitKey && (simpleKeys || !noValues),
-		indent: indent + indentStep,
-		noValues: false
+		implicitKey: !explicitKey,
+		indent: indent + indentStep
 	};
+	let keyComment = key.comment;
 	let keyCommentDone = false;
 	let chompKeep = false;
 	let str = stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true);
@@ -1032,11 +1393,11 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
 		explicitKey = true;
 	}
 	if (ctx.inFlow) {
-		if (noValues || value == null) {
+		if (value == null) {
 			if (keyCommentDone && onComment) onComment();
-			return str === "" ? "?" : explicitKey ? `? ${str}` : noValues ? str : `${str}:`;
+			return str === "" ? "?" : explicitKey ? `? ${str}` : `${str}:`;
 		}
-	} else if (noValues && !simpleKeys || value == null && explicitKey) {
+	} else if (value == null && explicitKey) {
 		str = `? ${str}`;
 		if (keyComment && !keyCommentDone) str += lineComment(str, ctx.indent, commentString(keyComment));
 		else if (chompKeep && onChompKeep) onChompKeep();
@@ -1051,7 +1412,7 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
 		if (keyComment) str += lineComment(str, ctx.indent, commentString(keyComment));
 	}
 	let vsb, vcb, valueComment;
-	if (value instanceof NodeBase) {
+	if (value) {
 		vsb = !!value.spaceBefore;
 		vcb = value.commentBefore;
 		valueComment = value.comment;
@@ -1059,7 +1420,6 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
 		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;
@@ -1077,11 +1437,11 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
 		if (valueStr === "" && !ctx.inFlow) {
 			if (ws === "\n" && valueComment) ws = "\n\n";
 		} else ws += `\n${ctx.indent}`;
-	} else if (!explicitKey && value instanceof Collection) {
+	} else if (!explicitKey && isCollection(value)) {
 		const vs0 = valueStr[0];
 		const nl0 = valueStr.indexOf("\n");
 		const hasNewline = nl0 !== -1;
-		const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0;
+		const flow = ctx.inFlow ?? value.flow ?? value.size === 0;
 		if (hasNewline || !flow) {
 			let hasPropsLine = false;
 			if (hasNewline && (vs0 === "&" || vs0 === "!")) {
@@ -1099,94 +1459,6 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
 	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 {
@@ -1197,32 +1469,97 @@ var Pair = class Pair {
 		this.value = value;
 	}
 	clone(schema) {
-		return new Pair(this.key.clone(schema), this.value?.clone(schema) ?? null);
+		const key = this.key.clone(schema);
+		const value = this.value?.clone(schema) ?? null;
+		return new Pair(key, value);
 	}
-	toJSON(_, ctx) {
-		return addPairToJSMap(ctx, ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {}, this);
+	toJS(doc, ctx) {
+		return addPairToJSMap(doc, ctx, ctx.mapAsMap ? /* @__PURE__ */ new Map() : {}, this, true);
 	}
 	toString(ctx, onComment, onChompKeep) {
 		return ctx?.doc ? stringifyPair(this, ctx, onComment, onChompKeep) : JSON.stringify(this);
 	}
 };
+//#endregion
+//#region src/nodes/toJS.ts
+/** A context used in `node.toJS()` implementations */
+var ToJSContext = class {
+	anchors = /* @__PURE__ */ new Map();
+	/** Cached anchor and alias nodes in the order they occur in the document */
+	aliasResolveCache;
+	mapAsMap;
+	mapKeyWarned = false;
+	maxAliasCount;
+	constructor(opt) {
+		this.mapAsMap = opt?.mapAsMap === true;
+		this.maxAliasCount = opt?.maxAliasCount ?? 100;
+	}
+	setAnchor(node, res) {
+		const anchor = this.anchors.get(node);
+		if (anchor) anchor.res = res;
+		else this.anchors.set(node, {
+			aliasCount: 0,
+			count: 1,
+			res
+		});
+	}
+	resolveAlias(doc, source) {
+		let data = this.anchors.get(source);
+		if (!data) {
+			source.toJS(doc, this);
+			data = this.anchors.get(source);
+		}
+		/* istanbul ignore if */
+		if (data?.res === void 0) throw new ReferenceError("This should not happen: Alias anchor was not resolved?");
+		if (this.maxAliasCount >= 0) {
+			data.count += 1;
+			data.aliasCount ||= this.#getAliasCount(doc, source);
+			if (data.count * data.aliasCount > this.maxAliasCount) throw new ReferenceError("Excessive alias count indicates a resource exhaustion attack");
+		}
+		return data.res;
+	}
+	#getAliasCount(doc, node) {
+		if (node instanceof Alias) {
+			const source = node.resolve(doc, this);
+			const anchor = source && this.anchors.get(source);
+			return anchor ? anchor.count * anchor.aliasCount : 0;
+		} else if (node instanceof Pair) {
+			const kc = this.#getAliasCount(doc, node.key);
+			const vc = this.#getAliasCount(doc, node.value);
+			return Math.max(kc, vc);
+		} else if (Array.isArray(node)) {
+			let count = 0;
+			for (const item of node) {
+				const c = this.#getAliasCount(doc, item);
+				if (c > count) count = c;
+			}
+			return count;
+		}
+		return 1;
+	}
+};
 //#endregion
 //#region src/nodes/Alias.ts
-var Alias = class Alias extends NodeBase {
+var Alias = class Alias {
 	source;
 	constructor(source) {
-		super();
 		this.source = source;
 		Object.defineProperty(this, "tag", { set() {
 			throw new Error("Alias nodes cannot have tags");
 		} });
 	}
+	/** Create a copy of this node.  */
+	clone() {
+		const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+		if (this.range) copy.range = [...this.range];
+		return copy;
+	}
 	/**
 	* Resolve the value of this alias within `doc`, finding the last
 	* instance of the `source` anchor before this node.
 	*/
 	resolve(doc, ctx) {
+		if (ctx?.maxAliasCount === 0) throw new ReferenceError("Alias resolution is disabled");
 		let nodes;
 		if (ctx?.aliasResolveCache) nodes = ctx.aliasResolveCache;
 		else {
@@ -1239,27 +1576,16 @@ var Alias = class Alias extends NodeBase {
 		}
 		return found;
 	}
-	toJSON(_arg, ctx) {
-		if (!ctx) return { source: this.source };
-		const { anchors, doc, maxAliasCount } = ctx;
+	/** A plain JavaScript representation of the resolved value of this alias. */
+	toJS(doc, ctx) {
+		if (!doc?.schema) throw new TypeError("A document argument is required");
+		ctx ??= new ToJSContext();
 		const 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;
+		return ctx.resolveAlias(doc, source);
 	}
 	toString(ctx, _onComment, _onChompKeep) {
 		const src = `*${this.source}`;
@@ -1274,122 +1600,6 @@ var Alias = class Alias extends NodeBase {
 		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 = {
@@ -1397,12 +1607,14 @@ const map = {
 	default: true,
 	nodeClass: YAMLMap,
 	tag: "tag:yaml.org,2002:map",
+	createNode(nc, obj) {
+		return YAMLMap.create(nc, obj);
+	},
 	resolve(map, onError) {
 		if (!(map instanceof YAMLMap)) onError("Expected a mapping for this tag");
 		return map;
 	}
 };
 //#endregion
 //#region src/schema/common/seq.ts
 const seq = {
@@ -1410,12 +1622,14 @@ const seq = {
 	default: true,
 	nodeClass: YAMLSeq,
 	tag: "tag:yaml.org,2002:seq",
+	createNode(nc, obj) {
+		return YAMLSeq.create(nc, obj);
+	},
 	resolve(seq, onError) {
 		if (!(seq instanceof YAMLSeq)) onError("Expected a sequence for this tag");
 		return seq;
 	}
 };
 //#endregion
 //#region src/schema/common/string.ts
 const string = {
@@ -1428,43 +1642,61 @@ const string = {
 		return stringifyString(item, ctx, onComment, onChompKeep);
 	}
 };
 //#endregion
 //#region src/schema/common/null.ts
+const nullValues = /* @__PURE__ */ new Set([
+	"",
+	"~",
+	"null",
+	"Null",
+	"NULL"
+]);
 const nullTag = {
 	identify: (value) => value == null,
 	createNode: () => new Scalar(null),
 	default: true,
 	tag: "tag:yaml.org,2002:null",
-	test: /^(?:~|[Nn]ull|NULL)?$/,
+	test: (value) => nullValues.has(value),
 	resolve: () => new Scalar(null),
-	stringify: ({ source }, ctx) => typeof source === "string" && nullTag.test.test(source) ? source : ctx.options.nullStr
+	stringify: ({ source }, ctx) => typeof source === "string" && nullTag.test(source) ? source : ctx.options.nullStr
 };
 //#endregion
 //#region src/schema/core/bool.ts
+const boolValues = /* @__PURE__ */ new Set([
+	"true",
+	"True",
+	"TRUE",
+	"false",
+	"False",
+	"FALSE"
+]);
 const boolTag = {
 	identify: (value) => typeof value === "boolean",
 	default: true,
 	tag: "tag:yaml.org,2002:bool",
-	test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
+	test: (value) => boolValues.has(value),
 	resolve: (str) => new Scalar(str[0] === "t" || str[0] === "T"),
 	stringify({ source, value }, ctx) {
-		if (source && boolTag.test.test(source)) {
+		if (source && boolTag.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 }) {
+function stringifyNumber({ format, minFractionDigits, source, tag, value }, version = "1.2") {
 	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";
+	if (!isFinite(num)) {
+		if (typeof value === "number" && source) {
+			const source_ = version === "1.1" ? source.replace(/_/g, "") : source;
+			if (parseFloat(source_) === num) return source;
+		}
+		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)) {
+	if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^-?\d/.test(n) && !n.includes("e")) {
 		let i = n.indexOf(".");
 		if (i < 0) {
 			i = n.length;
@@ -1475,23 +1707,43 @@ function stringifyNumber({ format, minFractionDigits, tag, value }) {
 	}
 	return n;
 }
 //#endregion
 //#region src/schema/core/float.ts
+const floatNaNValues = /* @__PURE__ */ new Set([
+	".nan",
+	".NaN",
+	".NAN",
+	".inf",
+	".Inf",
+	".INF",
+	"+.inf",
+	"+.Inf",
+	"+.INF",
+	"-.inf",
+	"-.Inf",
+	"-.INF"
+]);
+/** First char must be a digit, sign, or dot to match any float pattern */
+function couldBeFloat(value) {
+	const c = value.charCodeAt(0);
+	return c >= 48 && c <= 57 || c === 43 || c === 45 || c === 46;
+}
+const floatExpRe = /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/;
+const floatRe = /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/;
 const floatNaN$1 = {
 	identify: (value) => typeof value === "number",
 	default: true,
 	tag: "tag:yaml.org,2002:float",
-	test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
+	test: (value) => floatNaNValues.has(value),
 	resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
-	stringify: stringifyNumber
+	stringify: (node) => stringifyNumber(node)
 };
 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]+$/,
+	test: (value) => couldBeFloat(value) && floatExpRe.test(value),
 	resolve: (str) => parseFloat(str),
 	stringify(node) {
 		const num = Number(node.value);
@@ -1502,16 +1754,15 @@ const float$1 = {
 	identify: (value) => typeof value === "number",
 	default: true,
 	tag: "tag:yaml.org,2002:float",
-	test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
+	test: (value) => couldBeFloat(value) && floatRe.test(value),
 	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
+	stringify: (node) => stringifyNumber(node)
 };
 //#endregion
 //#region src/schema/core/int.ts
 const intIdentify$2 = (value) => typeof value === "bigint" || Number.isInteger(value);
@@ -1521,12 +1772,39 @@ function intStringify$1(node, radix, prefix) {
 	if (intIdentify$2(value) && value >= 0) return prefix + value.toString(radix);
 	return stringifyNumber(node);
 }
+function isOctInt(value) {
+	if (value.length < 3 || value[0] !== "0" || value[1] !== "o") return false;
+	for (let i = 2; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c < 48 || c > 55) return false;
+	}
+	return true;
+}
+function isInt(value) {
+	let i = 0;
+	if (value.length === 0) return false;
+	if (value.charCodeAt(0) === 43 || value.charCodeAt(0) === 45) i = 1;
+	if (i === value.length) return false;
+	for (; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c < 48 || c > 57) return false;
+	}
+	return true;
+}
+function isHexInt(value) {
+	if (value.length < 3 || value[0] !== "0" || value[1] !== "x") return false;
+	for (let i = 2; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (!(c >= 48 && c <= 57) && !(c >= 65 && c <= 70) && !(c >= 97 && c <= 102)) return false;
+	}
+	return true;
+}
 const intOct$1 = {
 	identify: (value) => intIdentify$2(value) && value >= 0,
 	default: true,
 	tag: "tag:yaml.org,2002:int",
 	format: "OCT",
-	test: /^0o[0-7]+$/,
+	test: isOctInt,
 	resolve: (str, _onError, opt) => intResolve$1(str, 2, 8, opt),
 	stringify: (node) => intStringify$1(node, 8, "0o")
 };
@@ -1534,20 +1812,19 @@ const int$1 = {
 	identify: intIdentify$2,
 	default: true,
 	tag: "tag:yaml.org,2002:int",
-	test: /^[-+]?[0-9]+$/,
+	test: isInt,
 	resolve: (str, _onError, opt) => intResolve$1(str, 0, 10, opt),
-	stringify: stringifyNumber
+	stringify: (node) => stringifyNumber(node)
 };
 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]+$/,
+	test: isHexInt,
 	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 = [
@@ -1563,7 +1840,6 @@ const schema$2 = [
 	floatExp$1,
 	float$1
 ];
 //#endregion
 //#region src/schema/json/schema.ts
 function intIdentify$1(value) {
@@ -1583,7 +1859,7 @@ const jsonScalars = [
 		createNode: () => new Scalar(null),
 		default: true,
 		tag: "tag:yaml.org,2002:null",
-		test: /^null$/,
+		test: (str) => str === "null",
 		resolve: () => null,
 		stringify: stringifyJSON
 	},
@@ -1591,7 +1867,7 @@ const jsonScalars = [
 		identify: (value) => typeof value === "boolean",
 		default: true,
 		tag: "tag:yaml.org,2002:bool",
-		test: /^true$|^false$/,
+		test: (str) => str === "true" || str === "false",
 		resolve: (str) => str === "true",
 		stringify: stringifyJSON
 	},
@@ -1599,7 +1875,7 @@ const jsonScalars = [
 		identify: intIdentify$1,
 		default: true,
 		tag: "tag:yaml.org,2002:int",
-		test: /^-?(?:0|[1-9][0-9]*)$/,
+		test: (str) => /^-?(?:0|[1-9][0-9]*)$/.test(str),
 		resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),
 		stringify: ({ value }) => intIdentify$1(value) ? value.toString() : JSON.stringify(value)
 	},
@@ -1607,7 +1883,7 @@ const jsonScalars = [
 		identify: (value) => typeof value === "number",
 		default: true,
 		tag: "tag:yaml.org,2002:float",
-		test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
+		test: (str) => /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/.test(str),
 		resolve: (str) => parseFloat(str),
 		stringify: stringifyJSON
 	}
@@ -1615,7 +1891,7 @@ const jsonScalars = [
 const jsonError = {
 	default: true,
 	tag: "",
-	test: /^/,
+	test: () => true,
 	resolve(str, onError) {
 		onError(`Unresolved plain scalar ${JSON.stringify(str)}`);
 		return str;
@@ -1627,13 +1903,20 @@ const schema$1 = [
 	...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",
+	/**
+	* Returns a Buffer in Node.js and an Uint8Array elsewhere
+	*
+	* To use the resulting buffer as an image, you'll want to do something like:
+	*
+	*   const blob = new Blob([buffer], { type: 'image/jpeg' })
+	*   document.querySelector('#photo').src = URL.createObjectURL(blob)
+	*/
 	resolve(src, onError) {
 		if (typeof Buffer === "function") return Buffer.from(src, "base64");
 		else if (typeof Uint8Array.fromBase64 === "function") return Uint8Array.fromBase64(src);
@@ -1673,23 +1956,22 @@ const binary = {
 		}, 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 (seq instanceof YAMLSeq) for (let i = 0; i < seq.length; ++i) {
+		const item = seq[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 instanceof YAMLMap) {
+			if (item.size > 1) onError("Each pair must have its own sequence indicator");
+			const pair = item.values.values().next().value ?? new Pair(new Scalar(null));
 			if (item.commentBefore) pair.key.commentBefore = pair.key.commentBefore ? `${item.commentBefore}\n${pair.key.commentBefore}` : item.commentBefore;
 			if (item.comment) {
 				const cn = pair.value ?? pair.key;
 				cn.comment = cn.comment ? `${item.comment}\n${cn.comment}` : item.comment;
 			}
-			seq.items[i] = pair;
-		} else seq.items[i] = new Pair(item, null);
+			seq[i] = pair;
+		} else seq[i] = new Pair(item, null);
 	}
 	else onError("Expected a sequence for this tag");
 	return seq;
@@ -1701,18 +1983,19 @@ function createPairs(nc, iterable) {
 	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) {
+		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));
+		pairs.push(nc.createPair(key, value));
 	}
 	return pairs;
 }
@@ -1723,44 +2006,62 @@ const 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);
+var YAMLOMap = class extends YAMLSeq {
+	constructor(schema, elements) {
+		super(schema, elements);
+		this.tag = omap.tag;
+	}
+	/**
+	* Append new pairs to the omap, and return its new length.
+	*/
+	push(...pairs) {
+		for (const pair of pairs) if (pair instanceof Pair) super.push(pair);
+		else throw new Error("Omap only supports Pair values");
+		return this.length;
+	}
+	/**
+	* Set a pair in this omap.
+	*
+	* Throws if `idx` is not an integer.
+	*/
+	set(idx, pair) {
+		if (!Number.isInteger(idx)) throw new TypeError(`Expected an integer, not ${JSON.stringify(idx)}.`);
+		if (idx < 0) {
+			if (idx < -this.length) throw new RangeError(`Invalid index ${idx}`);
+			idx += this.length;
+		}
+		this[idx] = pair;
+	}
 	/**
-	* If `ctx` is given, the return type is actually `Map<unknown, unknown>`,
+	* The returned value actually has type `Map<unknown, unknown>`,
 	* but TypeScript won't allow widening the signature of a child method.
 	*/
-	toJSON(_, ctx) {
-		if (!ctx) return super.toJSON(_);
+	toJS(doc, ctx) {
+		if (!ctx) return super.toJS(doc);
 		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 (this.anchor) ctx.anchors.set(this, {
+			aliasCount: 0,
+			count: 1,
+			res: map
+		});
+		for (const pair of this) {
+			const key = pair.key.toJS(doc, ctx);
+			const value = pair.value ? pair.value.toJS(doc, ctx) : null;
 			if (map.has(key)) throw new Error("Ordered maps must not include duplicate keys");
 			map.set(key, value);
 		}
 		return map;
 	}
-	static from(nc, iterable) {
-		const pairs = createPairs(nc, iterable);
-		const omap = new this(nc.schema);
-		omap.items = pairs.items;
-		return omap;
+	toString(ctx, onComment, onChompKeep) {
+		const keys = /* @__PURE__ */ new Set();
+		for (const pair of this) {
+			const key = this.schema.mapKey(pair);
+			if (keys.has(key)) throw new Error("Ordered maps must not include duplicate keys");
+			keys.add(key);
+		}
+		return super.toString(ctx, onComment, onChompKeep);
 	}
 };
 const omap = {
@@ -1769,26 +2070,31 @@ const omap = {
 	nodeClass: YAMLOMap,
 	default: false,
 	tag: "tag:yaml.org,2002:omap",
+	createNode(nc, iterable) {
+		const pairs = createPairs(nc, iterable);
+		return new YAMLOMap(nc.schema, pairs);
+	},
 	resolve(seq, onError) {
 		const pairs = resolvePairs(seq, onError);
 		const seenKeys = [];
-		for (const { key } of pairs.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);
+		for (const { key } of pairs) if (key instanceof Scalar) {
+			if (seenKeys.includes(key.value)) onError(`Ordered maps must not include duplicate keys: ${key.value}`);
+			else seenKeys.push(key.value);
+		}
+		return Object.assign(new YAMLOMap(seq.schema), pairs);
 	}
 };
 //#endregion
 //#region src/schema/yaml-1.1/bool.ts
 function boolStringify({ value, source }, ctx) {
-	if (source && (value ? trueTag : falseTag).test.test(source)) return source;
+	if (source && (value ? trueTag : falseTag).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)$/,
+	test: (str) => /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/.test(str),
 	resolve: () => new Scalar(true),
 	stringify: boolStringify
 };
@@ -1796,38 +2102,37 @@ 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)$/,
+	test: (str) => /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/.test(str),
 	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)$/,
+	test: (str) => /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/.test(str),
 	resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
-	stringify: stringifyNumber
+	stringify: (node) => stringifyNumber(node, "1.1")
 };
 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]+$/,
+	test: (str) => /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/.test(str),
 	resolve: (str) => parseFloat(str.replace(/_/g, "")),
 	stringify(node) {
 		const num = Number(node.value);
-		return isFinite(num) ? num.toExponential() : stringifyNumber(node);
+		return isFinite(num) ? num.toExponential() : stringifyNumber(node, "1.1");
 	}
 };
 const float = {
 	identify: (value) => typeof value === "number",
 	default: true,
 	tag: "tag:yaml.org,2002:float",
-	test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
+	test: (str) => /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/.test(str),
 	resolve(str) {
 		const node = new Scalar(parseFloat(str.replace(/_/g, "")));
 		const dot = str.indexOf(".");
@@ -1837,9 +2142,8 @@ const float = {
 		}
 		return node;
 	},
-	stringify: stringifyNumber
+	stringify: (node) => stringifyNumber(node, "1.1")
 };
 //#endregion
 //#region src/schema/yaml-1.1/int.ts
 const intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
@@ -1855,9 +2159,7 @@ function intResolve(str, offset, radix, { intAsBigInt }) {
 			case 8:
 				str = `0o${str}`;
 				break;
-			case 16:
-				str = `0x${str}`;
-				break;
+			case 16: str = `0x${str}`;
 		}
 		const n = BigInt(str);
 		return sign === "-" ? BigInt(-1) * n : n;
@@ -1878,7 +2180,7 @@ const intBin = {
 	default: true,
 	tag: "tag:yaml.org,2002:int",
 	format: "BIN",
-	test: /^[-+]?0b[0-1_]+$/,
+	test: (str) => /^[-+]?0b[0-1_]+$/.test(str),
 	resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),
 	stringify: (node) => intStringify(node, 2, "0b")
 };
@@ -1887,7 +2189,7 @@ const intOct = {
 	default: true,
 	tag: "tag:yaml.org,2002:int",
 	format: "OCT",
-	test: /^[-+]?0[0-7_]+$/,
+	test: (str) => /^[-+]?0[0-7_]+$/.test(str),
 	resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),
 	stringify: (node) => intStringify(node, 8, "0")
 };
@@ -1895,109 +2197,41 @@ const int = {
 	identify: intIdentify,
 	default: true,
 	tag: "tag:yaml.org,2002:int",
-	test: /^[-+]?[0-9][0-9_]*$/,
+	test: (str) => /^[-+]?[0-9][0-9_]*$/.test(str),
 	resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
-	stringify: stringifyNumber
+	stringify: (node) => stringifyNumber(node, "1.1")
 };
 const intHex = {
 	identify: intIdentify,
 	default: true,
 	tag: "tag:yaml.org,2002:int",
 	format: "HEX",
-	test: /^[-+]?0x[0-9a-fA-F_]+$/,
+	test: (str) => /^[-+]?0x[0-9a-fA-F_]+$/.test(str),
 	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;
+	createNode(nc, iterable) {
+		const set = new YAMLSet(nc.schema);
+		if (iterable && Symbol.iterator in Object(iterable)) for (let value of iterable) {
+			if (typeof nc.replacer === "function") value = nc.replacer.call(iterable, value, value);
+			const mk = nc.schema.mapKey(value);
+			set.values.set(mk, nc.create(value));
 		}
+		return set;
+	},
+	resolve(set, onError) {
+		if (!(set instanceof YAMLSet)) onError("Expected a set for this tag");
+		return set;
 	}
 };
 //#endregion
 //#region src/schema/yaml-1.1/timestamp.ts
 /** Internal types handle bigint as number, because TS can't figure it out. */
@@ -2041,7 +2275,7 @@ const intTime = {
 	default: true,
 	tag: "tag:yaml.org,2002:int",
 	format: "TIME",
-	test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,
+	test: (str) => /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/.test(str),
 	resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt),
 	stringify: stringifySexagesimal
 };
@@ -2050,17 +2284,18 @@ const floatTime = {
 	default: true,
 	tag: "tag:yaml.org,2002:float",
 	format: "TIME",
-	test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/,
+	test: (str) => /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/.test(str),
 	resolve: (str) => parseSexagesimal(str, false),
 	stringify: stringifySexagesimal
 };
+const timestampRe = 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})?))?)?$");
 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})?))?)?$"),
+	test: (str) => timestampRe.test(str),
 	resolve(str) {
-		const match = str.match(timestamp.test);
+		const match = str.match(timestampRe);
 		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;
@@ -2075,7 +2310,6 @@ const timestamp = {
 	},
 	stringify: ({ value }) => value?.toISOString().replace(/(T00:00:00)?\.000Z$/, "") ?? ""
 };
 //#endregion
 //#region src/schema/yaml-1.1/schema.ts
 const schema = [
@@ -2101,10 +2335,9 @@ const schema = [
 	floatTime,
 	timestamp
 ];
 //#endregion
 //#region src/schema/tags.ts
-const schemas = new Map([
+const schemas = /* @__PURE__ */ new Map([
 	["core", schema$2],
 	["failsafe", [
 		map,
@@ -2145,16 +2378,18 @@ const coreKnownTags = {
 };
 function getTags(customTags, schemaName, addMergeTag) {
 	const schemaTags = schemas.get(schemaName);
-	if (schemaTags && !customTags) return addMergeTag && !schemaTags.includes(merge) ? schemaTags.concat(merge) : schemaTags.slice();
+	if (schemaTags && !customTags) return addMergeTag && !schemaTags.includes(merge) ? [...schemaTags, merge] : schemaTags.slice();
 	let tags = schemaTags;
-	if (!tags) if (Array.isArray(customTags)) tags = [];
-	else {
-		const keys = Array.from(schemas.keys()).filter((key) => key !== "yaml11").map((key) => JSON.stringify(key)).join(", ");
-		throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
+	if (!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);
+	if (addMergeTag) tags = [...tags, merge];
 	return tags.reduce((tags, tag) => {
 		const tagObj = typeof tag === "string" ? tagsByName[tag] : tag;
 		if (!tagObj) {
@@ -2166,19 +2401,18 @@ function getTags(customTags, schemaName, addMergeTag) {
 		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;
+	mapKey;
 	name;
-	sortMapEntries;
 	tags;
 	toStringOptions;
-	constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
+	constructor({ compat, customTags, mapKey, merge, resolveKnownTags, schema, toStringDefaults }) {
 		this.compat = Array.isArray(compat) ? getTags(compat, "compat") : compat ? getTags(null, compat) : null;
+		this.mapKey = mapKey ?? defaultMapKey;
 		this.name = typeof schema === "string" && schema || "core";
 		this.knownTags = resolveKnownTags ? coreKnownTags : {};
 		this.tags = getTags(customTags, this.name, merge);
@@ -2186,7 +2420,6 @@ var Schema = class Schema {
 		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));
@@ -2194,7 +2427,11 @@ var Schema = class Schema {
 		return copy;
 	}
 };
+function defaultMapKey(value) {
+	if (value instanceof Pair) value = value.key;
+	if (value instanceof Scalar) value = value.value;
+	return value ?? null;
+}
 //#endregion
 //#region src/stringify/stringifyDocument.ts
 function stringifyDocument(doc, options) {
@@ -2216,27 +2453,27 @@ function stringifyDocument(doc, options) {
 		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;
+	let 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 {
+	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) {
@@ -2246,7 +2483,38 @@ function stringifyDocument(doc, options) {
 	}
 	return lines.join("\n") + "\n";
 }
+//#endregion
+//#region src/doc/applyReviver.ts
+function applyReviver(reviver, obj, key, val) {
+	if (val && typeof val === "object") {
+		if (Array.isArray(val)) for (let i = 0, len = val.length; i < len; ++i) {
+			const v0 = val[i];
+			const v1 = applyReviver(reviver, val, String(i), v0);
+			if (v1 === void 0) delete val[i];
+			else if (v1 !== v0) val[i] = v1;
+		}
+		else if (val instanceof Map) for (const k of Array.from(val.keys())) {
+			const v0 = val.get(k);
+			const v1 = applyReviver(reviver, val, k, v0);
+			if (v1 === void 0) val.delete(k);
+			else if (v1 !== v0) val.set(k, v1);
+		}
+		else if (val instanceof Set) for (const v0 of Array.from(val)) {
+			const v1 = applyReviver(reviver, val, v0, v0);
+			if (v1 === void 0) val.delete(v0);
+			else if (v1 !== v0) {
+				val.delete(v0);
+				val.add(v1);
+			}
+		}
+		else for (const [k, v0] of Object.entries(val)) {
+			const v1 = applyReviver(reviver, val, k, v0);
+			if (v1 === void 0) delete val[k];
+			else if (v1 !== v0) val[k] = v1;
+		}
+	}
+	return reviver.call(obj, key, val);
+}
 //#endregion
 //#region src/doc/Document.ts
 var Document = class Document {
@@ -2262,13 +2530,10 @@ var Document = class Document {
 	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;
-		}
+	constructor(value, replacerOrOptions, options) {
+		let replacer = null;
+		if (typeof replacerOrOptions === "function" || Array.isArray(replacerOrOptions)) replacer = replacerOrOptions;
+		else if (options === void 0 && replacerOrOptions) options = replacerOrOptions;
 		const opt = Object.assign({
 			intAsBigInt: false,
 			keepSourceTokens: false,
@@ -2276,7 +2541,6 @@ var Document = class Document {
 			prettyErrors: true,
 			strict: true,
 			stringKeys: false,
-			uniqueKeys: true,
 			version: "1.2"
 		}, options);
 		this.options = opt;
@@ -2286,7 +2550,7 @@ var Document = class Document {
 			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);
+		this.value = this.createNode(value, replacer, options);
 	}
 	/**
 	* Create a deep copy of this Document and its value.
@@ -2306,14 +2570,6 @@ var Document = class Document {
 		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.
 	*
@@ -2338,7 +2594,7 @@ var Document = class Document {
 		} 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);
+			if (asStr.length > 0) replacer = [...replacer, ...asStr];
 			nc = new NodeCreator(this, options, replacer);
 		} else {
 			options ??= replacer ?? void 0;
@@ -2359,63 +2615,34 @@ var Document = class Document {
 		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;
+		if (this.value instanceof YAMLMap || this.value instanceof YAMLSet) return this.value.get(key);
+		if (this.value instanceof YAMLSeq) {
+			if (Number.isInteger(key)) return this.value.at(key);
+			throw new TypeError(`Expected an integer, not ${JSON.stringify(key)}.`);
+		}
 	}
 	/**
-	* Checks if the document includes a value at `path`.
+	* Returns pair at `key`, or `undefined` if not found.
 	*/
-	hasIn(path) {
-		if (!path.length) return true;
-		return this.value instanceof Collection ? this.value.hasIn(path) : false;
+	getPair(key) {
+		if (this.value instanceof YAMLMap) return this.value.getPair(key);
+		if (this.value instanceof YAMLSeq) {
+			if (!Number.isInteger(key)) throw new TypeError(`Expected an integer, not ${JSON.stringify(key)}.`);
+			const pair = this.value.at(key);
+			if (pair instanceof Pair) return pair;
+			throw new TypeError(`Value at ${key} is not a Pair`);
+		}
 	}
 	/**
-	* Sets a value in this document. For `!!set`, `value` needs to be a
-	* boolean to add/remove the item from the set.
+	* Sets a value in this document's top-level collection. For `!!set`, `value` is ignored.
 	*/
 	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);
+		if (this.value instanceof YAMLSet) this.value.add(key);
+		else if (this.value instanceof YAMLMap || this.value instanceof YAMLSeq) this.value.set(key, value);
+		else throw new Error("Expected a YAML collection as document value");
 	}
 	/**
 	* Change the YAML version and schema used by the document.
@@ -2458,32 +2685,17 @@ var Document = class Document {
 		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);
+	/** A plain JavaScript representation of the document `value`. */
+	toJS(opt = {}) {
+		const { onAnchor, reviver } = opt;
+		const ctx = new ToJSContext(opt);
+		const res = this.value.toJS(this, ctx);
 		if (typeof onAnchor === "function") for (const { count, res } of ctx.anchors.values()) onAnchor(res, count);
 		return typeof reviver === "function" ? applyReviver(reviver, { "": res }, "", res) : res;
 	}
-	/**
-	* A JSON representation of the document `value`.
-	*
-	* @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 JSON representation of the document `value`.  */
+	toJSON() {
+		return this.toJS({ mapAsMap: false });
 	}
 	/** A YAML representation of the document. */
 	toString(options = {}) {
@@ -2495,11 +2707,6 @@ var Document = class Document {
 		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");
@@ -2538,32 +2745,43 @@ const REMOVE = Symbol("remove 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([]));
+		if (visit_(null, node.value, visitor_, [node]) === REMOVE) node.value = new Scalar(null);
+	} else visit_(null, node, visitor_, []);
 };
 visit.BREAK = BREAK;
 visit.SKIP = SKIP;
 visit.REMOVE = REMOVE;
 function visit_(key, node, visitor, path) {
 	const ctrl = callVisitor(key, node, visitor, path);
-	if (ctrl instanceof NodeBase || ctrl instanceof Pair) {
+	if (isNode(ctrl) || 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 (node instanceof YAMLSeq) {
+			path = [...path, node];
+			for (let i = 0; i < node.length; ++i) {
+				const ci = visit_(i, node[i], visitor, path);
 				if (typeof ci === "number") i = ci - 1;
 				else if (ci === BREAK) return BREAK;
 				else if (ci === REMOVE) {
-					node.items.splice(i, 1);
+					node.splice(i, 1);
 					i -= 1;
 				}
 			}
+		} else if (node instanceof YAMLMap || node instanceof YAMLSet) {
+			path = [...path, node];
+			const entries = Array.from(node.values);
+			const delKeys = [];
+			for (let i = 0; i < entries.length; ++i) {
+				const ci = visit_(i, entries[i][1], visitor, path);
+				if (typeof ci === "number") i = ci - 1;
+				else if (ci === BREAK) return BREAK;
+				else if (ci === REMOVE) delKeys.push(entries[i][0]);
+			}
+			for (const dk of delKeys) node.values.delete(dk);
 		} else if (node instanceof Pair) {
-			path = Object.freeze(path.concat(node));
+			path = [...path, node];
 			const ck = visit_("key", node.key, visitor, path);
 			if (ck === BREAK) return BREAK;
 			else if (ck === REMOVE) node.key = new Scalar(null);
@@ -2609,32 +2827,43 @@ function visit_(key, node, visitor, path) {
 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([]));
+		if (await visitAsync_(null, node.value, visitor_, [node]) === REMOVE) node.value = new Scalar(null);
+	} else await visitAsync_(null, node, visitor_, []);
 };
 visitAsync.BREAK = BREAK;
 visitAsync.SKIP = SKIP;
 visitAsync.REMOVE = REMOVE;
 async function visitAsync_(key, node, visitor, path) {
 	const ctrl = await callVisitor(key, node, visitor, path);
-	if (ctrl instanceof NodeBase || ctrl instanceof Pair) {
+	if (isNode(ctrl) || 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 (node instanceof YAMLSeq) {
+			path = [...path, node];
+			for (let i = 0; i < node.length; ++i) {
+				const ci = await visitAsync_(i, node[i], visitor, path);
 				if (typeof ci === "number") i = ci - 1;
 				else if (ci === BREAK) return BREAK;
 				else if (ci === REMOVE) {
-					node.items.splice(i, 1);
+					node.splice(i, 1);
 					i -= 1;
 				}
 			}
+		} else if (node instanceof YAMLMap || node instanceof YAMLSet) {
+			path = [...path, node];
+			const entries = Array.from(node.values);
+			const delKeys = [];
+			for (let i = 0; i < entries.length; ++i) {
+				const ci = await visitAsync_(i, entries[i][1], visitor, path);
+				if (typeof ci === "number") i = ci - 1;
+				else if (ci === BREAK) return BREAK;
+				else if (ci === REMOVE) delKeys.push(entries[i][0]);
+			}
+			for (const dk of delKeys) node.values.delete(dk);
 		} else if (node instanceof Pair) {
-			path = Object.freeze(path.concat(node));
+			path = [...path, node];
 			const ck = await visitAsync_("key", node.key, visitor, path);
 			if (ck === BREAK) return BREAK;
 			else if (ck === REMOVE) node.key = new Scalar(null);
@@ -2663,7 +2892,7 @@ function initVisitor(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 YAMLMap || node instanceof YAMLSet) return visitor.Map?.(key, node, path);
 	if (node instanceof YAMLSeq) return visitor.Seq?.(key, node, path);
 	if (node instanceof Pair) return visitor.Pair?.(key, node, path);
 	if (node instanceof Scalar) return visitor.Scalar?.(key, node, path);
@@ -2671,17 +2900,32 @@ function callVisitor(key, node, visitor, 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 {
+	if (parent instanceof YAMLSeq) parent[key] = node;
+	else if (parent instanceof YAMLMap) {
+		if (node instanceof Pair) {
+			const entries = Array.from(parent.values);
+			entries[key] = [parent.keyOf(node, true), node];
+			parent.values = new Map(entries);
+		} else throw new Error("Cannot replace map pair with non-pair value");
+	} else if (parent instanceof YAMLSet) {
+		if (isNode(node)) {
+			const entries = Array.from(parent.values);
+			entries[key] = [parent.keyOf(node, true), node];
+			parent.values = new Map(entries);
+		} else throw new Error("Cannot replace set value with non-node value");
+	} else if (parent instanceof Pair) {
+		if (isNode(node)) {
+			if (key === "key") parent.key = node;
+			else parent.value = node;
+		} else throw new Error(`Cannot replace pair ${key} with non-node value`);
+	} else if (parent instanceof Document) {
+		if (node instanceof Scalar || isCollection(node)) parent.value = node;
+		else throw new Error("Cannot replace Document value with non-node value");
+	} else {
 		const pt = parent instanceof Alias ? "alias" : "scalar";
 		throw new Error(`Cannot replace node with ${pt} parent`);
 	}
 }
 //#endregion
 //#region src/doc/directives.ts
 const escapeChars = {
@@ -2741,7 +2985,6 @@ var Directives = class Directives {
 					version: "1.2"
 				};
 				this.tags = Object.assign({}, Directives.defaultTags);
-				break;
 		}
 		return res;
 	}
@@ -2840,7 +3083,7 @@ var Directives = class Directives {
 		if (doc && tagEntries.length > 0) {
 			const tags = {};
 			visit(doc.value, (_key, node) => {
-				if (node instanceof NodeBase && node.tag) tags[node.tag] = true;
+				if (node?.tag) tags[node.tag] = true;
 			});
 			tagNames = Object.keys(tags);
 		} else tagNames = [];
@@ -2851,6 +3094,5 @@ var Directives = class Directives {
 		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 };
+export { Scalar as S, YAMLMap as _, Schema as a, stringifyString as b, seq as c, ToJSContext as d, Pair as f, YAMLSeq as g, YAMLSet as h, Document as i, map as l, isNode as m, visit as n, stringifyNumber as o, isCollection as p, visitAsync as r, string as s, Directives as t, Alias as u, debug as v, foldFlowLines as x, warn as y };