cngpac 0.0.1

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/errors.mjs

@@ -0,0 +1,56 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/errors.js
+var require_errors = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var YAMLError = class extends Error {
+		constructor(name, pos, code, message) {
+			super();
+			this.name = name;
+			this.code = code;
+			this.message = message;
+			this.pos = pos;
+		}
+	};
+	var YAMLParseError = class extends YAMLError {
+		constructor(pos, code, message) {
+			super("YAMLParseError", pos, code, message);
+		}
+	};
+	var YAMLWarning = class extends YAMLError {
+		constructor(pos, code, message) {
+			super("YAMLWarning", pos, code, message);
+		}
+	};
+	const prettifyError = (src, lc) => (error) => {
+		if (error.pos[0] === -1) return;
+		error.linePos = error.pos.map((pos) => lc.linePos(pos));
+		const { line, col } = error.linePos[0];
+		error.message += ` at line ${line}, column ${col}`;
+		let ci = col - 1;
+		let lineStr = src.substring(lc.lineStarts[line - 1], lc.lineStarts[line]).replace(/[\n\r]+$/, "");
+		if (ci >= 60 && lineStr.length > 80) {
+			const trimStart = Math.min(ci - 39, lineStr.length - 79);
+			lineStr = "…" + lineStr.substring(trimStart);
+			ci -= trimStart - 1;
+		}
+		if (lineStr.length > 80) lineStr = lineStr.substring(0, 79) + "…";
+		if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {
+			let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);
+			if (prev.length > 80) prev = prev.substring(0, 79) + "…\n";
+			lineStr = prev + lineStr;
+		}
+		if (/[^ ]/.test(lineStr)) {
+			let count = 1;
+			const end = error.linePos[1];
+			if (end?.line === line && end.col > col) count = Math.max(1, Math.min(end.col - col, 80 - ci));
+			const pointer = " ".repeat(ci) + "^".repeat(count);
+			error.message += `:\n\n${lineStr}\n${pointer}\n`;
+		}
+	};
+	exports.YAMLError = YAMLError;
+	exports.YAMLParseError = YAMLParseError;
+	exports.YAMLWarning = YAMLWarning;
+	exports.prettifyError = prettifyError;
+}));
+//#endregion
+export default require_errors();
+export { require_errors };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/index.mjs

@@ -0,0 +1,67 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "./nodes/identity.mjs";
+import { require_visit } from "./visit.mjs";
+import { require_Alias } from "./nodes/Alias.mjs";
+import { require_Scalar } from "./nodes/Scalar.mjs";
+import { require_Pair } from "./nodes/Pair.mjs";
+import { require_YAMLMap } from "./nodes/YAMLMap.mjs";
+import { require_YAMLSeq } from "./nodes/YAMLSeq.mjs";
+import { require_Schema } from "./schema/Schema.mjs";
+import { require_Document } from "./doc/Document.mjs";
+import { require_errors } from "./errors.mjs";
+import { require_composer } from "./compose/composer.mjs";
+import { require_cst } from "./parse/cst.mjs";
+import { require_lexer } from "./parse/lexer.mjs";
+import { require_line_counter } from "./parse/line-counter.mjs";
+import { require_parser } from "./parse/parser.mjs";
+import { require_public_api } from "./public-api.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var composer = require_composer();
+	var Document = require_Document();
+	var Schema = require_Schema();
+	var errors = require_errors();
+	var Alias = require_Alias();
+	var identity = require_identity();
+	var Pair = require_Pair();
+	var Scalar = require_Scalar();
+	var YAMLMap = require_YAMLMap();
+	var YAMLSeq = require_YAMLSeq();
+	require_cst();
+	var lexer = require_lexer();
+	var lineCounter = require_line_counter();
+	var parser = require_parser();
+	var publicApi = require_public_api();
+	var visit = require_visit();
+	exports.Composer = composer.Composer;
+	exports.Document = Document.Document;
+	exports.Schema = Schema.Schema;
+	exports.YAMLError = errors.YAMLError;
+	exports.YAMLParseError = errors.YAMLParseError;
+	exports.YAMLWarning = errors.YAMLWarning;
+	exports.Alias = Alias.Alias;
+	exports.isAlias = identity.isAlias;
+	exports.isCollection = identity.isCollection;
+	exports.isDocument = identity.isDocument;
+	exports.isMap = identity.isMap;
+	exports.isNode = identity.isNode;
+	exports.isPair = identity.isPair;
+	exports.isScalar = identity.isScalar;
+	exports.isSeq = identity.isSeq;
+	exports.Pair = Pair.Pair;
+	exports.Scalar = Scalar.Scalar;
+	exports.YAMLMap = YAMLMap.YAMLMap;
+	exports.YAMLSeq = YAMLSeq.YAMLSeq;
+	exports.Lexer = lexer.Lexer;
+	exports.LineCounter = lineCounter.LineCounter;
+	exports.Parser = parser.Parser;
+	exports.parse = publicApi.parse;
+	exports.parseAllDocuments = publicApi.parseAllDocuments;
+	exports.parseDocument = publicApi.parseDocument;
+	exports.stringify = publicApi.stringify;
+	exports.visit = visit.visit;
+	exports.visitAsync = visit.visitAsync;
+}));
+//#endregion
+export default require_dist();
+export { require_dist };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/log.mjs

@@ -0,0 +1,17 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/log.js
+var require_log = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var node_process = __require("process");
+	function debug(logLevel, ...messages) {
+		if (logLevel === "debug") console.log(...messages);
+	}
+	function warn(logLevel, warning) {
+		if (logLevel === "debug" || logLevel === "warn") if (typeof node_process.emitWarning === "function") node_process.emitWarning(warning);
+		else console.warn(warning);
+	}
+	exports.debug = debug;
+	exports.warn = warn;
+}));
+//#endregion
+export default require_log();
+export { require_log };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/Alias.mjs

@@ -0,0 +1,101 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "./identity.mjs";
+import { require_visit } from "../visit.mjs";
+import { require_anchors } from "../doc/anchors.mjs";
+import { require_toJS } from "./toJS.mjs";
+import { require_Node } from "./Node.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/Alias.js
+var require_Alias = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var anchors = require_anchors();
+	var visit = require_visit();
+	var identity = require_identity();
+	var Node = require_Node();
+	var toJS = require_toJS();
+	var Alias = class extends Node.NodeBase {
+		constructor(source) {
+			super(identity.ALIAS);
+			this.source = source;
+			Object.defineProperty(this, "tag", { set() {
+				throw new Error("Alias nodes cannot have tags");
+			} });
+		}
+		/**
+		* Resolve the value of this alias within `doc`, finding the last
+		* instance of the `source` anchor before this node.
+		*/
+		resolve(doc, ctx) {
+			let nodes;
+			if (ctx?.aliasResolveCache) nodes = ctx.aliasResolveCache;
+			else {
+				nodes = [];
+				visit.visit(doc, { Node: (_key, node) => {
+					if (identity.isAlias(node) || identity.hasAnchor(node)) nodes.push(node);
+				} });
+				if (ctx) ctx.aliasResolveCache = nodes;
+			}
+			let found = void 0;
+			for (const node of nodes) {
+				if (node === this) break;
+				if (node.anchor === this.source) found = node;
+			}
+			return found;
+		}
+		toJSON(_arg, ctx) {
+			if (!ctx) return { source: this.source };
+			const { anchors, doc, maxAliasCount } = ctx;
+			const source = this.resolve(doc, ctx);
+			if (!source) {
+				const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+				throw new ReferenceError(msg);
+			}
+			let data = anchors.get(source);
+			if (!data) {
+				toJS.toJS(source, null, ctx);
+				data = anchors.get(source);
+			}
+			/* istanbul ignore if */
+			if (data?.res === void 0) throw new ReferenceError("This should not happen: Alias anchor was not resolved?");
+			if (maxAliasCount >= 0) {
+				data.count += 1;
+				if (data.aliasCount === 0) data.aliasCount = getAliasCount(doc, source, anchors);
+				if (data.count * data.aliasCount > maxAliasCount) throw new ReferenceError("Excessive alias count indicates a resource exhaustion attack");
+			}
+			return data.res;
+		}
+		toString(ctx, _onComment, _onChompKeep) {
+			const src = `*${this.source}`;
+			if (ctx) {
+				anchors.anchorIsValid(this.source);
+				if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
+					const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+					throw new Error(msg);
+				}
+				if (ctx.implicitKey) return `${src} `;
+			}
+			return src;
+		}
+	};
+	function getAliasCount(doc, node, anchors) {
+		if (identity.isAlias(node)) {
+			const source = node.resolve(doc);
+			const anchor = anchors && source && anchors.get(source);
+			return anchor ? anchor.count * anchor.aliasCount : 0;
+		} else if (identity.isCollection(node)) {
+			let count = 0;
+			for (const item of node.items) {
+				const c = getAliasCount(doc, item, anchors);
+				if (c > count) count = c;
+			}
+			return count;
+		} else if (identity.isPair(node)) {
+			const kc = getAliasCount(doc, node.key, anchors);
+			const vc = getAliasCount(doc, node.value, anchors);
+			return Math.max(kc, vc);
+		}
+		return 1;
+	}
+	exports.Alias = Alias;
+}));
+//#endregion
+export default require_Alias();
+export { require_Alias };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/Collection.mjs

@@ -0,0 +1,127 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "./identity.mjs";
+import { require_Node } from "./Node.mjs";
+import { require_createNode } from "../doc/createNode.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/Collection.js
+var require_Collection = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var createNode = require_createNode();
+	var identity = require_identity();
+	var Node = require_Node();
+	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 createNode.createNode(v, void 0, {
+			aliasDuplicateObjects: false,
+			keepUndefined: false,
+			onAnchor: () => {
+				throw new Error("This should not happen, please report a bug.");
+			},
+			schema,
+			sourceObjects: /* @__PURE__ */ new Map()
+		});
+	}
+	const isEmptyPath = (path) => path == null || typeof path === "object" && !!path[Symbol.iterator]().next().done;
+	var Collection = class extends Node.NodeBase {
+		constructor(type, schema) {
+			super(type);
+			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) => identity.isNode(it) || identity.isPair(it) ? it.clone(schema) : it);
+			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 or a `{ key, value }` object, which may not have a key
+		* that already exists in the map.
+		*/
+		addIn(path, value) {
+			if (isEmptyPath(path)) this.add(value);
+			else {
+				const [key, ...rest] = path;
+				const node = this.get(key, true);
+				if (identity.isCollection(node)) 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, true);
+			if (identity.isCollection(node)) 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. By default unwraps
+		* scalar values from their surrounding node; to disable set `keepScalar` to
+		* `true` (collections are always returned intact).
+		*/
+		getIn(path, keepScalar) {
+			const [key, ...rest] = path;
+			const node = this.get(key, true);
+			if (rest.length === 0) return !keepScalar && identity.isScalar(node) ? node.value : node;
+			else return identity.isCollection(node) ? node.getIn(rest, keepScalar) : void 0;
+		}
+		hasAllNullValues(allowScalar) {
+			return this.items.every((node) => {
+				if (!identity.isPair(node)) return false;
+				const n = node.value;
+				return n == null || allowScalar && identity.isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag;
+			});
+		}
+		/**
+		* 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, true);
+			return identity.isCollection(node) ? node.hasIn(rest) : false;
+		}
+		/**
+		* Sets a value in this collection. For `!!set`, `value` needs to be a
+		* boolean to add/remove the item from the set.
+		*/
+		setIn(path, value) {
+			const [key, ...rest] = path;
+			if (rest.length === 0) this.set(key, value);
+			else {
+				const node = this.get(key, true);
+				if (identity.isCollection(node)) 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}`);
+			}
+		}
+	};
+	exports.Collection = Collection;
+	exports.collectionFromPath = collectionFromPath;
+	exports.isEmptyPath = isEmptyPath;
+}));
+//#endregion
+export default require_Collection();
+export { require_Collection };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/Node.mjs

@@ -0,0 +1,40 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "./identity.mjs";
+import { require_applyReviver } from "../doc/applyReviver.mjs";
+import { require_toJS } from "./toJS.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/Node.js
+var require_Node = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var applyReviver = require_applyReviver();
+	var identity = require_identity();
+	var toJS = require_toJS();
+	var NodeBase = class {
+		constructor(type) {
+			Object.defineProperty(this, identity.NODE_TYPE, { value: type });
+		}
+		/** Create a copy of this node.  */
+		clone() {
+			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 (!identity.isDocument(doc)) 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.toJS(this, "", ctx);
+			if (typeof onAnchor === "function") for (const { count, res } of ctx.anchors.values()) onAnchor(res, count);
+			return typeof reviver === "function" ? applyReviver.applyReviver(reviver, { "": res }, "", res) : res;
+		}
+	};
+	exports.NodeBase = NodeBase;
+}));
+//#endregion
+export default require_Node();
+export { require_Node };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/Pair.mjs

@@ -0,0 +1,40 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "./identity.mjs";
+import { require_createNode } from "../doc/createNode.mjs";
+import { require_stringifyPair } from "../stringify/stringifyPair.mjs";
+import { require_addPairToJSMap } from "./addPairToJSMap.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/Pair.js
+var require_Pair = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var createNode = require_createNode();
+	var stringifyPair = require_stringifyPair();
+	var addPairToJSMap = require_addPairToJSMap();
+	var identity = require_identity();
+	function createPair(key, value, ctx) {
+		return new Pair(createNode.createNode(key, void 0, ctx), createNode.createNode(value, void 0, ctx));
+	}
+	var Pair = class Pair {
+		constructor(key, value = null) {
+			Object.defineProperty(this, identity.NODE_TYPE, { value: identity.PAIR });
+			this.key = key;
+			this.value = value;
+		}
+		clone(schema) {
+			let { key, value } = this;
+			if (identity.isNode(key)) key = key.clone(schema);
+			if (identity.isNode(value)) value = value.clone(schema);
+			return new Pair(key, value);
+		}
+		toJSON(_, ctx) {
+			const pair = ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {};
+			return addPairToJSMap.addPairToJSMap(ctx, pair, this);
+		}
+		toString(ctx, onComment, onChompKeep) {
+			return ctx?.doc ? stringifyPair.stringifyPair(this, ctx, onComment, onChompKeep) : JSON.stringify(this);
+		}
+	};
+	exports.Pair = Pair;
+	exports.createPair = createPair;
+}));
+//#endregion
+export default require_Pair();
+export { require_Pair };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/Scalar.mjs

@@ -0,0 +1,33 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "./identity.mjs";
+import { require_toJS } from "./toJS.mjs";
+import { require_Node } from "./Node.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/Scalar.js
+var require_Scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var Node = require_Node();
+	var toJS = require_toJS();
+	const isScalarValue = (value) => !value || typeof value !== "function" && typeof value !== "object";
+	var Scalar = class extends Node.NodeBase {
+		constructor(value) {
+			super(identity.SCALAR);
+			this.value = value;
+		}
+		toJSON(arg, ctx) {
+			return ctx?.keep ? this.value : toJS.toJS(this.value, arg, ctx);
+		}
+		toString() {
+			return String(this.value);
+		}
+	};
+	Scalar.BLOCK_FOLDED = "BLOCK_FOLDED";
+	Scalar.BLOCK_LITERAL = "BLOCK_LITERAL";
+	Scalar.PLAIN = "PLAIN";
+	Scalar.QUOTE_DOUBLE = "QUOTE_DOUBLE";
+	Scalar.QUOTE_SINGLE = "QUOTE_SINGLE";
+	exports.Scalar = Scalar;
+	exports.isScalarValue = isScalarValue;
+}));
+//#endregion
+export default require_Scalar();
+export { require_Scalar };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/YAMLMap.mjs

@@ -0,0 +1,118 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "./identity.mjs";
+import { require_Scalar } from "./Scalar.mjs";
+import { require_Collection } from "./Collection.mjs";
+import { require_addPairToJSMap } from "./addPairToJSMap.mjs";
+import { require_Pair } from "./Pair.mjs";
+import { require_stringifyCollection } from "../stringify/stringifyCollection.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/YAMLMap.js
+var require_YAMLMap = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var stringifyCollection = require_stringifyCollection();
+	var addPairToJSMap = require_addPairToJSMap();
+	var Collection = require_Collection();
+	var identity = require_identity();
+	var Pair = require_Pair();
+	var Scalar = require_Scalar();
+	function findPair(items, key) {
+		const k = identity.isScalar(key) ? key.value : key;
+		for (const it of items) if (identity.isPair(it)) {
+			if (it.key === key || it.key === k) return it;
+			if (identity.isScalar(it.key) && it.key.value === k) return it;
+		}
+	}
+	var YAMLMap = class extends Collection.Collection {
+		static get tagName() {
+			return "tag:yaml.org,2002:map";
+		}
+		constructor(schema) {
+			super(identity.MAP, schema);
+			this.items = [];
+		}
+		/**
+		* A generic collection parsing method that can be extended
+		* to other node classes that inherit from YAMLMap
+		*/
+		static from(schema, obj, ctx) {
+			const { keepUndefined, replacer } = ctx;
+			const map = new this(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 || keepUndefined) map.items.push(Pair.createPair(key, value, ctx));
+			};
+			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 schema.sortMapEntries === "function") map.items.sort(schema.sortMapEntries);
+			return map;
+		}
+		/**
+		* Adds a value to the collection.
+		*
+		* @param overwrite - If not set `true`, using a key that is already in the
+		*   collection will throw. Otherwise, overwrites the previous value.
+		*/
+		add(pair, overwrite) {
+			let _pair;
+			if (identity.isPair(pair)) _pair = pair;
+			else if (!pair || typeof pair !== "object" || !("key" in pair)) _pair = new Pair.Pair(pair, pair?.value);
+			else _pair = new Pair.Pair(pair.key, pair.value);
+			const prev = findPair(this.items, _pair.key);
+			const sortEntries = this.schema?.sortMapEntries;
+			if (prev) {
+				if (!overwrite) throw new Error(`Key ${_pair.key} already set`);
+				if (identity.isScalar(prev.value) && Scalar.isScalarValue(_pair.value)) prev.value.value = _pair.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, keepScalar) {
+			const node = findPair(this.items, key)?.value;
+			return (!keepScalar && identity.isScalar(node) ? node.value : node) ?? void 0;
+		}
+		has(key) {
+			return !!findPair(this.items, key);
+		}
+		set(key, value) {
+			this.add(new Pair.Pair(key, value), true);
+		}
+		/**
+		* @param ctx - Conversion context, originally set in Document#toJS()
+		* @param {Class} Type - If set, forces the returned collection type
+		* @returns Instance of Type, Map, or Object
+		*/
+		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.addPairToJSMap(ctx, map, item);
+			return map;
+		}
+		toString(ctx, onComment, onChompKeep) {
+			if (!ctx) return JSON.stringify(this);
+			for (const item of this.items) if (!identity.isPair(item)) throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);
+			if (!ctx.allNullValues && this.hasAllNullValues(false)) ctx = Object.assign({}, ctx, { allNullValues: true });
+			return stringifyCollection.stringifyCollection(this, ctx, {
+				blockItemPrefix: "",
+				flowChars: {
+					start: "{",
+					end: "}"
+				},
+				itemIndent: ctx.indent || "",
+				onChompKeep,
+				onComment
+			});
+		}
+	};
+	exports.YAMLMap = YAMLMap;
+	exports.findPair = findPair;
+}));
+//#endregion
+export default require_YAMLMap();
+export { require_YAMLMap };