@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/arbitrary/_internals/mappers/UnboxedToBoxed.js

@@ -0,0 +1,22 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SBoolean, SNumber, SString } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/UnboxedToBoxed.js
+function unboxedToBoxedMapper(value) {
+	switch (typeof value) {
+		case "boolean": return new SBoolean(value);
+		case "number": return new SNumber(value);
+		case "string": return new SString(value);
+		default: return value;
+	}
+}
+function unboxedToBoxedUnmapper(value) {
+	if (typeof value !== "object" || value === null || !("constructor" in value)) return value;
+	return value.constructor === SBoolean || value.constructor === SNumber || value.constructor === SString ? value.valueOf() : value;
+}
+
+//#endregion
+export { unboxedToBoxedMapper, unboxedToBoxedUnmapper };

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

@@ -0,0 +1,14 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { anyArbitraryBuilder } from "./_internals/builders/AnyArbitraryBuilder.js";
+import { toQualifiedObjectConstraints } from "./_internals/helpers/QualifiedObjectConstraints.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/anything.js
+function anything(constraints) {
+	return anyArbitraryBuilder(toQualifiedObjectConstraints(constraints));
+}
+
+//#endregion
+export { anything };

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

@@ -0,0 +1,22 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { ArrayArbitrary } from "./_internals/ArrayArbitrary.js";
+import { MaxLengthUpperBound, maxGeneratedLengthFromSizeForArbitrary } from "./_internals/helpers/MaxLengthFromMinLength.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/array.js
+function array(arb, constraints = {}) {
+	const size = constraints.size;
+	const minLength = constraints.minLength || 0;
+	const maxLengthOrUnset = constraints.maxLength;
+	const depthIdentifier = constraints.depthIdentifier;
+	const maxLength = maxLengthOrUnset !== void 0 ? maxLengthOrUnset : MaxLengthUpperBound;
+	const specifiedMaxLength = maxLengthOrUnset !== void 0;
+	const maxGeneratedLength = maxGeneratedLengthFromSizeForArbitrary(size, minLength, maxLength, specifiedMaxLength);
+	const customSlices = constraints.experimentalCustomSlices || [];
+	return new ArrayArbitrary(arb, minLength, maxGeneratedLength, maxLength, depthIdentifier, void 0, customSlices);
+}
+
+//#endregion
+export { array };

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

@@ -0,0 +1,38 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SBigInt } from "../utils/globals.js";
+import { BigIntArbitrary } from "./_internals/BigIntArbitrary.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/bigInt.js
+function buildCompleteBigIntConstraints(constraints) {
+	const DefaultPow = 256;
+	const DefaultMin = SBigInt(-1) << SBigInt(DefaultPow - 1);
+	const DefaultMax = (SBigInt(1) << SBigInt(DefaultPow - 1)) - SBigInt(1);
+	const min = constraints.min;
+	const max = constraints.max;
+	return {
+		min: min !== void 0 ? min : DefaultMin - (max !== void 0 && max < SBigInt(0) ? max * max : SBigInt(0)),
+		max: max !== void 0 ? max : DefaultMax + (min !== void 0 && min > SBigInt(0) ? min * min : SBigInt(0))
+	};
+}
+function extractBigIntConstraints(args) {
+	if (args[0] === void 0) return {};
+	if (args[1] === void 0) {
+		const constraints = args[0];
+		return constraints;
+	}
+	return {
+		min: args[0],
+		max: args[1]
+	};
+}
+function bigInt(...args) {
+	const constraints = buildCompleteBigIntConstraints(extractBigIntConstraints(args));
+	if (constraints.min > constraints.max) throw new Error("fc.bigInt expects max to be greater than or equal to min");
+	return new BigIntArbitrary(constraints.min, constraints.max);
+}
+
+//#endregion
+export { bigInt };

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

@@ -0,0 +1,24 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { integer } from "./integer.js";
+import { noBias } from "./noBias.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/boolean.js
+function booleanMapper(v) {
+	return v === 1;
+}
+function booleanUnmapper(v) {
+	if (typeof v !== "boolean") throw new Error("Unsupported input type");
+	return v === true ? 1 : 0;
+}
+function boolean() {
+	return noBias(integer({
+		min: 0,
+		max: 1
+	}).map(booleanMapper, booleanUnmapper));
+}
+
+//#endregion
+export { boolean };

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

@@ -0,0 +1,13 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { ConstantArbitrary } from "./_internals/ConstantArbitrary.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/constant.js
+function constant(value) {
+	return new ConstantArbitrary([value]);
+}
+
+//#endregion
+export { constant };

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

@@ -0,0 +1,14 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { ConstantArbitrary } from "./_internals/ConstantArbitrary.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/constantFrom.js
+function constantFrom(...values) {
+	if (values.length === 0) throw new Error("fc.constantFrom expects at least one parameter");
+	return new ConstantArbitrary(values);
+}
+
+//#endregion
+export { constantFrom };

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

@@ -0,0 +1,30 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safeGetTime } from "../utils/globals.js";
+import { integer } from "./integer.js";
+import { timeToDateMapper, timeToDateMapperWithNaN, timeToDateUnmapper, timeToDateUnmapperWithNaN } from "./_internals/mappers/TimeToDate.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/date.js
+const safeNumberIsNaN = Number.isNaN;
+function date(constraints = {}) {
+	const intMin = constraints.min !== void 0 ? safeGetTime(constraints.min) : -864e13;
+	const intMax = constraints.max !== void 0 ? safeGetTime(constraints.max) : 864e13;
+	const noInvalidDate = constraints.noInvalidDate === void 0 || constraints.noInvalidDate;
+	if (safeNumberIsNaN(intMin)) throw new Error("fc.date min must be valid instance of Date");
+	if (safeNumberIsNaN(intMax)) throw new Error("fc.date max must be valid instance of Date");
+	if (intMin > intMax) throw new Error("fc.date max must be greater or equal to min");
+	if (noInvalidDate) return integer({
+		min: intMin,
+		max: intMax
+	}).map(timeToDateMapper, timeToDateUnmapper);
+	const valueForNaN = intMax + 1;
+	return integer({
+		min: intMin,
+		max: intMax + 1
+	}).map(timeToDateMapperWithNaN(valueForNaN), timeToDateUnmapperWithNaN(valueForNaN));
+}
+
+//#endregion
+export { date };

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

@@ -0,0 +1,27 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { tuple } from "./tuple.js";
+import { boolean } from "./boolean.js";
+import { constant } from "./constant.js";
+import { uniqueArray } from "./uniqueArray.js";
+import { keyValuePairsToObjectMapper, keyValuePairsToObjectUnmapper } from "./_internals/mappers/KeyValuePairsToObject.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/dictionary.js
+function dictionaryKeyExtractor(entry) {
+	return entry[0];
+}
+function dictionary(keyArb, valueArb, constraints = {}) {
+	const noNullPrototype = constraints.noNullPrototype !== false;
+	return tuple(uniqueArray(tuple(keyArb, valueArb), {
+		minLength: constraints.minKeys,
+		maxLength: constraints.maxKeys,
+		size: constraints.size,
+		selector: dictionaryKeyExtractor,
+		depthIdentifier: constraints.depthIdentifier
+	}), noNullPrototype ? constant(false) : boolean()).map(keyValuePairsToObjectMapper, keyValuePairsToObjectUnmapper);
+}
+
+//#endregion
+export { dictionary };

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

@@ -0,0 +1,54 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Unit64, add64, isEqual64, isStrictlyPositive64, isStrictlySmaller64, substract64 } from "./_internals/helpers/ArrayInt64.js";
+import { arrayInt64 } from "./_internals/ArrayInt64Arbitrary.js";
+import { doubleToIndex, indexToDouble } from "./_internals/helpers/DoubleHelpers.js";
+import { doubleOnlyMapper, doubleOnlyUnmapper, refineConstraintsForDoubleOnly } from "./_internals/helpers/DoubleOnlyHelpers.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/double.js
+const safeNumberIsInteger = Number.isInteger;
+const safeNumberIsNaN = Number.isNaN;
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeMaxValue = Number.MAX_VALUE;
+const safeNaN = Number.NaN;
+function safeDoubleToIndex(d, constraintsLabel) {
+	if (safeNumberIsNaN(d)) throw new Error("fc.double constraints." + constraintsLabel + " must be a 64-bit float");
+	return doubleToIndex(d);
+}
+function unmapperDoubleToIndex(value) {
+	if (typeof value !== "number") throw new Error("Unsupported type");
+	return doubleToIndex(value);
+}
+function numberIsNotInteger(value) {
+	return !safeNumberIsInteger(value);
+}
+function anyDouble(constraints) {
+	const { noDefaultInfinity = false, noNaN = false, minExcluded = false, maxExcluded = false, min = noDefaultInfinity ? -safeMaxValue : safeNegativeInfinity, max = noDefaultInfinity ? safeMaxValue : safePositiveInfinity } = constraints;
+	const minIndexRaw = safeDoubleToIndex(min, "min");
+	const minIndex = minExcluded ? add64(minIndexRaw, Unit64) : minIndexRaw;
+	const maxIndexRaw = safeDoubleToIndex(max, "max");
+	const maxIndex = maxExcluded ? substract64(maxIndexRaw, Unit64) : maxIndexRaw;
+	if (isStrictlySmaller64(maxIndex, minIndex)) throw new Error("fc.double constraints.min must be smaller or equal to constraints.max");
+	if (noNaN) return arrayInt64(minIndex, maxIndex).map(indexToDouble, unmapperDoubleToIndex);
+	const positiveMaxIdx = isStrictlyPositive64(maxIndex);
+	const minIndexWithNaN = positiveMaxIdx ? minIndex : substract64(minIndex, Unit64);
+	const maxIndexWithNaN = positiveMaxIdx ? add64(maxIndex, Unit64) : maxIndex;
+	return arrayInt64(minIndexWithNaN, maxIndexWithNaN).map((index) => {
+		if (isStrictlySmaller64(maxIndex, index) || isStrictlySmaller64(index, minIndex)) return safeNaN;
+		else return indexToDouble(index);
+	}, (value) => {
+		if (typeof value !== "number") throw new Error("Unsupported type");
+		if (safeNumberIsNaN(value)) return !isEqual64(maxIndex, maxIndexWithNaN) ? maxIndexWithNaN : minIndexWithNaN;
+		return doubleToIndex(value);
+	});
+}
+function double(constraints = {}) {
+	if (!constraints.noInteger) return anyDouble(constraints);
+	return anyDouble(refineConstraintsForDoubleOnly(constraints)).map(doubleOnlyMapper, doubleOnlyUnmapper).filter(numberIsNotInteger);
+}
+
+//#endregion
+export { double };

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

@@ -0,0 +1,60 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { integer } from "./integer.js";
+import { MAX_VALUE_32, floatToIndex, indexToFloat } from "./_internals/helpers/FloatHelpers.js";
+import { floatOnlyMapper, floatOnlyUnmapper, refineConstraintsForFloatOnly } from "./_internals/helpers/FloatOnlyHelpers.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/float.js
+const safeNumberIsInteger = Number.isInteger;
+const safeNumberIsNaN = Number.isNaN;
+const safeMathFround = Math.fround;
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeNaN = Number.NaN;
+function safeFloatToIndex(f, constraintsLabel) {
+	const conversionTrick = "you can convert any double to a 32-bit float by using `Math.fround(myDouble)`";
+	const errorMessage = "fc.float constraints." + constraintsLabel + " must be a 32-bit float - " + conversionTrick;
+	if (safeNumberIsNaN(f) || safeMathFround(f) !== f) throw new Error(errorMessage);
+	return floatToIndex(f);
+}
+function unmapperFloatToIndex(value) {
+	if (typeof value !== "number") throw new Error("Unsupported type");
+	return floatToIndex(value);
+}
+function numberIsNotInteger(value) {
+	return !safeNumberIsInteger(value);
+}
+function anyFloat(constraints) {
+	const { noDefaultInfinity = false, noNaN = false, minExcluded = false, maxExcluded = false, min = noDefaultInfinity ? -MAX_VALUE_32 : safeNegativeInfinity, max = noDefaultInfinity ? MAX_VALUE_32 : safePositiveInfinity } = constraints;
+	const minIndexRaw = safeFloatToIndex(min, "min");
+	const minIndex = minExcluded ? minIndexRaw + 1 : minIndexRaw;
+	const maxIndexRaw = safeFloatToIndex(max, "max");
+	const maxIndex = maxExcluded ? maxIndexRaw - 1 : maxIndexRaw;
+	if (minIndex > maxIndex) throw new Error("fc.float constraints.min must be smaller or equal to constraints.max");
+	if (noNaN) return integer({
+		min: minIndex,
+		max: maxIndex
+	}).map(indexToFloat, unmapperFloatToIndex);
+	const minIndexWithNaN = maxIndex > 0 ? minIndex : minIndex - 1;
+	const maxIndexWithNaN = maxIndex > 0 ? maxIndex + 1 : maxIndex;
+	return integer({
+		min: minIndexWithNaN,
+		max: maxIndexWithNaN
+	}).map((index) => {
+		if (index > maxIndex || index < minIndex) return safeNaN;
+		else return indexToFloat(index);
+	}, (value) => {
+		if (typeof value !== "number") throw new Error("Unsupported type");
+		if (safeNumberIsNaN(value)) return maxIndex !== maxIndexWithNaN ? maxIndexWithNaN : minIndexWithNaN;
+		return floatToIndex(value);
+	});
+}
+function float(constraints = {}) {
+	if (!constraints.noInteger) return anyFloat(constraints);
+	return anyFloat(refineConstraintsForFloatOnly(constraints)).map(floatOnlyMapper, floatOnlyUnmapper).filter(numberIsNotInteger);
+}
+
+//#endregion
+export { float };

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

@@ -0,0 +1,22 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SFloat32Array } from "../utils/globals.js";
+import { array } from "./array.js";
+import { float } from "./float.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/float32Array.js
+function toTypedMapper(data) {
+	return SFloat32Array.from(data);
+}
+function fromTypedUnmapper(value) {
+	if (!(value instanceof SFloat32Array)) throw new Error("Unexpected type");
+	return [...value];
+}
+function float32Array(constraints = {}) {
+	return array(float(constraints), constraints).map(toTypedMapper, fromTypedUnmapper);
+}
+
+//#endregion
+export { float32Array };

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

@@ -0,0 +1,22 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SFloat64Array } from "../utils/globals.js";
+import { array } from "./array.js";
+import { double } from "./double.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/float64Array.js
+function toTypedMapper(data) {
+	return SFloat64Array.from(data);
+}
+function fromTypedUnmapper(value) {
+	if (!(value instanceof SFloat64Array)) throw new Error("Unexpected type");
+	return [...value];
+}
+function float64Array(constraints = {}) {
+	return array(double(constraints), constraints).map(toTypedMapper, fromTypedUnmapper);
+}
+
+//#endregion
+export { float64Array };

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

@@ -0,0 +1,24 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { buildCharacterArbitrary } from "./_internals/builders/CharacterArbitraryBuilder.js";
+import { indexToPrintableIndexMapper, indexToPrintableIndexUnmapper } from "./_internals/mappers/IndexToPrintableIndex.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/fullUnicode.js
+const gapSize = 2048;
+function unicodeMapper(v) {
+	if (v < 55296) return indexToPrintableIndexMapper(v);
+	return v + gapSize;
+}
+function unicodeUnmapper(v) {
+	if (v < 55296) return indexToPrintableIndexUnmapper(v);
+	if (v <= 57343) return -1;
+	return v - gapSize;
+}
+function fullUnicode() {
+	return buildCharacterArbitrary(0, 1114111 - gapSize, unicodeMapper, unicodeUnmapper);
+}
+
+//#endregion
+export { fullUnicode };

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

@@ -0,0 +1,20 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { array } from "./array.js";
+import { fullUnicode } from "./fullUnicode.js";
+import { createSlicesForStringLegacy } from "./_internals/helpers/SlicesForStringBuilder.js";
+import { codePointsToStringMapper, codePointsToStringUnmapper } from "./_internals/mappers/CodePointsToString.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/fullUnicodeString.js
+const safeObjectAssign = Object.assign;
+function fullUnicodeString(constraints = {}) {
+	const charArbitrary = fullUnicode();
+	const experimentalCustomSlices = createSlicesForStringLegacy(charArbitrary, codePointsToStringUnmapper);
+	const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), { experimentalCustomSlices });
+	return array(charArbitrary, enrichedConstraints).map(codePointsToStringMapper, codePointsToStringUnmapper);
+}
+
+//#endregion
+export { fullUnicodeString };

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

@@ -0,0 +1,15 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SInt16Array } from "../utils/globals.js";
+import { integer } from "./integer.js";
+import { typedIntArrayArbitraryArbitraryBuilder } from "./_internals/builders/TypedIntArrayArbitraryBuilder.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/int16Array.js
+function int16Array(constraints = {}) {
+	return typedIntArrayArbitraryArbitraryBuilder(constraints, -32768, 32767, SInt16Array, integer);
+}
+
+//#endregion
+export { int16Array };

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

@@ -0,0 +1,15 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SInt32Array } from "../utils/globals.js";
+import { integer } from "./integer.js";
+import { typedIntArrayArbitraryArbitraryBuilder } from "./_internals/builders/TypedIntArrayArbitraryBuilder.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/int32Array.js
+function int32Array(constraints = {}) {
+	return typedIntArrayArbitraryArbitraryBuilder(constraints, -2147483648, 2147483647, SInt32Array, integer);
+}
+
+//#endregion
+export { int32Array };

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

@@ -0,0 +1,15 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SInt8Array } from "../utils/globals.js";
+import { integer } from "./integer.js";
+import { typedIntArrayArbitraryArbitraryBuilder } from "./_internals/builders/TypedIntArrayArbitraryBuilder.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/int8Array.js
+function int8Array(constraints = {}) {
+	return typedIntArrayArbitraryArbitraryBuilder(constraints, -128, 127, SInt8Array, integer);
+}
+
+//#endregion
+export { int8Array };

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

@@ -0,0 +1,26 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { IntegerArbitrary } from "./_internals/IntegerArbitrary.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/integer.js
+const safeNumberIsInteger = Number.isInteger;
+function buildCompleteIntegerConstraints(constraints) {
+	const min = constraints.min !== void 0 ? constraints.min : -2147483648;
+	const max = constraints.max !== void 0 ? constraints.max : 2147483647;
+	return {
+		min,
+		max
+	};
+}
+function integer(constraints = {}) {
+	const fullConstraints = buildCompleteIntegerConstraints(constraints);
+	if (fullConstraints.min > fullConstraints.max) throw new Error("fc.integer maximum value should be equal or greater than the minimum one");
+	if (!safeNumberIsInteger(fullConstraints.min)) throw new Error("fc.integer minimum value should be an integer");
+	if (!safeNumberIsInteger(fullConstraints.max)) throw new Error("fc.integer maximum value should be an integer");
+	return new IntegerArbitrary(fullConstraints.min, fullConstraints.max);
+}
+
+//#endregion
+export { integer };

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

@@ -0,0 +1,28 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safeHasOwnProperty } from "../utils/globals.js";
+import { LazyArbitrary } from "./_internals/LazyArbitrary.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/letrec.js
+const safeObjectCreate = Object.create;
+function letrec(builder) {
+	const lazyArbs = safeObjectCreate(null);
+	const tie = (key) => {
+		if (!safeHasOwnProperty(lazyArbs, key)) lazyArbs[key] = new LazyArbitrary(String(key));
+		return lazyArbs[key];
+	};
+	const strictArbs = builder(tie);
+	for (const key in strictArbs) {
+		if (!safeHasOwnProperty(strictArbs, key)) continue;
+		const lazyAtKey = lazyArbs[key];
+		const lazyArb = lazyAtKey !== void 0 ? lazyAtKey : new LazyArbitrary(key);
+		lazyArb.underlying = strictArbs[key];
+		lazyArbs[key] = lazyArb;
+	}
+	return strictArbs;
+}
+
+//#endregion
+export { letrec };

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

@@ -0,0 +1,26 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SError } from "../utils/globals.js";
+import { nat } from "./nat.js";
+import { indexToMappedConstantMapperFor, indexToMappedConstantUnmapperFor } from "./_internals/mappers/IndexToMappedConstant.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/mapToConstant.js
+function computeNumChoices(options) {
+	if (options.length === 0) throw new SError(`fc.mapToConstant expects at least one option`);
+	let numChoices = 0;
+	for (let idx = 0; idx !== options.length; ++idx) {
+		if (options[idx].num < 0) throw new SError(`fc.mapToConstant expects all options to have a number of entries greater or equal to zero`);
+		numChoices += options[idx].num;
+	}
+	if (numChoices === 0) throw new SError(`fc.mapToConstant expects at least one choice among options`);
+	return numChoices;
+}
+function mapToConstant(...entries) {
+	const numChoices = computeNumChoices(entries);
+	return nat({ max: numChoices - 1 }).map(indexToMappedConstantMapperFor(entries), indexToMappedConstantUnmapperFor(entries));
+}
+
+//#endregion
+export { mapToConstant };

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

@@ -0,0 +1,15 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { IntegerArbitrary } from "./_internals/IntegerArbitrary.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/maxSafeInteger.js
+const safeMinSafeInteger = Number.MIN_SAFE_INTEGER;
+const safeMaxSafeInteger = Number.MAX_SAFE_INTEGER;
+function maxSafeInteger() {
+	return new IntegerArbitrary(safeMinSafeInteger, safeMaxSafeInteger);
+}
+
+//#endregion
+export { maxSafeInteger };

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

@@ -0,0 +1,17 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { IntegerArbitrary } from "./_internals/IntegerArbitrary.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/nat.js
+const safeNumberIsInteger = Number.isInteger;
+function nat(arg) {
+	const max = typeof arg === "number" ? arg : arg && arg.max !== void 0 ? arg.max : 2147483647;
+	if (max < 0) throw new Error("fc.nat value should be greater than or equal to 0");
+	if (!safeNumberIsInteger(max)) throw new Error("fc.nat maximum value should be an integer");
+	return new IntegerArbitrary(0, max);
+}
+
+//#endregion
+export { nat };

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

@@ -0,0 +1,11 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/noBias.js
+function noBias(arb) {
+	return arb.noBias();
+}
+
+//#endregion
+export { noBias };

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

@@ -0,0 +1,31 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { isArbitrary } from "../check/arbitrary/definition/Arbitrary.js";
+import { safeMap, safeSlice } from "../utils/globals.js";
+import { FrequencyArbitrary } from "./_internals/FrequencyArbitrary.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/oneof.js
+function isOneOfContraints(param) {
+	return param != null && typeof param === "object" && !("generate" in param) && !("arbitrary" in param) && !("weight" in param);
+}
+function toWeightedArbitrary(maybeWeightedArbitrary) {
+	if (isArbitrary(maybeWeightedArbitrary)) return {
+		arbitrary: maybeWeightedArbitrary,
+		weight: 1
+	};
+	return maybeWeightedArbitrary;
+}
+function oneof(...args) {
+	const constraints = args[0];
+	if (isOneOfContraints(constraints)) {
+		const weightedArbs$1 = safeMap(safeSlice(args, 1), toWeightedArbitrary);
+		return FrequencyArbitrary.from(weightedArbs$1, constraints, "fc.oneof");
+	}
+	const weightedArbs = safeMap(args, toWeightedArbitrary);
+	return FrequencyArbitrary.from(weightedArbs, {}, "fc.oneof");
+}
+
+//#endregion
+export { oneof };