@fedify/fedify 1.6.0-dev.814 → 1.6.0

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/FrequencyArbitrary.js

@@ -0,0 +1,136 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Stream } from "../../stream/Stream.js";
+import { Value } from "../../check/arbitrary/definition/Value.js";
+import { Arbitrary } from "../../check/arbitrary/definition/Arbitrary.js";
+import { safePush } from "../../utils/globals.js";
+import { getDepthContextFor } from "./helpers/DepthContext.js";
+import { depthBiasFromSizeForArbitrary } from "./helpers/MaxLengthFromMinLength.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/FrequencyArbitrary.js
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeMaxSafeInteger = Number.MAX_SAFE_INTEGER;
+const safeNumberIsInteger = Number.isInteger;
+const safeMathFloor = Math.floor;
+const safeMathPow = Math.pow;
+const safeMathMin = Math.min;
+var FrequencyArbitrary = class FrequencyArbitrary extends Arbitrary {
+	static from(warbs, constraints, label) {
+		if (warbs.length === 0) throw new Error(`${label} expects at least one weighted arbitrary`);
+		let totalWeight = 0;
+		for (let idx = 0; idx !== warbs.length; ++idx) {
+			const currentArbitrary = warbs[idx].arbitrary;
+			if (currentArbitrary === void 0) throw new Error(`${label} expects arbitraries to be specified`);
+			const currentWeight = warbs[idx].weight;
+			totalWeight += currentWeight;
+			if (!safeNumberIsInteger(currentWeight)) throw new Error(`${label} expects weights to be integer values`);
+			if (currentWeight < 0) throw new Error(`${label} expects weights to be superior or equal to 0`);
+		}
+		if (totalWeight <= 0) throw new Error(`${label} expects the sum of weights to be strictly superior to 0`);
+		const sanitizedConstraints = {
+			depthBias: depthBiasFromSizeForArbitrary(constraints.depthSize, constraints.maxDepth !== void 0),
+			maxDepth: constraints.maxDepth != void 0 ? constraints.maxDepth : safePositiveInfinity,
+			withCrossShrink: !!constraints.withCrossShrink
+		};
+		return new FrequencyArbitrary(warbs, sanitizedConstraints, getDepthContextFor(constraints.depthIdentifier));
+	}
+	constructor(warbs, constraints, context) {
+		super();
+		this.warbs = warbs;
+		this.constraints = constraints;
+		this.context = context;
+		let currentWeight = 0;
+		this.cumulatedWeights = [];
+		for (let idx = 0; idx !== warbs.length; ++idx) {
+			currentWeight += warbs[idx].weight;
+			safePush(this.cumulatedWeights, currentWeight);
+		}
+		this.totalWeight = currentWeight;
+	}
+	generate(mrng, biasFactor) {
+		if (this.mustGenerateFirst()) return this.safeGenerateForIndex(mrng, 0, biasFactor);
+		const selected = mrng.nextInt(this.computeNegDepthBenefit(), this.totalWeight - 1);
+		for (let idx = 0; idx !== this.cumulatedWeights.length; ++idx) if (selected < this.cumulatedWeights[idx]) return this.safeGenerateForIndex(mrng, idx, biasFactor);
+		throw new Error(`Unable to generate from fc.frequency`);
+	}
+	canShrinkWithoutContext(value) {
+		return this.canShrinkWithoutContextIndex(value) !== -1;
+	}
+	shrink(value, context) {
+		if (context !== void 0) {
+			const safeContext = context;
+			const selectedIndex = safeContext.selectedIndex;
+			const originalBias = safeContext.originalBias;
+			const originalArbitrary = this.warbs[selectedIndex].arbitrary;
+			const originalShrinks = originalArbitrary.shrink(value, safeContext.originalContext).map((v) => this.mapIntoValue(selectedIndex, v, null, originalBias));
+			if (safeContext.clonedMrngForFallbackFirst !== null) {
+				if (safeContext.cachedGeneratedForFirst === void 0) safeContext.cachedGeneratedForFirst = this.safeGenerateForIndex(safeContext.clonedMrngForFallbackFirst, 0, originalBias);
+				const valueFromFirst = safeContext.cachedGeneratedForFirst;
+				return Stream.of(valueFromFirst).join(originalShrinks);
+			}
+			return originalShrinks;
+		}
+		const potentialSelectedIndex = this.canShrinkWithoutContextIndex(value);
+		if (potentialSelectedIndex === -1) return Stream.nil();
+		return this.defaultShrinkForFirst(potentialSelectedIndex).join(this.warbs[potentialSelectedIndex].arbitrary.shrink(value, void 0).map((v) => this.mapIntoValue(potentialSelectedIndex, v, null, void 0)));
+	}
+	defaultShrinkForFirst(selectedIndex) {
+		++this.context.depth;
+		try {
+			if (!this.mustFallbackToFirstInShrink(selectedIndex) || this.warbs[0].fallbackValue === void 0) return Stream.nil();
+		} finally {
+			--this.context.depth;
+		}
+		const rawShrinkValue = new Value(this.warbs[0].fallbackValue.default, void 0);
+		return Stream.of(this.mapIntoValue(0, rawShrinkValue, null, void 0));
+	}
+	canShrinkWithoutContextIndex(value) {
+		if (this.mustGenerateFirst()) return this.warbs[0].arbitrary.canShrinkWithoutContext(value) ? 0 : -1;
+		try {
+			++this.context.depth;
+			for (let idx = 0; idx !== this.warbs.length; ++idx) {
+				const warb = this.warbs[idx];
+				if (warb.weight !== 0 && warb.arbitrary.canShrinkWithoutContext(value)) return idx;
+			}
+			return -1;
+		} finally {
+			--this.context.depth;
+		}
+	}
+	mapIntoValue(idx, value, clonedMrngForFallbackFirst, biasFactor) {
+		const context = {
+			selectedIndex: idx,
+			originalBias: biasFactor,
+			originalContext: value.context,
+			clonedMrngForFallbackFirst
+		};
+		return new Value(value.value, context);
+	}
+	safeGenerateForIndex(mrng, idx, biasFactor) {
+		++this.context.depth;
+		try {
+			const value = this.warbs[idx].arbitrary.generate(mrng, biasFactor);
+			const clonedMrngForFallbackFirst = this.mustFallbackToFirstInShrink(idx) ? mrng.clone() : null;
+			return this.mapIntoValue(idx, value, clonedMrngForFallbackFirst, biasFactor);
+		} finally {
+			--this.context.depth;
+		}
+	}
+	mustGenerateFirst() {
+		return this.constraints.maxDepth <= this.context.depth;
+	}
+	mustFallbackToFirstInShrink(idx) {
+		return idx !== 0 && this.constraints.withCrossShrink && this.warbs[0].weight !== 0;
+	}
+	computeNegDepthBenefit() {
+		const depthBias = this.constraints.depthBias;
+		if (depthBias <= 0 || this.warbs[0].weight === 0) return 0;
+		const depthBenefit = safeMathFloor(safeMathPow(1 + depthBias, this.context.depth)) - 1;
+		return -safeMathMin(this.totalWeight * depthBenefit, safeMaxSafeInteger) || 0;
+	}
+};
+
+//#endregion
+export { FrequencyArbitrary };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/IntegerArbitrary.js

@@ -0,0 +1,64 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Stream } from "../../stream/Stream.js";
+import { Value } from "../../check/arbitrary/definition/Value.js";
+import { Arbitrary } from "../../check/arbitrary/definition/Arbitrary.js";
+import { biasNumericRange, integerLogLike } from "./helpers/BiasNumericRange.js";
+import { shrinkInteger } from "./helpers/ShrinkInteger.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/IntegerArbitrary.js
+const safeMathSign = Math.sign;
+const safeNumberIsInteger = Number.isInteger;
+const safeObjectIs = Object.is;
+var IntegerArbitrary = class IntegerArbitrary extends Arbitrary {
+	constructor(min, max) {
+		super();
+		this.min = min;
+		this.max = max;
+	}
+	generate(mrng, biasFactor) {
+		const range = this.computeGenerateRange(mrng, biasFactor);
+		return new Value(mrng.nextInt(range.min, range.max), void 0);
+	}
+	canShrinkWithoutContext(value) {
+		return typeof value === "number" && safeNumberIsInteger(value) && !safeObjectIs(value, -0) && this.min <= value && value <= this.max;
+	}
+	shrink(current, context) {
+		if (!IntegerArbitrary.isValidContext(current, context)) {
+			const target = this.defaultTarget();
+			return shrinkInteger(current, target, true);
+		}
+		if (this.isLastChanceTry(current, context)) return Stream.of(new Value(context, void 0));
+		return shrinkInteger(current, context, false);
+	}
+	defaultTarget() {
+		if (this.min <= 0 && this.max >= 0) return 0;
+		return this.min < 0 ? this.max : this.min;
+	}
+	computeGenerateRange(mrng, biasFactor) {
+		if (biasFactor === void 0 || mrng.nextInt(1, biasFactor) !== 1) return {
+			min: this.min,
+			max: this.max
+		};
+		const ranges = biasNumericRange(this.min, this.max, integerLogLike);
+		if (ranges.length === 1) return ranges[0];
+		const id = mrng.nextInt(-2 * (ranges.length - 1), ranges.length - 2);
+		return id < 0 ? ranges[0] : ranges[id + 1];
+	}
+	isLastChanceTry(current, context) {
+		if (current > 0) return current === context + 1 && current > this.min;
+		if (current < 0) return current === context - 1 && current < this.max;
+		return false;
+	}
+	static isValidContext(current, context) {
+		if (context === void 0) return false;
+		if (typeof context !== "number") throw new Error(`Invalid context type passed to IntegerArbitrary (#1)`);
+		if (context !== 0 && safeMathSign(current) !== safeMathSign(context)) throw new Error(`Invalid context value passed to IntegerArbitrary (#2)`);
+		return true;
+	}
+};
+
+//#endregion
+export { IntegerArbitrary };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/LazyArbitrary.js

@@ -0,0 +1,29 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Arbitrary } from "../../check/arbitrary/definition/Arbitrary.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/LazyArbitrary.js
+var LazyArbitrary = class extends Arbitrary {
+	constructor(name) {
+		super();
+		this.name = name;
+		this.underlying = null;
+	}
+	generate(mrng, biasFactor) {
+		if (!this.underlying) throw new Error(`Lazy arbitrary ${JSON.stringify(this.name)} not correctly initialized`);
+		return this.underlying.generate(mrng, biasFactor);
+	}
+	canShrinkWithoutContext(value) {
+		if (!this.underlying) throw new Error(`Lazy arbitrary ${JSON.stringify(this.name)} not correctly initialized`);
+		return this.underlying.canShrinkWithoutContext(value);
+	}
+	shrink(value, context) {
+		if (!this.underlying) throw new Error(`Lazy arbitrary ${JSON.stringify(this.name)} not correctly initialized`);
+		return this.underlying.shrink(value, context);
+	}
+};
+
+//#endregion
+export { LazyArbitrary };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/StringUnitArbitrary.js

@@ -0,0 +1,45 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safeNormalize, safePush } from "../../utils/globals.js";
+import { mapToConstant } from "../mapToConstant.js";
+import { asciiAlphabetRanges, autonomousDecomposableGraphemeRanges, autonomousGraphemeRanges, fullAlphabetRanges } from "./data/GraphemeRanges.js";
+import { convertGraphemeRangeToMapToConstantEntry, intersectGraphemeRanges } from "./helpers/GraphemeRangesHelpers.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/StringUnitArbitrary.js
+const registeredStringUnitInstancesMap = Object.create(null);
+function getAlphabetRanges(alphabet) {
+	switch (alphabet) {
+		case "full": return fullAlphabetRanges;
+		case "ascii": return asciiAlphabetRanges;
+	}
+}
+function getOrCreateStringUnitInstance(type, alphabet) {
+	const key = `${type}:${alphabet}`;
+	const registered = registeredStringUnitInstancesMap[key];
+	if (registered !== void 0) return registered;
+	const alphabetRanges = getAlphabetRanges(alphabet);
+	const ranges = type === "binary" ? alphabetRanges : intersectGraphemeRanges(alphabetRanges, autonomousGraphemeRanges);
+	const entries = [];
+	for (const range of ranges) safePush(entries, convertGraphemeRangeToMapToConstantEntry(range));
+	if (type === "grapheme") {
+		const decomposedRanges = intersectGraphemeRanges(alphabetRanges, autonomousDecomposableGraphemeRanges);
+		for (const range of decomposedRanges) {
+			const rawEntry = convertGraphemeRangeToMapToConstantEntry(range);
+			safePush(entries, {
+				num: rawEntry.num,
+				build: (idInGroup) => safeNormalize(rawEntry.build(idInGroup), "NFD")
+			});
+		}
+	}
+	const stringUnitInstance = mapToConstant(...entries);
+	registeredStringUnitInstancesMap[key] = stringUnitInstance;
+	return stringUnitInstance;
+}
+function stringUnit(type, alphabet) {
+	return getOrCreateStringUnitInstance(type, alphabet);
+}
+
+//#endregion
+export { stringUnit };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/TupleArbitrary.js

@@ -0,0 +1,74 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Stream } from "../../stream/Stream.js";
+import { cloneIfNeeded, cloneMethod } from "../../check/symbols.js";
+import { Value } from "../../check/arbitrary/definition/Value.js";
+import { Arbitrary } from "../../check/arbitrary/definition/Arbitrary.js";
+import { safeMap, safePush, safeSlice } from "../../utils/globals.js";
+import { makeLazy } from "../../stream/LazyIterableIterator.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/TupleArbitrary.js
+const safeArrayIsArray = Array.isArray;
+const safeObjectDefineProperty = Object.defineProperty;
+function tupleMakeItCloneable(vs, values) {
+	return safeObjectDefineProperty(vs, cloneMethod, { value: () => {
+		const cloned = [];
+		for (let idx = 0; idx !== values.length; ++idx) safePush(cloned, values[idx].value);
+		tupleMakeItCloneable(cloned, values);
+		return cloned;
+	} });
+}
+function tupleWrapper(values) {
+	let cloneable = false;
+	const vs = [];
+	const ctxs = [];
+	for (let idx = 0; idx !== values.length; ++idx) {
+		const v = values[idx];
+		cloneable = cloneable || v.hasToBeCloned;
+		safePush(vs, v.value);
+		safePush(ctxs, v.context);
+	}
+	if (cloneable) tupleMakeItCloneable(vs, values);
+	return new Value(vs, ctxs);
+}
+function tupleShrink(arbs, value, context) {
+	const shrinks = [];
+	const safeContext = safeArrayIsArray(context) ? context : [];
+	for (let idx = 0; idx !== arbs.length; ++idx) safePush(shrinks, makeLazy(() => arbs[idx].shrink(value[idx], safeContext[idx]).map((v) => {
+		const nextValues = safeMap(value, (v$1, idx$1) => new Value(cloneIfNeeded(v$1), safeContext[idx$1]));
+		return [
+			...safeSlice(nextValues, 0, idx),
+			v,
+			...safeSlice(nextValues, idx + 1)
+		];
+	}).map(tupleWrapper)));
+	return Stream.nil().join(...shrinks);
+}
+var TupleArbitrary = class extends Arbitrary {
+	constructor(arbs) {
+		super();
+		this.arbs = arbs;
+		for (let idx = 0; idx !== arbs.length; ++idx) {
+			const arb = arbs[idx];
+			if (arb == null || arb.generate == null) throw new Error(`Invalid parameter encountered at index ${idx}: expecting an Arbitrary`);
+		}
+	}
+	generate(mrng, biasFactor) {
+		const mapped = [];
+		for (let idx = 0; idx !== this.arbs.length; ++idx) safePush(mapped, this.arbs[idx].generate(mrng, biasFactor));
+		return tupleWrapper(mapped);
+	}
+	canShrinkWithoutContext(value) {
+		if (!safeArrayIsArray(value) || value.length !== this.arbs.length) return false;
+		for (let index = 0; index !== this.arbs.length; ++index) if (!this.arbs[index].canShrinkWithoutContext(value[index])) return false;
+		return true;
+	}
+	shrink(value, context) {
+		return tupleShrink(this.arbs, value, context);
+	}
+};
+
+//#endregion
+export { TupleArbitrary };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/WithShrinkFromOtherArbitrary.js

@@ -0,0 +1,40 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Value } from "../../check/arbitrary/definition/Value.js";
+import { Arbitrary } from "../../check/arbitrary/definition/Arbitrary.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/WithShrinkFromOtherArbitrary.js
+function isSafeContext(context) {
+	return context !== void 0;
+}
+function toGeneratorValue(value) {
+	if (value.hasToBeCloned) return new Value(value.value_, { generatorContext: value.context }, () => value.value);
+	return new Value(value.value_, { generatorContext: value.context });
+}
+function toShrinkerValue(value) {
+	if (value.hasToBeCloned) return new Value(value.value_, { shrinkerContext: value.context }, () => value.value);
+	return new Value(value.value_, { shrinkerContext: value.context });
+}
+var WithShrinkFromOtherArbitrary = class extends Arbitrary {
+	constructor(generatorArbitrary, shrinkerArbitrary) {
+		super();
+		this.generatorArbitrary = generatorArbitrary;
+		this.shrinkerArbitrary = shrinkerArbitrary;
+	}
+	generate(mrng, biasFactor) {
+		return toGeneratorValue(this.generatorArbitrary.generate(mrng, biasFactor));
+	}
+	canShrinkWithoutContext(value) {
+		return this.shrinkerArbitrary.canShrinkWithoutContext(value);
+	}
+	shrink(value, context) {
+		if (!isSafeContext(context)) return this.shrinkerArbitrary.shrink(value, void 0).map(toShrinkerValue);
+		if ("generatorContext" in context) return this.generatorArbitrary.shrink(value, context.generatorContext).map(toGeneratorValue);
+		return this.shrinkerArbitrary.shrink(value, context.shrinkerContext).map(toShrinkerValue);
+	}
+};
+
+//#endregion
+export { WithShrinkFromOtherArbitrary };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/AnyArbitraryBuilder.js

@@ -0,0 +1,97 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { tuple } from "../../tuple.js";
+import { stringify } from "../../../utils/stringify.js";
+import { createDepthIdentifier } from "../helpers/DepthContext.js";
+import { array } from "../../array.js";
+import { bigInt } from "../../bigInt.js";
+import { date } from "../../date.js";
+import { uniqueArray } from "../../uniqueArray.js";
+import { dictionary } from "../../dictionary.js";
+import { oneof } from "../../oneof.js";
+import { letrec } from "../../letrec.js";
+import { float32Array } from "../../float32Array.js";
+import { float64Array } from "../../float64Array.js";
+import { int16Array } from "../../int16Array.js";
+import { int32Array } from "../../int32Array.js";
+import { int8Array } from "../../int8Array.js";
+import { uint16Array } from "../../uint16Array.js";
+import { uint32Array } from "../../uint32Array.js";
+import { uint8Array } from "../../uint8Array.js";
+import { uint8ClampedArray } from "../../uint8ClampedArray.js";
+import { sparseArray } from "../../sparseArray.js";
+import { arrayToMapMapper, arrayToMapUnmapper } from "../mappers/ArrayToMap.js";
+import { arrayToSetMapper, arrayToSetUnmapper } from "../mappers/ArrayToSet.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/AnyArbitraryBuilder.js
+function mapOf(ka, va, maxKeys, size, depthIdentifier) {
+	return uniqueArray(tuple(ka, va), {
+		maxLength: maxKeys,
+		size,
+		comparator: "SameValueZero",
+		selector: (t) => t[0],
+		depthIdentifier
+	}).map(arrayToMapMapper, arrayToMapUnmapper);
+}
+function dictOf(ka, va, maxKeys, size, depthIdentifier, withNullPrototype) {
+	return dictionary(ka, va, {
+		maxKeys,
+		noNullPrototype: !withNullPrototype,
+		size,
+		depthIdentifier
+	});
+}
+function setOf(va, maxKeys, size, depthIdentifier) {
+	return uniqueArray(va, {
+		maxLength: maxKeys,
+		size,
+		comparator: "SameValueZero",
+		depthIdentifier
+	}).map(arrayToSetMapper, arrayToSetUnmapper);
+}
+function typedArray(constraints) {
+	return oneof(int8Array(constraints), uint8Array(constraints), uint8ClampedArray(constraints), int16Array(constraints), uint16Array(constraints), int32Array(constraints), uint32Array(constraints), float32Array(constraints), float64Array(constraints));
+}
+function anyArbitraryBuilder(constraints) {
+	const arbitrariesForBase = constraints.values;
+	const depthSize = constraints.depthSize;
+	const depthIdentifier = createDepthIdentifier();
+	const maxDepth = constraints.maxDepth;
+	const maxKeys = constraints.maxKeys;
+	const size = constraints.size;
+	const baseArb = oneof(...arbitrariesForBase, ...constraints.withBigInt ? [bigInt()] : [], ...constraints.withDate ? [date()] : []);
+	return letrec((tie) => ({
+		anything: oneof({
+			maxDepth,
+			depthSize,
+			depthIdentifier
+		}, baseArb, tie("array"), tie("object"), ...constraints.withMap ? [tie("map")] : [], ...constraints.withSet ? [tie("set")] : [], ...constraints.withObjectString ? [tie("anything").map((o) => stringify(o))] : [], ...constraints.withTypedArray ? [typedArray({
+			maxLength: maxKeys,
+			size
+		})] : [], ...constraints.withSparseArray ? [sparseArray(tie("anything"), {
+			maxNumElements: maxKeys,
+			size,
+			depthIdentifier
+		})] : []),
+		keys: constraints.withObjectString ? oneof({
+			arbitrary: constraints.key,
+			weight: 10
+		}, {
+			arbitrary: tie("anything").map((o) => stringify(o)),
+			weight: 1
+		}) : constraints.key,
+		array: array(tie("anything"), {
+			maxLength: maxKeys,
+			size,
+			depthIdentifier
+		}),
+		set: setOf(tie("anything"), maxKeys, size, depthIdentifier),
+		map: oneof(mapOf(tie("keys"), tie("anything"), maxKeys, size, depthIdentifier), mapOf(tie("anything"), tie("anything"), maxKeys, size, depthIdentifier)),
+		object: dictOf(tie("keys"), tie("anything"), maxKeys, size, depthIdentifier, constraints.withNullPrototype)
+	})).anything;
+}
+
+//#endregion
+export { anyArbitraryBuilder };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/BoxedArbitraryBuilder.js

@@ -0,0 +1,13 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { unboxedToBoxedMapper, unboxedToBoxedUnmapper } from "../mappers/UnboxedToBoxed.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/BoxedArbitraryBuilder.js
+function boxedArbitraryBuilder(arb) {
+	return arb.map(unboxedToBoxedMapper, unboxedToBoxedUnmapper);
+}
+
+//#endregion
+export { boxedArbitraryBuilder };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/CharacterArbitraryBuilder.js

@@ -0,0 +1,17 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { integer } from "../../integer.js";
+import { indexToCharStringMapper, indexToCharStringUnmapper } from "../mappers/IndexToCharString.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/CharacterArbitraryBuilder.js
+function buildCharacterArbitrary(min, max, mapToCode, unmapFromCode) {
+	return integer({
+		min,
+		max
+	}).map((n) => indexToCharStringMapper(mapToCode(n)), (c) => unmapFromCode(indexToCharStringUnmapper(c)));
+}
+
+//#endregion
+export { buildCharacterArbitrary };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/RestrictedIntegerArbitraryBuilder.js

@@ -0,0 +1,23 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { integer } from "../../integer.js";
+import { WithShrinkFromOtherArbitrary } from "../WithShrinkFromOtherArbitrary.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/RestrictedIntegerArbitraryBuilder.js
+function restrictedIntegerArbitraryBuilder(min, maxGenerated, max) {
+	const generatorArbitrary = integer({
+		min,
+		max: maxGenerated
+	});
+	if (maxGenerated === max) return generatorArbitrary;
+	const shrinkerArbitrary = integer({
+		min,
+		max
+	});
+	return new WithShrinkFromOtherArbitrary(generatorArbitrary, shrinkerArbitrary);
+}
+
+//#endregion
+export { restrictedIntegerArbitraryBuilder };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/TypedIntArrayArbitraryBuilder.js

@@ -0,0 +1,32 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { array } from "../../array.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/builders/TypedIntArrayArbitraryBuilder.js
+var __rest = void 0 && (void 0).__rest || function(s, e) {
+	var t = {};
+	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+	if (s != null && typeof Object.getOwnPropertySymbols === "function") {
+		for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+	}
+	return t;
+};
+function typedIntArrayArbitraryArbitraryBuilder(constraints, defaultMin, defaultMax, TypedArrayClass, arbitraryBuilder) {
+	const generatorName = TypedArrayClass.name;
+	const { min = defaultMin, max = defaultMax } = constraints, arrayConstraints = __rest(constraints, ["min", "max"]);
+	if (min > max) throw new Error(`Invalid range passed to ${generatorName}: min must be lower than or equal to max`);
+	if (min < defaultMin) throw new Error(`Invalid min value passed to ${generatorName}: min must be greater than or equal to ${defaultMin}`);
+	if (max > defaultMax) throw new Error(`Invalid max value passed to ${generatorName}: max must be lower than or equal to ${defaultMax}`);
+	return array(arbitraryBuilder({
+		min,
+		max
+	}), arrayConstraints).map((data) => TypedArrayClass.from(data), (value) => {
+		if (!(value instanceof TypedArrayClass)) throw new Error("Invalid type");
+		return [...value];
+	});
+}
+
+//#endregion
+export { typedIntArrayArbitraryArbitraryBuilder };