cngpac 0.0.1

package/dist/src/node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.mjs

@@ -0,0 +1,57 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const ESC = "\x1B";
+	const CSI = `${ESC}[`;
+	const beep = "\x07";
+	const cursor = {
+		to(x, y) {
+			if (!y) return `${CSI}${x + 1}G`;
+			return `${CSI}${y + 1};${x + 1}H`;
+		},
+		move(x, y) {
+			let ret = "";
+			if (x < 0) ret += `${CSI}${-x}D`;
+			else if (x > 0) ret += `${CSI}${x}C`;
+			if (y < 0) ret += `${CSI}${-y}A`;
+			else if (y > 0) ret += `${CSI}${y}B`;
+			return ret;
+		},
+		up: (count = 1) => `${CSI}${count}A`,
+		down: (count = 1) => `${CSI}${count}B`,
+		forward: (count = 1) => `${CSI}${count}C`,
+		backward: (count = 1) => `${CSI}${count}D`,
+		nextLine: (count = 1) => `${CSI}E`.repeat(count),
+		prevLine: (count = 1) => `${CSI}F`.repeat(count),
+		left: `${CSI}G`,
+		hide: `${CSI}?25l`,
+		show: `${CSI}?25h`,
+		save: `${ESC}7`,
+		restore: `${ESC}8`
+	};
+	module.exports = {
+		cursor,
+		scroll: {
+			up: (count = 1) => `${CSI}S`.repeat(count),
+			down: (count = 1) => `${CSI}T`.repeat(count)
+		},
+		erase: {
+			screen: `${CSI}2J`,
+			up: (count = 1) => `${CSI}1J`.repeat(count),
+			down: (count = 1) => `${CSI}J`.repeat(count),
+			line: `${CSI}2K`,
+			lineEnd: `${CSI}K`,
+			lineStart: `${CSI}1K`,
+			lines(count) {
+				let clear = "";
+				for (let i = 0; i < count; i++) clear += this.line + (i < count - 1 ? cursor.up() : "");
+				if (count) clear += cursor.left;
+				return clear;
+			}
+		},
+		beep
+	};
+}));
+//#endregion
+export default require_src();
+export { require_src };

package/dist/src/node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.mjs

@@ -0,0 +1,72 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_has_flag } from "../../../has-flag@4.0.0/node_modules/has-flag/index.mjs";
+//#region node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js
+var require_supports_color = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const os = __require("os");
+	const tty = __require("tty");
+	const hasFlag = require_has_flag();
+	const { env } = process;
+	let forceColor;
+	if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) forceColor = 0;
+	else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) forceColor = 1;
+	if ("FORCE_COLOR" in env) if (env.FORCE_COLOR === "true") forceColor = 1;
+	else if (env.FORCE_COLOR === "false") forceColor = 0;
+	else forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+	function translateLevel(level) {
+		if (level === 0) return false;
+		return {
+			level,
+			hasBasic: true,
+			has256: level >= 2,
+			has16m: level >= 3
+		};
+	}
+	function supportsColor(haveStream, streamIsTTY) {
+		if (forceColor === 0) return 0;
+		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+		if (hasFlag("color=256")) return 2;
+		if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
+		const min = forceColor || 0;
+		if (env.TERM === "dumb") return min;
+		if (process.platform === "win32") {
+			const osRelease = os.release().split(".");
+			if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+			return 1;
+		}
+		if ("CI" in env) {
+			if ([
+				"TRAVIS",
+				"CIRCLECI",
+				"APPVEYOR",
+				"GITLAB_CI",
+				"GITHUB_ACTIONS",
+				"BUILDKITE"
+			].some((sign) => sign in env) || env.CI_NAME === "codeship") return 1;
+			return min;
+		}
+		if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+		if (env.COLORTERM === "truecolor") return 3;
+		if ("TERM_PROGRAM" in env) {
+			const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+			switch (env.TERM_PROGRAM) {
+				case "iTerm.app": return version >= 3 ? 3 : 2;
+				case "Apple_Terminal": return 2;
+			}
+		}
+		if (/-256(color)?$/i.test(env.TERM)) return 2;
+		if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+		if ("COLORTERM" in env) return 1;
+		return min;
+	}
+	function getSupportLevel(stream) {
+		return translateLevel(supportsColor(stream, stream && stream.isTTY));
+	}
+	module.exports = {
+		supportsColor: getSupportLevel,
+		stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+		stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+	};
+}));
+//#endregion
+export default require_supports_color();
+export { require_supports_color };

package/dist/src/node_modules/.pnpm/trough@2.2.0/node_modules/trough/lib/index.mjs

@@ -0,0 +1,157 @@
+//#region node_modules/.pnpm/trough@2.2.0/node_modules/trough/lib/index.js
+/**
+* @typedef {(error?: Error | null | undefined, ...output: Array<any>) => void} Callback
+*   Callback.
+*
+* @typedef {(...input: Array<any>) => any} Middleware
+*   Ware.
+*
+* @typedef Pipeline
+*   Pipeline.
+* @property {Run} run
+*   Run the pipeline.
+* @property {Use} use
+*   Add middleware.
+*
+* @typedef {(...input: Array<any>) => void} Run
+*   Call all middleware.
+*
+*   Calls `done` on completion with either an error or the output of the
+*   last middleware.
+*
+*   > 👉 **Note**: as the length of input defines whether async functions get a
+*   > `next` function,
+*   > it’s recommended to keep `input` at one value normally.
+
+*
+* @typedef {(fn: Middleware) => Pipeline} Use
+*   Add middleware.
+*/
+/**
+* Create new middleware.
+*
+* @returns {Pipeline}
+*   Pipeline.
+*/
+function trough() {
+	/** @type {Array<Middleware>} */
+	const fns = [];
+	/** @type {Pipeline} */
+	const pipeline = {
+		run,
+		use
+	};
+	return pipeline;
+	/** @type {Run} */
+	function run(...values) {
+		let middlewareIndex = -1;
+		/** @type {Callback} */
+		const callback = values.pop();
+		if (typeof callback !== "function") throw new TypeError("Expected function as last argument, not " + callback);
+		next(null, ...values);
+		/**
+		* Run the next `fn`, or we’re done.
+		*
+		* @param {Error | null | undefined} error
+		* @param {Array<any>} output
+		*/
+		function next(error, ...output) {
+			const fn = fns[++middlewareIndex];
+			let index = -1;
+			if (error) {
+				callback(error);
+				return;
+			}
+			while (++index < values.length) if (output[index] === null || output[index] === void 0) output[index] = values[index];
+			values = output;
+			if (fn) wrap(fn, next)(...output);
+			else callback(null, ...output);
+		}
+	}
+	/** @type {Use} */
+	function use(middelware) {
+		if (typeof middelware !== "function") throw new TypeError("Expected `middelware` to be a function, not " + middelware);
+		fns.push(middelware);
+		return pipeline;
+	}
+}
+/**
+* Wrap `middleware` into a uniform interface.
+*
+* You can pass all input to the resulting function.
+* `callback` is then called with the output of `middleware`.
+*
+* If `middleware` accepts more arguments than the later given in input,
+* an extra `done` function is passed to it after that input,
+* which must be called by `middleware`.
+*
+* The first value in `input` is the main input value.
+* All other input values are the rest input values.
+* The values given to `callback` are the input values,
+* merged with every non-nullish output value.
+*
+* * if `middleware` throws an error,
+*   returns a promise that is rejected,
+*   or calls the given `done` function with an error,
+*   `callback` is called with that error
+* * if `middleware` returns a value or returns a promise that is resolved,
+*   that value is the main output value
+* * if `middleware` calls `done`,
+*   all non-nullish values except for the first one (the error) overwrite the
+*   output values
+*
+* @param {Middleware} middleware
+*   Function to wrap.
+* @param {Callback} callback
+*   Callback called with the output of `middleware`.
+* @returns {Run}
+*   Wrapped middleware.
+*/
+function wrap(middleware, callback) {
+	/** @type {boolean} */
+	let called;
+	return wrapped;
+	/**
+	* Call `middleware`.
+	* @this {any}
+	* @param {Array<any>} parameters
+	* @returns {void}
+	*/
+	function wrapped(...parameters) {
+		const fnExpectsCallback = middleware.length > parameters.length;
+		/** @type {any} */
+		let result;
+		if (fnExpectsCallback) parameters.push(done);
+		try {
+			result = middleware.apply(this, parameters);
+		} catch (error) {
+			const exception = error;
+			if (fnExpectsCallback && called) throw exception;
+			return done(exception);
+		}
+		if (!fnExpectsCallback) if (result && result.then && typeof result.then === "function") result.then(then, done);
+		else if (result instanceof Error) done(result);
+		else then(result);
+	}
+	/**
+	* Call `callback`, only once.
+	*
+	* @type {Callback}
+	*/
+	function done(error, ...output) {
+		if (!called) {
+			called = true;
+			callback(error, ...output);
+		}
+	}
+	/**
+	* Call `done` with one value.
+	*
+	* @param {any} [value]
+	*/
+	function then(value) {
+		done(null, value);
+	}
+}
+//#endregion
+export { trough };

package/dist/src/node_modules/.pnpm/unified@11.0.5/node_modules/unified/lib/callable-instance.mjs

@@ -0,0 +1,13 @@
+//#region node_modules/.pnpm/unified@11.0.5/node_modules/unified/lib/callable-instance.js
+const CallableInstance = (function(property) {
+	const proto = this.constructor.prototype;
+	const value = proto[property];
+	/** @type {(...parameters: Array<unknown>) => unknown} */
+	const apply = function() {
+		return value.apply(apply, arguments);
+	};
+	Object.setPrototypeOf(apply, proto);
+	return apply;
+});
+//#endregion
+export { CallableInstance };