cngpac 0.0.1

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/public-api.mjs

@@ -0,0 +1,97 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "./nodes/identity.mjs";
+import { require_log } from "./log.mjs";
+import { require_Document } from "./doc/Document.mjs";
+import { require_errors } from "./errors.mjs";
+import { require_composer } from "./compose/composer.mjs";
+import { require_line_counter } from "./parse/line-counter.mjs";
+import { require_parser } from "./parse/parser.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/public-api.js
+var require_public_api = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var composer = require_composer();
+	var Document = require_Document();
+	var errors = require_errors();
+	var log = require_log();
+	var identity = require_identity();
+	var lineCounter = require_line_counter();
+	var parser = require_parser();
+	function parseOptions(options) {
+		const prettyErrors = options.prettyErrors !== false;
+		return {
+			lineCounter: options.lineCounter || prettyErrors && new lineCounter.LineCounter() || null,
+			prettyErrors
+		};
+	}
+	/**
+	* Parse the input as a stream of YAML documents.
+	*
+	* Documents should be separated from each other by `...` or `---` marker lines.
+	*
+	* @returns If an empty `docs` array is returned, it will be of type
+	*   EmptyStream and contain additional stream information. In
+	*   TypeScript, you should use `'empty' in docs` as a type guard for it.
+	*/
+	function parseAllDocuments(source, options = {}) {
+		const { lineCounter, prettyErrors } = parseOptions(options);
+		const parser$1 = new parser.Parser(lineCounter?.addNewLine);
+		const composer$1 = new composer.Composer(options);
+		const docs = Array.from(composer$1.compose(parser$1.parse(source)));
+		if (prettyErrors && lineCounter) for (const doc of docs) {
+			doc.errors.forEach(errors.prettifyError(source, lineCounter));
+			doc.warnings.forEach(errors.prettifyError(source, lineCounter));
+		}
+		if (docs.length > 0) return docs;
+		return Object.assign([], { empty: true }, composer$1.streamInfo());
+	}
+	/** Parse an input string into a single YAML.Document */
+	function parseDocument(source, options = {}) {
+		const { lineCounter, prettyErrors } = parseOptions(options);
+		const parser$1 = new parser.Parser(lineCounter?.addNewLine);
+		const composer$1 = new composer.Composer(options);
+		let doc = null;
+		for (const _doc of composer$1.compose(parser$1.parse(source), true, source.length)) if (!doc) doc = _doc;
+		else if (doc.options.logLevel !== "silent") {
+			doc.errors.push(new errors.YAMLParseError(_doc.range.slice(0, 2), "MULTIPLE_DOCS", "Source contains multiple documents; please use YAML.parseAllDocuments()"));
+			break;
+		}
+		if (prettyErrors && lineCounter) {
+			doc.errors.forEach(errors.prettifyError(source, lineCounter));
+			doc.warnings.forEach(errors.prettifyError(source, lineCounter));
+		}
+		return doc;
+	}
+	function parse(src, reviver, options) {
+		let _reviver = void 0;
+		if (typeof reviver === "function") _reviver = reviver;
+		else if (options === void 0 && reviver && typeof reviver === "object") options = reviver;
+		const doc = parseDocument(src, options);
+		if (!doc) return null;
+		doc.warnings.forEach((warning) => log.warn(doc.options.logLevel, warning));
+		if (doc.errors.length > 0) if (doc.options.logLevel !== "silent") throw doc.errors[0];
+		else doc.errors = [];
+		return doc.toJS(Object.assign({ reviver: _reviver }, options));
+	}
+	function stringify(value, replacer, options) {
+		let _replacer = null;
+		if (typeof replacer === "function" || Array.isArray(replacer)) _replacer = replacer;
+		else if (options === void 0 && replacer) options = replacer;
+		if (typeof options === "string") options = options.length;
+		if (typeof options === "number") {
+			const indent = Math.round(options);
+			options = indent < 1 ? void 0 : indent > 8 ? { indent: 8 } : { indent };
+		}
+		if (value === void 0) {
+			const { keepUndefined } = options ?? replacer ?? {};
+			if (!keepUndefined) return void 0;
+		}
+		if (identity.isDocument(value) && !_replacer) return value.toString(options);
+		return new Document.Document(value, _replacer, options).toString(options);
+	}
+	exports.parse = parse;
+	exports.parseAllDocuments = parseAllDocuments;
+	exports.parseDocument = parseDocument;
+	exports.stringify = stringify;
+}));
+//#endregion
+export default require_public_api();
+export { require_public_api };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/Schema.mjs

@@ -0,0 +1,36 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+import { require_map } from "./common/map.mjs";
+import { require_seq } from "./common/seq.mjs";
+import { require_string } from "./common/string.mjs";
+import { require_tags } from "./tags.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/Schema.js
+var require_Schema = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var map = require_map();
+	var seq = require_seq();
+	var string = require_string();
+	var tags = require_tags();
+	const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+	exports.Schema = class Schema {
+		constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
+			this.compat = Array.isArray(compat) ? tags.getTags(compat, "compat") : compat ? tags.getTags(null, compat) : null;
+			this.name = typeof schema === "string" && schema || "core";
+			this.knownTags = resolveKnownTags ? tags.coreKnownTags : {};
+			this.tags = tags.getTags(customTags, this.name, merge);
+			this.toStringOptions = toStringDefaults ?? null;
+			Object.defineProperty(this, identity.MAP, { value: map.map });
+			Object.defineProperty(this, identity.SCALAR, { value: string.string });
+			Object.defineProperty(this, identity.SEQ, { value: seq.seq });
+			this.sortMapEntries = typeof sortMapEntries === "function" ? sortMapEntries : sortMapEntries === true ? sortMapEntriesByKey : null;
+		}
+		clone() {
+			const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));
+			copy.tags = this.tags.slice();
+			return copy;
+		}
+	};
+}));
+//#endregion
+export default require_Schema();
+export { require_Schema };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/common/map.mjs

@@ -0,0 +1,22 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../../nodes/identity.mjs";
+import { require_YAMLMap } from "../../nodes/YAMLMap.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/common/map.js
+var require_map = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var YAMLMap = require_YAMLMap();
+	exports.map = {
+		collection: "map",
+		default: true,
+		nodeClass: YAMLMap.YAMLMap,
+		tag: "tag:yaml.org,2002:map",
+		resolve(map, onError) {
+			if (!identity.isMap(map)) onError("Expected a mapping for this tag");
+			return map;
+		},
+		createNode: (schema, obj, ctx) => YAMLMap.YAMLMap.from(schema, obj, ctx)
+	};
+}));
+//#endregion
+export default require_map();
+export { require_map };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/common/null.mjs

@@ -0,0 +1,19 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_Scalar } from "../../nodes/Scalar.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/common/null.js
+var require_null = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Scalar = require_Scalar();
+	const nullTag = {
+		identify: (value) => value == null,
+		createNode: () => new Scalar.Scalar(null),
+		default: true,
+		tag: "tag:yaml.org,2002:null",
+		test: /^(?:~|[Nn]ull|NULL)?$/,
+		resolve: () => new Scalar.Scalar(null),
+		stringify: ({ source }, ctx) => typeof source === "string" && nullTag.test.test(source) ? source : ctx.options.nullStr
+	};
+	exports.nullTag = nullTag;
+}));
+//#endregion
+export default require_null();
+export { require_null };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/common/seq.mjs

@@ -0,0 +1,22 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../../nodes/identity.mjs";
+import { require_YAMLSeq } from "../../nodes/YAMLSeq.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/common/seq.js
+var require_seq = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var YAMLSeq = require_YAMLSeq();
+	exports.seq = {
+		collection: "seq",
+		default: true,
+		nodeClass: YAMLSeq.YAMLSeq,
+		tag: "tag:yaml.org,2002:seq",
+		resolve(seq, onError) {
+			if (!identity.isSeq(seq)) onError("Expected a sequence for this tag");
+			return seq;
+		},
+		createNode: (schema, obj, ctx) => YAMLSeq.YAMLSeq.from(schema, obj, ctx)
+	};
+}));
+//#endregion
+export default require_seq();
+export { require_seq };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/common/string.mjs

@@ -0,0 +1,19 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_stringifyString } from "../../stringify/stringifyString.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/common/string.js
+var require_string = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var stringifyString = require_stringifyString();
+	exports.string = {
+		identify: (value) => typeof value === "string",
+		default: true,
+		tag: "tag:yaml.org,2002:str",
+		resolve: (str) => str,
+		stringify(item, ctx, onComment, onChompKeep) {
+			ctx = Object.assign({ actualString: true }, ctx);
+			return stringifyString.stringifyString(item, ctx, onComment, onChompKeep);
+		}
+	};
+}));
+//#endregion
+export default require_string();
+export { require_string };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/core/bool.mjs

@@ -0,0 +1,23 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_Scalar } from "../../nodes/Scalar.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/core/bool.js
+var require_bool = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Scalar = require_Scalar();
+	const boolTag = {
+		identify: (value) => typeof value === "boolean",
+		default: true,
+		tag: "tag:yaml.org,2002:bool",
+		test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
+		resolve: (str) => new Scalar.Scalar(str[0] === "t" || str[0] === "T"),
+		stringify({ source, value }, ctx) {
+			if (source && boolTag.test.test(source)) {
+				if (value === (source[0] === "t" || source[0] === "T")) return source;
+			}
+			return value ? ctx.options.trueStr : ctx.options.falseStr;
+		}
+	};
+	exports.boolTag = boolTag;
+}));
+//#endregion
+export default require_bool();
+export { require_bool };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/core/float.mjs

@@ -0,0 +1,46 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_Scalar } from "../../nodes/Scalar.mjs";
+import { require_stringifyNumber } from "../../stringify/stringifyNumber.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/core/float.js
+var require_float = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Scalar = require_Scalar();
+	var stringifyNumber = require_stringifyNumber();
+	const floatNaN = {
+		identify: (value) => typeof value === "number",
+		default: true,
+		tag: "tag:yaml.org,2002:float",
+		test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
+		resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
+		stringify: stringifyNumber.stringifyNumber
+	};
+	const floatExp = {
+		identify: (value) => typeof value === "number",
+		default: true,
+		tag: "tag:yaml.org,2002:float",
+		format: "EXP",
+		test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
+		resolve: (str) => parseFloat(str),
+		stringify(node) {
+			const num = Number(node.value);
+			return isFinite(num) ? num.toExponential() : stringifyNumber.stringifyNumber(node);
+		}
+	};
+	exports.float = {
+		identify: (value) => typeof value === "number",
+		default: true,
+		tag: "tag:yaml.org,2002:float",
+		test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
+		resolve(str) {
+			const node = new Scalar.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.stringifyNumber
+	};
+	exports.floatExp = floatExp;
+	exports.floatNaN = floatNaN;
+}));
+//#endregion
+export default require_float();
+export { require_float };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/core/int.mjs

@@ -0,0 +1,45 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_stringifyNumber } from "../../stringify/stringifyNumber.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/core/int.js
+var require_int = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var stringifyNumber = require_stringifyNumber();
+	const intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
+	const intResolve = (str, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix);
+	function intStringify(node, radix, prefix) {
+		const { value } = node;
+		if (intIdentify(value) && value >= 0) return prefix + value.toString(radix);
+		return stringifyNumber.stringifyNumber(node);
+	}
+	const intOct = {
+		identify: (value) => intIdentify(value) && value >= 0,
+		default: true,
+		tag: "tag:yaml.org,2002:int",
+		format: "OCT",
+		test: /^0o[0-7]+$/,
+		resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt),
+		stringify: (node) => intStringify(node, 8, "0o")
+	};
+	const int = {
+		identify: intIdentify,
+		default: true,
+		tag: "tag:yaml.org,2002:int",
+		test: /^[-+]?[0-9]+$/,
+		resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
+		stringify: stringifyNumber.stringifyNumber
+	};
+	const intHex = {
+		identify: (value) => intIdentify(value) && value >= 0,
+		default: true,
+		tag: "tag:yaml.org,2002:int",
+		format: "HEX",
+		test: /^0x[0-9a-fA-F]+$/,
+		resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
+		stringify: (node) => intStringify(node, 16, "0x")
+	};
+	exports.int = int;
+	exports.intHex = intHex;
+	exports.intOct = intOct;
+}));
+//#endregion
+export default require_int();
+export { require_int };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/core/schema.mjs

@@ -0,0 +1,34 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_map } from "../common/map.mjs";
+import { require_seq } from "../common/seq.mjs";
+import { require_string } from "../common/string.mjs";
+import { require_null } from "../common/null.mjs";
+import { require_bool } from "./bool.mjs";
+import { require_float } from "./float.mjs";
+import { require_int } from "./int.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/core/schema.js
+var require_schema = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var map = require_map();
+	var _null = require_null();
+	var seq = require_seq();
+	var string = require_string();
+	var bool = require_bool();
+	var float = require_float();
+	var int = require_int();
+	exports.schema = [
+		map.map,
+		seq.seq,
+		string.string,
+		_null.nullTag,
+		bool.boolTag,
+		int.intOct,
+		int.int,
+		int.intHex,
+		float.floatNaN,
+		float.floatExp,
+		float.float
+	];
+}));
+//#endregion
+export default require_schema();
+export { require_schema };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/json/schema.mjs

@@ -0,0 +1,68 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_Scalar } from "../../nodes/Scalar.mjs";
+import { require_map } from "../common/map.mjs";
+import { require_seq } from "../common/seq.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/json/schema.js
+var require_schema = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Scalar = require_Scalar();
+	var map = require_map();
+	var seq = require_seq();
+	function intIdentify(value) {
+		return typeof value === "bigint" || Number.isInteger(value);
+	}
+	const stringifyJSON = ({ value }) => JSON.stringify(value);
+	const jsonScalars = [
+		{
+			identify: (value) => typeof value === "string",
+			default: true,
+			tag: "tag:yaml.org,2002:str",
+			resolve: (str) => str,
+			stringify: stringifyJSON
+		},
+		{
+			identify: (value) => value == null,
+			createNode: () => new Scalar.Scalar(null),
+			default: true,
+			tag: "tag:yaml.org,2002:null",
+			test: /^null$/,
+			resolve: () => null,
+			stringify: stringifyJSON
+		},
+		{
+			identify: (value) => typeof value === "boolean",
+			default: true,
+			tag: "tag:yaml.org,2002:bool",
+			test: /^true$|^false$/,
+			resolve: (str) => str === "true",
+			stringify: stringifyJSON
+		},
+		{
+			identify: intIdentify,
+			default: true,
+			tag: "tag:yaml.org,2002:int",
+			test: /^-?(?:0|[1-9][0-9]*)$/,
+			resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),
+			stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value)
+		},
+		{
+			identify: (value) => typeof value === "number",
+			default: true,
+			tag: "tag:yaml.org,2002:float",
+			test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
+			resolve: (str) => parseFloat(str),
+			stringify: stringifyJSON
+		}
+	];
+	exports.schema = [map.map, seq.seq].concat(jsonScalars, {
+		default: true,
+		tag: "",
+		test: /^/,
+		resolve(str, onError) {
+			onError(`Unresolved plain scalar ${JSON.stringify(str)}`);
+			return str;
+		}
+	});
+}));
+//#endregion
+export default require_schema();
+export { require_schema };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/tags.mjs

@@ -0,0 +1,103 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_merge } from "./yaml-1.1/merge.mjs";
+import { require_map } from "./common/map.mjs";
+import { require_seq } from "./common/seq.mjs";
+import { require_string } from "./common/string.mjs";
+import { require_null } from "./common/null.mjs";
+import { require_bool } from "./core/bool.mjs";
+import { require_float } from "./core/float.mjs";
+import { require_int } from "./core/int.mjs";
+import { require_schema } from "./core/schema.mjs";
+import { require_schema as require_schema$1 } from "./json/schema.mjs";
+import { require_binary } from "./yaml-1.1/binary.mjs";
+import { require_pairs } from "./yaml-1.1/pairs.mjs";
+import { require_omap } from "./yaml-1.1/omap.mjs";
+import { require_set } from "./yaml-1.1/set.mjs";
+import { require_timestamp } from "./yaml-1.1/timestamp.mjs";
+import { require_schema as require_schema$2 } from "./yaml-1.1/schema.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/tags.js
+var require_tags = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var map = require_map();
+	var _null = require_null();
+	var seq = require_seq();
+	var string = require_string();
+	var bool = require_bool();
+	var float = require_float();
+	var int = require_int();
+	var schema = require_schema();
+	var schema$1 = require_schema$1();
+	var binary = require_binary();
+	var merge = require_merge();
+	var omap = require_omap();
+	var pairs = require_pairs();
+	var schema$2 = require_schema$2();
+	var set = require_set();
+	var timestamp = require_timestamp();
+	const schemas = new Map([
+		["core", schema.schema],
+		["failsafe", [
+			map.map,
+			seq.seq,
+			string.string
+		]],
+		["json", schema$1.schema],
+		["yaml11", schema$2.schema],
+		["yaml-1.1", schema$2.schema]
+	]);
+	const tagsByName = {
+		binary: binary.binary,
+		bool: bool.boolTag,
+		float: float.float,
+		floatExp: float.floatExp,
+		floatNaN: float.floatNaN,
+		floatTime: timestamp.floatTime,
+		int: int.int,
+		intHex: int.intHex,
+		intOct: int.intOct,
+		intTime: timestamp.intTime,
+		map: map.map,
+		merge: merge.merge,
+		null: _null.nullTag,
+		omap: omap.omap,
+		pairs: pairs.pairs,
+		seq: seq.seq,
+		set: set.set,
+		timestamp: timestamp.timestamp
+	};
+	const coreKnownTags = {
+		"tag:yaml.org,2002:binary": binary.binary,
+		"tag:yaml.org,2002:merge": merge.merge,
+		"tag:yaml.org,2002:omap": omap.omap,
+		"tag:yaml.org,2002:pairs": pairs.pairs,
+		"tag:yaml.org,2002:set": set.set,
+		"tag:yaml.org,2002:timestamp": timestamp.timestamp
+	};
+	function getTags(customTags, schemaName, addMergeTag) {
+		const schemaTags = schemas.get(schemaName);
+		if (schemaTags && !customTags) return addMergeTag && !schemaTags.includes(merge.merge) ? schemaTags.concat(merge.merge) : schemaTags.slice();
+		let tags = schemaTags;
+		if (!tags) if (Array.isArray(customTags)) tags = [];
+		else {
+			const keys = Array.from(schemas.keys()).filter((key) => key !== "yaml11").map((key) => JSON.stringify(key)).join(", ");
+			throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
+		}
+		if (Array.isArray(customTags)) for (const tag of customTags) tags = tags.concat(tag);
+		else if (typeof customTags === "function") tags = customTags(tags.slice());
+		if (addMergeTag) tags = tags.concat(merge.merge);
+		return tags.reduce((tags, tag) => {
+			const tagObj = typeof tag === "string" ? tagsByName[tag] : tag;
+			if (!tagObj) {
+				const tagName = JSON.stringify(tag);
+				const keys = Object.keys(tagsByName).map((key) => JSON.stringify(key)).join(", ");
+				throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);
+			}
+			if (!tags.includes(tagObj)) tags.push(tagObj);
+			return tags;
+		}, []);
+	}
+	exports.coreKnownTags = coreKnownTags;
+	exports.getTags = getTags;
+}));
+//#endregion
+export default require_tags();
+export { require_tags };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/yaml-1.1/binary.mjs

@@ -0,0 +1,53 @@
+import { __commonJSMin, __require } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_Scalar } from "../../nodes/Scalar.mjs";
+import { require_stringifyString } from "../../stringify/stringifyString.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/yaml-1.1/binary.js
+var require_binary = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var node_buffer = __require("buffer");
+	var Scalar = require_Scalar();
+	var stringifyString = require_stringifyString();
+	exports.binary = {
+		identify: (value) => value instanceof Uint8Array,
+		default: false,
+		tag: "tag:yaml.org,2002:binary",
+		resolve(src, onError) {
+			if (typeof node_buffer.Buffer === "function") return node_buffer.Buffer.from(src, "base64");
+			else if (typeof atob === "function") {
+				const str = atob(src.replace(/[\n\r]/g, ""));
+				const buffer = new Uint8Array(str.length);
+				for (let i = 0; i < str.length; ++i) buffer[i] = str.charCodeAt(i);
+				return buffer;
+			} else {
+				onError("This environment does not support reading binary tags; either Buffer or atob is required");
+				return src;
+			}
+		},
+		stringify({ comment, type, value }, ctx, onComment, onChompKeep) {
+			if (!value) return "";
+			const buf = value;
+			let str;
+			if (typeof node_buffer.Buffer === "function") str = buf instanceof node_buffer.Buffer ? buf.toString("base64") : node_buffer.Buffer.from(buf.buffer).toString("base64");
+			else if (typeof btoa === "function") {
+				let s = "";
+				for (let i = 0; i < buf.length; ++i) s += String.fromCharCode(buf[i]);
+				str = btoa(s);
+			} else throw new Error("This environment does not support writing binary tags; either Buffer or btoa is required");
+			type ?? (type = Scalar.Scalar.BLOCK_LITERAL);
+			if (type !== Scalar.Scalar.QUOTE_DOUBLE) {
+				const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);
+				const n = Math.ceil(str.length / lineWidth);
+				const lines = new Array(n);
+				for (let i = 0, o = 0; i < n; ++i, o += lineWidth) lines[i] = str.substr(o, lineWidth);
+				str = lines.join(type === Scalar.Scalar.BLOCK_LITERAL ? "\n" : " ");
+			}
+			return stringifyString.stringifyString({
+				comment,
+				type,
+				value: str
+			}, ctx, onComment, onChompKeep);
+		}
+	};
+}));
+//#endregion
+export default require_binary();
+export { require_binary };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/yaml-1.1/bool.mjs

@@ -0,0 +1,31 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_Scalar } from "../../nodes/Scalar.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/yaml-1.1/bool.js
+var require_bool = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Scalar = require_Scalar();
+	function boolStringify({ value, source }, ctx) {
+		if (source && (value ? trueTag : falseTag).test.test(source)) return source;
+		return value ? ctx.options.trueStr : ctx.options.falseStr;
+	}
+	const trueTag = {
+		identify: (value) => value === true,
+		default: true,
+		tag: "tag:yaml.org,2002:bool",
+		test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
+		resolve: () => new Scalar.Scalar(true),
+		stringify: boolStringify
+	};
+	const falseTag = {
+		identify: (value) => value === false,
+		default: true,
+		tag: "tag:yaml.org,2002:bool",
+		test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,
+		resolve: () => new Scalar.Scalar(false),
+		stringify: boolStringify
+	};
+	exports.falseTag = falseTag;
+	exports.trueTag = trueTag;
+}));
+//#endregion
+export default require_bool();
+export { require_bool };