@fedify/fedify 1.6.0-dev.813 → 1.6.0-experiment.0

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/utils/stringify.js

@@ -0,0 +1,217 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SMap, SString, SSymbol, safeFilter, safeGetTime, safeIndexOf, safeJoin, safeMap, safePush, safeToISOString, safeToString } from "./globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/utils/stringify.js
+const safeArrayFrom = Array.from;
+const safeBufferIsBuffer = typeof Buffer !== "undefined" ? Buffer.isBuffer : void 0;
+const safeJsonStringify = JSON.stringify;
+const safeNumberIsNaN = Number.isNaN;
+const safeObjectKeys = Object.keys;
+const safeObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
+const safeObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const safeObjectGetPrototypeOf = Object.getPrototypeOf;
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const toStringMethod = Symbol.for("fast-check/toStringMethod");
+function hasToStringMethod(instance) {
+	return instance !== null && (typeof instance === "object" || typeof instance === "function") && toStringMethod in instance && typeof instance[toStringMethod] === "function";
+}
+const asyncToStringMethod = Symbol.for("fast-check/asyncToStringMethod");
+function hasAsyncToStringMethod(instance) {
+	return instance !== null && (typeof instance === "object" || typeof instance === "function") && asyncToStringMethod in instance && typeof instance[asyncToStringMethod] === "function";
+}
+const findSymbolNameRegex = /^Symbol\((.*)\)$/;
+function getSymbolDescription(s) {
+	if (s.description !== void 0) return s.description;
+	const m = findSymbolNameRegex.exec(SString(s));
+	return m && m[1].length ? m[1] : null;
+}
+function stringifyNumber(numValue) {
+	switch (numValue) {
+		case 0: return 1 / numValue === safeNegativeInfinity ? "-0" : "0";
+		case safeNegativeInfinity: return "Number.NEGATIVE_INFINITY";
+		case safePositiveInfinity: return "Number.POSITIVE_INFINITY";
+		default: return numValue === numValue ? SString(numValue) : "Number.NaN";
+	}
+}
+function isSparseArray(arr) {
+	let previousNumberedIndex = -1;
+	for (const index in arr) {
+		const numberedIndex = Number(index);
+		if (numberedIndex !== previousNumberedIndex + 1) return true;
+		previousNumberedIndex = numberedIndex;
+	}
+	return previousNumberedIndex + 1 !== arr.length;
+}
+function stringifyInternal(value, previousValues, getAsyncContent) {
+	const currentValues = [...previousValues, value];
+	if (typeof value === "object") {
+		if (safeIndexOf(previousValues, value) !== -1) return "[cyclic]";
+	}
+	if (hasAsyncToStringMethod(value)) {
+		const content = getAsyncContent(value);
+		if (content.state === "fulfilled") return content.value;
+	}
+	if (hasToStringMethod(value)) try {
+		return value[toStringMethod]();
+	} catch (err) {}
+	switch (safeToString(value)) {
+		case "[object Array]": {
+			const arr = value;
+			if (arr.length >= 50 && isSparseArray(arr)) {
+				const assignments = [];
+				for (const index in arr) if (!safeNumberIsNaN(Number(index))) safePush(assignments, `${index}:${stringifyInternal(arr[index], currentValues, getAsyncContent)}`);
+				return assignments.length !== 0 ? `Object.assign(Array(${arr.length}),{${safeJoin(assignments, ",")}})` : `Array(${arr.length})`;
+			}
+			const stringifiedArray = safeJoin(safeMap(arr, (v) => stringifyInternal(v, currentValues, getAsyncContent)), ",");
+			return arr.length === 0 || arr.length - 1 in arr ? `[${stringifiedArray}]` : `[${stringifiedArray},]`;
+		}
+		case "[object BigInt]": return `${value}n`;
+		case "[object Boolean]": {
+			const unboxedToString = value == true ? "true" : "false";
+			return typeof value === "boolean" ? unboxedToString : `new Boolean(${unboxedToString})`;
+		}
+		case "[object Date]": {
+			const d = value;
+			return safeNumberIsNaN(safeGetTime(d)) ? `new Date(NaN)` : `new Date(${safeJsonStringify(safeToISOString(d))})`;
+		}
+		case "[object Map]": return `new Map(${stringifyInternal(Array.from(value), currentValues, getAsyncContent)})`;
+		case "[object Null]": return `null`;
+		case "[object Number]": return typeof value === "number" ? stringifyNumber(value) : `new Number(${stringifyNumber(Number(value))})`;
+		case "[object Object]": {
+			try {
+				const toStringAccessor = value.toString;
+				if (typeof toStringAccessor === "function" && toStringAccessor !== Object.prototype.toString) return value.toString();
+			} catch (err) {
+				return "[object Object]";
+			}
+			const mapper = (k) => `${k === "__proto__" ? "[\"__proto__\"]" : typeof k === "symbol" ? `[${stringifyInternal(k, currentValues, getAsyncContent)}]` : safeJsonStringify(k)}:${stringifyInternal(value[k], currentValues, getAsyncContent)}`;
+			const stringifiedProperties = [...safeMap(safeObjectKeys(value), mapper), ...safeMap(safeFilter(safeObjectGetOwnPropertySymbols(value), (s) => {
+				const descriptor = safeObjectGetOwnPropertyDescriptor(value, s);
+				return descriptor && descriptor.enumerable;
+			}), mapper)];
+			const rawRepr = "{" + safeJoin(stringifiedProperties, ",") + "}";
+			if (safeObjectGetPrototypeOf(value) === null) return rawRepr === "{}" ? "Object.create(null)" : `Object.assign(Object.create(null),${rawRepr})`;
+			return rawRepr;
+		}
+		case "[object Set]": return `new Set(${stringifyInternal(Array.from(value), currentValues, getAsyncContent)})`;
+		case "[object String]": return typeof value === "string" ? safeJsonStringify(value) : `new String(${safeJsonStringify(value)})`;
+		case "[object Symbol]": {
+			const s = value;
+			if (SSymbol.keyFor(s) !== void 0) return `Symbol.for(${safeJsonStringify(SSymbol.keyFor(s))})`;
+			const desc = getSymbolDescription(s);
+			if (desc === null) return "Symbol()";
+			const knownSymbol = desc.startsWith("Symbol.") && SSymbol[desc.substring(7)];
+			return s === knownSymbol ? desc : `Symbol(${safeJsonStringify(desc)})`;
+		}
+		case "[object Promise]": {
+			const promiseContent = getAsyncContent(value);
+			switch (promiseContent.state) {
+				case "fulfilled": return `Promise.resolve(${stringifyInternal(promiseContent.value, currentValues, getAsyncContent)})`;
+				case "rejected": return `Promise.reject(${stringifyInternal(promiseContent.value, currentValues, getAsyncContent)})`;
+				case "pending": return `new Promise(() => {/*pending*/})`;
+				case "unknown":
+				default: return `new Promise(() => {/*unknown*/})`;
+			}
+		}
+		case "[object Error]":
+			if (value instanceof Error) return `new Error(${stringifyInternal(value.message, currentValues, getAsyncContent)})`;
+			break;
+		case "[object Undefined]": return `undefined`;
+		case "[object Int8Array]":
+		case "[object Uint8Array]":
+		case "[object Uint8ClampedArray]":
+		case "[object Int16Array]":
+		case "[object Uint16Array]":
+		case "[object Int32Array]":
+		case "[object Uint32Array]":
+		case "[object Float32Array]":
+		case "[object Float64Array]":
+		case "[object BigInt64Array]":
+		case "[object BigUint64Array]": {
+			if (typeof safeBufferIsBuffer === "function" && safeBufferIsBuffer(value)) return `Buffer.from(${stringifyInternal(safeArrayFrom(value.values()), currentValues, getAsyncContent)})`;
+			const valuePrototype = safeObjectGetPrototypeOf(value);
+			const className = valuePrototype && valuePrototype.constructor && valuePrototype.constructor.name;
+			if (typeof className === "string") {
+				const typedArray = value;
+				const valuesFromTypedArr = typedArray.values();
+				return `${className}.from(${stringifyInternal(safeArrayFrom(valuesFromTypedArr), currentValues, getAsyncContent)})`;
+			}
+			break;
+		}
+	}
+	try {
+		return value.toString();
+	} catch (_a) {
+		return safeToString(value);
+	}
+}
+function stringify(value) {
+	return stringifyInternal(value, [], () => ({
+		state: "unknown",
+		value: void 0
+	}));
+}
+function possiblyAsyncStringify(value) {
+	const stillPendingMarker = SSymbol();
+	const pendingPromisesForCache = [];
+	const cache = new SMap();
+	function createDelay0() {
+		let handleId = null;
+		const cancel = () => {
+			if (handleId !== null) clearTimeout(handleId);
+		};
+		const delay = new Promise((resolve) => {
+			handleId = setTimeout(() => {
+				handleId = null;
+				resolve(stillPendingMarker);
+			}, 0);
+		});
+		return {
+			delay,
+			cancel
+		};
+	}
+	const unknownState = {
+		state: "unknown",
+		value: void 0
+	};
+	const getAsyncContent = function getAsyncContent$1(data) {
+		const cacheKey = data;
+		if (cache.has(cacheKey)) return cache.get(cacheKey);
+		const delay0 = createDelay0();
+		const p = asyncToStringMethod in data ? Promise.resolve().then(() => data[asyncToStringMethod]()) : data;
+		p.catch(() => {});
+		pendingPromisesForCache.push(Promise.race([p, delay0.delay]).then((successValue) => {
+			if (successValue === stillPendingMarker) cache.set(cacheKey, {
+				state: "pending",
+				value: void 0
+			});
+			else cache.set(cacheKey, {
+				state: "fulfilled",
+				value: successValue
+			});
+			delay0.cancel();
+		}, (errorValue) => {
+			cache.set(cacheKey, {
+				state: "rejected",
+				value: errorValue
+			});
+			delay0.cancel();
+		}));
+		cache.set(cacheKey, unknownState);
+		return unknownState;
+	};
+	function loop() {
+		const stringifiedValue = stringifyInternal(value, [], getAsyncContent);
+		if (pendingPromisesForCache.length === 0) return stringifiedValue;
+		return Promise.all(pendingPromisesForCache.splice(0)).then(loop);
+	}
+	return loop();
+}
+
+//#endregion
+export { asyncToStringMethod, hasAsyncToStringMethod, hasToStringMethod, possiblyAsyncStringify, stringify, toStringMethod };

package/dist/node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UniformArrayIntDistribution.js

@@ -0,0 +1,20 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { unsafeUniformArrayIntDistribution } from "./UnsafeUniformArrayIntDistribution.js";
+
+//#region node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UniformArrayIntDistribution.js
+function uniformArrayIntDistribution(from, to, rng) {
+	if (rng != null) {
+		var nextRng = rng.clone();
+		return [unsafeUniformArrayIntDistribution(from, to, nextRng), nextRng];
+	}
+	return function(rng$1) {
+		var nextRng$1 = rng$1.clone();
+		return [unsafeUniformArrayIntDistribution(from, to, nextRng$1), nextRng$1];
+	};
+}
+
+//#endregion
+export { uniformArrayIntDistribution };

package/dist/node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UniformBigIntDistribution.js

@@ -0,0 +1,20 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { unsafeUniformBigIntDistribution } from "./UnsafeUniformBigIntDistribution.js";
+
+//#region node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UniformBigIntDistribution.js
+function uniformBigIntDistribution(from, to, rng) {
+	if (rng != null) {
+		var nextRng = rng.clone();
+		return [unsafeUniformBigIntDistribution(from, to, nextRng), nextRng];
+	}
+	return function(rng$1) {
+		var nextRng$1 = rng$1.clone();
+		return [unsafeUniformBigIntDistribution(from, to, nextRng$1), nextRng$1];
+	};
+}
+
+//#endregion
+export { uniformBigIntDistribution };

package/dist/node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UniformIntDistribution.js

@@ -0,0 +1,20 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { unsafeUniformIntDistribution } from "./UnsafeUniformIntDistribution.js";
+
+//#region node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UniformIntDistribution.js
+function uniformIntDistribution(from, to, rng) {
+	if (rng != null) {
+		var nextRng = rng.clone();
+		return [unsafeUniformIntDistribution(from, to, nextRng), nextRng];
+	}
+	return function(rng$1) {
+		var nextRng$1 = rng$1.clone();
+		return [unsafeUniformIntDistribution(from, to, nextRng$1), nextRng$1];
+	};
+}
+
+//#endregion
+export { uniformIntDistribution };

package/dist/node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformArrayIntDistribution.js

@@ -0,0 +1,20 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { addArrayIntToNew, addOneToPositiveArrayInt, substractArrayIntToNew, trimArrayIntInplace } from "./internals/ArrayInt.js";
+import { unsafeUniformArrayIntDistributionInternal } from "./internals/UnsafeUniformArrayIntDistributionInternal.js";
+
+//#region node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformArrayIntDistribution.js
+function unsafeUniformArrayIntDistribution(from, to, rng) {
+	var rangeSize = trimArrayIntInplace(addOneToPositiveArrayInt(substractArrayIntToNew(to, from)));
+	var emptyArrayIntData = rangeSize.data.slice(0);
+	var g = unsafeUniformArrayIntDistributionInternal(emptyArrayIntData, rangeSize.data, rng);
+	return trimArrayIntInplace(addArrayIntToNew({
+		sign: 1,
+		data: g
+	}, from));
+}
+
+//#endregion
+export { unsafeUniformArrayIntDistribution };

package/dist/node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformBigIntDistribution.js

@@ -0,0 +1,32 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformBigIntDistribution.js
+var SBigInt = typeof BigInt !== "undefined" ? BigInt : void 0;
+function unsafeUniformBigIntDistribution(from, to, rng) {
+	var diff = to - from + SBigInt(1);
+	var MinRng = SBigInt(-2147483648);
+	var NumValues = SBigInt(4294967296);
+	var FinalNumValues = NumValues;
+	var NumIterations = 1;
+	while (FinalNumValues < diff) {
+		FinalNumValues *= NumValues;
+		++NumIterations;
+	}
+	var MaxAcceptedRandom = FinalNumValues - FinalNumValues % diff;
+	while (true) {
+		var value = SBigInt(0);
+		for (var num = 0; num !== NumIterations; ++num) {
+			var out = rng.unsafeNext();
+			value = NumValues * value + (SBigInt(out) - MinRng);
+		}
+		if (value < MaxAcceptedRandom) {
+			var inDiff = value % diff;
+			return inDiff + from;
+		}
+	}
+}
+
+//#endregion
+export { unsafeUniformBigIntDistribution };

package/dist/node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformIntDistribution.js

@@ -0,0 +1,43 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { fromNumberToArrayInt64, substractArrayInt64 } from "./internals/ArrayInt.js";
+import { unsafeUniformIntDistributionInternal } from "./internals/UnsafeUniformIntDistributionInternal.js";
+import { unsafeUniformArrayIntDistributionInternal } from "./internals/UnsafeUniformArrayIntDistributionInternal.js";
+
+//#region node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformIntDistribution.js
+var safeNumberMaxSafeInteger = Number.MAX_SAFE_INTEGER;
+var sharedA = {
+	sign: 1,
+	data: [0, 0]
+};
+var sharedB = {
+	sign: 1,
+	data: [0, 0]
+};
+var sharedC = {
+	sign: 1,
+	data: [0, 0]
+};
+var sharedData = [0, 0];
+function uniformLargeIntInternal(from, to, rangeSize, rng) {
+	var rangeSizeArrayIntValue = rangeSize <= safeNumberMaxSafeInteger ? fromNumberToArrayInt64(sharedC, rangeSize) : substractArrayInt64(sharedC, fromNumberToArrayInt64(sharedA, to), fromNumberToArrayInt64(sharedB, from));
+	if (rangeSizeArrayIntValue.data[1] === 4294967295) {
+		rangeSizeArrayIntValue.data[0] += 1;
+		rangeSizeArrayIntValue.data[1] = 0;
+	} else rangeSizeArrayIntValue.data[1] += 1;
+	unsafeUniformArrayIntDistributionInternal(sharedData, rangeSizeArrayIntValue.data, rng);
+	return sharedData[0] * 4294967296 + sharedData[1] + from;
+}
+function unsafeUniformIntDistribution(from, to, rng) {
+	var rangeSize = to - from;
+	if (rangeSize <= 4294967295) {
+		var g = unsafeUniformIntDistributionInternal(rangeSize + 1, rng);
+		return g + from;
+	}
+	return uniformLargeIntInternal(from, to, rangeSize, rng);
+}
+
+//#endregion
+export { unsafeUniformIntDistribution };

package/dist/node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/internals/ArrayInt.js

@@ -0,0 +1,139 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/internals/ArrayInt.js
+function addArrayIntToNew(arrayIntA, arrayIntB) {
+	if (arrayIntA.sign !== arrayIntB.sign) return substractArrayIntToNew(arrayIntA, {
+		sign: -arrayIntB.sign,
+		data: arrayIntB.data
+	});
+	var data = [];
+	var reminder = 0;
+	var dataA = arrayIntA.data;
+	var dataB = arrayIntB.data;
+	for (var indexA = dataA.length - 1, indexB = dataB.length - 1; indexA >= 0 || indexB >= 0; --indexA, --indexB) {
+		var vA = indexA >= 0 ? dataA[indexA] : 0;
+		var vB = indexB >= 0 ? dataB[indexB] : 0;
+		var current = vA + vB + reminder;
+		data.push(current >>> 0);
+		reminder = ~~(current / 4294967296);
+	}
+	if (reminder !== 0) data.push(reminder);
+	return {
+		sign: arrayIntA.sign,
+		data: data.reverse()
+	};
+}
+function addOneToPositiveArrayInt(arrayInt) {
+	arrayInt.sign = 1;
+	var data = arrayInt.data;
+	for (var index = data.length - 1; index >= 0; --index) if (data[index] === 4294967295) data[index] = 0;
+	else {
+		data[index] += 1;
+		return arrayInt;
+	}
+	data.unshift(1);
+	return arrayInt;
+}
+function isStrictlySmaller(dataA, dataB) {
+	var maxLength = Math.max(dataA.length, dataB.length);
+	for (var index = 0; index < maxLength; ++index) {
+		var indexA = index + dataA.length - maxLength;
+		var indexB = index + dataB.length - maxLength;
+		var vA = indexA >= 0 ? dataA[indexA] : 0;
+		var vB = indexB >= 0 ? dataB[indexB] : 0;
+		if (vA < vB) return true;
+		if (vA > vB) return false;
+	}
+	return false;
+}
+function substractArrayIntToNew(arrayIntA, arrayIntB) {
+	if (arrayIntA.sign !== arrayIntB.sign) return addArrayIntToNew(arrayIntA, {
+		sign: -arrayIntB.sign,
+		data: arrayIntB.data
+	});
+	var dataA = arrayIntA.data;
+	var dataB = arrayIntB.data;
+	if (isStrictlySmaller(dataA, dataB)) {
+		var out = substractArrayIntToNew(arrayIntB, arrayIntA);
+		out.sign = -out.sign;
+		return out;
+	}
+	var data = [];
+	var reminder = 0;
+	for (var indexA = dataA.length - 1, indexB = dataB.length - 1; indexA >= 0 || indexB >= 0; --indexA, --indexB) {
+		var vA = indexA >= 0 ? dataA[indexA] : 0;
+		var vB = indexB >= 0 ? dataB[indexB] : 0;
+		var current = vA - vB - reminder;
+		data.push(current >>> 0);
+		reminder = current < 0 ? 1 : 0;
+	}
+	return {
+		sign: arrayIntA.sign,
+		data: data.reverse()
+	};
+}
+function trimArrayIntInplace(arrayInt) {
+	var data = arrayInt.data;
+	var firstNonZero = 0;
+	for (; firstNonZero !== data.length && data[firstNonZero] === 0; ++firstNonZero);
+	if (firstNonZero === data.length) {
+		arrayInt.sign = 1;
+		arrayInt.data = [0];
+		return arrayInt;
+	}
+	data.splice(0, firstNonZero);
+	return arrayInt;
+}
+function fromNumberToArrayInt64(out, n) {
+	if (n < 0) {
+		var posN = -n;
+		out.sign = -1;
+		out.data[0] = ~~(posN / 4294967296);
+		out.data[1] = posN >>> 0;
+	} else {
+		out.sign = 1;
+		out.data[0] = ~~(n / 4294967296);
+		out.data[1] = n >>> 0;
+	}
+	return out;
+}
+function substractArrayInt64(out, arrayIntA, arrayIntB) {
+	var lowA = arrayIntA.data[1];
+	var highA = arrayIntA.data[0];
+	var signA = arrayIntA.sign;
+	var lowB = arrayIntB.data[1];
+	var highB = arrayIntB.data[0];
+	var signB = arrayIntB.sign;
+	out.sign = 1;
+	if (signA === 1 && signB === -1) {
+		var low_1 = lowA + lowB;
+		var high = highA + highB + (low_1 > 4294967295 ? 1 : 0);
+		out.data[0] = high >>> 0;
+		out.data[1] = low_1 >>> 0;
+		return out;
+	}
+	var lowFirst = lowA;
+	var highFirst = highA;
+	var lowSecond = lowB;
+	var highSecond = highB;
+	if (signA === -1) {
+		lowFirst = lowB;
+		highFirst = highB;
+		lowSecond = lowA;
+		highSecond = highA;
+	}
+	var reminderLow = 0;
+	var low = lowFirst - lowSecond;
+	if (low < 0) {
+		reminderLow = 1;
+		low = low >>> 0;
+	}
+	out.data[0] = highFirst - highSecond - reminderLow;
+	out.data[1] = low;
+	return out;
+}
+
+//#endregion
+export { addArrayIntToNew, addOneToPositiveArrayInt, fromNumberToArrayInt64, substractArrayInt64, substractArrayIntToNew, trimArrayIntInplace };

package/dist/node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/internals/UnsafeUniformArrayIntDistributionInternal.js

@@ -0,0 +1,26 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { unsafeUniformIntDistributionInternal } from "./UnsafeUniformIntDistributionInternal.js";
+
+//#region node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/internals/UnsafeUniformArrayIntDistributionInternal.js
+function unsafeUniformArrayIntDistributionInternal(out, rangeSize, rng) {
+	var rangeLength = rangeSize.length;
+	while (true) {
+		for (var index = 0; index !== rangeLength; ++index) {
+			var indexRangeSize = index === 0 ? rangeSize[0] + 1 : 4294967296;
+			var g = unsafeUniformIntDistributionInternal(indexRangeSize, rng);
+			out[index] = g;
+		}
+		for (var index = 0; index !== rangeLength; ++index) {
+			var current = out[index];
+			var currentInRange = rangeSize[index];
+			if (current < currentInRange) return out;
+			else if (current > currentInRange) break;
+		}
+	}
+}
+
+//#endregion
+export { unsafeUniformArrayIntDistributionInternal };

package/dist/node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/internals/UnsafeUniformIntDistributionInternal.js

@@ -0,0 +1,14 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/internals/UnsafeUniformIntDistributionInternal.js
+function unsafeUniformIntDistributionInternal(rangeSize, rng) {
+	var MaxAllowed = rangeSize > 2 ? ~~(4294967296 / rangeSize) * rangeSize : 4294967296;
+	var deltaV = rng.unsafeNext() + 2147483648;
+	while (deltaV >= MaxAllowed) deltaV = rng.unsafeNext() + 2147483648;
+	return deltaV % rangeSize;
+}
+
+//#endregion
+export { unsafeUniformIntDistributionInternal };

package/dist/node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/generator/LinearCongruential.js

@@ -0,0 +1,53 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/pure-rand@6.1.0/node_modules/pure-rand/lib/esm/generator/LinearCongruential.js
+var MULTIPLIER = 214013;
+var INCREMENT = 2531011;
+var MASK = 4294967295;
+var MASK_2 = (1 << 31) - 1;
+var computeNextSeed = function(seed) {
+	return seed * MULTIPLIER + INCREMENT & MASK;
+};
+var computeValueFromNextSeed = function(nextseed) {
+	return (nextseed & MASK_2) >> 16;
+};
+var LinearCongruential32 = function() {
+	function LinearCongruential32$1(seed) {
+		this.seed = seed;
+	}
+	LinearCongruential32$1.prototype.clone = function() {
+		return new LinearCongruential32$1(this.seed);
+	};
+	LinearCongruential32$1.prototype.next = function() {
+		var nextRng = new LinearCongruential32$1(this.seed);
+		var out = nextRng.unsafeNext();
+		return [out, nextRng];
+	};
+	LinearCongruential32$1.prototype.unsafeNext = function() {
+		var s1 = computeNextSeed(this.seed);
+		var v1 = computeValueFromNextSeed(s1);
+		var s2 = computeNextSeed(s1);
+		var v2 = computeValueFromNextSeed(s2);
+		this.seed = computeNextSeed(s2);
+		var v3 = computeValueFromNextSeed(this.seed);
+		var vnext = v3 + (v2 + (v1 << 15) << 15);
+		return vnext | 0;
+	};
+	LinearCongruential32$1.prototype.getState = function() {
+		return [this.seed];
+	};
+	return LinearCongruential32$1;
+}();
+function fromState(state) {
+	var valid = state.length === 1;
+	if (!valid) throw new Error("The state must have been produced by a congruential32 RandomGenerator");
+	return new LinearCongruential32(state[0]);
+}
+var congruential32 = Object.assign(function(seed) {
+	return new LinearCongruential32(seed);
+}, { fromState });
+
+//#endregion
+export { congruential32 };