cngpac 0.0.1

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

@@ -0,0 +1,115 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+import { require_anchors } from "../doc/anchors.mjs";
+import { require_stringifyComment } from "./stringifyComment.mjs";
+import { require_stringifyString } from "./stringifyString.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/stringify/stringify.js
+var require_stringify = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var anchors = require_anchors();
+	var identity = require_identity();
+	var stringifyComment = require_stringifyComment();
+	var stringifyString = require_stringifyString();
+	function createStringifyContext(doc, options) {
+		const opt = Object.assign({
+			blockQuote: true,
+			commentString: stringifyComment.stringifyComment,
+			defaultKeyType: null,
+			defaultStringType: "PLAIN",
+			directives: null,
+			doubleQuotedAsJSON: false,
+			doubleQuotedMinMultiLineLength: 40,
+			falseStr: "false",
+			flowCollectionPadding: true,
+			indentSeq: true,
+			lineWidth: 80,
+			minContentWidth: 20,
+			nullStr: "null",
+			simpleKeys: false,
+			singleQuote: null,
+			trailingComma: false,
+			trueStr: "true",
+			verifyAliasOrder: true
+		}, doc.schema.toStringOptions, options);
+		let inFlow;
+		switch (opt.collectionStyle) {
+			case "block":
+				inFlow = false;
+				break;
+			case "flow":
+				inFlow = true;
+				break;
+			default: inFlow = null;
+		}
+		return {
+			anchors: /* @__PURE__ */ new Set(),
+			doc,
+			flowCollectionPadding: opt.flowCollectionPadding ? " " : "",
+			indent: "",
+			indentStep: typeof opt.indent === "number" ? " ".repeat(opt.indent) : "  ",
+			inFlow,
+			options: opt
+		};
+	}
+	function getTagObject(tags, item) {
+		if (item.tag) {
+			const match = tags.filter((t) => t.tag === item.tag);
+			if (match.length > 0) return match.find((t) => t.format === item.format) ?? match[0];
+		}
+		let tagObj = void 0;
+		let obj;
+		if (identity.isScalar(item)) {
+			obj = item.value;
+			let match = tags.filter((t) => t.identify?.(obj));
+			if (match.length > 1) {
+				const testMatch = match.filter((t) => t.test);
+				if (testMatch.length > 0) match = testMatch;
+			}
+			tagObj = match.find((t) => t.format === item.format) ?? match.find((t) => !t.format);
+		} else {
+			obj = item;
+			tagObj = tags.find((t) => t.nodeClass && obj instanceof t.nodeClass);
+		}
+		if (!tagObj) {
+			const name = obj?.constructor?.name ?? (obj === null ? "null" : typeof obj);
+			throw new Error(`Tag not resolved for ${name} value`);
+		}
+		return tagObj;
+	}
+	function stringifyProps(node, tagObj, { anchors: anchors$1, doc }) {
+		if (!doc.directives) return "";
+		const props = [];
+		const anchor = (identity.isScalar(node) || identity.isCollection(node)) && node.anchor;
+		if (anchor && anchors.anchorIsValid(anchor)) {
+			anchors$1.add(anchor);
+			props.push(`&${anchor}`);
+		}
+		const tag = node.tag ?? (tagObj.default ? null : tagObj.tag);
+		if (tag) props.push(doc.directives.tagString(tag));
+		return props.join(" ");
+	}
+	function stringify(item, ctx, onComment, onChompKeep) {
+		if (identity.isPair(item)) return item.toString(ctx, onComment, onChompKeep);
+		if (identity.isAlias(item)) {
+			if (ctx.doc.directives) return item.toString(ctx);
+			if (ctx.resolvedAliases?.has(item)) throw new TypeError(`Cannot stringify circular structure without alias nodes`);
+			else {
+				if (ctx.resolvedAliases) ctx.resolvedAliases.add(item);
+				else ctx.resolvedAliases = new Set([item]);
+				item = item.resolve(ctx.doc);
+			}
+		}
+		let tagObj = void 0;
+		const node = identity.isNode(item) ? item : ctx.doc.createNode(item, { onTagObj: (o) => tagObj = o });
+		tagObj ?? (tagObj = getTagObject(ctx.doc.schema.tags, node));
+		const props = stringifyProps(node, tagObj, ctx);
+		if (props.length > 0) ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;
+		const str = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : identity.isScalar(node) ? stringifyString.stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep);
+		if (!props) return str;
+		return identity.isScalar(node) || str[0] === "{" || str[0] === "[" ? `${props} ${str}` : `${props}\n${ctx.indent}${str}`;
+	}
+	exports.createStringifyContext = createStringifyContext;
+	exports.stringify = stringify;
+}));
+//#endregion
+export default require_stringify();
+export { require_stringify };

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

@@ -0,0 +1,124 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+import { require_stringifyComment } from "./stringifyComment.mjs";
+import { require_stringify } from "./stringify.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/stringify/stringifyCollection.js
+var require_stringifyCollection = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var stringify = require_stringify();
+	var stringifyComment = require_stringifyComment();
+	function stringifyCollection(collection, ctx, options) {
+		return (ctx.inFlow ?? collection.flow ? stringifyFlowCollection : stringifyBlockCollection)(collection, ctx, options);
+	}
+	function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {
+		const { indent, options: { commentString } } = ctx;
+		const itemCtx = Object.assign({}, ctx, {
+			indent: itemIndent,
+			type: null
+		});
+		let chompKeep = false;
+		const lines = [];
+		for (let i = 0; i < items.length; ++i) {
+			const item = items[i];
+			let comment = null;
+			if (identity.isNode(item)) {
+				if (!chompKeep && item.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, item.commentBefore, chompKeep);
+				if (item.comment) comment = item.comment;
+			} else if (identity.isPair(item)) {
+				const ik = identity.isNode(item.key) ? item.key : null;
+				if (ik) {
+					if (!chompKeep && ik.spaceBefore) lines.push("");
+					addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);
+				}
+			}
+			chompKeep = false;
+			let str = stringify.stringify(item, itemCtx, () => comment = null, () => chompKeep = true);
+			if (comment) str += stringifyComment.lineComment(str, itemIndent, commentString(comment));
+			if (chompKeep && comment) chompKeep = false;
+			lines.push(blockItemPrefix + str);
+		}
+		let str;
+		if (lines.length === 0) str = flowChars.start + flowChars.end;
+		else {
+			str = lines[0];
+			for (let i = 1; i < lines.length; ++i) {
+				const line = lines[i];
+				str += line ? `\n${indent}${line}` : "\n";
+			}
+		}
+		if (comment) {
+			str += "\n" + stringifyComment.indentComment(commentString(comment), indent);
+			if (onComment) onComment();
+		} else if (chompKeep && onChompKeep) onChompKeep();
+		return str;
+	}
+	function stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) {
+		const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;
+		itemIndent += indentStep;
+		const itemCtx = Object.assign({}, ctx, {
+			indent: itemIndent,
+			inFlow: true,
+			type: null
+		});
+		let reqNewline = false;
+		let linesAtValue = 0;
+		const lines = [];
+		for (let i = 0; i < items.length; ++i) {
+			const item = items[i];
+			let comment = null;
+			if (identity.isNode(item)) {
+				if (item.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, item.commentBefore, false);
+				if (item.comment) comment = item.comment;
+			} else if (identity.isPair(item)) {
+				const ik = identity.isNode(item.key) ? item.key : null;
+				if (ik) {
+					if (ik.spaceBefore) lines.push("");
+					addCommentBefore(ctx, lines, ik.commentBefore, false);
+					if (ik.comment) reqNewline = true;
+				}
+				const iv = identity.isNode(item.value) ? item.value : null;
+				if (iv) {
+					if (iv.comment) comment = iv.comment;
+					if (iv.commentBefore) reqNewline = true;
+				} else if (item.value == null && ik?.comment) comment = ik.comment;
+			}
+			if (comment) reqNewline = true;
+			let str = stringify.stringify(item, itemCtx, () => comment = null);
+			reqNewline || (reqNewline = lines.length > linesAtValue || str.includes("\n"));
+			if (i < items.length - 1) str += ",";
+			else if (ctx.options.trailingComma) {
+				if (ctx.options.lineWidth > 0) reqNewline || (reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str.length + 2) > ctx.options.lineWidth);
+				if (reqNewline) str += ",";
+			}
+			if (comment) str += stringifyComment.lineComment(str, itemIndent, commentString(comment));
+			lines.push(str);
+			linesAtValue = lines.length;
+		}
+		const { start, end } = flowChars;
+		if (lines.length === 0) return start + end;
+		else {
+			if (!reqNewline) {
+				const len = lines.reduce((sum, line) => sum + line.length + 2, 2);
+				reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;
+			}
+			if (reqNewline) {
+				let str = start;
+				for (const line of lines) str += line ? `\n${indentStep}${indent}${line}` : "\n";
+				return `${str}\n${indent}${end}`;
+			} else return `${start}${fcPadding}${lines.join(" ")}${fcPadding}${end}`;
+		}
+	}
+	function addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {
+		if (comment && chompKeep) comment = comment.replace(/^\n+/, "");
+		if (comment) {
+			const ic = stringifyComment.indentComment(commentString(comment), indent);
+			lines.push(ic.trimStart());
+		}
+	}
+	exports.stringifyCollection = stringifyCollection;
+}));
+//#endregion
+export default require_stringifyCollection();
+export { require_stringifyCollection };

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

@@ -0,0 +1,23 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/stringify/stringifyComment.js
+var require_stringifyComment = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Stringifies a comment.
+	*
+	* Empty comment lines are left empty,
+	* lines consisting of a single space are replaced by `#`,
+	* and all other lines are prefixed with a `#`.
+	*/
+	const stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, "#");
+	function indentComment(comment, indent) {
+		if (/^\n+$/.test(comment)) return comment.substring(1);
+		return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;
+	}
+	const lineComment = (str, indent, comment) => str.endsWith("\n") ? indentComment(comment, indent) : comment.includes("\n") ? "\n" + indentComment(comment, indent) : (str.endsWith(" ") ? "" : " ") + comment;
+	exports.indentComment = indentComment;
+	exports.lineComment = lineComment;
+	exports.stringifyComment = stringifyComment;
+}));
+//#endregion
+export default require_stringifyComment();
+export { require_stringifyComment };

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

@@ -0,0 +1,67 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+import { require_stringifyComment } from "./stringifyComment.mjs";
+import { require_stringify } from "./stringify.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/stringify/stringifyDocument.js
+var require_stringifyDocument = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var stringify = require_stringify();
+	var stringifyComment = require_stringifyComment();
+	function stringifyDocument(doc, options) {
+		const lines = [];
+		let hasDirectives = options.directives === true;
+		if (options.directives !== false && doc.directives) {
+			const dir = doc.directives.toString(doc);
+			if (dir) {
+				lines.push(dir);
+				hasDirectives = true;
+			} else if (doc.directives.docStart) hasDirectives = true;
+		}
+		if (hasDirectives) lines.push("---");
+		const ctx = stringify.createStringifyContext(doc, options);
+		const { commentString } = ctx.options;
+		if (doc.commentBefore) {
+			if (lines.length !== 1) lines.unshift("");
+			const cs = commentString(doc.commentBefore);
+			lines.unshift(stringifyComment.indentComment(cs, ""));
+		}
+		let chompKeep = false;
+		let contentComment = null;
+		if (doc.contents) {
+			if (identity.isNode(doc.contents)) {
+				if (doc.contents.spaceBefore && hasDirectives) lines.push("");
+				if (doc.contents.commentBefore) {
+					const cs = commentString(doc.contents.commentBefore);
+					lines.push(stringifyComment.indentComment(cs, ""));
+				}
+				ctx.forceBlockIndent = !!doc.comment;
+				contentComment = doc.contents.comment;
+			}
+			const onChompKeep = contentComment ? void 0 : () => chompKeep = true;
+			let body = stringify.stringify(doc.contents, ctx, () => contentComment = null, onChompKeep);
+			if (contentComment) body += stringifyComment.lineComment(body, "", commentString(contentComment));
+			if ((body[0] === "|" || body[0] === ">") && lines[lines.length - 1] === "---") lines[lines.length - 1] = `--- ${body}`;
+			else lines.push(body);
+		} else lines.push(stringify.stringify(doc.contents, ctx));
+		if (doc.directives?.docEnd) if (doc.comment) {
+			const cs = commentString(doc.comment);
+			if (cs.includes("\n")) {
+				lines.push("...");
+				lines.push(stringifyComment.indentComment(cs, ""));
+			} else lines.push(`... ${cs}`);
+		} else lines.push("...");
+		else {
+			let dc = doc.comment;
+			if (dc && chompKeep) dc = dc.replace(/^\n+/, "");
+			if (dc) {
+				if ((!chompKeep || contentComment) && lines[lines.length - 1] !== "") lines.push("");
+				lines.push(stringifyComment.indentComment(commentString(dc), ""));
+			}
+		}
+		return lines.join("\n") + "\n";
+	}
+	exports.stringifyDocument = stringifyDocument;
+}));
+//#endregion
+export default require_stringifyDocument();
+export { require_stringifyDocument };

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

@@ -0,0 +1,24 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/stringify/stringifyNumber.js
+var require_stringifyNumber = /* @__PURE__ */ __commonJSMin(((exports) => {
+	function stringifyNumber({ format, minFractionDigits, tag, value }) {
+		if (typeof value === "bigint") return String(value);
+		const num = typeof value === "number" ? value : Number(value);
+		if (!isFinite(num)) return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf";
+		let n = Object.is(value, -0) ? "-0" : JSON.stringify(value);
+		if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n)) {
+			let i = n.indexOf(".");
+			if (i < 0) {
+				i = n.length;
+				n += ".";
+			}
+			let d = minFractionDigits - (n.length - i - 1);
+			while (d-- > 0) n += "0";
+		}
+		return n;
+	}
+	exports.stringifyNumber = stringifyNumber;
+}));
+//#endregion
+export default require_stringifyNumber();
+export { require_stringifyNumber };

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

@@ -0,0 +1,104 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+import { require_Scalar } from "../nodes/Scalar.mjs";
+import { require_stringifyComment } from "./stringifyComment.mjs";
+import { require_stringify } from "./stringify.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/stringify/stringifyPair.js
+var require_stringifyPair = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var Scalar = require_Scalar();
+	var stringify = require_stringify();
+	var stringifyComment = require_stringifyComment();
+	function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
+		const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
+		let keyComment = identity.isNode(key) && key.comment || null;
+		if (simpleKeys) {
+			if (keyComment) throw new Error("With simple keys, key nodes cannot have comments");
+			if (identity.isCollection(key) || !identity.isNode(key) && typeof key === "object") throw new Error("With simple keys, collection cannot be used as a key value");
+		}
+		let explicitKey = !simpleKeys && (!key || keyComment && value == null && !ctx.inFlow || identity.isCollection(key) || (identity.isScalar(key) ? key.type === Scalar.Scalar.BLOCK_FOLDED || key.type === Scalar.Scalar.BLOCK_LITERAL : typeof key === "object"));
+		ctx = Object.assign({}, ctx, {
+			allNullValues: false,
+			implicitKey: !explicitKey && (simpleKeys || !allNullValues),
+			indent: indent + indentStep
+		});
+		let keyCommentDone = false;
+		let chompKeep = false;
+		let str = stringify.stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true);
+		if (!explicitKey && !ctx.inFlow && str.length > 1024) {
+			if (simpleKeys) throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
+			explicitKey = true;
+		}
+		if (ctx.inFlow) {
+			if (allNullValues || value == null) {
+				if (keyCommentDone && onComment) onComment();
+				return str === "" ? "?" : explicitKey ? `? ${str}` : str;
+			}
+		} else if (allNullValues && !simpleKeys || value == null && explicitKey) {
+			str = `? ${str}`;
+			if (keyComment && !keyCommentDone) str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment));
+			else if (chompKeep && onChompKeep) onChompKeep();
+			return str;
+		}
+		if (keyCommentDone) keyComment = null;
+		if (explicitKey) {
+			if (keyComment) str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment));
+			str = `? ${str}\n${indent}:`;
+		} else {
+			str = `${str}:`;
+			if (keyComment) str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment));
+		}
+		let vsb, vcb, valueComment;
+		if (identity.isNode(value)) {
+			vsb = !!value.spaceBefore;
+			vcb = value.commentBefore;
+			valueComment = value.comment;
+		} else {
+			vsb = false;
+			vcb = null;
+			valueComment = null;
+			if (value && typeof value === "object") value = doc.createNode(value);
+		}
+		ctx.implicitKey = false;
+		if (!explicitKey && !keyComment && identity.isScalar(value)) ctx.indentAtStart = str.length + 1;
+		chompKeep = false;
+		if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && identity.isSeq(value) && !value.flow && !value.tag && !value.anchor) ctx.indent = ctx.indent.substring(2);
+		let valueCommentDone = false;
+		const valueStr = stringify.stringify(value, ctx, () => valueCommentDone = true, () => chompKeep = true);
+		let ws = " ";
+		if (keyComment || vsb || vcb) {
+			ws = vsb ? "\n" : "";
+			if (vcb) {
+				const cs = commentString(vcb);
+				ws += `\n${stringifyComment.indentComment(cs, ctx.indent)}`;
+			}
+			if (valueStr === "" && !ctx.inFlow) {
+				if (ws === "\n" && valueComment) ws = "\n\n";
+			} else ws += `\n${ctx.indent}`;
+		} else if (!explicitKey && identity.isCollection(value)) {
+			const vs0 = valueStr[0];
+			const nl0 = valueStr.indexOf("\n");
+			const hasNewline = nl0 !== -1;
+			const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0;
+			if (hasNewline || !flow) {
+				let hasPropsLine = false;
+				if (hasNewline && (vs0 === "&" || vs0 === "!")) {
+					let sp0 = valueStr.indexOf(" ");
+					if (vs0 === "&" && sp0 !== -1 && sp0 < nl0 && valueStr[sp0 + 1] === "!") sp0 = valueStr.indexOf(" ", sp0 + 1);
+					if (sp0 === -1 || nl0 < sp0) hasPropsLine = true;
+				}
+				if (!hasPropsLine) ws = `\n${ctx.indent}`;
+			}
+		} else if (valueStr === "" || valueStr[0] === "\n") ws = "";
+		str += ws + valueStr;
+		if (ctx.inFlow) {
+			if (valueCommentDone && onComment) onComment();
+		} else if (valueComment && !valueCommentDone) str += stringifyComment.lineComment(str, ctx.indent, commentString(valueComment));
+		else if (chompKeep && onChompKeep) onChompKeep();
+		return str;
+	}
+	exports.stringifyPair = stringifyPair;
+}));
+//#endregion
+export default require_stringifyPair();
+export { require_stringifyPair };