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

@@ -0,0 +1,98 @@
+
+      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/helpers/ArrayInt64.js
+const Zero64 = {
+	sign: 1,
+	data: [0, 0]
+};
+const Unit64 = {
+	sign: 1,
+	data: [0, 1]
+};
+function isZero64(a) {
+	return a.data[0] === 0 && a.data[1] === 0;
+}
+function isStrictlyNegative64(a) {
+	return a.sign === -1 && !isZero64(a);
+}
+function isStrictlyPositive64(a) {
+	return a.sign === 1 && !isZero64(a);
+}
+function isEqual64(a, b) {
+	if (a.data[0] === b.data[0] && a.data[1] === b.data[1]) return a.sign === b.sign || a.data[0] === 0 && a.data[1] === 0;
+	return false;
+}
+function isStrictlySmaller64Internal(a, b) {
+	return a[0] < b[0] || a[0] === b[0] && a[1] < b[1];
+}
+function isStrictlySmaller64(a, b) {
+	if (a.sign === b.sign) return a.sign === 1 ? isStrictlySmaller64Internal(a.data, b.data) : isStrictlySmaller64Internal(b.data, a.data);
+	return a.sign === -1 && (!isZero64(a) || !isZero64(b));
+}
+function clone64(a) {
+	return {
+		sign: a.sign,
+		data: [a.data[0], a.data[1]]
+	};
+}
+function substract64DataInternal(a, b) {
+	let reminderLow = 0;
+	let low = a[1] - b[1];
+	if (low < 0) {
+		reminderLow = 1;
+		low = low >>> 0;
+	}
+	return [a[0] - b[0] - reminderLow, low];
+}
+function substract64Internal(a, b) {
+	if (a.sign === 1 && b.sign === -1) {
+		const low = a.data[1] + b.data[1];
+		const high = a.data[0] + b.data[0] + (low > 4294967295 ? 1 : 0);
+		return {
+			sign: 1,
+			data: [high >>> 0, low >>> 0]
+		};
+	}
+	return {
+		sign: 1,
+		data: a.sign === 1 ? substract64DataInternal(a.data, b.data) : substract64DataInternal(b.data, a.data)
+	};
+}
+function substract64(arrayIntA, arrayIntB) {
+	if (isStrictlySmaller64(arrayIntA, arrayIntB)) {
+		const out = substract64Internal(arrayIntB, arrayIntA);
+		out.sign = -1;
+		return out;
+	}
+	return substract64Internal(arrayIntA, arrayIntB);
+}
+function negative64(arrayIntA) {
+	return {
+		sign: -arrayIntA.sign,
+		data: [arrayIntA.data[0], arrayIntA.data[1]]
+	};
+}
+function add64(arrayIntA, arrayIntB) {
+	if (isZero64(arrayIntB)) {
+		if (isZero64(arrayIntA)) return clone64(Zero64);
+		return clone64(arrayIntA);
+	}
+	return substract64(arrayIntA, negative64(arrayIntB));
+}
+function halve64(a) {
+	return {
+		sign: a.sign,
+		data: [Math.floor(a.data[0] / 2), (a.data[0] % 2 === 1 ? 2147483648 : 0) + Math.floor(a.data[1] / 2)]
+	};
+}
+function logLike64(a) {
+	return {
+		sign: a.sign,
+		data: [0, Math.floor(Math.log(a.data[0] * 4294967296 + a.data[1]) / Math.log(2))]
+	};
+}
+
+//#endregion
+export { Unit64, Zero64, add64, clone64, halve64, isEqual64, isStrictlyNegative64, isStrictlyPositive64, isStrictlySmaller64, isZero64, logLike64, substract64 };

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

@@ -0,0 +1,53 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SBigInt, SString } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/BiasNumericRange.js
+const safeMathFloor = Math.floor;
+const safeMathLog = Math.log;
+function integerLogLike(v) {
+	return safeMathFloor(safeMathLog(v) / safeMathLog(2));
+}
+function bigIntLogLike(v) {
+	if (v === SBigInt(0)) return SBigInt(0);
+	return SBigInt(SString(v).length);
+}
+function biasNumericRange(min, max, logLike) {
+	if (min === max) return [{
+		min,
+		max
+	}];
+	if (min < 0 && max > 0) {
+		const logMin = logLike(-min);
+		const logMax = logLike(max);
+		return [
+			{
+				min: -logMin,
+				max: logMax
+			},
+			{
+				min: max - logMax,
+				max
+			},
+			{
+				min,
+				max: min + logMin
+			}
+		];
+	}
+	const logGap = logLike(max - min);
+	const arbCloseToMin = {
+		min,
+		max: min + logGap
+	};
+	const arbCloseToMax = {
+		min: max - logGap,
+		max
+	};
+	return min < 0 ? [arbCloseToMax, arbCloseToMin] : [arbCloseToMin, arbCloseToMax];
+}
+
+//#endregion
+export { biasNumericRange, bigIntLogLike, integerLogLike };

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

@@ -0,0 +1,15 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { NoopSlicedGenerator } from "../implementations/NoopSlicedGenerator.js";
+import { SlicedBasedGenerator } from "../implementations/SlicedBasedGenerator.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/BuildSlicedGenerator.js
+function buildSlicedGenerator(arb, mrng, slices, biasFactor) {
+	if (biasFactor === void 0 || slices.length === 0 || mrng.nextInt(1, biasFactor) !== 1) return new NoopSlicedGenerator(arb, mrng, biasFactor);
+	return new SlicedBasedGenerator(arb, mrng, slices, biasFactor);
+}
+
+//#endregion
+export { buildSlicedGenerator };

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

@@ -0,0 +1,27 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safePush } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/CustomEqualSet.js
+var CustomEqualSet = class {
+	constructor(isEqual) {
+		this.isEqual = isEqual;
+		this.data = [];
+	}
+	tryAdd(value) {
+		for (let idx = 0; idx !== this.data.length; ++idx) if (this.isEqual(this.data[idx], value)) return false;
+		safePush(this.data, value);
+		return true;
+	}
+	size() {
+		return this.data.length;
+	}
+	getData() {
+		return this.data;
+	}
+};
+
+//#endregion
+export { CustomEqualSet };

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

@@ -0,0 +1,24 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safeMapGet, safeMapSet } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/DepthContext.js
+const depthContextCache = new Map();
+function getDepthContextFor(contextMeta) {
+	if (contextMeta === void 0) return { depth: 0 };
+	if (typeof contextMeta !== "string") return contextMeta;
+	const cachedContext = safeMapGet(depthContextCache, contextMeta);
+	if (cachedContext !== void 0) return cachedContext;
+	const context = { depth: 0 };
+	safeMapSet(depthContextCache, contextMeta, context);
+	return context;
+}
+function createDepthIdentifier() {
+	const identifier = { depth: 0 };
+	return identifier;
+}
+
+//#endregion
+export { createDepthIdentifier, getDepthContextFor };

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

@@ -0,0 +1,96 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { clone64, isEqual64 } from "./ArrayInt64.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/DoubleHelpers.js
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeEpsilon = Number.EPSILON;
+const INDEX_POSITIVE_INFINITY = {
+	sign: 1,
+	data: [2146435072, 0]
+};
+const INDEX_NEGATIVE_INFINITY = {
+	sign: -1,
+	data: [2146435072, 1]
+};
+const f64 = new Float64Array(1);
+const u32 = new Uint32Array(f64.buffer, f64.byteOffset);
+function bitCastDoubleToUInt64(f) {
+	f64[0] = f;
+	return [u32[1], u32[0]];
+}
+function decomposeDouble(d) {
+	const { 0: hi, 1: lo } = bitCastDoubleToUInt64(d);
+	const signBit = hi >>> 31;
+	const exponentBits = hi >>> 20 & 2047;
+	const significandBits = (hi & 1048575) * 4294967296 + lo;
+	const exponent = exponentBits === 0 ? -1022 : exponentBits - 1023;
+	let significand = exponentBits === 0 ? 0 : 1;
+	significand += significandBits / 2 ** 52;
+	significand *= signBit === 0 ? 1 : -1;
+	return {
+		exponent,
+		significand
+	};
+}
+function positiveNumberToInt64(n) {
+	return [~~(n / 4294967296), n >>> 0];
+}
+function indexInDoubleFromDecomp(exponent, significand) {
+	if (exponent === -1022) {
+		const rescaledSignificand$1 = significand * 2 ** 52;
+		return positiveNumberToInt64(rescaledSignificand$1);
+	}
+	const rescaledSignificand = (significand - 1) * 2 ** 52;
+	const exponentOnlyHigh = (exponent + 1023) * 2 ** 20;
+	const index = positiveNumberToInt64(rescaledSignificand);
+	index[0] += exponentOnlyHigh;
+	return index;
+}
+function doubleToIndex(d) {
+	if (d === safePositiveInfinity) return clone64(INDEX_POSITIVE_INFINITY);
+	if (d === safeNegativeInfinity) return clone64(INDEX_NEGATIVE_INFINITY);
+	const decomp = decomposeDouble(d);
+	const exponent = decomp.exponent;
+	const significand = decomp.significand;
+	if (d > 0 || d === 0 && 1 / d === safePositiveInfinity) return {
+		sign: 1,
+		data: indexInDoubleFromDecomp(exponent, significand)
+	};
+	else {
+		const indexOpposite = indexInDoubleFromDecomp(exponent, -significand);
+		if (indexOpposite[1] === 4294967295) {
+			indexOpposite[0] += 1;
+			indexOpposite[1] = 0;
+		} else indexOpposite[1] += 1;
+		return {
+			sign: -1,
+			data: indexOpposite
+		};
+	}
+}
+function indexToDouble(index) {
+	if (index.sign === -1) {
+		const indexOpposite = {
+			sign: 1,
+			data: [index.data[0], index.data[1]]
+		};
+		if (indexOpposite.data[1] === 0) {
+			indexOpposite.data[0] -= 1;
+			indexOpposite.data[1] = 4294967295;
+		} else indexOpposite.data[1] -= 1;
+		return -indexToDouble(indexOpposite);
+	}
+	if (isEqual64(index, INDEX_POSITIVE_INFINITY)) return safePositiveInfinity;
+	if (index.data[0] < 2097152) return (index.data[0] * 4294967296 + index.data[1]) * 2 ** -1074;
+	const postIndexHigh = index.data[0] - 2097152;
+	const exponent = -1021 + (postIndexHigh >> 20);
+	const significand = 1 + ((postIndexHigh & 1048575) * 2 ** 32 + index.data[1]) * safeEpsilon;
+	return significand * 2 ** exponent;
+}
+
+//#endregion
+export { doubleToIndex, indexToDouble };

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

@@ -0,0 +1,25 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { refineConstraintsForFloatingOnly } from "./FloatingOnlyHelpers.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/DoubleOnlyHelpers.js
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeMaxValue = Number.MAX_VALUE;
+const maxNonIntegerValue = 4503599627370495.5;
+const onlyIntegersAfterThisValue = 4503599627370496;
+function refineConstraintsForDoubleOnly(constraints) {
+	return refineConstraintsForFloatingOnly(constraints, safeMaxValue, maxNonIntegerValue, onlyIntegersAfterThisValue);
+}
+function doubleOnlyMapper(value) {
+	return value === onlyIntegersAfterThisValue ? safePositiveInfinity : value === -onlyIntegersAfterThisValue ? safeNegativeInfinity : value;
+}
+function doubleOnlyUnmapper(value) {
+	if (typeof value !== "number") throw new Error("Unsupported type");
+	return value === safePositiveInfinity ? onlyIntegersAfterThisValue : value === safeNegativeInfinity ? -onlyIntegersAfterThisValue : value;
+}
+
+//#endregion
+export { doubleOnlyMapper, doubleOnlyUnmapper, refineConstraintsForDoubleOnly };

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

@@ -0,0 +1,57 @@
+
+      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/helpers/FloatHelpers.js
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const MIN_VALUE_32 = 2 ** -126 * 2 ** -23;
+const MAX_VALUE_32 = 2 ** 127 * (1 + (2 ** 23 - 1) / 2 ** 23);
+const EPSILON_32 = 2 ** -23;
+const INDEX_POSITIVE_INFINITY = 2139095040;
+const INDEX_NEGATIVE_INFINITY = -2139095041;
+const f32 = new Float32Array(1);
+const u32 = new Uint32Array(f32.buffer, f32.byteOffset);
+function bitCastFloatToUInt32(f) {
+	f32[0] = f;
+	return u32[0];
+}
+function decomposeFloat(f) {
+	const bits = bitCastFloatToUInt32(f);
+	const signBit = bits >>> 31;
+	const exponentBits = bits >>> 23 & 255;
+	const significandBits = bits & 8388607;
+	const exponent = exponentBits === 0 ? -126 : exponentBits - 127;
+	let significand = exponentBits === 0 ? 0 : 1;
+	significand += significandBits / 2 ** 23;
+	significand *= signBit === 0 ? 1 : -1;
+	return {
+		exponent,
+		significand
+	};
+}
+function indexInFloatFromDecomp(exponent, significand) {
+	if (exponent === -126) return significand * 8388608;
+	return (exponent + 127) * 8388608 + (significand - 1) * 8388608;
+}
+function floatToIndex(f) {
+	if (f === safePositiveInfinity) return INDEX_POSITIVE_INFINITY;
+	if (f === safeNegativeInfinity) return INDEX_NEGATIVE_INFINITY;
+	const decomp = decomposeFloat(f);
+	const exponent = decomp.exponent;
+	const significand = decomp.significand;
+	if (f > 0 || f === 0 && 1 / f === safePositiveInfinity) return indexInFloatFromDecomp(exponent, significand);
+	else return -indexInFloatFromDecomp(exponent, -significand) - 1;
+}
+function indexToFloat(index) {
+	if (index < 0) return -indexToFloat(-index - 1);
+	if (index === INDEX_POSITIVE_INFINITY) return safePositiveInfinity;
+	if (index < 16777216) return index * 2 ** -149;
+	const postIndex = index - 16777216;
+	const exponent = -125 + (postIndex >> 23);
+	const significand = 1 + (postIndex & 8388607) / 8388608;
+	return significand * 2 ** exponent;
+}
+
+//#endregion
+export { MAX_VALUE_32, floatToIndex, indexToFloat };

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

@@ -0,0 +1,26 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { refineConstraintsForFloatingOnly } from "./FloatingOnlyHelpers.js";
+import { MAX_VALUE_32 } from "./FloatHelpers.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/FloatOnlyHelpers.js
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+const safeMaxValue = MAX_VALUE_32;
+const maxNonIntegerValue = 8388607.5;
+const onlyIntegersAfterThisValue = 8388608;
+function refineConstraintsForFloatOnly(constraints) {
+	return refineConstraintsForFloatingOnly(constraints, safeMaxValue, maxNonIntegerValue, onlyIntegersAfterThisValue);
+}
+function floatOnlyMapper(value) {
+	return value === onlyIntegersAfterThisValue ? safePositiveInfinity : value === -onlyIntegersAfterThisValue ? safeNegativeInfinity : value;
+}
+function floatOnlyUnmapper(value) {
+	if (typeof value !== "number") throw new Error("Unsupported type");
+	return value === safePositiveInfinity ? onlyIntegersAfterThisValue : value === safeNegativeInfinity ? -onlyIntegersAfterThisValue : value;
+}
+
+//#endregion
+export { floatOnlyMapper, floatOnlyUnmapper, refineConstraintsForFloatOnly };

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

@@ -0,0 +1,26 @@
+
+      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/helpers/FloatingOnlyHelpers.js
+const safeNumberIsInteger = Number.isInteger;
+const safeObjectIs = Object.is;
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+function refineConstraintsForFloatingOnly(constraints, maxValue, maxNonIntegerValue, onlyIntegersAfterThisValue) {
+	const { noDefaultInfinity = false, minExcluded = false, maxExcluded = false, min = noDefaultInfinity ? -maxValue : safeNegativeInfinity, max = noDefaultInfinity ? maxValue : safePositiveInfinity } = constraints;
+	const effectiveMin = minExcluded ? min < -maxNonIntegerValue ? -onlyIntegersAfterThisValue : Math.max(min, -maxNonIntegerValue) : min === safeNegativeInfinity ? Math.max(min, -onlyIntegersAfterThisValue) : Math.max(min, -maxNonIntegerValue);
+	const effectiveMax = maxExcluded ? max > maxNonIntegerValue ? onlyIntegersAfterThisValue : Math.min(max, maxNonIntegerValue) : max === safePositiveInfinity ? Math.min(max, onlyIntegersAfterThisValue) : Math.min(max, maxNonIntegerValue);
+	const fullConstraints = {
+		noDefaultInfinity: false,
+		minExcluded: minExcluded || (min !== safeNegativeInfinity || minExcluded) && safeNumberIsInteger(effectiveMin),
+		maxExcluded: maxExcluded || (max !== safePositiveInfinity || maxExcluded) && safeNumberIsInteger(effectiveMax),
+		min: safeObjectIs(effectiveMin, -0) ? 0 : effectiveMin,
+		max: safeObjectIs(effectiveMax, 0) ? -0 : effectiveMax,
+		noNaN: constraints.noNaN || false
+	};
+	return fullConstraints;
+}
+
+//#endregion
+export { refineConstraintsForFloatingOnly };

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

@@ -0,0 +1,58 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safePop, safePush } from "../../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/GraphemeRangesHelpers.js
+const safeStringFromCodePoint = String.fromCodePoint;
+const safeMathMin = Math.min;
+const safeMathMax = Math.max;
+function convertGraphemeRangeToMapToConstantEntry(range) {
+	if (range.length === 1) {
+		const codePointString = safeStringFromCodePoint(range[0]);
+		return {
+			num: 1,
+			build: () => codePointString
+		};
+	}
+	const rangeStart = range[0];
+	return {
+		num: range[1] - range[0] + 1,
+		build: (idInGroup) => safeStringFromCodePoint(rangeStart + idInGroup)
+	};
+}
+function intersectGraphemeRanges(rangesA, rangesB) {
+	const mergedRanges = [];
+	let cursorA = 0;
+	let cursorB = 0;
+	while (cursorA < rangesA.length && cursorB < rangesB.length) {
+		const rangeA = rangesA[cursorA];
+		const rangeAMin = rangeA[0];
+		const rangeAMax = rangeA.length === 1 ? rangeA[0] : rangeA[1];
+		const rangeB = rangesB[cursorB];
+		const rangeBMin = rangeB[0];
+		const rangeBMax = rangeB.length === 1 ? rangeB[0] : rangeB[1];
+		if (rangeAMax < rangeBMin) cursorA += 1;
+		else if (rangeBMax < rangeAMin) cursorB += 1;
+		else {
+			let min = safeMathMax(rangeAMin, rangeBMin);
+			const max = safeMathMin(rangeAMax, rangeBMax);
+			if (mergedRanges.length >= 1) {
+				const lastMergedRange = mergedRanges[mergedRanges.length - 1];
+				const lastMergedRangeMax = lastMergedRange.length === 1 ? lastMergedRange[0] : lastMergedRange[1];
+				if (lastMergedRangeMax + 1 === min) {
+					min = lastMergedRange[0];
+					safePop(mergedRanges);
+				}
+			}
+			safePush(mergedRanges, min === max ? [min] : [min, max]);
+			if (rangeAMax <= max) cursorA += 1;
+			if (rangeBMax <= max) cursorB += 1;
+		}
+	}
+	return mergedRanges;
+}
+
+//#endregion
+export { convertGraphemeRangeToMapToConstantEntry, intersectGraphemeRanges };

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

@@ -0,0 +1,72 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safeIndexOf } from "../../../utils/globals.js";
+import { readConfigureGlobal } from "../../../check/runner/configuration/GlobalParameters.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/MaxLengthFromMinLength.js
+const safeMathFloor = Math.floor;
+const safeMathMin = Math.min;
+const MaxLengthUpperBound = 2147483647;
+const orderedSize = [
+	"xsmall",
+	"small",
+	"medium",
+	"large",
+	"xlarge"
+];
+const orderedRelativeSize = [
+	"-4",
+	"-3",
+	"-2",
+	"-1",
+	"=",
+	"+1",
+	"+2",
+	"+3",
+	"+4"
+];
+const DefaultSize = "small";
+function maxLengthFromMinLength(minLength, size) {
+	switch (size) {
+		case "xsmall": return safeMathFloor(1.1 * minLength) + 1;
+		case "small": return 2 * minLength + 10;
+		case "medium": return 11 * minLength + 100;
+		case "large": return 101 * minLength + 1e3;
+		case "xlarge": return 1001 * minLength + 1e4;
+		default: throw new Error(`Unable to compute lengths based on received size: ${size}`);
+	}
+}
+function relativeSizeToSize(size, defaultSize) {
+	const sizeInRelative = safeIndexOf(orderedRelativeSize, size);
+	if (sizeInRelative === -1) return size;
+	const defaultSizeInSize = safeIndexOf(orderedSize, defaultSize);
+	if (defaultSizeInSize === -1) throw new Error(`Unable to offset size based on the unknown defaulted one: ${defaultSize}`);
+	const resultingSizeInSize = defaultSizeInSize + sizeInRelative - 4;
+	return resultingSizeInSize < 0 ? orderedSize[0] : resultingSizeInSize >= orderedSize.length ? orderedSize[orderedSize.length - 1] : orderedSize[resultingSizeInSize];
+}
+function maxGeneratedLengthFromSizeForArbitrary(size, minLength, maxLength, specifiedMaxLength) {
+	const { baseSize: defaultSize = DefaultSize, defaultSizeToMaxWhenMaxSpecified } = readConfigureGlobal() || {};
+	const definedSize = size !== void 0 ? size : specifiedMaxLength && defaultSizeToMaxWhenMaxSpecified ? "max" : defaultSize;
+	if (definedSize === "max") return maxLength;
+	const finalSize = relativeSizeToSize(definedSize, defaultSize);
+	return safeMathMin(maxLengthFromMinLength(minLength, finalSize), maxLength);
+}
+function depthBiasFromSizeForArbitrary(depthSizeOrSize, specifiedMaxDepth) {
+	if (typeof depthSizeOrSize === "number") return 1 / depthSizeOrSize;
+	const { baseSize: defaultSize = DefaultSize, defaultSizeToMaxWhenMaxSpecified } = readConfigureGlobal() || {};
+	const definedSize = depthSizeOrSize !== void 0 ? depthSizeOrSize : specifiedMaxDepth && defaultSizeToMaxWhenMaxSpecified ? "max" : defaultSize;
+	if (definedSize === "max") return 0;
+	const finalSize = relativeSizeToSize(definedSize, defaultSize);
+	switch (finalSize) {
+		case "xsmall": return 1;
+		case "small": return .5;
+		case "medium": return .25;
+		case "large": return .125;
+		case "xlarge": return .0625;
+	}
+}
+
+//#endregion
+export { MaxLengthUpperBound, depthBiasFromSizeForArbitrary, maxGeneratedLengthFromSizeForArbitrary };

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

@@ -0,0 +1,16 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+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/NoUndefinedAsContext.js
+const UndefinedContextPlaceholder = Symbol("UndefinedContextPlaceholder");
+function noUndefinedAsContext(value) {
+	if (value.context !== void 0) return value;
+	if (value.hasToBeCloned) return new Value(value.value_, UndefinedContextPlaceholder, () => value.value);
+	return new Value(value.value_, UndefinedContextPlaceholder);
+}
+
+//#endregion
+export { UndefinedContextPlaceholder, noUndefinedAsContext };

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

@@ -0,0 +1,58 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { boolean } from "../../boolean.js";
+import { constant } from "../../constant.js";
+import { oneof } from "../../oneof.js";
+import { string } from "../../string.js";
+import { double } from "../../double.js";
+import { maxSafeInteger } from "../../maxSafeInteger.js";
+import { fullUnicodeString } from "../../fullUnicodeString.js";
+import { boxedArbitraryBuilder } from "../builders/BoxedArbitraryBuilder.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/QualifiedObjectConstraints.js
+function defaultValues(constraints, stringArbitrary) {
+	return [
+		boolean(),
+		maxSafeInteger(),
+		double(),
+		stringArbitrary(constraints),
+		oneof(stringArbitrary(constraints), constant(null), constant(void 0))
+	];
+}
+function boxArbitraries(arbs) {
+	return arbs.map((arb) => boxedArbitraryBuilder(arb));
+}
+function boxArbitrariesIfNeeded(arbs, boxEnabled) {
+	return boxEnabled ? boxArbitraries(arbs).concat(arbs) : arbs;
+}
+function toQualifiedObjectConstraints(settings = {}) {
+	function orDefault(optionalValue, defaultValue) {
+		return optionalValue !== void 0 ? optionalValue : defaultValue;
+	}
+	const stringArbitrary = "stringUnit" in settings ? string : settings.withUnicodeString ? fullUnicodeString : string;
+	const valueConstraints = {
+		size: settings.size,
+		unit: settings.stringUnit
+	};
+	return {
+		key: orDefault(settings.key, stringArbitrary(valueConstraints)),
+		values: boxArbitrariesIfNeeded(orDefault(settings.values, defaultValues(valueConstraints, stringArbitrary)), orDefault(settings.withBoxedValues, false)),
+		depthSize: settings.depthSize,
+		maxDepth: settings.maxDepth,
+		maxKeys: settings.maxKeys,
+		size: settings.size,
+		withSet: orDefault(settings.withSet, false),
+		withMap: orDefault(settings.withMap, false),
+		withObjectString: orDefault(settings.withObjectString, false),
+		withNullPrototype: orDefault(settings.withNullPrototype, false),
+		withBigInt: orDefault(settings.withBigInt, false),
+		withDate: orDefault(settings.withDate, false),
+		withTypedArray: orDefault(settings.withTypedArray, false),
+		withSparseArray: orDefault(settings.withSparseArray, false)
+	};
+}
+
+//#endregion
+export { toQualifiedObjectConstraints };