cngpac 0.0.1

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-block-seq.mjs

@@ -0,0 +1,48 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_YAMLSeq } from "../nodes/YAMLSeq.mjs";
+import { require_resolve_props } from "./resolve-props.mjs";
+import { require_util_flow_indent_check } from "./util-flow-indent-check.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-block-seq.js
+var require_resolve_block_seq = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var YAMLSeq = require_YAMLSeq();
+	var resolveProps = require_resolve_props();
+	var utilFlowIndentCheck = require_util_flow_indent_check();
+	function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, tag) {
+		const seq = new (tag?.nodeClass ?? YAMLSeq.YAMLSeq)(ctx.schema);
+		if (ctx.atRoot) ctx.atRoot = false;
+		if (ctx.atKey) ctx.atKey = false;
+		let offset = bs.offset;
+		let commentEnd = null;
+		for (const { start, value } of bs.items) {
+			const props = resolveProps.resolveProps(start, {
+				indicator: "seq-item-ind",
+				next: value,
+				offset,
+				onError,
+				parentIndent: bs.indent,
+				startOnNewline: true
+			});
+			if (!props.found) if (props.anchor || props.tag || value) if (value?.type === "block-seq") onError(props.end, "BAD_INDENT", "All sequence items must start at the same column");
+			else onError(offset, "MISSING_CHAR", "Sequence item without - indicator");
+			else {
+				commentEnd = props.end;
+				if (props.comment) seq.comment = props.comment;
+				continue;
+			}
+			const node = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, start, null, props, onError);
+			if (ctx.schema.compat) utilFlowIndentCheck.flowIndentCheck(bs.indent, value, onError);
+			offset = node.range[2];
+			seq.items.push(node);
+		}
+		seq.range = [
+			bs.offset,
+			offset,
+			commentEnd ?? offset
+		];
+		return seq;
+	}
+	exports.resolveBlockSeq = resolveBlockSeq;
+}));
+//#endregion
+export default require_resolve_block_seq();
+export { require_resolve_block_seq };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-end.mjs

@@ -0,0 +1,41 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-end.js
+var require_resolve_end = /* @__PURE__ */ __commonJSMin(((exports) => {
+	function resolveEnd(end, offset, reqSpace, onError) {
+		let comment = "";
+		if (end) {
+			let hasSpace = false;
+			let sep = "";
+			for (const token of end) {
+				const { source, type } = token;
+				switch (type) {
+					case "space":
+						hasSpace = true;
+						break;
+					case "comment": {
+						if (reqSpace && !hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
+						const cb = source.substring(1) || " ";
+						if (!comment) comment = cb;
+						else comment += sep + cb;
+						sep = "";
+						break;
+					}
+					case "newline":
+						if (comment) sep += source;
+						hasSpace = true;
+						break;
+					default: onError(token, "UNEXPECTED_TOKEN", `Unexpected ${type} at node end`);
+				}
+				offset += source.length;
+			}
+		}
+		return {
+			comment,
+			offset
+		};
+	}
+	exports.resolveEnd = resolveEnd;
+}));
+//#endregion
+export default require_resolve_end();
+export { require_resolve_end };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-flow-collection.mjs

@@ -0,0 +1,166 @@
+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";
+import { require_YAMLSeq } from "../nodes/YAMLSeq.mjs";
+import { require_resolve_props } from "./resolve-props.mjs";
+import { require_util_contains_newline } from "./util-contains-newline.mjs";
+import { require_util_map_includes } from "./util-map-includes.mjs";
+import { require_resolve_end } from "./resolve-end.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-flow-collection.js
+var require_resolve_flow_collection = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var Pair = require_Pair();
+	var YAMLMap = require_YAMLMap();
+	var YAMLSeq = require_YAMLSeq();
+	var resolveEnd = require_resolve_end();
+	var resolveProps = require_resolve_props();
+	var utilContainsNewline = require_util_contains_newline();
+	var utilMapIncludes = require_util_map_includes();
+	const blockMsg = "Block collections are not allowed within flow collections";
+	const isBlock = (token) => token && (token.type === "block-map" || token.type === "block-seq");
+	function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) {
+		const isMap = fc.start.source === "{";
+		const fcName = isMap ? "flow map" : "flow sequence";
+		const coll = new (tag?.nodeClass ?? (isMap ? YAMLMap.YAMLMap : YAMLSeq.YAMLSeq))(ctx.schema);
+		coll.flow = true;
+		const atRoot = ctx.atRoot;
+		if (atRoot) ctx.atRoot = false;
+		if (ctx.atKey) ctx.atKey = false;
+		let offset = fc.offset + fc.start.source.length;
+		for (let i = 0; i < fc.items.length; ++i) {
+			const collItem = fc.items[i];
+			const { start, key, sep, value } = collItem;
+			const props = resolveProps.resolveProps(start, {
+				flow: fcName,
+				indicator: "explicit-key-ind",
+				next: key ?? sep?.[0],
+				offset,
+				onError,
+				parentIndent: fc.indent,
+				startOnNewline: false
+			});
+			if (!props.found) {
+				if (!props.anchor && !props.tag && !sep && !value) {
+					if (i === 0 && props.comma) onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
+					else if (i < fc.items.length - 1) onError(props.start, "UNEXPECTED_TOKEN", `Unexpected empty item in ${fcName}`);
+					if (props.comment) if (coll.comment) coll.comment += "\n" + props.comment;
+					else coll.comment = props.comment;
+					offset = props.end;
+					continue;
+				}
+				if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key)) onError(key, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
+			}
+			if (i === 0) {
+				if (props.comma) onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
+			} else {
+				if (!props.comma) onError(props.start, "MISSING_CHAR", `Missing , between ${fcName} items`);
+				if (props.comment) {
+					let prevItemComment = "";
+					loop: for (const st of start) switch (st.type) {
+						case "comma":
+						case "space": break;
+						case "comment":
+							prevItemComment = st.source.substring(1);
+							break loop;
+						default: break loop;
+					}
+					if (prevItemComment) {
+						let prev = coll.items[coll.items.length - 1];
+						if (identity.isPair(prev)) prev = prev.value ?? prev.key;
+						if (prev.comment) prev.comment += "\n" + prevItemComment;
+						else prev.comment = prevItemComment;
+						props.comment = props.comment.substring(prevItemComment.length + 1);
+					}
+				}
+			}
+			if (!isMap && !sep && !props.found) {
+				const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep, null, props, onError);
+				coll.items.push(valueNode);
+				offset = valueNode.range[2];
+				if (isBlock(value)) onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
+			} else {
+				ctx.atKey = true;
+				const keyStart = props.end;
+				const keyNode = key ? composeNode(ctx, key, props, onError) : composeEmptyNode(ctx, keyStart, start, null, props, onError);
+				if (isBlock(key)) onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
+				ctx.atKey = false;
+				const valueProps = resolveProps.resolveProps(sep ?? [], {
+					flow: fcName,
+					indicator: "map-value-ind",
+					next: value,
+					offset: keyNode.range[2],
+					onError,
+					parentIndent: fc.indent,
+					startOnNewline: false
+				});
+				if (valueProps.found) {
+					if (!isMap && !props.found && ctx.options.strict) {
+						if (sep) for (const st of sep) {
+							if (st === valueProps.found) break;
+							if (st.type === "newline") {
+								onError(st, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
+								break;
+							}
+						}
+						if (props.start < valueProps.found.offset - 1024) onError(valueProps.found, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit flow sequence key");
+					}
+				} else if (value) if ("source" in value && value.source?.[0] === ":") onError(value, "MISSING_CHAR", `Missing space after : in ${fcName}`);
+				else onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
+				const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError) : null;
+				if (valueNode) {
+					if (isBlock(value)) onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
+				} else if (valueProps.comment) if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
+				else keyNode.comment = valueProps.comment;
+				const pair = new Pair.Pair(keyNode, valueNode);
+				if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
+				if (isMap) {
+					const map = coll;
+					if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode)) onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
+					map.items.push(pair);
+				} else {
+					const map = new YAMLMap.YAMLMap(ctx.schema);
+					map.flow = true;
+					map.items.push(pair);
+					const endRange = (valueNode ?? keyNode).range;
+					map.range = [
+						keyNode.range[0],
+						endRange[1],
+						endRange[2]
+					];
+					coll.items.push(map);
+				}
+				offset = valueNode ? valueNode.range[2] : valueProps.end;
+			}
+		}
+		const expectedEnd = isMap ? "}" : "]";
+		const [ce, ...ee] = fc.end;
+		let cePos = offset;
+		if (ce?.source === expectedEnd) cePos = ce.offset + ce.source.length;
+		else {
+			const name = fcName[0].toUpperCase() + fcName.substring(1);
+			const msg = atRoot ? `${name} must end with a ${expectedEnd}` : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`;
+			onError(offset, atRoot ? "MISSING_CHAR" : "BAD_INDENT", msg);
+			if (ce && ce.source.length !== 1) ee.unshift(ce);
+		}
+		if (ee.length > 0) {
+			const end = resolveEnd.resolveEnd(ee, cePos, ctx.options.strict, onError);
+			if (end.comment) if (coll.comment) coll.comment += "\n" + end.comment;
+			else coll.comment = end.comment;
+			coll.range = [
+				fc.offset,
+				cePos,
+				end.offset
+			];
+		} else coll.range = [
+			fc.offset,
+			cePos,
+			cePos
+		];
+		return coll;
+	}
+	exports.resolveFlowCollection = resolveFlowCollection;
+}));
+//#endregion
+export default require_resolve_flow_collection();
+export { require_resolve_flow_collection };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-flow-scalar.mjs

@@ -0,0 +1,211 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_Scalar } from "../nodes/Scalar.mjs";
+import { require_resolve_end } from "./resolve-end.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-flow-scalar.js
+var require_resolve_flow_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Scalar = require_Scalar();
+	var resolveEnd = require_resolve_end();
+	function resolveFlowScalar(scalar, strict, onError) {
+		const { offset, type, source, end } = scalar;
+		let _type;
+		let value;
+		const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
+		switch (type) {
+			case "scalar":
+				_type = Scalar.Scalar.PLAIN;
+				value = plainValue(source, _onError);
+				break;
+			case "single-quoted-scalar":
+				_type = Scalar.Scalar.QUOTE_SINGLE;
+				value = singleQuotedValue(source, _onError);
+				break;
+			case "double-quoted-scalar":
+				_type = Scalar.Scalar.QUOTE_DOUBLE;
+				value = doubleQuotedValue(source, _onError);
+				break;
+			default:
+				onError(scalar, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
+				return {
+					value: "",
+					type: null,
+					comment: "",
+					range: [
+						offset,
+						offset + source.length,
+						offset + source.length
+					]
+				};
+		}
+		const valueEnd = offset + source.length;
+		const re = resolveEnd.resolveEnd(end, valueEnd, strict, onError);
+		return {
+			value,
+			type: _type,
+			comment: re.comment,
+			range: [
+				offset,
+				valueEnd,
+				re.offset
+			]
+		};
+	}
+	function plainValue(source, onError) {
+		let badChar = "";
+		switch (source[0]) {
+			case "	":
+				badChar = "a tab character";
+				break;
+			case ",":
+				badChar = "flow indicator character ,";
+				break;
+			case "%":
+				badChar = "directive indicator character %";
+				break;
+			case "|":
+			case ">":
+				badChar = `block scalar indicator ${source[0]}`;
+				break;
+			case "@":
+			case "`":
+				badChar = `reserved character ${source[0]}`;
+				break;
+		}
+		if (badChar) onError(0, "BAD_SCALAR_START", `Plain value cannot start with ${badChar}`);
+		return foldLines(source);
+	}
+	function singleQuotedValue(source, onError) {
+		if (source[source.length - 1] !== "'" || source.length === 1) onError(source.length, "MISSING_CHAR", "Missing closing 'quote");
+		return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+	}
+	function foldLines(source) {
+		/**
+		* The negative lookbehind here and in the `re` RegExp is to
+		* prevent causing a polynomial search time in certain cases.
+		*
+		* The try-catch is for Safari, which doesn't support this yet:
+		* https://caniuse.com/js-regexp-lookbehind
+		*/
+		let first, line;
+		try {
+			first = /* @__PURE__ */ new RegExp("(.*?)(?<![ 	])[ 	]*\r?\n", "sy");
+			line = /* @__PURE__ */ new RegExp("[ 	]*(.*?)(?:(?<![ 	])[ 	]*)?\r?\n", "sy");
+		} catch {
+			first = /(.*?)[ \t]*\r?\n/sy;
+			line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+		}
+		let match = first.exec(source);
+		if (!match) return source;
+		let res = match[1];
+		let sep = " ";
+		let pos = first.lastIndex;
+		line.lastIndex = pos;
+		while (match = line.exec(source)) {
+			if (match[1] === "") if (sep === "\n") res += sep;
+			else sep = "\n";
+			else {
+				res += sep + match[1];
+				sep = " ";
+			}
+			pos = line.lastIndex;
+		}
+		const last = /[ \t]*(.*)/sy;
+		last.lastIndex = pos;
+		match = last.exec(source);
+		return res + sep + (match?.[1] ?? "");
+	}
+	function doubleQuotedValue(source, onError) {
+		let res = "";
+		for (let i = 1; i < source.length - 1; ++i) {
+			const ch = source[i];
+			if (ch === "\r" && source[i + 1] === "\n") continue;
+			if (ch === "\n") {
+				const { fold, offset } = foldNewline(source, i);
+				res += fold;
+				i = offset;
+			} else if (ch === "\\") {
+				let next = source[++i];
+				const cc = escapeCodes[next];
+				if (cc) res += cc;
+				else if (next === "\n") {
+					next = source[i + 1];
+					while (next === " " || next === "	") next = source[++i + 1];
+				} else if (next === "\r" && source[i + 1] === "\n") {
+					next = source[++i + 1];
+					while (next === " " || next === "	") next = source[++i + 1];
+				} else if (next === "x" || next === "u" || next === "U") {
+					const length = {
+						x: 2,
+						u: 4,
+						U: 8
+					}[next];
+					res += parseCharCode(source, i + 1, length, onError);
+					i += length;
+				} else {
+					const raw = source.substr(i - 1, 2);
+					onError(i - 1, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
+					res += raw;
+				}
+			} else if (ch === " " || ch === "	") {
+				const wsStart = i;
+				let next = source[i + 1];
+				while (next === " " || next === "	") next = source[++i + 1];
+				if (next !== "\n" && !(next === "\r" && source[i + 2] === "\n")) res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
+			} else res += ch;
+		}
+		if (source[source.length - 1] !== "\"" || source.length === 1) onError(source.length, "MISSING_CHAR", "Missing closing \"quote");
+		return res;
+	}
+	/**
+	* Fold a single newline into a space, multiple newlines to N - 1 newlines.
+	* Presumes `source[offset] === '\n'`
+	*/
+	function foldNewline(source, offset) {
+		let fold = "";
+		let ch = source[offset + 1];
+		while (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+			if (ch === "\r" && source[offset + 2] !== "\n") break;
+			if (ch === "\n") fold += "\n";
+			offset += 1;
+			ch = source[offset + 1];
+		}
+		if (!fold) fold = " ";
+		return {
+			fold,
+			offset
+		};
+	}
+	const escapeCodes = {
+		"0": "\0",
+		a: "\x07",
+		b: "\b",
+		e: "\x1B",
+		f: "\f",
+		n: "\n",
+		r: "\r",
+		t: "	",
+		v: "\v",
+		N: "…",
+		_: "\xA0",
+		L: "\u2028",
+		P: "\u2029",
+		" ": " ",
+		"\"": "\"",
+		"/": "/",
+		"\\": "\\",
+		"	": "	"
+	};
+	function parseCharCode(source, offset, length, onError) {
+		const cc = source.substr(offset, length);
+		const code = cc.length === length && /^[0-9a-fA-F]+$/.test(cc) ? parseInt(cc, 16) : NaN;
+		if (isNaN(code)) {
+			const raw = source.substr(offset - 2, length + 2);
+			onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
+			return raw;
+		}
+		return String.fromCodePoint(code);
+	}
+	exports.resolveFlowScalar = resolveFlowScalar;
+}));
+//#endregion
+export default require_resolve_flow_scalar();
+export { require_resolve_flow_scalar };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-props.mjs

@@ -0,0 +1,110 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-props.js
+var require_resolve_props = /* @__PURE__ */ __commonJSMin(((exports) => {
+	function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIndent, startOnNewline }) {
+		let spaceBefore = false;
+		let atNewline = startOnNewline;
+		let hasSpace = startOnNewline;
+		let comment = "";
+		let commentSep = "";
+		let hasNewline = false;
+		let reqSpace = false;
+		let tab = null;
+		let anchor = null;
+		let tag = null;
+		let newlineAfterProp = null;
+		let comma = null;
+		let found = null;
+		let start = null;
+		for (const token of tokens) {
+			if (reqSpace) {
+				if (token.type !== "space" && token.type !== "newline" && token.type !== "comma") onError(token.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
+				reqSpace = false;
+			}
+			if (tab) {
+				if (atNewline && token.type !== "comment" && token.type !== "newline") onError(tab, "TAB_AS_INDENT", "Tabs are not allowed as indentation");
+				tab = null;
+			}
+			switch (token.type) {
+				case "space":
+					if (!flow && (indicator !== "doc-start" || next?.type !== "flow-collection") && token.source.includes("	")) tab = token;
+					hasSpace = true;
+					break;
+				case "comment": {
+					if (!hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
+					const cb = token.source.substring(1) || " ";
+					if (!comment) comment = cb;
+					else comment += commentSep + cb;
+					commentSep = "";
+					atNewline = false;
+					break;
+				}
+				case "newline":
+					if (atNewline) {
+						if (comment) comment += token.source;
+						else if (!found || indicator !== "seq-item-ind") spaceBefore = true;
+					} else commentSep += token.source;
+					atNewline = true;
+					hasNewline = true;
+					if (anchor || tag) newlineAfterProp = token;
+					hasSpace = true;
+					break;
+				case "anchor":
+					if (anchor) onError(token, "MULTIPLE_ANCHORS", "A node can have at most one anchor");
+					if (token.source.endsWith(":")) onError(token.offset + token.source.length - 1, "BAD_ALIAS", "Anchor ending in : is ambiguous", true);
+					anchor = token;
+					start ?? (start = token.offset);
+					atNewline = false;
+					hasSpace = false;
+					reqSpace = true;
+					break;
+				case "tag":
+					if (tag) onError(token, "MULTIPLE_TAGS", "A node can have at most one tag");
+					tag = token;
+					start ?? (start = token.offset);
+					atNewline = false;
+					hasSpace = false;
+					reqSpace = true;
+					break;
+				case indicator:
+					if (anchor || tag) onError(token, "BAD_PROP_ORDER", `Anchors and tags must be after the ${token.source} indicator`);
+					if (found) onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.source} in ${flow ?? "collection"}`);
+					found = token;
+					atNewline = indicator === "seq-item-ind" || indicator === "explicit-key-ind";
+					hasSpace = false;
+					break;
+				case "comma": if (flow) {
+					if (comma) onError(token, "UNEXPECTED_TOKEN", `Unexpected , in ${flow}`);
+					comma = token;
+					atNewline = false;
+					hasSpace = false;
+					break;
+				}
+				default:
+					onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.type} token`);
+					atNewline = false;
+					hasSpace = false;
+			}
+		}
+		const last = tokens[tokens.length - 1];
+		const end = last ? last.offset + last.source.length : offset;
+		if (reqSpace && next && next.type !== "space" && next.type !== "newline" && next.type !== "comma" && (next.type !== "scalar" || next.source !== "")) onError(next.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
+		if (tab && (atNewline && tab.indent <= parentIndent || next?.type === "block-map" || next?.type === "block-seq")) onError(tab, "TAB_AS_INDENT", "Tabs are not allowed as indentation");
+		return {
+			comma,
+			found,
+			spaceBefore,
+			comment,
+			hasNewline,
+			anchor,
+			tag,
+			newlineAfterProp,
+			end,
+			start: start ?? end
+		};
+	}
+	exports.resolveProps = resolveProps;
+}));
+//#endregion
+export default require_resolve_props();
+export { require_resolve_props };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/util-contains-newline.mjs

@@ -0,0 +1,32 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/util-contains-newline.js
+var require_util_contains_newline = /* @__PURE__ */ __commonJSMin(((exports) => {
+	function containsNewline(key) {
+		if (!key) return null;
+		switch (key.type) {
+			case "alias":
+			case "scalar":
+			case "double-quoted-scalar":
+			case "single-quoted-scalar":
+				if (key.source.includes("\n")) return true;
+				if (key.end) {
+					for (const st of key.end) if (st.type === "newline") return true;
+				}
+				return false;
+			case "flow-collection":
+				for (const it of key.items) {
+					for (const st of it.start) if (st.type === "newline") return true;
+					if (it.sep) {
+						for (const st of it.sep) if (st.type === "newline") return true;
+					}
+					if (containsNewline(it.key) || containsNewline(it.value)) return true;
+				}
+				return false;
+			default: return true;
+		}
+	}
+	exports.containsNewline = containsNewline;
+}));
+//#endregion
+export default require_util_contains_newline();
+export { require_util_contains_newline };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/util-empty-scalar-position.mjs

@@ -0,0 +1,30 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/util-empty-scalar-position.js
+var require_util_empty_scalar_position = /* @__PURE__ */ __commonJSMin(((exports) => {
+	function emptyScalarPosition(offset, before, pos) {
+		if (before) {
+			pos ?? (pos = before.length);
+			for (let i = pos - 1; i >= 0; --i) {
+				let st = before[i];
+				switch (st.type) {
+					case "space":
+					case "comment":
+					case "newline":
+						offset -= st.source.length;
+						continue;
+				}
+				st = before[++i];
+				while (st?.type === "space") {
+					offset += st.source.length;
+					st = before[++i];
+				}
+				break;
+			}
+		}
+		return offset;
+	}
+	exports.emptyScalarPosition = emptyScalarPosition;
+}));
+//#endregion
+export default require_util_empty_scalar_position();
+export { require_util_empty_scalar_position };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/util-flow-indent-check.mjs

@@ -0,0 +1,16 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_util_contains_newline } from "./util-contains-newline.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/util-flow-indent-check.js
+var require_util_flow_indent_check = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var utilContainsNewline = require_util_contains_newline();
+	function flowIndentCheck(indent, fc, onError) {
+		if (fc?.type === "flow-collection") {
+			const end = fc.end[0];
+			if (end.indent === indent && (end.source === "]" || end.source === "}") && utilContainsNewline.containsNewline(fc)) onError(end, "BAD_INDENT", "Flow end indicator should be more indented than parent", true);
+		}
+	}
+	exports.flowIndentCheck = flowIndentCheck;
+}));
+//#endregion
+export default require_util_flow_indent_check();
+export { require_util_flow_indent_check };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/util-map-includes.mjs

@@ -0,0 +1,16 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/util-map-includes.js
+var require_util_map_includes = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	function mapIncludes(ctx, items, search) {
+		const { uniqueKeys } = ctx.options;
+		if (uniqueKeys === false) return false;
+		const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a, b) => a === b || identity.isScalar(a) && identity.isScalar(b) && a.value === b.value;
+		return items.some((pair) => isEqual(pair.key, search));
+	}
+	exports.mapIncludes = mapIncludes;
+}));
+//#endregion
+export default require_util_map_includes();
+export { require_util_map_includes };