@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/check/property/SkipAfterProperty.js

@@ -0,0 +1,61 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { PreconditionFailure } from "../precondition/PreconditionFailure.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/property/SkipAfterProperty.js
+function interruptAfter(timeMs, setTimeoutSafe, clearTimeoutSafe) {
+	let timeoutHandle = null;
+	const promise = new Promise((resolve) => {
+		timeoutHandle = setTimeoutSafe(() => {
+			const preconditionFailure = new PreconditionFailure(true);
+			resolve(preconditionFailure);
+		}, timeMs);
+	});
+	return {
+		clear: () => clearTimeoutSafe(timeoutHandle),
+		promise
+	};
+}
+var SkipAfterProperty = class {
+	constructor(property, getTime, timeLimit, interruptExecution, setTimeoutSafe, clearTimeoutSafe) {
+		this.property = property;
+		this.getTime = getTime;
+		this.interruptExecution = interruptExecution;
+		this.setTimeoutSafe = setTimeoutSafe;
+		this.clearTimeoutSafe = clearTimeoutSafe;
+		this.skipAfterTime = this.getTime() + timeLimit;
+		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 remainingTime = this.skipAfterTime - this.getTime();
+		if (remainingTime <= 0) {
+			const preconditionFailure = new PreconditionFailure(this.interruptExecution);
+			if (this.isAsync()) return Promise.resolve(preconditionFailure);
+			else return preconditionFailure;
+		}
+		if (this.interruptExecution && this.isAsync()) {
+			const t = interruptAfter(remainingTime, this.setTimeoutSafe, this.clearTimeoutSafe);
+			const propRun = Promise.race([this.property.run(v, dontRunHook), t.promise]);
+			propRun.then(t.clear, t.clear);
+			return propRun;
+		}
+		return this.property.run(v, dontRunHook);
+	}
+};
+
+//#endregion
+export { SkipAfterProperty };

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

@@ -0,0 +1,52 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SError } from "../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/property/TimeoutProperty.js
+const timeoutAfter = (timeMs, setTimeoutSafe, clearTimeoutSafe) => {
+	let timeoutHandle = null;
+	const promise = new Promise((resolve) => {
+		timeoutHandle = setTimeoutSafe(() => {
+			resolve({
+				error: new SError(`Property timeout: exceeded limit of ${timeMs} milliseconds`),
+				errorMessage: `Property timeout: exceeded limit of ${timeMs} milliseconds`
+			});
+		}, timeMs);
+	});
+	return {
+		clear: () => clearTimeoutSafe(timeoutHandle),
+		promise
+	};
+};
+var TimeoutProperty = class {
+	constructor(property, timeMs, setTimeoutSafe, clearTimeoutSafe) {
+		this.property = property;
+		this.timeMs = timeMs;
+		this.setTimeoutSafe = setTimeoutSafe;
+		this.clearTimeoutSafe = clearTimeoutSafe;
+		if (this.property.runBeforeEach !== void 0 && this.property.runAfterEach !== void 0) {
+			this.runBeforeEach = () => Promise.resolve(this.property.runBeforeEach());
+			this.runAfterEach = () => Promise.resolve(this.property.runAfterEach());
+		}
+	}
+	isAsync() {
+		return true;
+	}
+	generate(mrng, runId) {
+		return this.property.generate(mrng, runId);
+	}
+	shrink(value) {
+		return this.property.shrink(value);
+	}
+	async run(v, dontRunHook) {
+		const t = timeoutAfter(this.timeMs, this.setTimeoutSafe, this.clearTimeoutSafe);
+		const propRun = Promise.race([this.property.run(v, dontRunHook), t.promise]);
+		propRun.then(t.clear, t.clear);
+		return propRun;
+	}
+};
+
+//#endregion
+export { TimeoutProperty };

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

@@ -0,0 +1,29 @@
+
+      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/UnbiasedProperty.js
+var UnbiasedProperty = class {
+	constructor(property) {
+		this.property = property;
+		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, void 0);
+	}
+	shrink(value) {
+		return this.property.shrink(value);
+	}
+	run(v, dontRunHook) {
+		return this.property.run(v, dontRunHook);
+	}
+};
+
+//#endregion
+export { UnbiasedProperty };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/DecorateProperty.js

@@ -0,0 +1,26 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SkipAfterProperty } from "../property/SkipAfterProperty.js";
+import { TimeoutProperty } from "../property/TimeoutProperty.js";
+import { UnbiasedProperty } from "../property/UnbiasedProperty.js";
+import { IgnoreEqualValuesProperty } from "../property/IgnoreEqualValuesProperty.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/DecorateProperty.js
+const safeDateNow = Date.now;
+const safeSetTimeout = setTimeout;
+const safeClearTimeout = clearTimeout;
+function decorateProperty(rawProperty, qParams) {
+	let prop = rawProperty;
+	if (rawProperty.isAsync() && qParams.timeout != null) prop = new TimeoutProperty(prop, qParams.timeout, safeSetTimeout, safeClearTimeout);
+	if (qParams.unbiased) prop = new UnbiasedProperty(prop);
+	if (qParams.skipAllAfterTimeLimit != null) prop = new SkipAfterProperty(prop, safeDateNow, qParams.skipAllAfterTimeLimit, false, safeSetTimeout, safeClearTimeout);
+	if (qParams.interruptAfterTimeLimit != null) prop = new SkipAfterProperty(prop, safeDateNow, qParams.interruptAfterTimeLimit, true, safeSetTimeout, safeClearTimeout);
+	if (qParams.skipEqualValues) prop = new IgnoreEqualValuesProperty(prop, true);
+	if (qParams.ignoreEqualValues) prop = new IgnoreEqualValuesProperty(prop, false);
+	return prop;
+}
+
+//#endregion
+export { decorateProperty };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/Runner.js

@@ -0,0 +1,61 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Stream, stream } from "../../stream/Stream.js";
+import { readConfigureGlobal } from "./configuration/GlobalParameters.js";
+import { QualifiedParameters } from "./configuration/QualifiedParameters.js";
+import { decorateProperty } from "./DecorateProperty.js";
+import { RunnerIterator } from "./RunnerIterator.js";
+import { SourceValuesIterator } from "./SourceValuesIterator.js";
+import { lazyToss, toss } from "./Tosser.js";
+import { pathWalk } from "./utils/PathWalker.js";
+import { asyncReportRunDetails, reportRunDetails } from "./utils/RunDetailsFormatter.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/Runner.js
+const safeObjectAssign = Object.assign;
+function runIt(property, shrink, sourceValues, verbose, interruptedAsFailure) {
+	const isModernProperty = property.runBeforeEach !== void 0 && property.runAfterEach !== void 0;
+	const runner = new RunnerIterator(sourceValues, shrink, verbose, interruptedAsFailure);
+	for (const v of runner) {
+		if (isModernProperty) property.runBeforeEach();
+		const out = property.run(v, isModernProperty);
+		if (isModernProperty) property.runAfterEach();
+		runner.handleResult(out);
+	}
+	return runner.runExecution;
+}
+async function asyncRunIt(property, shrink, sourceValues, verbose, interruptedAsFailure) {
+	const isModernProperty = property.runBeforeEach !== void 0 && property.runAfterEach !== void 0;
+	const runner = new RunnerIterator(sourceValues, shrink, verbose, interruptedAsFailure);
+	for (const v of runner) {
+		if (isModernProperty) await property.runBeforeEach();
+		const out = await property.run(v, isModernProperty);
+		if (isModernProperty) await property.runAfterEach();
+		runner.handleResult(out);
+	}
+	return runner.runExecution;
+}
+function check(rawProperty, params) {
+	if (rawProperty == null || rawProperty.generate == null) throw new Error("Invalid property encountered, please use a valid property");
+	if (rawProperty.run == null) throw new Error("Invalid property encountered, please use a valid property not an arbitrary");
+	const qParams = QualifiedParameters.read(safeObjectAssign(safeObjectAssign({}, readConfigureGlobal()), params));
+	if (qParams.reporter !== null && qParams.asyncReporter !== null) throw new Error("Invalid parameters encountered, reporter and asyncReporter cannot be specified together");
+	if (qParams.asyncReporter !== null && !rawProperty.isAsync()) throw new Error("Invalid parameters encountered, only asyncProperty can be used when asyncReporter specified");
+	const property = decorateProperty(rawProperty, qParams);
+	const maxInitialIterations = qParams.path.length === 0 || qParams.path.indexOf(":") === -1 ? qParams.numRuns : -1;
+	const maxSkips = qParams.numRuns * qParams.maxSkipsPerRun;
+	const shrink = (...args) => property.shrink(...args);
+	const initialValues = qParams.path.length === 0 ? toss(property, qParams.seed, qParams.randomType, qParams.examples) : pathWalk(qParams.path, stream(lazyToss(property, qParams.seed, qParams.randomType, qParams.examples)), shrink);
+	const sourceValues = new SourceValuesIterator(initialValues, maxInitialIterations, maxSkips);
+	const finalShrink = !qParams.endOnFailure ? shrink : Stream.nil;
+	return property.isAsync() ? asyncRunIt(property, finalShrink, sourceValues, qParams.verbose, qParams.markInterruptAsFailure).then((e) => e.toRunDetails(qParams.seed, qParams.path, maxSkips, qParams)) : runIt(property, finalShrink, sourceValues, qParams.verbose, qParams.markInterruptAsFailure).toRunDetails(qParams.seed, qParams.path, maxSkips, qParams);
+}
+function assert(property, params) {
+	const out = check(property, params);
+	if (property.isAsync()) return out.then(asyncReportRunDetails);
+	else reportRunDetails(out);
+}
+
+//#endregion
+export { assert as assert$1, check };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/RunnerIterator.js

@@ -0,0 +1,47 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { PreconditionFailure } from "../precondition/PreconditionFailure.js";
+import { RunExecution } from "./reporter/RunExecution.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/RunnerIterator.js
+var RunnerIterator = class {
+	constructor(sourceValues, shrink, verbose, interruptedAsFailure) {
+		this.sourceValues = sourceValues;
+		this.shrink = shrink;
+		this.runExecution = new RunExecution(verbose, interruptedAsFailure);
+		this.currentIdx = -1;
+		this.nextValues = sourceValues;
+	}
+	[Symbol.iterator]() {
+		return this;
+	}
+	next() {
+		const nextValue = this.nextValues.next();
+		if (nextValue.done || this.runExecution.interrupted) return {
+			done: true,
+			value: void 0
+		};
+		this.currentValue = nextValue.value;
+		++this.currentIdx;
+		return {
+			done: false,
+			value: nextValue.value.value_
+		};
+	}
+	handleResult(result) {
+		if (result != null && typeof result === "object" && !PreconditionFailure.isFailure(result)) {
+			this.runExecution.fail(this.currentValue.value_, this.currentIdx, result);
+			this.currentIdx = -1;
+			this.nextValues = this.shrink(this.currentValue);
+		} else if (result != null) if (!result.interruptExecution) {
+			this.runExecution.skip(this.currentValue.value_);
+			this.sourceValues.skippedOne();
+		} else this.runExecution.interrupt();
+		else this.runExecution.success(this.currentValue.value_);
+	}
+};
+
+//#endregion
+export { RunnerIterator };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/SourceValuesIterator.js

@@ -0,0 +1,35 @@
+
+      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/runner/SourceValuesIterator.js
+var SourceValuesIterator = class {
+	constructor(initialValues, maxInitialIterations, remainingSkips) {
+		this.initialValues = initialValues;
+		this.maxInitialIterations = maxInitialIterations;
+		this.remainingSkips = remainingSkips;
+	}
+	[Symbol.iterator]() {
+		return this;
+	}
+	next() {
+		if (--this.maxInitialIterations !== -1 && this.remainingSkips >= 0) {
+			const n = this.initialValues.next();
+			if (!n.done) return {
+				value: n.value,
+				done: false
+			};
+		}
+		return {
+			value: void 0,
+			done: true
+		};
+	}
+	skippedOne() {
+		--this.remainingSkips;
+		++this.maxInitialIterations;
+	}
+};
+
+//#endregion
+export { SourceValuesIterator };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/Tosser.js

@@ -0,0 +1,33 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Value } from "../arbitrary/definition/Value.js";
+import { safeMap } from "../../utils/globals.js";
+import { skipN } from "../../../../../../../pure-rand@6.1.0/node_modules/pure-rand/lib/esm/generator/RandomGenerator.js";
+import { Random } from "../../random/generator/Random.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/Tosser.js
+function tossNext(generator, rng, index) {
+	rng.unsafeJump();
+	return generator.generate(new Random(rng), index);
+}
+function* toss(generator, seed, random, examples) {
+	for (let idx = 0; idx !== examples.length; ++idx) yield new Value(examples[idx], void 0);
+	for (let idx = 0, rng = random(seed);; ++idx) yield tossNext(generator, rng, idx);
+}
+function lazyGenerate(generator, rng, idx) {
+	return () => generator.generate(new Random(rng), idx);
+}
+function* lazyToss(generator, seed, random, examples) {
+	yield* safeMap(examples, (e) => () => new Value(e, void 0));
+	let idx = 0;
+	let rng = random(seed);
+	for (;;) {
+		rng = rng.jump ? rng.jump() : skipN(rng, 42);
+		yield lazyGenerate(generator, rng, idx++);
+	}
+}
+
+//#endregion
+export { lazyToss, toss };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/configuration/GlobalParameters.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/runner/configuration/GlobalParameters.js
+let globalParameters = {};
+function readConfigureGlobal() {
+	return globalParameters;
+}
+
+//#endregion
+export { readConfigureGlobal };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/configuration/QualifiedParameters.js

@@ -0,0 +1,121 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { unsafeSkipN } from "../../../../../../../../pure-rand@6.1.0/node_modules/pure-rand/lib/esm/generator/RandomGenerator.js";
+import { pure_rand_default } from "../../../../../../../../pure-rand@6.1.0/node_modules/pure-rand/lib/esm/pure-rand.js";
+import { VerbosityLevel } from "./VerbosityLevel.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/configuration/QualifiedParameters.js
+const safeDateNow = Date.now;
+const safeMathMin = Math.min;
+const safeMathRandom = Math.random;
+var QualifiedParameters = class QualifiedParameters {
+	constructor(op) {
+		const p = op || {};
+		this.seed = QualifiedParameters.readSeed(p);
+		this.randomType = QualifiedParameters.readRandomType(p);
+		this.numRuns = QualifiedParameters.readNumRuns(p);
+		this.verbose = QualifiedParameters.readVerbose(p);
+		this.maxSkipsPerRun = QualifiedParameters.readOrDefault(p, "maxSkipsPerRun", 100);
+		this.timeout = QualifiedParameters.safeTimeout(QualifiedParameters.readOrDefault(p, "timeout", null));
+		this.skipAllAfterTimeLimit = QualifiedParameters.safeTimeout(QualifiedParameters.readOrDefault(p, "skipAllAfterTimeLimit", null));
+		this.interruptAfterTimeLimit = QualifiedParameters.safeTimeout(QualifiedParameters.readOrDefault(p, "interruptAfterTimeLimit", null));
+		this.markInterruptAsFailure = QualifiedParameters.readBoolean(p, "markInterruptAsFailure");
+		this.skipEqualValues = QualifiedParameters.readBoolean(p, "skipEqualValues");
+		this.ignoreEqualValues = QualifiedParameters.readBoolean(p, "ignoreEqualValues");
+		this.logger = QualifiedParameters.readOrDefault(p, "logger", (v) => {
+			console.log(v);
+		});
+		this.path = QualifiedParameters.readOrDefault(p, "path", "");
+		this.unbiased = QualifiedParameters.readBoolean(p, "unbiased");
+		this.examples = QualifiedParameters.readOrDefault(p, "examples", []);
+		this.endOnFailure = QualifiedParameters.readBoolean(p, "endOnFailure");
+		this.reporter = QualifiedParameters.readOrDefault(p, "reporter", null);
+		this.asyncReporter = QualifiedParameters.readOrDefault(p, "asyncReporter", null);
+		this.errorWithCause = QualifiedParameters.readBoolean(p, "errorWithCause");
+	}
+	toParameters() {
+		const orUndefined = (value) => value !== null ? value : void 0;
+		const parameters = {
+			seed: this.seed,
+			randomType: this.randomType,
+			numRuns: this.numRuns,
+			maxSkipsPerRun: this.maxSkipsPerRun,
+			timeout: orUndefined(this.timeout),
+			skipAllAfterTimeLimit: orUndefined(this.skipAllAfterTimeLimit),
+			interruptAfterTimeLimit: orUndefined(this.interruptAfterTimeLimit),
+			markInterruptAsFailure: this.markInterruptAsFailure,
+			skipEqualValues: this.skipEqualValues,
+			ignoreEqualValues: this.ignoreEqualValues,
+			path: this.path,
+			logger: this.logger,
+			unbiased: this.unbiased,
+			verbose: this.verbose,
+			examples: this.examples,
+			endOnFailure: this.endOnFailure,
+			reporter: orUndefined(this.reporter),
+			asyncReporter: orUndefined(this.asyncReporter),
+			errorWithCause: this.errorWithCause
+		};
+		return parameters;
+	}
+	static read(op) {
+		return new QualifiedParameters(op);
+	}
+};
+QualifiedParameters.createQualifiedRandomGenerator = (random) => {
+	return (seed) => {
+		const rng = random(seed);
+		if (rng.unsafeJump === void 0) rng.unsafeJump = () => unsafeSkipN(rng, 42);
+		return rng;
+	};
+};
+QualifiedParameters.readSeed = (p) => {
+	if (p.seed == null) return safeDateNow() ^ safeMathRandom() * 4294967296;
+	const seed32 = p.seed | 0;
+	if (p.seed === seed32) return seed32;
+	const gap = p.seed - seed32;
+	return seed32 ^ gap * 4294967296;
+};
+QualifiedParameters.readRandomType = (p) => {
+	if (p.randomType == null) return pure_rand_default.xorshift128plus;
+	if (typeof p.randomType === "string") switch (p.randomType) {
+		case "mersenne": return QualifiedParameters.createQualifiedRandomGenerator(pure_rand_default.mersenne);
+		case "congruential":
+		case "congruential32": return QualifiedParameters.createQualifiedRandomGenerator(pure_rand_default.congruential32);
+		case "xorshift128plus": return pure_rand_default.xorshift128plus;
+		case "xoroshiro128plus": return pure_rand_default.xoroshiro128plus;
+		default: throw new Error(`Invalid random specified: '${p.randomType}'`);
+	}
+	const mrng = p.randomType(0);
+	if ("min" in mrng && mrng.min !== -2147483648) throw new Error(`Invalid random number generator: min must equal -0x80000000, got ${String(mrng.min)}`);
+	if ("max" in mrng && mrng.max !== 2147483647) throw new Error(`Invalid random number generator: max must equal 0x7fffffff, got ${String(mrng.max)}`);
+	if ("unsafeJump" in mrng) return p.randomType;
+	return QualifiedParameters.createQualifiedRandomGenerator(p.randomType);
+};
+QualifiedParameters.readNumRuns = (p) => {
+	const defaultValue = 100;
+	if (p.numRuns != null) return p.numRuns;
+	if (p.num_runs != null) return p.num_runs;
+	return defaultValue;
+};
+QualifiedParameters.readVerbose = (p) => {
+	if (p.verbose == null) return VerbosityLevel.None;
+	if (typeof p.verbose === "boolean") return p.verbose === true ? VerbosityLevel.Verbose : VerbosityLevel.None;
+	if (p.verbose <= VerbosityLevel.None) return VerbosityLevel.None;
+	if (p.verbose >= VerbosityLevel.VeryVerbose) return VerbosityLevel.VeryVerbose;
+	return p.verbose | 0;
+};
+QualifiedParameters.readBoolean = (p, key) => p[key] === true;
+QualifiedParameters.readOrDefault = (p, key, defaultValue) => {
+	const value = p[key];
+	return value != null ? value : defaultValue;
+};
+QualifiedParameters.safeTimeout = (value) => {
+	if (value === null) return null;
+	return safeMathMin(value, 2147483647);
+};
+
+//#endregion
+export { QualifiedParameters };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/configuration/VerbosityLevel.js

@@ -0,0 +1,14 @@
+
+      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/runner/configuration/VerbosityLevel.js
+var VerbosityLevel;
+(function(VerbosityLevel$1) {
+	VerbosityLevel$1[VerbosityLevel$1["None"] = 0] = "None";
+	VerbosityLevel$1[VerbosityLevel$1["Verbose"] = 1] = "Verbose";
+	VerbosityLevel$1[VerbosityLevel$1["VeryVerbose"] = 2] = "VeryVerbose";
+})(VerbosityLevel || (VerbosityLevel = {}));
+
+//#endregion
+export { VerbosityLevel };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/reporter/ExecutionStatus.js

@@ -0,0 +1,14 @@
+
+      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/runner/reporter/ExecutionStatus.js
+var ExecutionStatus;
+(function(ExecutionStatus$1) {
+	ExecutionStatus$1[ExecutionStatus$1["Success"] = 0] = "Success";
+	ExecutionStatus$1[ExecutionStatus$1["Skipped"] = -1] = "Skipped";
+	ExecutionStatus$1[ExecutionStatus$1["Failure"] = 1] = "Failure";
+})(ExecutionStatus || (ExecutionStatus = {}));
+
+//#endregion
+export { ExecutionStatus };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/reporter/RunExecution.js

@@ -0,0 +1,116 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safeSplit } from "../../../utils/globals.js";
+import { VerbosityLevel } from "../configuration/VerbosityLevel.js";
+import { ExecutionStatus } from "./ExecutionStatus.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/reporter/RunExecution.js
+var RunExecution = class RunExecution {
+	constructor(verbosity, interruptedAsFailure) {
+		this.verbosity = verbosity;
+		this.interruptedAsFailure = interruptedAsFailure;
+		this.isSuccess = () => this.pathToFailure == null;
+		this.firstFailure = () => this.pathToFailure ? +safeSplit(this.pathToFailure, ":")[0] : -1;
+		this.numShrinks = () => this.pathToFailure ? safeSplit(this.pathToFailure, ":").length - 1 : 0;
+		this.rootExecutionTrees = [];
+		this.currentLevelExecutionTrees = this.rootExecutionTrees;
+		this.failure = null;
+		this.numSkips = 0;
+		this.numSuccesses = 0;
+		this.interrupted = false;
+	}
+	appendExecutionTree(status, value) {
+		const currentTree = {
+			status,
+			value,
+			children: []
+		};
+		this.currentLevelExecutionTrees.push(currentTree);
+		return currentTree;
+	}
+	fail(value, id, failure) {
+		if (this.verbosity >= VerbosityLevel.Verbose) {
+			const currentTree = this.appendExecutionTree(ExecutionStatus.Failure, value);
+			this.currentLevelExecutionTrees = currentTree.children;
+		}
+		if (this.pathToFailure == null) this.pathToFailure = `${id}`;
+		else this.pathToFailure += `:${id}`;
+		this.value = value;
+		this.failure = failure;
+	}
+	skip(value) {
+		if (this.verbosity >= VerbosityLevel.VeryVerbose) this.appendExecutionTree(ExecutionStatus.Skipped, value);
+		if (this.pathToFailure == null) ++this.numSkips;
+	}
+	success(value) {
+		if (this.verbosity >= VerbosityLevel.VeryVerbose) this.appendExecutionTree(ExecutionStatus.Success, value);
+		if (this.pathToFailure == null) ++this.numSuccesses;
+	}
+	interrupt() {
+		this.interrupted = true;
+	}
+	extractFailures() {
+		if (this.isSuccess()) return [];
+		const failures = [];
+		let cursor = this.rootExecutionTrees;
+		while (cursor.length > 0 && cursor[cursor.length - 1].status === ExecutionStatus.Failure) {
+			const failureTree = cursor[cursor.length - 1];
+			failures.push(failureTree.value);
+			cursor = failureTree.children;
+		}
+		return failures;
+	}
+	toRunDetails(seed, basePath, maxSkips, qParams) {
+		if (!this.isSuccess()) return {
+			failed: true,
+			interrupted: this.interrupted,
+			numRuns: this.firstFailure() + 1 - this.numSkips,
+			numSkips: this.numSkips,
+			numShrinks: this.numShrinks(),
+			seed,
+			counterexample: this.value,
+			counterexamplePath: RunExecution.mergePaths(basePath, this.pathToFailure),
+			error: this.failure.errorMessage,
+			errorInstance: this.failure.error,
+			failures: this.extractFailures(),
+			executionSummary: this.rootExecutionTrees,
+			verbose: this.verbosity,
+			runConfiguration: qParams.toParameters()
+		};
+		const considerInterruptedAsFailure = this.interruptedAsFailure || this.numSuccesses === 0;
+		const failed = this.numSkips > maxSkips || this.interrupted && considerInterruptedAsFailure;
+		const out = {
+			failed,
+			interrupted: this.interrupted,
+			numRuns: this.numSuccesses,
+			numSkips: this.numSkips,
+			numShrinks: 0,
+			seed,
+			counterexample: null,
+			counterexamplePath: null,
+			error: null,
+			errorInstance: null,
+			failures: [],
+			executionSummary: this.rootExecutionTrees,
+			verbose: this.verbosity,
+			runConfiguration: qParams.toParameters()
+		};
+		return out;
+	}
+};
+RunExecution.mergePaths = (offsetPath, path) => {
+	if (offsetPath.length === 0) return path;
+	const offsetItems = offsetPath.split(":");
+	const remainingItems = path.split(":");
+	const middle = +offsetItems[offsetItems.length - 1] + +remainingItems[0];
+	return [
+		...offsetItems.slice(0, offsetItems.length - 1),
+		`${middle}`,
+		...remainingItems.slice(1)
+	].join(":");
+};
+
+//#endregion
+export { RunExecution };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/utils/PathWalker.js

@@ -0,0 +1,24 @@
+
+      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/runner/utils/PathWalker.js
+function produce(producer) {
+	return producer();
+}
+function pathWalk(path, initialProducers, shrink) {
+	const producers = initialProducers;
+	const segments = path.split(":").map((text) => +text);
+	if (segments.length === 0) return producers.map(produce);
+	if (!segments.every((v) => !Number.isNaN(v))) throw new Error(`Unable to replay, got invalid path=${path}`);
+	let values = producers.drop(segments[0]).map(produce);
+	for (const s of segments.slice(1)) {
+		const valueToShrink = values.getNthOrLast(0);
+		if (valueToShrink === null) throw new Error(`Unable to replay, got wrong path=${path}`);
+		values = shrink(valueToShrink).drop(s);
+	}
+	return values;
+}
+
+//#endregion
+export { pathWalk };