cngpac 0.0.1

package/dist/src/node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.mjs

@@ -0,0 +1,13 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js
+var require_has_flag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = (flag, argv = process.argv) => {
+		const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+		const position = argv.indexOf(prefix + flag);
+		const terminatorPosition = argv.indexOf("--");
+		return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+	};
+}));
+//#endregion
+export default require_has_flag();
+export { require_has_flag };

package/dist/src/node_modules/.pnpm/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.mjs

@@ -0,0 +1,8 @@
+//#region node_modules/.pnpm/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.js
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+//#endregion
+export { isPlainObject as default };

package/dist/src/node_modules/.pnpm/json-with-bigint@3.5.8/node_modules/json-with-bigint/json-with-bigint.mjs

@@ -0,0 +1,137 @@
+//#region node_modules/.pnpm/json-with-bigint@3.5.8/node_modules/json-with-bigint/json-with-bigint.js
+const intRegex = /^-?\d+$/;
+const noiseValue = /^-?\d+n+$/;
+const originalStringify = JSON.stringify;
+const originalParse = JSON.parse;
+const customFormat = /^-?\d+n$/;
+const bigIntsStringify = /([\[:])?"(-?\d+)n"($|([\\n]|\s)*(\s|[\\n])*[,\}\]])/g;
+const noiseStringify = /([\[:])?("-?\d+n+)n("$|"([\\n]|\s)*(\s|[\\n])*[,\}\]])/g;
+/**
+* @typedef {(this: any, key: string | number | undefined, value: any) => any} Replacer
+* @typedef {(key: string | number | undefined, value: any, context?: { source: string }) => any} Reviver
+*/
+/**
+* Converts a JavaScript value to a JSON string.
+*
+* Supports serialization of BigInt values using two strategies:
+* 1. Custom format "123n" → "123" (universal fallback)
+* 2. Native JSON.rawJSON() (Node.js 22+, fastest) when available
+*
+* All other values are serialized exactly like native JSON.stringify().
+*
+* @param {*} value The value to convert to a JSON string.
+* @param {Replacer | Array<string | number> | null} [replacer]
+*   A function that alters the behavior of the stringification process,
+*   or an array of strings/numbers to indicate properties to exclude.
+* @param {string | number} [space]
+*   A string or number to specify indentation or pretty-printing.
+* @returns {string} The JSON string representation.
+*/
+const JSONStringify = (value, replacer, space) => {
+	if ("rawJSON" in JSON) return originalStringify(value, (key, value) => {
+		if (typeof value === "bigint") return JSON.rawJSON(value.toString());
+		if (typeof replacer === "function") return replacer(key, value);
+		if (Array.isArray(replacer) && replacer.includes(key)) return value;
+		return value;
+	}, space);
+	if (!value) return originalStringify(value, replacer, space);
+	return originalStringify(value, (key, value) => {
+		if (typeof value === "string" && noiseValue.test(value)) return value.toString() + "n";
+		if (typeof value === "bigint") return value.toString() + "n";
+		if (typeof replacer === "function") return replacer(key, value);
+		if (Array.isArray(replacer) && replacer.includes(key)) return value;
+		return value;
+	}, space).replace(bigIntsStringify, "$1$2$3").replace(noiseStringify, "$1$2$3");
+};
+const featureCache = /* @__PURE__ */ new Map();
+/**
+* Detects if the current JSON.parse implementation supports the context.source feature.
+*
+* Uses toString() fingerprinting to cache results and automatically detect runtime
+* replacements of JSON.parse (polyfills, mocks, etc.).
+*
+* @returns {boolean} true if context.source is supported, false otherwise.
+*/
+const isContextSourceSupported = () => {
+	const parseFingerprint = JSON.parse.toString();
+	if (featureCache.has(parseFingerprint)) return featureCache.get(parseFingerprint);
+	try {
+		const result = JSON.parse("1", (_, __, context) => !!context?.source && context.source === "1");
+		featureCache.set(parseFingerprint, result);
+		return result;
+	} catch {
+		featureCache.set(parseFingerprint, false);
+		return false;
+	}
+};
+/**
+* Reviver function that converts custom-format BigInt strings back to BigInt values.
+* Also handles "noise" strings that accidentally match the BigInt format.
+*
+* @param {string | number | undefined} key The object key.
+* @param {*} value The value being parsed.
+* @param {object} [context] Parse context (if supported by JSON.parse).
+* @param {Reviver} [userReviver] User's custom reviver function.
+* @returns {any} The transformed value.
+*/
+const convertMarkedBigIntsReviver = (key, value, context, userReviver) => {
+	if (typeof value === "string" && customFormat.test(value)) return BigInt(value.slice(0, -1));
+	if (typeof value === "string" && noiseValue.test(value)) return value.slice(0, -1);
+	if (typeof userReviver !== "function") return value;
+	return userReviver(key, value, context);
+};
+/**
+* Fast JSON.parse implementation (~2x faster than classic fallback).
+* Uses JSON.parse's context.source feature to detect integers and convert
+* large numbers directly to BigInt without string manipulation.
+*
+* Does not support legacy custom format from v1 of this library.
+*
+* @param {string} text JSON string to parse.
+* @param {Reviver} [reviver] Transform function to apply to each value.
+* @returns {any} Parsed JavaScript value.
+*/
+const JSONParseV2 = (text, reviver) => {
+	return JSON.parse(text, (key, value, context) => {
+		const isBigNumber = typeof value === "number" && (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER);
+		const isInt = context && intRegex.test(context.source);
+		if (isBigNumber && isInt) return BigInt(context.source);
+		if (typeof reviver !== "function") return value;
+		return reviver(key, value, context);
+	});
+};
+const MAX_INT = Number.MAX_SAFE_INTEGER.toString();
+const MAX_DIGITS = MAX_INT.length;
+const stringsOrLargeNumbers = /"(?:\\.|[^"])*"|-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/g;
+const noiseValueWithQuotes = /^"-?\d+n+"$/;
+/**
+* Converts a JSON string into a JavaScript value.
+*
+* Supports parsing of large integers using two strategies:
+* 1. Classic fallback: Marks large numbers with "123n" format, then converts to BigInt
+* 2. Fast path (JSONParseV2): Uses context.source feature (~2x faster) when available
+*
+* All other JSON values are parsed exactly like native JSON.parse().
+*
+* @param {string} text A valid JSON string.
+* @param {Reviver} [reviver]
+*   A function that transforms the results. This function is called for each member
+*   of the object. If a member contains nested objects, the nested objects are
+*   transformed before the parent object is.
+* @returns {any} The parsed JavaScript value.
+* @throws {SyntaxError} If text is not valid JSON.
+*/
+const JSONParse = (text, reviver) => {
+	if (!text) return originalParse(text, reviver);
+	if (isContextSourceSupported()) return JSONParseV2(text, reviver);
+	return originalParse(text.replace(stringsOrLargeNumbers, (text, digits, fractional, exponential) => {
+		const isString = text[0] === "\"";
+		if (isString && noiseValueWithQuotes.test(text)) return text.substring(0, text.length - 1) + "n\"";
+		const isFractionalOrExponential = fractional || exponential;
+		const isLessThanMaxSafeInt = digits && (digits.length < MAX_DIGITS || digits.length === MAX_DIGITS && digits <= MAX_INT);
+		if (isString || isFractionalOrExponential || isLessThanMaxSafeInt) return text;
+		return "\"" + text + "n\"";
+	}), (key, value, context) => convertMarkedBigIntsReviver(key, value, context, reviver));
+};
+//#endregion
+export { JSONParse, JSONStringify };

package/dist/src/node_modules/.pnpm/localstorage-polyfill@1.0.1/node_modules/localstorage-polyfill/localStorage.mjs

@@ -0,0 +1,39 @@
+//#region node_modules/.pnpm/localstorage-polyfill@1.0.1/node_modules/localstorage-polyfill/localStorage.js
+const valuesMap = /* @__PURE__ */ new Map();
+var LocalStorage = class {
+	getItem(key) {
+		const stringKey = String(key);
+		if (valuesMap.has(key)) return String(valuesMap.get(stringKey));
+		return null;
+	}
+	setItem(key, val) {
+		valuesMap.set(String(key), String(val));
+	}
+	removeItem(key) {
+		valuesMap.delete(key);
+	}
+	clear() {
+		valuesMap.clear();
+	}
+	key(i) {
+		if (arguments.length === 0) throw new TypeError("Failed to execute 'key' on 'Storage': 1 argument required, but only 0 present.");
+		return Array.from(valuesMap.keys())[i];
+	}
+	get length() {
+		return valuesMap.size;
+	}
+};
+const instance = new LocalStorage();
+global.localStorage = new Proxy(instance, {
+	set: function(obj, prop, value) {
+		if (LocalStorage.prototype.hasOwnProperty(prop)) instance[prop] = value;
+		else instance.setItem(prop, value);
+		return true;
+	},
+	get: function(target, name) {
+		if (LocalStorage.prototype.hasOwnProperty(name)) return instance[name];
+		if (valuesMap.has(name)) return instance.getItem(name);
+	}
+});
+//#endregion
+export {};

package/dist/src/node_modules/.pnpm/longest-streak@3.1.0/node_modules/longest-streak/index.mjs

@@ -0,0 +1,29 @@
+//#region node_modules/.pnpm/longest-streak@3.1.0/node_modules/longest-streak/index.js
+/**
+* Get the count of the longest repeating streak of `substring` in `value`.
+*
+* @param {string} value
+*   Content to search in.
+* @param {string} substring
+*   Substring to look for, typically one character.
+* @returns {number}
+*   Count of most frequent adjacent `substring`s in `value`.
+*/
+function longestStreak(value, substring) {
+	const source = String(value);
+	let index = source.indexOf(substring);
+	let expected = index;
+	let count = 0;
+	let max = 0;
+	if (typeof substring !== "string") throw new TypeError("Expected substring");
+	while (index !== -1) {
+		if (index === expected) {
+			if (++count > max) max = count;
+		} else count = 1;
+		expected = index + substring.length;
+		index = source.indexOf(substring, expected);
+	}
+	return max;
+}
+//#endregion
+export { longestStreak };