@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/sparseArray.js

@@ -0,0 +1,68 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SArray, safeMap, safeSlice } from "../utils/globals.js";
+import { tuple } from "./tuple.js";
+import { MaxLengthUpperBound, maxGeneratedLengthFromSizeForArbitrary } from "./_internals/helpers/MaxLengthFromMinLength.js";
+import { uniqueArray } from "./uniqueArray.js";
+import { restrictedIntegerArbitraryBuilder } from "./_internals/builders/RestrictedIntegerArbitraryBuilder.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/sparseArray.js
+const safeMathMin = Math.min;
+const safeMathMax = Math.max;
+const safeArrayIsArray = SArray.isArray;
+const safeObjectEntries = Object.entries;
+function extractMaxIndex(indexesAndValues) {
+	let maxIndex = -1;
+	for (let index = 0; index !== indexesAndValues.length; ++index) maxIndex = safeMathMax(maxIndex, indexesAndValues[index][0]);
+	return maxIndex;
+}
+function arrayFromItems(length, indexesAndValues) {
+	const array = SArray(length);
+	for (let index = 0; index !== indexesAndValues.length; ++index) {
+		const it = indexesAndValues[index];
+		if (it[0] < length) array[it[0]] = it[1];
+	}
+	return array;
+}
+function sparseArray(arb, constraints = {}) {
+	const { size, minNumElements = 0, maxLength = MaxLengthUpperBound, maxNumElements = maxLength, noTrailingHole, depthIdentifier } = constraints;
+	const maxGeneratedNumElements = maxGeneratedLengthFromSizeForArbitrary(size, minNumElements, maxNumElements, constraints.maxNumElements !== void 0);
+	const maxGeneratedLength = maxGeneratedLengthFromSizeForArbitrary(size, maxGeneratedNumElements, maxLength, constraints.maxLength !== void 0);
+	if (minNumElements > maxLength) throw new Error(`The minimal number of non-hole elements cannot be higher than the maximal length of the array`);
+	if (minNumElements > maxNumElements) throw new Error(`The minimal number of non-hole elements cannot be higher than the maximal number of non-holes`);
+	const resultedMaxNumElements = safeMathMin(maxNumElements, maxLength);
+	const resultedSizeMaxNumElements = constraints.maxNumElements !== void 0 || size !== void 0 ? size : "=";
+	const maxGeneratedIndexAuthorized = safeMathMax(maxGeneratedLength - 1, 0);
+	const maxIndexAuthorized = safeMathMax(maxLength - 1, 0);
+	const sparseArrayNoTrailingHole = uniqueArray(tuple(restrictedIntegerArbitraryBuilder(0, maxGeneratedIndexAuthorized, maxIndexAuthorized), arb), {
+		size: resultedSizeMaxNumElements,
+		minLength: minNumElements,
+		maxLength: resultedMaxNumElements,
+		selector: (item) => item[0],
+		depthIdentifier
+	}).map((items) => {
+		const lastIndex = extractMaxIndex(items);
+		return arrayFromItems(lastIndex + 1, items);
+	}, (value) => {
+		if (!safeArrayIsArray(value)) throw new Error("Not supported entry type");
+		if (noTrailingHole && value.length !== 0 && !(value.length - 1 in value)) throw new Error("No trailing hole");
+		return safeMap(safeObjectEntries(value), (entry) => [Number(entry[0]), entry[1]]);
+	});
+	if (noTrailingHole || maxLength === minNumElements) return sparseArrayNoTrailingHole;
+	return tuple(sparseArrayNoTrailingHole, restrictedIntegerArbitraryBuilder(minNumElements, maxGeneratedLength, maxLength)).map((data) => {
+		const sparse = data[0];
+		const targetLength = data[1];
+		if (sparse.length >= targetLength) return sparse;
+		const longerSparse = safeSlice(sparse);
+		longerSparse.length = targetLength;
+		return longerSparse;
+	}, (value) => {
+		if (!safeArrayIsArray(value)) throw new Error("Not supported entry type");
+		return [value, value.length];
+	});
+}
+
+//#endregion
+export { sparseArray };

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

@@ -0,0 +1,32 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { array } from "./array.js";
+import { patternsToStringMapper, patternsToStringUnmapperFor } from "./_internals/mappers/PatternsToString.js";
+import { createSlicesForString } from "./_internals/helpers/SlicesForStringBuilder.js";
+import { stringUnit } from "./_internals/StringUnitArbitrary.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/string.js
+const safeObjectAssign = Object.assign;
+function extractUnitArbitrary(constraints) {
+	if (typeof constraints.unit === "object") return constraints.unit;
+	switch (constraints.unit) {
+		case "grapheme": return stringUnit("grapheme", "full");
+		case "grapheme-composite": return stringUnit("composite", "full");
+		case "grapheme-ascii":
+		case void 0: return stringUnit("grapheme", "ascii");
+		case "binary": return stringUnit("binary", "full");
+		case "binary-ascii": return stringUnit("binary", "ascii");
+	}
+}
+function string(constraints = {}) {
+	const charArbitrary = extractUnitArbitrary(constraints);
+	const unmapper = patternsToStringUnmapperFor(charArbitrary, constraints);
+	const experimentalCustomSlices = createSlicesForString(charArbitrary, constraints);
+	const enrichedConstraints = safeObjectAssign(safeObjectAssign({}, constraints), { experimentalCustomSlices });
+	return array(charArbitrary, enrichedConstraints).map(patternsToStringMapper, unmapper);
+}
+
+//#endregion
+export { string };

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

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

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

@@ -0,0 +1,15 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SUint16Array } 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/uint16Array.js
+function uint16Array(constraints = {}) {
+	return typedIntArrayArbitraryArbitraryBuilder(constraints, 0, 65535, SUint16Array, integer);
+}
+
+//#endregion
+export { uint16Array };

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

@@ -0,0 +1,15 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SUint32Array } 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/uint32Array.js
+function uint32Array(constraints = {}) {
+	return typedIntArrayArbitraryArbitraryBuilder(constraints, 0, 4294967295, SUint32Array, integer);
+}
+
+//#endregion
+export { uint32Array };

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

@@ -0,0 +1,15 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SUint8Array } 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/uint8Array.js
+function uint8Array(constraints = {}) {
+	return typedIntArrayArbitraryArbitraryBuilder(constraints, 0, 255, SUint8Array, integer);
+}
+
+//#endregion
+export { uint8Array };

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

@@ -0,0 +1,15 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SUint8ClampedArray } 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/uint8ClampedArray.js
+function uint8ClampedArray(constraints = {}) {
+	return typedIntArrayArbitraryArbitraryBuilder(constraints, 0, 255, SUint8ClampedArray, integer);
+}
+
+//#endregion
+export { uint8ClampedArray };

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

@@ -0,0 +1,47 @@
+
+      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";
+import { CustomEqualSet } from "./_internals/helpers/CustomEqualSet.js";
+import { StrictlyEqualSet } from "./_internals/helpers/StrictlyEqualSet.js";
+import { SameValueSet } from "./_internals/helpers/SameValueSet.js";
+import { SameValueZeroSet } from "./_internals/helpers/SameValueZeroSet.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/uniqueArray.js
+function buildUniqueArraySetBuilder(constraints) {
+	if (typeof constraints.comparator === "function") {
+		if (constraints.selector === void 0) {
+			const comparator$1 = constraints.comparator;
+			const isEqualForBuilder$1 = (nextA, nextB) => comparator$1(nextA.value_, nextB.value_);
+			return () => new CustomEqualSet(isEqualForBuilder$1);
+		}
+		const comparator = constraints.comparator;
+		const selector$1 = constraints.selector;
+		const refinedSelector$1 = (next) => selector$1(next.value_);
+		const isEqualForBuilder = (nextA, nextB) => comparator(refinedSelector$1(nextA), refinedSelector$1(nextB));
+		return () => new CustomEqualSet(isEqualForBuilder);
+	}
+	const selector = constraints.selector || ((v) => v);
+	const refinedSelector = (next) => selector(next.value_);
+	switch (constraints.comparator) {
+		case "IsStrictlyEqual": return () => new StrictlyEqualSet(refinedSelector);
+		case "SameValueZero": return () => new SameValueZeroSet(refinedSelector);
+		case "SameValue":
+		case void 0: return () => new SameValueSet(refinedSelector);
+	}
+}
+function uniqueArray(arb, constraints = {}) {
+	const minLength = constraints.minLength !== void 0 ? constraints.minLength : 0;
+	const maxLength = constraints.maxLength !== void 0 ? constraints.maxLength : MaxLengthUpperBound;
+	const maxGeneratedLength = maxGeneratedLengthFromSizeForArbitrary(constraints.size, minLength, maxLength, constraints.maxLength !== void 0);
+	const depthIdentifier = constraints.depthIdentifier;
+	const setBuilder = buildUniqueArraySetBuilder(constraints);
+	const arrayArb = new ArrayArbitrary(arb, minLength, maxGeneratedLength, maxLength, depthIdentifier, setBuilder, []);
+	if (minLength === 0) return arrayArb;
+	return arrayArb.filter((tab) => tab.length >= minLength);
+}
+
+//#endregion
+export { uniqueArray };

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

@@ -0,0 +1,184 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Stream } from "../../../stream/Stream.js";
+import { cloneMethod, hasCloneMethod } from "../../symbols.js";
+import { Value } from "./Value.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/arbitrary/definition/Arbitrary.js
+const safeObjectAssign = Object.assign;
+var Arbitrary = class {
+	filter(refinement) {
+		return new FilterArbitrary(this, refinement);
+	}
+	map(mapper, unmapper) {
+		return new MapArbitrary(this, mapper, unmapper);
+	}
+	chain(chainer) {
+		return new ChainArbitrary(this, chainer);
+	}
+	noShrink() {
+		return new NoShrinkArbitrary(this);
+	}
+	noBias() {
+		return new NoBiasArbitrary(this);
+	}
+};
+var ChainArbitrary = class extends Arbitrary {
+	constructor(arb, chainer) {
+		super();
+		this.arb = arb;
+		this.chainer = chainer;
+	}
+	generate(mrng, biasFactor) {
+		const clonedMrng = mrng.clone();
+		const src = this.arb.generate(mrng, biasFactor);
+		return this.valueChainer(src, mrng, clonedMrng, biasFactor);
+	}
+	canShrinkWithoutContext(value) {
+		return false;
+	}
+	shrink(value, context) {
+		if (this.isSafeContext(context)) return (!context.stoppedForOriginal ? this.arb.shrink(context.originalValue, context.originalContext).map((v) => this.valueChainer(v, context.clonedMrng.clone(), context.clonedMrng, context.originalBias)) : Stream.nil()).join(context.chainedArbitrary.shrink(value, context.chainedContext).map((dst) => {
+			const newContext = safeObjectAssign(safeObjectAssign({}, context), {
+				chainedContext: dst.context,
+				stoppedForOriginal: true
+			});
+			return new Value(dst.value_, newContext);
+		}));
+		return Stream.nil();
+	}
+	valueChainer(v, generateMrng, clonedMrng, biasFactor) {
+		const chainedArbitrary = this.chainer(v.value_);
+		const dst = chainedArbitrary.generate(generateMrng, biasFactor);
+		const context = {
+			originalBias: biasFactor,
+			originalValue: v.value_,
+			originalContext: v.context,
+			stoppedForOriginal: false,
+			chainedArbitrary,
+			chainedContext: dst.context,
+			clonedMrng
+		};
+		return new Value(dst.value_, context);
+	}
+	isSafeContext(context) {
+		return context != null && typeof context === "object" && "originalBias" in context && "originalValue" in context && "originalContext" in context && "stoppedForOriginal" in context && "chainedArbitrary" in context && "chainedContext" in context && "clonedMrng" in context;
+	}
+};
+var MapArbitrary = class extends Arbitrary {
+	constructor(arb, mapper, unmapper) {
+		super();
+		this.arb = arb;
+		this.mapper = mapper;
+		this.unmapper = unmapper;
+		this.bindValueMapper = (v) => this.valueMapper(v);
+	}
+	generate(mrng, biasFactor) {
+		const g = this.arb.generate(mrng, biasFactor);
+		return this.valueMapper(g);
+	}
+	canShrinkWithoutContext(value) {
+		if (this.unmapper !== void 0) try {
+			const unmapped = this.unmapper(value);
+			return this.arb.canShrinkWithoutContext(unmapped);
+		} catch (_err) {
+			return false;
+		}
+		return false;
+	}
+	shrink(value, context) {
+		if (this.isSafeContext(context)) return this.arb.shrink(context.originalValue, context.originalContext).map(this.bindValueMapper);
+		if (this.unmapper !== void 0) {
+			const unmapped = this.unmapper(value);
+			return this.arb.shrink(unmapped, void 0).map(this.bindValueMapper);
+		}
+		return Stream.nil();
+	}
+	mapperWithCloneIfNeeded(v) {
+		const sourceValue = v.value;
+		const mappedValue = this.mapper(sourceValue);
+		if (v.hasToBeCloned && (typeof mappedValue === "object" && mappedValue !== null || typeof mappedValue === "function") && Object.isExtensible(mappedValue) && !hasCloneMethod(mappedValue)) Object.defineProperty(mappedValue, cloneMethod, { get: () => () => this.mapperWithCloneIfNeeded(v)[0] });
+		return [mappedValue, sourceValue];
+	}
+	valueMapper(v) {
+		const [mappedValue, sourceValue] = this.mapperWithCloneIfNeeded(v);
+		const context = {
+			originalValue: sourceValue,
+			originalContext: v.context
+		};
+		return new Value(mappedValue, context);
+	}
+	isSafeContext(context) {
+		return context != null && typeof context === "object" && "originalValue" in context && "originalContext" in context;
+	}
+};
+var FilterArbitrary = class extends Arbitrary {
+	constructor(arb, refinement) {
+		super();
+		this.arb = arb;
+		this.refinement = refinement;
+		this.bindRefinementOnValue = (v) => this.refinementOnValue(v);
+	}
+	generate(mrng, biasFactor) {
+		while (true) {
+			const g = this.arb.generate(mrng, biasFactor);
+			if (this.refinementOnValue(g)) return g;
+		}
+	}
+	canShrinkWithoutContext(value) {
+		return this.arb.canShrinkWithoutContext(value) && this.refinement(value);
+	}
+	shrink(value, context) {
+		return this.arb.shrink(value, context).filter(this.bindRefinementOnValue);
+	}
+	refinementOnValue(v) {
+		return this.refinement(v.value);
+	}
+};
+var NoShrinkArbitrary = class extends Arbitrary {
+	constructor(arb) {
+		super();
+		this.arb = arb;
+	}
+	generate(mrng, biasFactor) {
+		return this.arb.generate(mrng, biasFactor);
+	}
+	canShrinkWithoutContext(value) {
+		return this.arb.canShrinkWithoutContext(value);
+	}
+	shrink(_value, _context) {
+		return Stream.nil();
+	}
+	noShrink() {
+		return this;
+	}
+};
+var NoBiasArbitrary = class extends Arbitrary {
+	constructor(arb) {
+		super();
+		this.arb = arb;
+	}
+	generate(mrng, _biasFactor) {
+		return this.arb.generate(mrng, void 0);
+	}
+	canShrinkWithoutContext(value) {
+		return this.arb.canShrinkWithoutContext(value);
+	}
+	shrink(value, context) {
+		return this.arb.shrink(value, context);
+	}
+	noBias() {
+		return this;
+	}
+};
+function isArbitrary(instance) {
+	return typeof instance === "object" && instance !== null && "generate" in instance && "shrink" in instance && "canShrinkWithoutContext" in instance;
+}
+function assertIsArbitrary(instance) {
+	if (!isArbitrary(instance)) throw new Error("Unexpected value received: not an instance of Arbitrary");
+}
+
+//#endregion
+export { Arbitrary, assertIsArbitrary, isArbitrary };

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

@@ -0,0 +1,31 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { cloneMethod, hasCloneMethod } from "../../symbols.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/arbitrary/definition/Value.js
+const safeObjectDefineProperty = Object.defineProperty;
+var Value = class {
+	constructor(value_, context, customGetValue = void 0) {
+		this.value_ = value_;
+		this.context = context;
+		this.hasToBeCloned = customGetValue !== void 0 || hasCloneMethod(value_);
+		this.readOnce = false;
+		if (this.hasToBeCloned) safeObjectDefineProperty(this, "value", { get: customGetValue !== void 0 ? customGetValue : this.getValue });
+		else this.value = value_;
+	}
+	getValue() {
+		if (this.hasToBeCloned) {
+			if (!this.readOnce) {
+				this.readOnce = true;
+				return this.value_;
+			}
+			return this.value_[cloneMethod]();
+		}
+		return this.value_;
+	}
+};
+
+//#endregion
+export { Value };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/precondition/PreconditionFailure.js

@@ -0,0 +1,19 @@
+
+      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/check/precondition/PreconditionFailure.js
+var PreconditionFailure = class PreconditionFailure extends Error {
+	constructor(interruptExecution = false) {
+		super();
+		this.interruptExecution = interruptExecution;
+		this.footprint = PreconditionFailure.SharedFootPrint;
+	}
+	static isFailure(err) {
+		return err != null && err.footprint === PreconditionFailure.SharedFootPrint;
+	}
+};
+PreconditionFailure.SharedFootPrint = Symbol.for("fast-check/PreconditionFailure");
+
+//#endregion
+export { PreconditionFailure };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/property/IRawProperty.js

@@ -0,0 +1,12 @@
+
+      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/check/property/IRawProperty.js
+const safeMathLog = Math.log;
+function runIdToFrequency(runId) {
+	return 2 + ~~(safeMathLog(runId + 1) * .4342944819032518);
+}
+
+//#endregion
+export { runIdToFrequency };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/property/IgnoreEqualValuesProperty.js

@@ -0,0 +1,52 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { PreconditionFailure } from "../precondition/PreconditionFailure.js";
+import { stringify } from "../../utils/stringify.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/property/IgnoreEqualValuesProperty.js
+function fromSyncCached(cachedValue) {
+	return cachedValue === null ? new PreconditionFailure() : cachedValue;
+}
+function fromCached(...data) {
+	if (data[1]) return data[0].then(fromSyncCached);
+	return fromSyncCached(data[0]);
+}
+function fromCachedUnsafe(cachedValue, isAsync) {
+	return fromCached(cachedValue, isAsync);
+}
+var IgnoreEqualValuesProperty = class {
+	constructor(property, skipRuns) {
+		this.property = property;
+		this.skipRuns = skipRuns;
+		this.coveredCases = new Map();
+		if (this.property.runBeforeEach !== void 0 && this.property.runAfterEach !== void 0) {
+			this.runBeforeEach = () => this.property.runBeforeEach();
+			this.runAfterEach = () => this.property.runAfterEach();
+		}
+	}
+	isAsync() {
+		return this.property.isAsync();
+	}
+	generate(mrng, runId) {
+		return this.property.generate(mrng, runId);
+	}
+	shrink(value) {
+		return this.property.shrink(value);
+	}
+	run(v, dontRunHook) {
+		const stringifiedValue = stringify(v);
+		if (this.coveredCases.has(stringifiedValue)) {
+			const lastOutput = this.coveredCases.get(stringifiedValue);
+			if (!this.skipRuns) return lastOutput;
+			return fromCachedUnsafe(lastOutput, this.property.isAsync());
+		}
+		const out = this.property.run(v, dontRunHook);
+		this.coveredCases.set(stringifiedValue, out);
+		return out;
+	}
+};
+
+//#endregion
+export { IgnoreEqualValuesProperty };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/property/Property.generic.js

@@ -0,0 +1,77 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { PreconditionFailure } from "../precondition/PreconditionFailure.js";
+import { Stream } from "../../stream/Stream.js";
+import { SError, SString } from "../../utils/globals.js";
+import { runIdToFrequency } from "./IRawProperty.js";
+import { readConfigureGlobal } from "../runner/configuration/GlobalParameters.js";
+import { UndefinedContextPlaceholder, noUndefinedAsContext } from "../../arbitrary/_internals/helpers/NoUndefinedAsContext.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/property/Property.generic.js
+var Property = class Property {
+	constructor(arb, predicate) {
+		this.arb = arb;
+		this.predicate = predicate;
+		const { beforeEach = Property.dummyHook, afterEach = Property.dummyHook, asyncBeforeEach, asyncAfterEach } = readConfigureGlobal() || {};
+		if (asyncBeforeEach !== void 0) throw SError("\"asyncBeforeEach\" can't be set when running synchronous properties");
+		if (asyncAfterEach !== void 0) throw SError("\"asyncAfterEach\" can't be set when running synchronous properties");
+		this.beforeEachHook = beforeEach;
+		this.afterEachHook = afterEach;
+	}
+	isAsync() {
+		return false;
+	}
+	generate(mrng, runId) {
+		const value = this.arb.generate(mrng, runId != null ? runIdToFrequency(runId) : void 0);
+		return noUndefinedAsContext(value);
+	}
+	shrink(value) {
+		if (value.context === void 0 && !this.arb.canShrinkWithoutContext(value.value_)) return Stream.nil();
+		const safeContext = value.context !== UndefinedContextPlaceholder ? value.context : void 0;
+		return this.arb.shrink(value.value_, safeContext).map(noUndefinedAsContext);
+	}
+	runBeforeEach() {
+		this.beforeEachHook();
+	}
+	runAfterEach() {
+		this.afterEachHook();
+	}
+	run(v, dontRunHook) {
+		if (!dontRunHook) this.beforeEachHook();
+		try {
+			const output = this.predicate(v);
+			return output == null || output === true ? null : {
+				error: new SError("Property failed by returning false"),
+				errorMessage: "Error: Property failed by returning false"
+			};
+		} catch (err) {
+			if (PreconditionFailure.isFailure(err)) return err;
+			if (err instanceof SError && err.stack) return {
+				error: err,
+				errorMessage: err.stack
+			};
+			return {
+				error: err,
+				errorMessage: SString(err)
+			};
+		} finally {
+			if (!dontRunHook) this.afterEachHook();
+		}
+	}
+	beforeEach(hookFunction) {
+		const previousBeforeEachHook = this.beforeEachHook;
+		this.beforeEachHook = () => hookFunction(previousBeforeEachHook);
+		return this;
+	}
+	afterEach(hookFunction) {
+		const previousAfterEachHook = this.afterEachHook;
+		this.afterEachHook = () => hookFunction(previousAfterEachHook);
+		return this;
+	}
+};
+Property.dummyHook = () => {};
+
+//#endregion
+export { Property };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/property/Property.js

@@ -0,0 +1,22 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { assertIsArbitrary } from "../arbitrary/definition/Arbitrary.js";
+import { safeForEach, safeMap, safeSlice } from "../../utils/globals.js";
+import { tuple } from "../../arbitrary/tuple.js";
+import { AlwaysShrinkableArbitrary } from "../../arbitrary/_internals/AlwaysShrinkableArbitrary.js";
+import { Property } from "./Property.generic.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/property/Property.js
+function property(...args) {
+	if (args.length < 2) throw new Error("property expects at least two parameters");
+	const arbs = safeSlice(args, 0, args.length - 1);
+	const p = args[args.length - 1];
+	safeForEach(arbs, assertIsArbitrary);
+	const mappedArbs = safeMap(arbs, (arb) => new AlwaysShrinkableArbitrary(arb));
+	return new Property(tuple(...mappedArbs), (t) => p(...t));
+}
+
+//#endregion
+export { property };