@hot-updater/server 0.30.11 → 0.31.0

package/dist/node_modules/.pnpm/@noble_hashes@1.8.0/node_modules/@noble/hashes/utils.cjs

@@ -0,0 +1,275 @@
+"use strict";
+const require_runtime = require("../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_cryptoNode$1 = require("./cryptoNode.cjs");
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/utils.js
+var require_utils = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	/**
+	* Utilities for hex, bytes, CSPRNG.
+	* @module
+	*/
+	/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.Hash = exports.nextTick = exports.swap32IfBE = exports.byteSwapIfBE = exports.swap8IfBE = exports.isLE = void 0;
+	exports.isBytes = isBytes;
+	exports.anumber = anumber;
+	exports.abytes = abytes;
+	exports.ahash = ahash;
+	exports.aexists = aexists;
+	exports.aoutput = aoutput;
+	exports.u8 = u8;
+	exports.u32 = u32;
+	exports.clean = clean;
+	exports.createView = createView;
+	exports.rotr = rotr;
+	exports.rotl = rotl;
+	exports.byteSwap = byteSwap;
+	exports.byteSwap32 = byteSwap32;
+	exports.bytesToHex = bytesToHex;
+	exports.hexToBytes = hexToBytes;
+	exports.asyncLoop = asyncLoop;
+	exports.utf8ToBytes = utf8ToBytes;
+	exports.bytesToUtf8 = bytesToUtf8;
+	exports.toBytes = toBytes;
+	exports.kdfInputToBytes = kdfInputToBytes;
+	exports.concatBytes = concatBytes;
+	exports.checkOpts = checkOpts;
+	exports.createHasher = createHasher;
+	exports.createOptHasher = createOptHasher;
+	exports.createXOFer = createXOFer;
+	exports.randomBytes = randomBytes;
+	const crypto_1 = require_cryptoNode$1.default;
+	/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+	function isBytes(a) {
+		return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+	}
+	/** Asserts something is positive integer. */
+	function anumber(n) {
+		if (!Number.isSafeInteger(n) || n < 0) throw new Error("positive integer expected, got " + n);
+	}
+	/** Asserts something is Uint8Array. */
+	function abytes(b, ...lengths) {
+		if (!isBytes(b)) throw new Error("Uint8Array expected");
+		if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+	}
+	/** Asserts something is hash */
+	function ahash(h) {
+		if (typeof h !== "function" || typeof h.create !== "function") throw new Error("Hash should be wrapped by utils.createHasher");
+		anumber(h.outputLen);
+		anumber(h.blockLen);
+	}
+	/** Asserts a hash instance has not been destroyed / finished */
+	function aexists(instance, checkFinished = true) {
+		if (instance.destroyed) throw new Error("Hash instance has been destroyed");
+		if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
+	}
+	/** Asserts output is properly-sized byte array */
+	function aoutput(out, instance) {
+		abytes(out);
+		const min = instance.outputLen;
+		if (out.length < min) throw new Error("digestInto() expects output buffer of length at least " + min);
+	}
+	/** Cast u8 / u16 / u32 to u8. */
+	function u8(arr) {
+		return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+	}
+	/** Cast u8 / u16 / u32 to u32. */
+	function u32(arr) {
+		return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+	}
+	/** Zeroize a byte array. Warning: JS provides no guarantees. */
+	function clean(...arrays) {
+		for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+	}
+	/** Create DataView of an array for easy byte-level manipulation. */
+	function createView(arr) {
+		return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+	}
+	/** The rotate right (circular right shift) operation for uint32 */
+	function rotr(word, shift) {
+		return word << 32 - shift | word >>> shift;
+	}
+	/** The rotate left (circular left shift) operation for uint32 */
+	function rotl(word, shift) {
+		return word << shift | word >>> 32 - shift >>> 0;
+	}
+	/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+	exports.isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+	/** The byte swap operation for uint32 */
+	function byteSwap(word) {
+		return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+	}
+	/** Conditionally byte swap if on a big-endian platform */
+	exports.swap8IfBE = exports.isLE ? (n) => n : (n) => byteSwap(n);
+	/** @deprecated */
+	exports.byteSwapIfBE = exports.swap8IfBE;
+	/** In place byte swap for Uint32Array */
+	function byteSwap32(arr) {
+		for (let i = 0; i < arr.length; i++) arr[i] = byteSwap(arr[i]);
+		return arr;
+	}
+	exports.swap32IfBE = exports.isLE ? (u) => u : byteSwap32;
+	const hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+	const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+	/**
+	* Convert byte array to hex string. Uses built-in function, when available.
+	* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+	*/
+	function bytesToHex(bytes) {
+		abytes(bytes);
+		if (hasHexBuiltin) return bytes.toHex();
+		let hex = "";
+		for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
+		return hex;
+	}
+	const asciis = {
+		_0: 48,
+		_9: 57,
+		A: 65,
+		F: 70,
+		a: 97,
+		f: 102
+	};
+	function asciiToBase16(ch) {
+		if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0;
+		if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10);
+		if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10);
+	}
+	/**
+	* Convert hex string to byte array. Uses built-in function, when available.
+	* @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+	*/
+	function hexToBytes(hex) {
+		if (typeof hex !== "string") throw new Error("hex string expected, got " + typeof hex);
+		if (hasHexBuiltin) return Uint8Array.fromHex(hex);
+		const hl = hex.length;
+		const al = hl / 2;
+		if (hl % 2) throw new Error("hex string expected, got unpadded hex of length " + hl);
+		const array = new Uint8Array(al);
+		for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+			const n1 = asciiToBase16(hex.charCodeAt(hi));
+			const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+			if (n1 === void 0 || n2 === void 0) {
+				const char = hex[hi] + hex[hi + 1];
+				throw new Error("hex string expected, got non-hex character \"" + char + "\" at index " + hi);
+			}
+			array[ai] = n1 * 16 + n2;
+		}
+		return array;
+	}
+	/**
+	* There is no setImmediate in browser and setTimeout is slow.
+	* Call of async fn will return Promise, which will be fullfiled only on
+	* next scheduler queue processing step and this is exactly what we need.
+	*/
+	const nextTick = async () => {};
+	exports.nextTick = nextTick;
+	/** Returns control to thread each 'tick' ms to avoid blocking. */
+	async function asyncLoop(iters, tick, cb) {
+		let ts = Date.now();
+		for (let i = 0; i < iters; i++) {
+			cb(i);
+			const diff = Date.now() - ts;
+			if (diff >= 0 && diff < tick) continue;
+			await (0, exports.nextTick)();
+			ts += diff;
+		}
+	}
+	/**
+	* Converts string to bytes using UTF8 encoding.
+	* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+	*/
+	function utf8ToBytes(str) {
+		if (typeof str !== "string") throw new Error("string expected");
+		return new Uint8Array(new TextEncoder().encode(str));
+	}
+	/**
+	* Converts bytes to string using UTF8 encoding.
+	* @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'
+	*/
+	function bytesToUtf8(bytes) {
+		return new TextDecoder().decode(bytes);
+	}
+	/**
+	* Normalizes (non-hex) string or Uint8Array to Uint8Array.
+	* Warning: when Uint8Array is passed, it would NOT get copied.
+	* Keep in mind for future mutable operations.
+	*/
+	function toBytes(data) {
+		if (typeof data === "string") data = utf8ToBytes(data);
+		abytes(data);
+		return data;
+	}
+	/**
+	* Helper for KDFs: consumes uint8array or string.
+	* When string is passed, does utf8 decoding, using TextDecoder.
+	*/
+	function kdfInputToBytes(data) {
+		if (typeof data === "string") data = utf8ToBytes(data);
+		abytes(data);
+		return data;
+	}
+	/** Copies several Uint8Arrays into one. */
+	function concatBytes(...arrays) {
+		let sum = 0;
+		for (let i = 0; i < arrays.length; i++) {
+			const a = arrays[i];
+			abytes(a);
+			sum += a.length;
+		}
+		const res = new Uint8Array(sum);
+		for (let i = 0, pad = 0; i < arrays.length; i++) {
+			const a = arrays[i];
+			res.set(a, pad);
+			pad += a.length;
+		}
+		return res;
+	}
+	function checkOpts(defaults, opts) {
+		if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]") throw new Error("options should be object or undefined");
+		return Object.assign(defaults, opts);
+	}
+	/** For runtime check if class implements interface */
+	var Hash = class {};
+	exports.Hash = Hash;
+	/** Wraps hash function, creating an interface on top of it */
+	function createHasher(hashCons) {
+		const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+		const tmp = hashCons();
+		hashC.outputLen = tmp.outputLen;
+		hashC.blockLen = tmp.blockLen;
+		hashC.create = () => hashCons();
+		return hashC;
+	}
+	function createOptHasher(hashCons) {
+		const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+		const tmp = hashCons({});
+		hashC.outputLen = tmp.outputLen;
+		hashC.blockLen = tmp.blockLen;
+		hashC.create = (opts) => hashCons(opts);
+		return hashC;
+	}
+	function createXOFer(hashCons) {
+		const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+		const tmp = hashCons({});
+		hashC.outputLen = tmp.outputLen;
+		hashC.blockLen = tmp.blockLen;
+		hashC.create = (opts) => hashCons(opts);
+		return hashC;
+	}
+	exports.wrapConstructor = createHasher;
+	exports.wrapConstructorWithOpts = createOptHasher;
+	exports.wrapXOFConstructorWithOpts = createXOFer;
+	/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
+	function randomBytes(bytesLength = 32) {
+		if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === "function") return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+		if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === "function") return Uint8Array.from(crypto_1.crypto.randomBytes(bytesLength));
+		throw new Error("crypto.getRandomValues must be defined");
+	}
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_utils();
+	}
+});

package/dist/node_modules/.pnpm/@noble_hashes@1.8.0/node_modules/@noble/hashes/utils.mjs

@@ -0,0 +1,270 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_cryptoNode } from "./cryptoNode.mjs";
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Utilities for hex, bytes, CSPRNG.
+	* @module
+	*/
+	/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.Hash = exports.nextTick = exports.swap32IfBE = exports.byteSwapIfBE = exports.swap8IfBE = exports.isLE = void 0;
+	exports.isBytes = isBytes;
+	exports.anumber = anumber;
+	exports.abytes = abytes;
+	exports.ahash = ahash;
+	exports.aexists = aexists;
+	exports.aoutput = aoutput;
+	exports.u8 = u8;
+	exports.u32 = u32;
+	exports.clean = clean;
+	exports.createView = createView;
+	exports.rotr = rotr;
+	exports.rotl = rotl;
+	exports.byteSwap = byteSwap;
+	exports.byteSwap32 = byteSwap32;
+	exports.bytesToHex = bytesToHex;
+	exports.hexToBytes = hexToBytes;
+	exports.asyncLoop = asyncLoop;
+	exports.utf8ToBytes = utf8ToBytes;
+	exports.bytesToUtf8 = bytesToUtf8;
+	exports.toBytes = toBytes;
+	exports.kdfInputToBytes = kdfInputToBytes;
+	exports.concatBytes = concatBytes;
+	exports.checkOpts = checkOpts;
+	exports.createHasher = createHasher;
+	exports.createOptHasher = createOptHasher;
+	exports.createXOFer = createXOFer;
+	exports.randomBytes = randomBytes;
+	const crypto_1 = require_cryptoNode();
+	/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+	function isBytes(a) {
+		return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+	}
+	/** Asserts something is positive integer. */
+	function anumber(n) {
+		if (!Number.isSafeInteger(n) || n < 0) throw new Error("positive integer expected, got " + n);
+	}
+	/** Asserts something is Uint8Array. */
+	function abytes(b, ...lengths) {
+		if (!isBytes(b)) throw new Error("Uint8Array expected");
+		if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+	}
+	/** Asserts something is hash */
+	function ahash(h) {
+		if (typeof h !== "function" || typeof h.create !== "function") throw new Error("Hash should be wrapped by utils.createHasher");
+		anumber(h.outputLen);
+		anumber(h.blockLen);
+	}
+	/** Asserts a hash instance has not been destroyed / finished */
+	function aexists(instance, checkFinished = true) {
+		if (instance.destroyed) throw new Error("Hash instance has been destroyed");
+		if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
+	}
+	/** Asserts output is properly-sized byte array */
+	function aoutput(out, instance) {
+		abytes(out);
+		const min = instance.outputLen;
+		if (out.length < min) throw new Error("digestInto() expects output buffer of length at least " + min);
+	}
+	/** Cast u8 / u16 / u32 to u8. */
+	function u8(arr) {
+		return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+	}
+	/** Cast u8 / u16 / u32 to u32. */
+	function u32(arr) {
+		return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+	}
+	/** Zeroize a byte array. Warning: JS provides no guarantees. */
+	function clean(...arrays) {
+		for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+	}
+	/** Create DataView of an array for easy byte-level manipulation. */
+	function createView(arr) {
+		return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+	}
+	/** The rotate right (circular right shift) operation for uint32 */
+	function rotr(word, shift) {
+		return word << 32 - shift | word >>> shift;
+	}
+	/** The rotate left (circular left shift) operation for uint32 */
+	function rotl(word, shift) {
+		return word << shift | word >>> 32 - shift >>> 0;
+	}
+	/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+	exports.isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+	/** The byte swap operation for uint32 */
+	function byteSwap(word) {
+		return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+	}
+	/** Conditionally byte swap if on a big-endian platform */
+	exports.swap8IfBE = exports.isLE ? (n) => n : (n) => byteSwap(n);
+	/** @deprecated */
+	exports.byteSwapIfBE = exports.swap8IfBE;
+	/** In place byte swap for Uint32Array */
+	function byteSwap32(arr) {
+		for (let i = 0; i < arr.length; i++) arr[i] = byteSwap(arr[i]);
+		return arr;
+	}
+	exports.swap32IfBE = exports.isLE ? (u) => u : byteSwap32;
+	const hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+	const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+	/**
+	* Convert byte array to hex string. Uses built-in function, when available.
+	* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+	*/
+	function bytesToHex(bytes) {
+		abytes(bytes);
+		if (hasHexBuiltin) return bytes.toHex();
+		let hex = "";
+		for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
+		return hex;
+	}
+	const asciis = {
+		_0: 48,
+		_9: 57,
+		A: 65,
+		F: 70,
+		a: 97,
+		f: 102
+	};
+	function asciiToBase16(ch) {
+		if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0;
+		if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10);
+		if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10);
+	}
+	/**
+	* Convert hex string to byte array. Uses built-in function, when available.
+	* @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+	*/
+	function hexToBytes(hex) {
+		if (typeof hex !== "string") throw new Error("hex string expected, got " + typeof hex);
+		if (hasHexBuiltin) return Uint8Array.fromHex(hex);
+		const hl = hex.length;
+		const al = hl / 2;
+		if (hl % 2) throw new Error("hex string expected, got unpadded hex of length " + hl);
+		const array = new Uint8Array(al);
+		for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+			const n1 = asciiToBase16(hex.charCodeAt(hi));
+			const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+			if (n1 === void 0 || n2 === void 0) {
+				const char = hex[hi] + hex[hi + 1];
+				throw new Error("hex string expected, got non-hex character \"" + char + "\" at index " + hi);
+			}
+			array[ai] = n1 * 16 + n2;
+		}
+		return array;
+	}
+	/**
+	* There is no setImmediate in browser and setTimeout is slow.
+	* Call of async fn will return Promise, which will be fullfiled only on
+	* next scheduler queue processing step and this is exactly what we need.
+	*/
+	const nextTick = async () => {};
+	exports.nextTick = nextTick;
+	/** Returns control to thread each 'tick' ms to avoid blocking. */
+	async function asyncLoop(iters, tick, cb) {
+		let ts = Date.now();
+		for (let i = 0; i < iters; i++) {
+			cb(i);
+			const diff = Date.now() - ts;
+			if (diff >= 0 && diff < tick) continue;
+			await (0, exports.nextTick)();
+			ts += diff;
+		}
+	}
+	/**
+	* Converts string to bytes using UTF8 encoding.
+	* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+	*/
+	function utf8ToBytes(str) {
+		if (typeof str !== "string") throw new Error("string expected");
+		return new Uint8Array(new TextEncoder().encode(str));
+	}
+	/**
+	* Converts bytes to string using UTF8 encoding.
+	* @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'
+	*/
+	function bytesToUtf8(bytes) {
+		return new TextDecoder().decode(bytes);
+	}
+	/**
+	* Normalizes (non-hex) string or Uint8Array to Uint8Array.
+	* Warning: when Uint8Array is passed, it would NOT get copied.
+	* Keep in mind for future mutable operations.
+	*/
+	function toBytes(data) {
+		if (typeof data === "string") data = utf8ToBytes(data);
+		abytes(data);
+		return data;
+	}
+	/**
+	* Helper for KDFs: consumes uint8array or string.
+	* When string is passed, does utf8 decoding, using TextDecoder.
+	*/
+	function kdfInputToBytes(data) {
+		if (typeof data === "string") data = utf8ToBytes(data);
+		abytes(data);
+		return data;
+	}
+	/** Copies several Uint8Arrays into one. */
+	function concatBytes(...arrays) {
+		let sum = 0;
+		for (let i = 0; i < arrays.length; i++) {
+			const a = arrays[i];
+			abytes(a);
+			sum += a.length;
+		}
+		const res = new Uint8Array(sum);
+		for (let i = 0, pad = 0; i < arrays.length; i++) {
+			const a = arrays[i];
+			res.set(a, pad);
+			pad += a.length;
+		}
+		return res;
+	}
+	function checkOpts(defaults, opts) {
+		if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]") throw new Error("options should be object or undefined");
+		return Object.assign(defaults, opts);
+	}
+	/** For runtime check if class implements interface */
+	var Hash = class {};
+	exports.Hash = Hash;
+	/** Wraps hash function, creating an interface on top of it */
+	function createHasher(hashCons) {
+		const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+		const tmp = hashCons();
+		hashC.outputLen = tmp.outputLen;
+		hashC.blockLen = tmp.blockLen;
+		hashC.create = () => hashCons();
+		return hashC;
+	}
+	function createOptHasher(hashCons) {
+		const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+		const tmp = hashCons({});
+		hashC.outputLen = tmp.outputLen;
+		hashC.blockLen = tmp.blockLen;
+		hashC.create = (opts) => hashCons(opts);
+		return hashC;
+	}
+	function createXOFer(hashCons) {
+		const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+		const tmp = hashCons({});
+		hashC.outputLen = tmp.outputLen;
+		hashC.blockLen = tmp.blockLen;
+		hashC.create = (opts) => hashCons(opts);
+		return hashC;
+	}
+	exports.wrapConstructor = createHasher;
+	exports.wrapConstructorWithOpts = createOptHasher;
+	exports.wrapXOFConstructorWithOpts = createXOFer;
+	/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
+	function randomBytes(bytesLength = 32) {
+		if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === "function") return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+		if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === "function") return Uint8Array.from(crypto_1.crypto.randomBytes(bytesLength));
+		throw new Error("crypto.getRandomValues must be defined");
+	}
+}));
+//#endregion
+export default require_utils();
+export { require_utils };

package/dist/node_modules/.pnpm/@paralleldrive_cuid2@2.3.1/node_modules/@paralleldrive/cuid2/index.cjs

@@ -0,0 +1,17 @@
+const require_runtime = require("../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_index = require("./src/index.cjs");
+//#region ../../node_modules/.pnpm/@paralleldrive+cuid2@2.3.1/node_modules/@paralleldrive/cuid2/index.js
+var require_cuid2 = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const { createId, init, getConstants, isCuid } = require_index.default;
+	module.exports.createId = createId;
+	module.exports.init = init;
+	module.exports.getConstants = getConstants;
+	module.exports.isCuid = isCuid;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_cuid2();
+	}
+});

package/dist/node_modules/.pnpm/@paralleldrive_cuid2@2.3.1/node_modules/@paralleldrive/cuid2/index.mjs

@@ -0,0 +1,13 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_src } from "./src/index.mjs";
+//#region ../../node_modules/.pnpm/@paralleldrive+cuid2@2.3.1/node_modules/@paralleldrive/cuid2/index.js
+var require_cuid2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { createId, init, getConstants, isCuid } = require_src();
+	module.exports.createId = createId;
+	module.exports.init = init;
+	module.exports.getConstants = getConstants;
+	module.exports.isCuid = isCuid;
+}));
+//#endregion
+export default require_cuid2();
+export { require_cuid2 };

package/dist/node_modules/.pnpm/@paralleldrive_cuid2@2.3.1/node_modules/@paralleldrive/cuid2/src/index.cjs

@@ -0,0 +1,69 @@
+const require_runtime = require("../../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_sha3$1 = require("../../../../../@noble_hashes@1.8.0/node_modules/@noble/hashes/sha3.cjs");
+//#region ../../node_modules/.pnpm/@paralleldrive+cuid2@2.3.1/node_modules/@paralleldrive/cuid2/src/index.js
+var require_src = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const { sha3_512: sha3 } = require_sha3$1.default;
+	const defaultLength = 24;
+	const bigLength = 32;
+	const createEntropy = (length = 4, random = Math.random) => {
+		let entropy = "";
+		while (entropy.length < length) entropy = entropy + Math.floor(random() * 36).toString(36);
+		return entropy;
+	};
+	function bufToBigInt(buf) {
+		let bits = 8n;
+		let value = 0n;
+		for (const i of buf.values()) {
+			const bi = BigInt(i);
+			value = (value << bits) + bi;
+		}
+		return value;
+	}
+	const hash = (input = "") => {
+		return bufToBigInt(sha3(input)).toString(36).slice(1);
+	};
+	const alphabet = Array.from({ length: 26 }, (x, i) => String.fromCharCode(i + 97));
+	const randomLetter = (random) => alphabet[Math.floor(random() * alphabet.length)];
+	const createFingerprint = ({ globalObj = typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : {}, random = Math.random } = {}) => {
+		const globals = Object.keys(globalObj).toString();
+		return hash(globals.length ? globals + createEntropy(bigLength, random) : createEntropy(bigLength, random)).substring(0, bigLength);
+	};
+	const createCounter = (count) => () => {
+		return count++;
+	};
+	const initialCountMax = 476782367;
+	const init = ({ random = Math.random, counter = createCounter(Math.floor(random() * initialCountMax)), length = defaultLength, fingerprint = createFingerprint({ random }) } = {}) => {
+		return function cuid2() {
+			const firstLetter = randomLetter(random);
+			const time = Date.now().toString(36);
+			const count = counter().toString(36);
+			return `${firstLetter + hash(`${time + createEntropy(length, random) + count + fingerprint}`).substring(1, length)}`;
+		};
+	};
+	const createId = init();
+	const isCuid = (id, { minLength = 2, maxLength = bigLength } = {}) => {
+		const length = id.length;
+		const regex = /^[0-9a-z]+$/;
+		try {
+			if (typeof id === "string" && length >= minLength && length <= maxLength && regex.test(id)) return true;
+		} finally {}
+		return false;
+	};
+	module.exports.getConstants = () => ({
+		defaultLength,
+		bigLength
+	});
+	module.exports.init = init;
+	module.exports.createId = createId;
+	module.exports.bufToBigInt = bufToBigInt;
+	module.exports.createCounter = createCounter;
+	module.exports.createFingerprint = createFingerprint;
+	module.exports.isCuid = isCuid;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_src();
+	}
+});