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

@@ -0,0 +1,41 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SSet, safeAdd, safePush } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SameValueSet.js
+const safeObjectIs = Object.is;
+var SameValueSet = class {
+	constructor(selector) {
+		this.selector = selector;
+		this.selectedItemsExceptMinusZero = new SSet();
+		this.data = [];
+		this.hasMinusZero = false;
+	}
+	tryAdd(value) {
+		const selected = this.selector(value);
+		if (safeObjectIs(selected, -0)) {
+			if (this.hasMinusZero) return false;
+			safePush(this.data, value);
+			this.hasMinusZero = true;
+			return true;
+		}
+		const sizeBefore = this.selectedItemsExceptMinusZero.size;
+		safeAdd(this.selectedItemsExceptMinusZero, selected);
+		if (sizeBefore !== this.selectedItemsExceptMinusZero.size) {
+			safePush(this.data, value);
+			return true;
+		}
+		return false;
+	}
+	size() {
+		return this.data.length;
+	}
+	getData() {
+		return this.data;
+	}
+};
+
+//#endregion
+export { SameValueSet };

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

@@ -0,0 +1,33 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SSet, safeAdd, safePush } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SameValueZeroSet.js
+var SameValueZeroSet = class {
+	constructor(selector) {
+		this.selector = selector;
+		this.selectedItems = new SSet();
+		this.data = [];
+	}
+	tryAdd(value) {
+		const selected = this.selector(value);
+		const sizeBefore = this.selectedItems.size;
+		safeAdd(this.selectedItems, selected);
+		if (sizeBefore !== this.selectedItems.size) {
+			safePush(this.data, value);
+			return true;
+		}
+		return false;
+	}
+	size() {
+		return this.data.length;
+	}
+	getData() {
+		return this.data;
+	}
+};
+
+//#endregion
+export { SameValueZeroSet };

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

@@ -0,0 +1,37 @@
+
+      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 { SBigInt } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ShrinkBigInt.js
+function halveBigInt(n) {
+	return n / SBigInt(2);
+}
+function shrinkBigInt(current, target, tryTargetAsap) {
+	const realGap = current - target;
+	function* shrinkDecr() {
+		let previous = tryTargetAsap ? void 0 : target;
+		const gap = tryTargetAsap ? realGap : halveBigInt(realGap);
+		for (let toremove = gap; toremove > 0; toremove = halveBigInt(toremove)) {
+			const next = current - toremove;
+			yield new Value(next, previous);
+			previous = next;
+		}
+	}
+	function* shrinkIncr() {
+		let previous = tryTargetAsap ? void 0 : target;
+		const gap = tryTargetAsap ? realGap : halveBigInt(realGap);
+		for (let toremove = gap; toremove < 0; toremove = halveBigInt(toremove)) {
+			const next = current - toremove;
+			yield new Value(next, previous);
+			previous = next;
+		}
+	}
+	return realGap > 0 ? stream(shrinkDecr()) : stream(shrinkIncr());
+}
+
+//#endregion
+export { shrinkBigInt };

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

@@ -0,0 +1,41 @@
+
+      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";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/ShrinkInteger.js
+const safeMathCeil = Math.ceil;
+const safeMathFloor = Math.floor;
+function halvePosInteger(n) {
+	return safeMathFloor(n / 2);
+}
+function halveNegInteger(n) {
+	return safeMathCeil(n / 2);
+}
+function shrinkInteger(current, target, tryTargetAsap) {
+	const realGap = current - target;
+	function* shrinkDecr() {
+		let previous = tryTargetAsap ? void 0 : target;
+		const gap = tryTargetAsap ? realGap : halvePosInteger(realGap);
+		for (let toremove = gap; toremove > 0; toremove = halvePosInteger(toremove)) {
+			const next = toremove === realGap ? target : current - toremove;
+			yield new Value(next, previous);
+			previous = next;
+		}
+	}
+	function* shrinkIncr() {
+		let previous = tryTargetAsap ? void 0 : target;
+		const gap = tryTargetAsap ? realGap : halveNegInteger(realGap);
+		for (let toremove = gap; toremove < 0; toremove = halveNegInteger(toremove)) {
+			const next = toremove === realGap ? target : current - toremove;
+			yield new Value(next, previous);
+			previous = next;
+		}
+	}
+	return realGap > 0 ? stream(shrinkDecr()) : stream(shrinkIncr());
+}
+
+//#endregion
+export { shrinkInteger };

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

@@ -0,0 +1,74 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safeGet, safePush, safeSet } from "../../../utils/globals.js";
+import { MaxLengthUpperBound } from "./MaxLengthFromMinLength.js";
+import { tokenizeString } from "./TokenizeString.js";
+import { patternsToStringUnmapperIsValidLength } from "../mappers/PatternsToString.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/SlicesForStringBuilder.js
+const dangerousStrings = [
+	"__defineGetter__",
+	"__defineSetter__",
+	"__lookupGetter__",
+	"__lookupSetter__",
+	"__proto__",
+	"constructor",
+	"hasOwnProperty",
+	"isPrototypeOf",
+	"propertyIsEnumerable",
+	"toLocaleString",
+	"toString",
+	"valueOf",
+	"apply",
+	"arguments",
+	"bind",
+	"call",
+	"caller",
+	"length",
+	"name",
+	"prototype",
+	"key",
+	"ref"
+];
+function computeCandidateStringLegacy(dangerous, charArbitrary, stringSplitter) {
+	let candidate;
+	try {
+		candidate = stringSplitter(dangerous);
+	} catch (err) {
+		return void 0;
+	}
+	for (const entry of candidate) if (!charArbitrary.canShrinkWithoutContext(entry)) return void 0;
+	return candidate;
+}
+function createSlicesForStringLegacy(charArbitrary, stringSplitter) {
+	const slicesForString = [];
+	for (const dangerous of dangerousStrings) {
+		const candidate = computeCandidateStringLegacy(dangerous, charArbitrary, stringSplitter);
+		if (candidate !== void 0) safePush(slicesForString, candidate);
+	}
+	return slicesForString;
+}
+const slicesPerArbitrary = new WeakMap();
+function createSlicesForStringNoConstraints(charArbitrary) {
+	const slicesForString = [];
+	for (const dangerous of dangerousStrings) {
+		const candidate = tokenizeString(charArbitrary, dangerous, 0, MaxLengthUpperBound);
+		if (candidate !== void 0) safePush(slicesForString, candidate);
+	}
+	return slicesForString;
+}
+function createSlicesForString(charArbitrary, constraints) {
+	let slices = safeGet(slicesPerArbitrary, charArbitrary);
+	if (slices === void 0) {
+		slices = createSlicesForStringNoConstraints(charArbitrary);
+		safeSet(slicesPerArbitrary, charArbitrary, slices);
+	}
+	const slicesForConstraints = [];
+	for (const slice of slices) if (patternsToStringUnmapperIsValidLength(slice, constraints)) safePush(slicesForConstraints, slice);
+	return slicesForConstraints;
+}
+
+//#endregion
+export { createSlicesForString, createSlicesForStringLegacy };

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

@@ -0,0 +1,38 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SSet, safeAdd, safePush } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/StrictlyEqualSet.js
+const safeNumberIsNaN = Number.isNaN;
+var StrictlyEqualSet = class {
+	constructor(selector) {
+		this.selector = selector;
+		this.selectedItemsExceptNaN = new SSet();
+		this.data = [];
+	}
+	tryAdd(value) {
+		const selected = this.selector(value);
+		if (safeNumberIsNaN(selected)) {
+			safePush(this.data, value);
+			return true;
+		}
+		const sizeBefore = this.selectedItemsExceptNaN.size;
+		safeAdd(this.selectedItemsExceptNaN, selected);
+		if (sizeBefore !== this.selectedItemsExceptNaN.size) {
+			safePush(this.data, value);
+			return true;
+		}
+		return false;
+	}
+	size() {
+		return this.data.length;
+	}
+	getData() {
+		return this.data;
+	}
+};
+
+//#endregion
+export { StrictlyEqualSet };

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

@@ -0,0 +1,47 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safePop, safePush, safeSubstring } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/TokenizeString.js
+function tokenizeString(patternsArb, value, minLength, maxLength) {
+	if (value.length === 0) {
+		if (minLength > 0) return void 0;
+		return [];
+	}
+	if (maxLength <= 0) return void 0;
+	const stack = [{
+		endIndexChunks: 0,
+		nextStartIndex: 1,
+		chunks: []
+	}];
+	while (stack.length > 0) {
+		const last = safePop(stack);
+		for (let index = last.nextStartIndex; index <= value.length; ++index) {
+			const chunk = safeSubstring(value, last.endIndexChunks, index);
+			if (patternsArb.canShrinkWithoutContext(chunk)) {
+				const newChunks = [...last.chunks, chunk];
+				if (index === value.length) {
+					if (newChunks.length < minLength) break;
+					return newChunks;
+				}
+				safePush(stack, {
+					endIndexChunks: last.endIndexChunks,
+					nextStartIndex: index + 1,
+					chunks: last.chunks
+				});
+				if (newChunks.length < maxLength) safePush(stack, {
+					endIndexChunks: index,
+					nextStartIndex: index + 1,
+					chunks: newChunks
+				});
+				break;
+			}
+		}
+	}
+	return void 0;
+}
+
+//#endregion
+export { tokenizeString };

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

@@ -0,0 +1,21 @@
+
+      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/_internals/implementations/NoopSlicedGenerator.js
+var NoopSlicedGenerator = class {
+	constructor(arb, mrng, biasFactor) {
+		this.arb = arb;
+		this.mrng = mrng;
+		this.biasFactor = biasFactor;
+	}
+	attemptExact() {
+		return;
+	}
+	next() {
+		return this.arb.generate(this.mrng, this.biasFactor);
+	}
+};
+
+//#endregion
+export { NoopSlicedGenerator };

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

@@ -0,0 +1,53 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Value } from "../../../check/arbitrary/definition/Value.js";
+import { safePush } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/implementations/SlicedBasedGenerator.js
+const safeMathMin = Math.min;
+const safeMathMax = Math.max;
+var SlicedBasedGenerator = class {
+	constructor(arb, mrng, slices, biasFactor) {
+		this.arb = arb;
+		this.mrng = mrng;
+		this.slices = slices;
+		this.biasFactor = biasFactor;
+		this.activeSliceIndex = 0;
+		this.nextIndexInSlice = 0;
+		this.lastIndexInSlice = -1;
+	}
+	attemptExact(targetLength) {
+		if (targetLength !== 0 && this.mrng.nextInt(1, this.biasFactor) === 1) {
+			const eligibleIndices = [];
+			for (let index = 0; index !== this.slices.length; ++index) {
+				const slice = this.slices[index];
+				if (slice.length === targetLength) safePush(eligibleIndices, index);
+			}
+			if (eligibleIndices.length === 0) return;
+			this.activeSliceIndex = eligibleIndices[this.mrng.nextInt(0, eligibleIndices.length - 1)];
+			this.nextIndexInSlice = 0;
+			this.lastIndexInSlice = targetLength - 1;
+		}
+	}
+	next() {
+		if (this.nextIndexInSlice <= this.lastIndexInSlice) return new Value(this.slices[this.activeSliceIndex][this.nextIndexInSlice++], void 0);
+		if (this.mrng.nextInt(1, this.biasFactor) !== 1) return this.arb.generate(this.mrng, this.biasFactor);
+		this.activeSliceIndex = this.mrng.nextInt(0, this.slices.length - 1);
+		const slice = this.slices[this.activeSliceIndex];
+		if (this.mrng.nextInt(1, this.biasFactor) !== 1) {
+			this.nextIndexInSlice = 1;
+			this.lastIndexInSlice = slice.length - 1;
+			return new Value(slice[0], void 0);
+		}
+		const rangeBoundaryA = this.mrng.nextInt(0, slice.length - 1);
+		const rangeBoundaryB = this.mrng.nextInt(0, slice.length - 1);
+		this.nextIndexInSlice = safeMathMin(rangeBoundaryA, rangeBoundaryB);
+		this.lastIndexInSlice = safeMathMax(rangeBoundaryA, rangeBoundaryB);
+		return new Value(slice[this.nextIndexInSlice++], void 0);
+	}
+};
+
+//#endregion
+export { SlicedBasedGenerator };

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

@@ -0,0 +1,16 @@
+
+      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/_internals/mappers/ArrayToMap.js
+function arrayToMapMapper(data) {
+	return new Map(data);
+}
+function arrayToMapUnmapper(value) {
+	if (typeof value !== "object" || value === null) throw new Error("Incompatible instance received: should be a non-null object");
+	if (!("constructor" in value) || value.constructor !== Map) throw new Error("Incompatible instance received: should be of exact type Map");
+	return Array.from(value);
+}
+
+//#endregion
+export { arrayToMapMapper, arrayToMapUnmapper };

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

@@ -0,0 +1,16 @@
+
+      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/_internals/mappers/ArrayToSet.js
+function arrayToSetMapper(data) {
+	return new Set(data);
+}
+function arrayToSetUnmapper(value) {
+	if (typeof value !== "object" || value === null) throw new Error("Incompatible instance received: should be a non-null object");
+	if (!("constructor" in value) || value.constructor !== Set) throw new Error("Incompatible instance received: should be of exact type Set");
+	return Array.from(value);
+}
+
+//#endregion
+export { arrayToSetMapper, arrayToSetUnmapper };

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

@@ -0,0 +1,17 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safeJoin } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/CodePointsToString.js
+function codePointsToStringMapper(tab) {
+	return safeJoin(tab, "");
+}
+function codePointsToStringUnmapper(value) {
+	if (typeof value !== "string") throw new Error("Cannot unmap the passed value");
+	return [...value];
+}
+
+//#endregion
+export { codePointsToStringMapper, codePointsToStringUnmapper };

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

@@ -0,0 +1,20 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safeCharCodeAt } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/IndexToCharString.js
+const indexToCharStringMapper = String.fromCodePoint;
+function indexToCharStringUnmapper(c) {
+	if (typeof c !== "string") throw new Error("Cannot unmap non-string");
+	if (c.length === 0 || c.length > 2) throw new Error("Cannot unmap string with more or less than one character");
+	const c1 = safeCharCodeAt(c, 0);
+	if (c.length === 1) return c1;
+	const c2 = safeCharCodeAt(c, 1);
+	if (c1 < 55296 || c1 > 56319 || c2 < 56320 || c2 > 57343) throw new Error("Cannot unmap invalid surrogate pairs");
+	return c.codePointAt(0);
+}
+
+//#endregion
+export { indexToCharStringMapper, indexToCharStringUnmapper };

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

@@ -0,0 +1,69 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SError, SMap, SNumber, safeMapGet, safeMapSet } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/IndexToMappedConstant.js
+const safeObjectIs = Object.is;
+function buildDichotomyEntries(entries) {
+	let currentFrom = 0;
+	const dichotomyEntries = [];
+	for (const entry of entries) {
+		const from = currentFrom;
+		currentFrom = from + entry.num;
+		const to = currentFrom - 1;
+		dichotomyEntries.push({
+			from,
+			to,
+			entry
+		});
+	}
+	return dichotomyEntries;
+}
+function findDichotomyEntry(dichotomyEntries, choiceIndex) {
+	let min = 0;
+	let max = dichotomyEntries.length;
+	while (max - min > 1) {
+		const mid = ~~((min + max) / 2);
+		if (choiceIndex < dichotomyEntries[mid].from) max = mid;
+		else min = mid;
+	}
+	return dichotomyEntries[min];
+}
+function indexToMappedConstantMapperFor(entries) {
+	const dichotomyEntries = buildDichotomyEntries(entries);
+	return function indexToMappedConstantMapper(choiceIndex) {
+		const dichotomyEntry = findDichotomyEntry(dichotomyEntries, choiceIndex);
+		return dichotomyEntry.entry.build(choiceIndex - dichotomyEntry.from);
+	};
+}
+function buildReverseMapping(entries) {
+	const reverseMapping = {
+		mapping: new SMap(),
+		negativeZeroIndex: void 0
+	};
+	let choiceIndex = 0;
+	for (let entryIdx = 0; entryIdx !== entries.length; ++entryIdx) {
+		const entry = entries[entryIdx];
+		for (let idxInEntry = 0; idxInEntry !== entry.num; ++idxInEntry) {
+			const value = entry.build(idxInEntry);
+			if (value === 0 && 1 / value === SNumber.NEGATIVE_INFINITY) reverseMapping.negativeZeroIndex = choiceIndex;
+			else safeMapSet(reverseMapping.mapping, value, choiceIndex);
+			++choiceIndex;
+		}
+	}
+	return reverseMapping;
+}
+function indexToMappedConstantUnmapperFor(entries) {
+	let reverseMapping = null;
+	return function indexToMappedConstantUnmapper(value) {
+		if (reverseMapping === null) reverseMapping = buildReverseMapping(entries);
+		const choiceIndex = safeObjectIs(value, -0) ? reverseMapping.negativeZeroIndex : safeMapGet(reverseMapping.mapping, value);
+		if (choiceIndex === void 0) throw new SError("Unknown value encountered cannot be built using this mapToConstant");
+		return choiceIndex;
+	};
+}
+
+//#endregion
+export { indexToMappedConstantMapperFor, indexToMappedConstantUnmapperFor };

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

@@ -0,0 +1,18 @@
+
+      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/_internals/mappers/IndexToPrintableIndex.js
+function indexToPrintableIndexMapper(v) {
+	if (v < 95) return v + 32;
+	if (v <= 126) return v - 95;
+	return v;
+}
+function indexToPrintableIndexUnmapper(v) {
+	if (v >= 32 && v <= 126) return v - 32;
+	if (v >= 0 && v <= 31) return v + 95;
+	return v;
+}
+
+//#endregion
+export { indexToPrintableIndexMapper, indexToPrintableIndexUnmapper };

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

@@ -0,0 +1,42 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SError, safeEvery } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/KeyValuePairsToObject.js
+const safeObjectCreate = Object.create;
+const safeObjectDefineProperty = Object.defineProperty;
+const safeObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const safeObjectGetPrototypeOf = Object.getPrototypeOf;
+const safeObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
+const safeObjectGetOwnPropertyNames = Object.getOwnPropertyNames;
+const safeObjectEntries = Object.entries;
+function keyValuePairsToObjectMapper(definition) {
+	const obj = definition[1] ? safeObjectCreate(null) : {};
+	for (const keyValue of definition[0]) safeObjectDefineProperty(obj, keyValue[0], {
+		enumerable: true,
+		configurable: true,
+		writable: true,
+		value: keyValue[1]
+	});
+	return obj;
+}
+function buildIsValidPropertyNameFilter(obj) {
+	return function isValidPropertyNameFilter(key) {
+		const descriptor = safeObjectGetOwnPropertyDescriptor(obj, key);
+		return descriptor !== void 0 && !!descriptor.configurable && !!descriptor.enumerable && !!descriptor.writable && descriptor.get === void 0 && descriptor.set === void 0;
+	};
+}
+function keyValuePairsToObjectUnmapper(value) {
+	if (typeof value !== "object" || value === null) throw new SError("Incompatible instance received: should be a non-null object");
+	const hasNullPrototype = safeObjectGetPrototypeOf(value) === null;
+	const hasObjectPrototype = "constructor" in value && value.constructor === Object;
+	if (!hasNullPrototype && !hasObjectPrototype) throw new SError("Incompatible instance received: should be of exact type Object");
+	if (safeObjectGetOwnPropertySymbols(value).length > 0) throw new SError("Incompatible instance received: should contain symbols");
+	if (!safeEvery(safeObjectGetOwnPropertyNames(value), buildIsValidPropertyNameFilter(value))) throw new SError("Incompatible instance received: should contain only c/e/w properties without get/set");
+	return [safeObjectEntries(value), hasNullPrototype];
+}
+
+//#endregion
+export { keyValuePairsToObjectMapper, keyValuePairsToObjectUnmapper };

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

@@ -0,0 +1,32 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SError, safeJoin } from "../../../utils/globals.js";
+import { MaxLengthUpperBound } from "../helpers/MaxLengthFromMinLength.js";
+import { tokenizeString } from "../helpers/TokenizeString.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/PatternsToString.js
+function patternsToStringMapper(tab) {
+	return safeJoin(tab, "");
+}
+function minLengthFrom(constraints) {
+	return constraints.minLength !== void 0 ? constraints.minLength : 0;
+}
+function maxLengthFrom(constraints) {
+	return constraints.maxLength !== void 0 ? constraints.maxLength : MaxLengthUpperBound;
+}
+function patternsToStringUnmapperIsValidLength(tokens, constraints) {
+	return minLengthFrom(constraints) <= tokens.length && tokens.length <= maxLengthFrom(constraints);
+}
+function patternsToStringUnmapperFor(patternsArb, constraints) {
+	return function patternsToStringUnmapper(value) {
+		if (typeof value !== "string") throw new SError("Unsupported value");
+		const tokens = tokenizeString(patternsArb, value, minLengthFrom(constraints), maxLengthFrom(constraints));
+		if (tokens === void 0) throw new SError("Unable to unmap received string");
+		return tokens;
+	};
+}
+
+//#endregion
+export { patternsToStringMapper, patternsToStringUnmapperFor, patternsToStringUnmapperIsValidLength };

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

@@ -0,0 +1,30 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SDate, SError, safeGetTime } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/mappers/TimeToDate.js
+const safeNaN = Number.NaN;
+const safeNumberIsNaN = Number.isNaN;
+function timeToDateMapper(time) {
+	return new SDate(time);
+}
+function timeToDateUnmapper(value) {
+	if (!(value instanceof SDate) || value.constructor !== SDate) throw new SError("Not a valid value for date unmapper");
+	return safeGetTime(value);
+}
+function timeToDateMapperWithNaN(valueForNaN) {
+	return (time) => {
+		return time === valueForNaN ? new SDate(safeNaN) : timeToDateMapper(time);
+	};
+}
+function timeToDateUnmapperWithNaN(valueForNaN) {
+	return (value) => {
+		const time = timeToDateUnmapper(value);
+		return safeNumberIsNaN(time) ? valueForNaN : time;
+	};
+}
+
+//#endregion
+export { timeToDateMapper, timeToDateMapperWithNaN, timeToDateUnmapper, timeToDateUnmapperWithNaN };