cngpac 0.0.1

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

@@ -0,0 +1,49 @@
+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/yaml-1.1/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.replace(/_/g, "")),
+		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.replace(/_/g, "")));
+			const dot = str.indexOf(".");
+			if (dot !== -1) {
+				const f = str.substring(dot + 1).replace(/_/g, "");
+				if (f[f.length - 1] === "0") node.minFractionDigits = f.length;
+			}
+			return node;
+		},
+		stringify: stringifyNumber.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/yaml-1.1/int.mjs

@@ -0,0 +1,79 @@
+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/yaml-1.1/int.js
+var require_int = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var stringifyNumber = require_stringifyNumber();
+	const intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
+	function intResolve(str, offset, radix, { intAsBigInt }) {
+		const sign = str[0];
+		if (sign === "-" || sign === "+") offset += 1;
+		str = str.substring(offset).replace(/_/g, "");
+		if (intAsBigInt) {
+			switch (radix) {
+				case 2:
+					str = `0b${str}`;
+					break;
+				case 8:
+					str = `0o${str}`;
+					break;
+				case 16:
+					str = `0x${str}`;
+					break;
+			}
+			const n = BigInt(str);
+			return sign === "-" ? BigInt(-1) * n : n;
+		}
+		const n = parseInt(str, radix);
+		return sign === "-" ? -1 * n : n;
+	}
+	function intStringify(node, radix, prefix) {
+		const { value } = node;
+		if (intIdentify(value)) {
+			const str = value.toString(radix);
+			return value < 0 ? "-" + prefix + str.substr(1) : prefix + str;
+		}
+		return stringifyNumber.stringifyNumber(node);
+	}
+	const intBin = {
+		identify: intIdentify,
+		default: true,
+		tag: "tag:yaml.org,2002:int",
+		format: "BIN",
+		test: /^[-+]?0b[0-1_]+$/,
+		resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),
+		stringify: (node) => intStringify(node, 2, "0b")
+	};
+	const intOct = {
+		identify: intIdentify,
+		default: true,
+		tag: "tag:yaml.org,2002:int",
+		format: "OCT",
+		test: /^[-+]?0[0-7_]+$/,
+		resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),
+		stringify: (node) => intStringify(node, 8, "0")
+	};
+	const int = {
+		identify: intIdentify,
+		default: true,
+		tag: "tag:yaml.org,2002:int",
+		test: /^[-+]?[0-9][0-9_]*$/,
+		resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
+		stringify: stringifyNumber.stringifyNumber
+	};
+	const intHex = {
+		identify: intIdentify,
+		default: true,
+		tag: "tag:yaml.org,2002:int",
+		format: "HEX",
+		test: /^[-+]?0x[0-9a-fA-F_]+$/,
+		resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
+		stringify: (node) => intStringify(node, 16, "0x")
+	};
+	exports.int = int;
+	exports.intBin = intBin;
+	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/yaml-1.1/merge.mjs

@@ -0,0 +1,45 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../../nodes/identity.mjs";
+import { require_Scalar } from "../../nodes/Scalar.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/yaml-1.1/merge.js
+var require_merge = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var Scalar = require_Scalar();
+	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.Scalar(Symbol(MERGE_KEY)), { addToJSMap: addMergeToJSMap }),
+		stringify: () => MERGE_KEY
+	};
+	const isMergeKey = (ctx, key) => (merge.identify(key) || identity.isScalar(key) && (!key.type || key.type === Scalar.Scalar.PLAIN) && merge.identify(key.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default);
+	function addMergeToJSMap(ctx, map, value) {
+		value = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
+		if (identity.isSeq(value)) 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 source = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
+		if (!identity.isMap(source)) throw new Error("Merge sources must be maps or map aliases");
+		const srcMap = source.toJSON(null, ctx, Map);
+		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;
+	}
+	exports.addMergeToJSMap = addMergeToJSMap;
+	exports.isMergeKey = isMergeKey;
+	exports.merge = merge;
+}));
+//#endregion
+export default require_merge();
+export { require_merge };

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

@@ -0,0 +1,71 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../../nodes/identity.mjs";
+import { require_toJS } from "../../nodes/toJS.mjs";
+import { require_YAMLMap } from "../../nodes/YAMLMap.mjs";
+import { require_YAMLSeq } from "../../nodes/YAMLSeq.mjs";
+import { require_pairs } from "./pairs.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/yaml-1.1/omap.js
+var require_omap = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var toJS = require_toJS();
+	var YAMLMap = require_YAMLMap();
+	var YAMLSeq = require_YAMLSeq();
+	var pairs = require_pairs();
+	var YAMLOMap = class YAMLOMap extends YAMLSeq.YAMLSeq {
+		constructor() {
+			super();
+			this.add = YAMLMap.YAMLMap.prototype.add.bind(this);
+			this.delete = YAMLMap.YAMLMap.prototype.delete.bind(this);
+			this.get = YAMLMap.YAMLMap.prototype.get.bind(this);
+			this.has = YAMLMap.YAMLMap.prototype.has.bind(this);
+			this.set = YAMLMap.YAMLMap.prototype.set.bind(this);
+			this.tag = YAMLOMap.tag;
+		}
+		/**
+		* If `ctx` is given, the return type is actually `Map<unknown, unknown>`,
+		* but TypeScript won't allow widening the signature of a child method.
+		*/
+		toJSON(_, ctx) {
+			if (!ctx) return super.toJSON(_);
+			const map = /* @__PURE__ */ new Map();
+			if (ctx?.onCreate) ctx.onCreate(map);
+			for (const pair of this.items) {
+				let key, value;
+				if (identity.isPair(pair)) {
+					key = toJS.toJS(pair.key, "", ctx);
+					value = toJS.toJS(pair.value, key, ctx);
+				} else key = toJS.toJS(pair, "", ctx);
+				if (map.has(key)) throw new Error("Ordered maps must not include duplicate keys");
+				map.set(key, value);
+			}
+			return map;
+		}
+		static from(schema, iterable, ctx) {
+			const pairs$1 = pairs.createPairs(schema, iterable, ctx);
+			const omap = new this();
+			omap.items = pairs$1.items;
+			return omap;
+		}
+	};
+	YAMLOMap.tag = "tag:yaml.org,2002:omap";
+	const omap = {
+		collection: "seq",
+		identify: (value) => value instanceof Map,
+		nodeClass: YAMLOMap,
+		default: false,
+		tag: "tag:yaml.org,2002:omap",
+		resolve(seq, onError) {
+			const pairs$1 = pairs.resolvePairs(seq, onError);
+			const seenKeys = [];
+			for (const { key } of pairs$1.items) if (identity.isScalar(key)) 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$1);
+		},
+		createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)
+	};
+	exports.YAMLOMap = YAMLOMap;
+	exports.omap = omap;
+}));
+//#endregion
+export default require_omap();
+export { require_omap };

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

@@ -0,0 +1,67 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../../nodes/identity.mjs";
+import { require_Scalar } from "../../nodes/Scalar.mjs";
+import { require_Pair } from "../../nodes/Pair.mjs";
+import { require_YAMLSeq } from "../../nodes/YAMLSeq.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/yaml-1.1/pairs.js
+var require_pairs = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var Pair = require_Pair();
+	var Scalar = require_Scalar();
+	var YAMLSeq = require_YAMLSeq();
+	function resolvePairs(seq, onError) {
+		if (identity.isSeq(seq)) for (let i = 0; i < seq.items.length; ++i) {
+			let item = seq.items[i];
+			if (identity.isPair(item)) continue;
+			else if (identity.isMap(item)) {
+				if (item.items.length > 1) onError("Each pair must have its own sequence indicator");
+				const pair = item.items[0] || new Pair.Pair(new Scalar.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;
+				}
+				item = pair;
+			}
+			seq.items[i] = identity.isPair(item) ? item : new Pair.Pair(item);
+		}
+		else onError("Expected a sequence for this tag");
+		return seq;
+	}
+	function createPairs(schema, iterable, ctx) {
+		const { replacer } = ctx;
+		const pairs = new YAMLSeq.YAMLSeq(schema);
+		pairs.tag = "tag:yaml.org,2002:pairs";
+		let i = 0;
+		if (iterable && Symbol.iterator in Object(iterable)) for (let it of iterable) {
+			if (typeof replacer === "function") it = replacer.call(iterable, String(i++), it);
+			let key, value;
+			if (Array.isArray(it)) if (it.length === 2) {
+				key = it[0];
+				value = it[1];
+			} else throw new TypeError(`Expected [key, value] tuple: ${it}`);
+			else if (it && it instanceof Object) {
+				const keys = Object.keys(it);
+				if (keys.length === 1) {
+					key = keys[0];
+					value = it[key];
+				} else throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);
+			} else key = it;
+			pairs.items.push(Pair.createPair(key, value, ctx));
+		}
+		return pairs;
+	}
+	const pairs = {
+		collection: "seq",
+		default: false,
+		tag: "tag:yaml.org,2002:pairs",
+		resolve: resolvePairs,
+		createNode: createPairs
+	};
+	exports.createPairs = createPairs;
+	exports.pairs = pairs;
+	exports.resolvePairs = resolvePairs;
+}));
+//#endregion
+export default require_pairs();
+export { require_pairs };

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

@@ -0,0 +1,56 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_merge } from "./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_binary } from "./binary.mjs";
+import { require_pairs } from "./pairs.mjs";
+import { require_omap } from "./omap.mjs";
+import { require_bool } from "./bool.mjs";
+import { require_float } from "./float.mjs";
+import { require_int } from "./int.mjs";
+import { require_set } from "./set.mjs";
+import { require_timestamp } from "./timestamp.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/yaml-1.1/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 binary = require_binary();
+	var bool = require_bool();
+	var float = require_float();
+	var int = require_int();
+	var merge = require_merge();
+	var omap = require_omap();
+	var pairs = require_pairs();
+	var set = require_set();
+	var timestamp = require_timestamp();
+	exports.schema = [
+		map.map,
+		seq.seq,
+		string.string,
+		_null.nullTag,
+		bool.trueTag,
+		bool.falseTag,
+		int.intBin,
+		int.intOct,
+		int.int,
+		int.intHex,
+		float.floatNaN,
+		float.floatExp,
+		float.float,
+		binary.binary,
+		merge.merge,
+		omap.omap,
+		pairs.pairs,
+		set.set,
+		timestamp.intTime,
+		timestamp.floatTime,
+		timestamp.timestamp
+	];
+}));
+//#endregion
+export default require_schema();
+export { require_schema };

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

@@ -0,0 +1,74 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../../nodes/identity.mjs";
+import { require_Pair } from "../../nodes/Pair.mjs";
+import { require_YAMLMap } from "../../nodes/YAMLMap.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/schema/yaml-1.1/set.js
+var require_set = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var Pair = require_Pair();
+	var YAMLMap = require_YAMLMap();
+	var YAMLSet = class YAMLSet extends YAMLMap.YAMLMap {
+		constructor(schema) {
+			super(schema);
+			this.tag = YAMLSet.tag;
+		}
+		add(key) {
+			let pair;
+			if (identity.isPair(key)) pair = key;
+			else if (key && typeof key === "object" && "key" in key && "value" in key && key.value === null) pair = new Pair.Pair(key.key, null);
+			else pair = new Pair.Pair(key, null);
+			if (!YAMLMap.findPair(this.items, pair.key)) this.items.push(pair);
+		}
+		/**
+		* If `keepPair` is `true`, returns the Pair matching `key`.
+		* Otherwise, returns the value of that Pair's key.
+		*/
+		get(key, keepPair) {
+			const pair = YAMLMap.findPair(this.items, key);
+			return !keepPair && identity.isPair(pair) ? identity.isScalar(pair.key) ? pair.key.value : pair.key : pair;
+		}
+		set(key, value) {
+			if (typeof value !== "boolean") throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);
+			const prev = YAMLMap.findPair(this.items, key);
+			if (prev && !value) this.items.splice(this.items.indexOf(prev), 1);
+			else if (!prev && value) this.items.push(new Pair.Pair(key));
+		}
+		toJSON(_, ctx) {
+			return super.toJSON(_, ctx, Set);
+		}
+		toString(ctx, onComment, onChompKeep) {
+			if (!ctx) return JSON.stringify(this);
+			if (this.hasAllNullValues(true)) return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep);
+			else throw new Error("Set items must all have null values");
+		}
+		static from(schema, iterable, ctx) {
+			const { replacer } = ctx;
+			const set = new this(schema);
+			if (iterable && Symbol.iterator in Object(iterable)) for (let value of iterable) {
+				if (typeof replacer === "function") value = replacer.call(iterable, value, value);
+				set.items.push(Pair.createPair(value, null, ctx));
+			}
+			return set;
+		}
+	};
+	YAMLSet.tag = "tag:yaml.org,2002:set";
+	const set = {
+		collection: "map",
+		identify: (value) => value instanceof Set,
+		nodeClass: YAMLSet,
+		default: false,
+		tag: "tag:yaml.org,2002:set",
+		createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),
+		resolve(map, onError) {
+			if (identity.isMap(map)) if (map.hasAllNullValues(true)) return Object.assign(new YAMLSet(), map);
+			else onError("Set items must all have null values");
+			else onError("Expected a mapping for this tag");
+			return map;
+		}
+	};
+	exports.YAMLSet = YAMLSet;
+	exports.set = set;
+}));
+//#endregion
+export default require_set();
+export { require_set };

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

@@ -0,0 +1,87 @@
+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/yaml-1.1/timestamp.js
+var require_timestamp = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var stringifyNumber = require_stringifyNumber();
+	/** Internal types handle bigint as number, because TS can't figure it out. */
+	function parseSexagesimal(str, asBigInt) {
+		const sign = str[0];
+		const parts = sign === "-" || sign === "+" ? str.substring(1) : str;
+		const num = (n) => asBigInt ? BigInt(n) : Number(n);
+		const res = parts.replace(/_/g, "").split(":").reduce((res, p) => res * num(60) + num(p), num(0));
+		return sign === "-" ? num(-1) * res : res;
+	}
+	/**
+	* hhhh:mm:ss.sss
+	*
+	* Internal types handle bigint as number, because TS can't figure it out.
+	*/
+	function stringifySexagesimal(node) {
+		let { value } = node;
+		let num = (n) => n;
+		if (typeof value === "bigint") num = (n) => BigInt(n);
+		else if (isNaN(value) || !isFinite(value)) return stringifyNumber.stringifyNumber(node);
+		let sign = "";
+		if (value < 0) {
+			sign = "-";
+			value *= num(-1);
+		}
+		const _60 = num(60);
+		const parts = [value % _60];
+		if (value < 60) parts.unshift(0);
+		else {
+			value = (value - parts[0]) / _60;
+			parts.unshift(value % _60);
+			if (value >= 60) {
+				value = (value - parts[0]) / _60;
+				parts.unshift(value);
+			}
+		}
+		return sign + parts.map((n) => String(n).padStart(2, "0")).join(":").replace(/000000\d*$/, "");
+	}
+	const intTime = {
+		identify: (value) => typeof value === "bigint" || Number.isInteger(value),
+		default: true,
+		tag: "tag:yaml.org,2002:int",
+		format: "TIME",
+		test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,
+		resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt),
+		stringify: stringifySexagesimal
+	};
+	const floatTime = {
+		identify: (value) => typeof value === "number",
+		default: true,
+		tag: "tag:yaml.org,2002:float",
+		format: "TIME",
+		test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/,
+		resolve: (str) => parseSexagesimal(str, false),
+		stringify: stringifySexagesimal
+	};
+	const timestamp = {
+		identify: (value) => value instanceof Date,
+		default: true,
+		tag: "tag:yaml.org,2002:timestamp",
+		test: RegExp("^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?$"),
+		resolve(str) {
+			const match = str.match(timestamp.test);
+			if (!match) throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd");
+			const [, year, month, day, hour, minute, second] = match.map(Number);
+			const millisec = match[7] ? Number((match[7] + "00").substr(1, 3)) : 0;
+			let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);
+			const tz = match[8];
+			if (tz && tz !== "Z") {
+				let d = parseSexagesimal(tz, false);
+				if (Math.abs(d) < 30) d *= 60;
+				date -= 6e4 * d;
+			}
+			return new Date(date);
+		},
+		stringify: ({ value }) => value?.toISOString().replace(/(T00:00:00)?\.000Z$/, "") ?? ""
+	};
+	exports.floatTime = floatTime;
+	exports.intTime = intTime;
+	exports.timestamp = timestamp;
+}));
+//#endregion
+export default require_timestamp();
+export { require_timestamp };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/stringify/foldFlowLines.mjs

@@ -0,0 +1,119 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/stringify/foldFlowLines.js
+var require_foldFlowLines = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const FOLD_FLOW = "flow";
+	const FOLD_BLOCK = "block";
+	const FOLD_QUOTED = "quoted";
+	/**
+	* Tries to keep input at up to `lineWidth` characters, splitting only on spaces
+	* not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are
+	* terminated with `\n` and started with `indent`.
+	*/
+	function foldFlowLines(text, indent, mode = "flow", { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {
+		if (!lineWidth || lineWidth < 0) return text;
+		if (lineWidth < minContentWidth) minContentWidth = 0;
+		const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);
+		if (text.length <= endStep) return text;
+		const folds = [];
+		const escapedFolds = {};
+		let end = lineWidth - indent.length;
+		if (typeof indentAtStart === "number") if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) folds.push(0);
+		else end = lineWidth - indentAtStart;
+		let split = void 0;
+		let prev = void 0;
+		let overflow = false;
+		let i = -1;
+		let escStart = -1;
+		let escEnd = -1;
+		if (mode === FOLD_BLOCK) {
+			i = consumeMoreIndentedLines(text, i, indent.length);
+			if (i !== -1) end = i + endStep;
+		}
+		for (let ch; ch = text[i += 1];) {
+			if (mode === FOLD_QUOTED && ch === "\\") {
+				escStart = i;
+				switch (text[i + 1]) {
+					case "x":
+						i += 3;
+						break;
+					case "u":
+						i += 5;
+						break;
+					case "U":
+						i += 9;
+						break;
+					default: i += 1;
+				}
+				escEnd = i;
+			}
+			if (ch === "\n") {
+				if (mode === FOLD_BLOCK) i = consumeMoreIndentedLines(text, i, indent.length);
+				end = i + indent.length + endStep;
+				split = void 0;
+			} else {
+				if (ch === " " && prev && prev !== " " && prev !== "\n" && prev !== "	") {
+					const next = text[i + 1];
+					if (next && next !== " " && next !== "\n" && next !== "	") split = i;
+				}
+				if (i >= end) if (split) {
+					folds.push(split);
+					end = split + endStep;
+					split = void 0;
+				} else if (mode === FOLD_QUOTED) {
+					while (prev === " " || prev === "	") {
+						prev = ch;
+						ch = text[i += 1];
+						overflow = true;
+					}
+					const j = i > escEnd + 1 ? i - 2 : escStart - 1;
+					if (escapedFolds[j]) return text;
+					folds.push(j);
+					escapedFolds[j] = true;
+					end = j + endStep;
+					split = void 0;
+				} else overflow = true;
+			}
+			prev = ch;
+		}
+		if (overflow && onOverflow) onOverflow();
+		if (folds.length === 0) return text;
+		if (onFold) onFold();
+		let res = text.slice(0, folds[0]);
+		for (let i = 0; i < folds.length; ++i) {
+			const fold = folds[i];
+			const end = folds[i + 1] || text.length;
+			if (fold === 0) res = `\n${indent}${text.slice(0, end)}`;
+			else {
+				if (mode === FOLD_QUOTED && escapedFolds[fold]) res += `${text[fold]}\\`;
+				res += `\n${indent}${text.slice(fold + 1, end)}`;
+			}
+		}
+		return res;
+	}
+	/**
+	* Presumes `i + 1` is at the start of a line
+	* @returns index of last newline in more-indented block
+	*/
+	function consumeMoreIndentedLines(text, i, indent) {
+		let end = i;
+		let start = i + 1;
+		let ch = text[start];
+		while (ch === " " || ch === "	") if (i < start + indent) ch = text[++i];
+		else {
+			do
+				ch = text[++i];
+			while (ch && ch !== "\n");
+			end = i;
+			start = i + 1;
+			ch = text[start];
+		}
+		return end;
+	}
+	exports.FOLD_BLOCK = FOLD_BLOCK;
+	exports.FOLD_FLOW = FOLD_FLOW;
+	exports.FOLD_QUOTED = FOLD_QUOTED;
+	exports.foldFlowLines = foldFlowLines;
+}));
+//#endregion
+export default require_foldFlowLines();
+export { require_foldFlowLines };