@fedify/fedify 1.6.0-dev.814 → 1.6.0

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/undefined.js

@@ -0,0 +1,24 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/undefined.js
+const undefinedType = {
+	tag: "tag:yaml.org,2002:js/undefined",
+	kind: "scalar",
+	resolve() {
+		return true;
+	},
+	construct() {
+		return void 0;
+	},
+	predicate(object) {
+		return typeof object === "undefined";
+	},
+	represent() {
+		return "";
+	}
+};
+
+//#endregion
+export { undefinedType };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_utils.js

@@ -0,0 +1,17 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_utils.js
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+function isNegativeZero(i) {
+	return i === 0 && Number.NEGATIVE_INFINITY === 1 / i;
+}
+function isPlainObject(object) {
+	return Object.prototype.toString.call(object) === "[object Object]";
+}
+
+//#endregion
+export { isNegativeZero, isObject, isPlainObject };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/mod.js

@@ -0,0 +1,5 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { parse } from "./parse.js";

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/parse.js

@@ -0,0 +1,54 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { isEOL } from "./_chars.js";
+import { SCHEMA_MAP } from "./_schema.js";
+import { LoaderState } from "./_loader_state.js";
+
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/parse.js
+function sanitizeInput(input) {
+	input = String(input);
+	if (input.length > 0) {
+		if (!isEOL(input.charCodeAt(input.length - 1))) input += "\n";
+		if (input.charCodeAt(0) === 65279) input = input.slice(1);
+	}
+	input += "\0";
+	return input;
+}
+/**
+* Parse and return a YAML string as a parsed YAML document object.
+*
+* Note: This does not support functions. Untrusted data is safe to parse.
+*
+* @example Usage
+* ```ts
+* import { parse } from "@std/yaml/parse";
+* import { assertEquals } from "@std/assert";
+*
+* const data = parse(`
+* id: 1
+* name: Alice
+* `);
+*
+* assertEquals(data, { id: 1, name: "Alice" });
+* ```
+*
+* @throws {SyntaxError} Throws error on invalid YAML.
+* @param content YAML string to parse.
+* @param options Parsing options.
+* @returns Parsed document.
+*/ function parse(content, options = {}) {
+	content = sanitizeInput(content);
+	const state = new LoaderState(content, {
+		...options,
+		schema: SCHEMA_MAP.get(options.schema)
+	});
+	const documentGenerator = state.readDocuments();
+	const document = documentGenerator.next().value;
+	if (!documentGenerator.next().done) throw new SyntaxError("Found more than 1 document in the stream: expected a single document");
+	return document ?? null;
+}
+
+//#endregion
+export { parse };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/stringify.js

@@ -0,0 +1,4 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    

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

@@ -0,0 +1,30 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Stream } from "../../stream/Stream.js";
+import { Arbitrary } from "../../check/arbitrary/definition/Arbitrary.js";
+import { UndefinedContextPlaceholder, noUndefinedAsContext } from "./helpers/NoUndefinedAsContext.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/AlwaysShrinkableArbitrary.js
+var AlwaysShrinkableArbitrary = class extends Arbitrary {
+	constructor(arb) {
+		super();
+		this.arb = arb;
+	}
+	generate(mrng, biasFactor) {
+		const value = this.arb.generate(mrng, biasFactor);
+		return noUndefinedAsContext(value);
+	}
+	canShrinkWithoutContext(value) {
+		return true;
+	}
+	shrink(value, context) {
+		if (context === void 0 && !this.arb.canShrinkWithoutContext(value)) return Stream.nil();
+		const safeContext = context !== UndefinedContextPlaceholder ? context : void 0;
+		return this.arb.shrink(value, safeContext).map(noUndefinedAsContext);
+	}
+};
+
+//#endregion
+export { AlwaysShrinkableArbitrary };

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

@@ -0,0 +1,203 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Stream } from "../../stream/Stream.js";
+import { cloneIfNeeded, cloneMethod } from "../../check/symbols.js";
+import { Value } from "../../check/arbitrary/definition/Value.js";
+import { Arbitrary } from "../../check/arbitrary/definition/Arbitrary.js";
+import { safeMap, safePush, safeSlice } from "../../utils/globals.js";
+import { makeLazy } from "../../stream/LazyIterableIterator.js";
+import { integer } from "../integer.js";
+import { getDepthContextFor } from "./helpers/DepthContext.js";
+import { buildSlicedGenerator } from "./helpers/BuildSlicedGenerator.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/ArrayArbitrary.js
+const safeMathFloor = Math.floor;
+const safeMathLog = Math.log;
+const safeMathMax = Math.max;
+const safeArrayIsArray = Array.isArray;
+function biasedMaxLength(minLength, maxLength) {
+	if (minLength === maxLength) return minLength;
+	return minLength + safeMathFloor(safeMathLog(maxLength - minLength) / safeMathLog(2));
+}
+var ArrayArbitrary = class ArrayArbitrary extends Arbitrary {
+	constructor(arb, minLength, maxGeneratedLength, maxLength, depthIdentifier, setBuilder, customSlices) {
+		super();
+		this.arb = arb;
+		this.minLength = minLength;
+		this.maxGeneratedLength = maxGeneratedLength;
+		this.maxLength = maxLength;
+		this.setBuilder = setBuilder;
+		this.customSlices = customSlices;
+		this.lengthArb = integer({
+			min: minLength,
+			max: maxGeneratedLength
+		});
+		this.depthContext = getDepthContextFor(depthIdentifier);
+	}
+	preFilter(tab) {
+		if (this.setBuilder === void 0) return tab;
+		const s = this.setBuilder();
+		for (let index = 0; index !== tab.length; ++index) s.tryAdd(tab[index]);
+		return s.getData();
+	}
+	static makeItCloneable(vs, shrinkables) {
+		vs[cloneMethod] = () => {
+			const cloned = [];
+			for (let idx = 0; idx !== shrinkables.length; ++idx) safePush(cloned, shrinkables[idx].value);
+			this.makeItCloneable(cloned, shrinkables);
+			return cloned;
+		};
+		return vs;
+	}
+	generateNItemsNoDuplicates(setBuilder, N, mrng, biasFactorItems) {
+		let numSkippedInRow = 0;
+		const s = setBuilder();
+		const slicedGenerator = buildSlicedGenerator(this.arb, mrng, this.customSlices, biasFactorItems);
+		while (s.size() < N && numSkippedInRow < this.maxGeneratedLength) {
+			const current = slicedGenerator.next();
+			if (s.tryAdd(current)) numSkippedInRow = 0;
+			else numSkippedInRow += 1;
+		}
+		return s.getData();
+	}
+	safeGenerateNItemsNoDuplicates(setBuilder, N, mrng, biasFactorItems) {
+		const depthImpact = safeMathMax(0, N - biasedMaxLength(this.minLength, this.maxGeneratedLength));
+		this.depthContext.depth += depthImpact;
+		try {
+			return this.generateNItemsNoDuplicates(setBuilder, N, mrng, biasFactorItems);
+		} finally {
+			this.depthContext.depth -= depthImpact;
+		}
+	}
+	generateNItems(N, mrng, biasFactorItems) {
+		const items = [];
+		const slicedGenerator = buildSlicedGenerator(this.arb, mrng, this.customSlices, biasFactorItems);
+		slicedGenerator.attemptExact(N);
+		for (let index = 0; index !== N; ++index) {
+			const current = slicedGenerator.next();
+			safePush(items, current);
+		}
+		return items;
+	}
+	safeGenerateNItems(N, mrng, biasFactorItems) {
+		const depthImpact = safeMathMax(0, N - biasedMaxLength(this.minLength, this.maxGeneratedLength));
+		this.depthContext.depth += depthImpact;
+		try {
+			return this.generateNItems(N, mrng, biasFactorItems);
+		} finally {
+			this.depthContext.depth -= depthImpact;
+		}
+	}
+	wrapper(itemsRaw, shrunkOnce, itemsRawLengthContext, startIndex) {
+		const items = shrunkOnce ? this.preFilter(itemsRaw) : itemsRaw;
+		let cloneable = false;
+		const vs = [];
+		const itemsContexts = [];
+		for (let idx = 0; idx !== items.length; ++idx) {
+			const s = items[idx];
+			cloneable = cloneable || s.hasToBeCloned;
+			safePush(vs, s.value);
+			safePush(itemsContexts, s.context);
+		}
+		if (cloneable) ArrayArbitrary.makeItCloneable(vs, items);
+		const context = {
+			shrunkOnce,
+			lengthContext: itemsRaw.length === items.length && itemsRawLengthContext !== void 0 ? itemsRawLengthContext : void 0,
+			itemsContexts,
+			startIndex
+		};
+		return new Value(vs, context);
+	}
+	generate(mrng, biasFactor) {
+		const biasMeta = this.applyBias(mrng, biasFactor);
+		const targetSize = biasMeta.size;
+		const items = this.setBuilder !== void 0 ? this.safeGenerateNItemsNoDuplicates(this.setBuilder, targetSize, mrng, biasMeta.biasFactorItems) : this.safeGenerateNItems(targetSize, mrng, biasMeta.biasFactorItems);
+		return this.wrapper(items, false, void 0, 0);
+	}
+	applyBias(mrng, biasFactor) {
+		if (biasFactor === void 0) return { size: this.lengthArb.generate(mrng, void 0).value };
+		if (this.minLength === this.maxGeneratedLength) return {
+			size: this.lengthArb.generate(mrng, void 0).value,
+			biasFactorItems: biasFactor
+		};
+		if (mrng.nextInt(1, biasFactor) !== 1) return { size: this.lengthArb.generate(mrng, void 0).value };
+		if (mrng.nextInt(1, biasFactor) !== 1 || this.minLength === this.maxGeneratedLength) return {
+			size: this.lengthArb.generate(mrng, void 0).value,
+			biasFactorItems: biasFactor
+		};
+		const maxBiasedLength = biasedMaxLength(this.minLength, this.maxGeneratedLength);
+		const targetSizeValue = integer({
+			min: this.minLength,
+			max: maxBiasedLength
+		}).generate(mrng, void 0);
+		return {
+			size: targetSizeValue.value,
+			biasFactorItems: biasFactor
+		};
+	}
+	canShrinkWithoutContext(value) {
+		if (!safeArrayIsArray(value) || this.minLength > value.length || value.length > this.maxLength) return false;
+		for (let index = 0; index !== value.length; ++index) {
+			if (!(index in value)) return false;
+			if (!this.arb.canShrinkWithoutContext(value[index])) return false;
+		}
+		const filtered = this.preFilter(safeMap(value, (item) => new Value(item, void 0)));
+		return filtered.length === value.length;
+	}
+	shrinkItemByItem(value, safeContext, endIndex) {
+		const shrinks = [];
+		for (let index = safeContext.startIndex; index < endIndex; ++index) safePush(shrinks, makeLazy(() => this.arb.shrink(value[index], safeContext.itemsContexts[index]).map((v) => {
+			const beforeCurrent = safeMap(safeSlice(value, 0, index), (v$1, i) => new Value(cloneIfNeeded(v$1), safeContext.itemsContexts[i]));
+			const afterCurrent = safeMap(safeSlice(value, index + 1), (v$1, i) => new Value(cloneIfNeeded(v$1), safeContext.itemsContexts[i + index + 1]));
+			return [
+				[
+					...beforeCurrent,
+					v,
+					...afterCurrent
+				],
+				void 0,
+				index
+			];
+		})));
+		return Stream.nil().join(...shrinks);
+	}
+	shrinkImpl(value, context) {
+		if (value.length === 0) return Stream.nil();
+		const safeContext = context !== void 0 ? context : {
+			shrunkOnce: false,
+			lengthContext: void 0,
+			itemsContexts: [],
+			startIndex: 0
+		};
+		return this.lengthArb.shrink(value.length, safeContext.lengthContext).drop(safeContext.shrunkOnce && safeContext.lengthContext === void 0 && value.length > this.minLength + 1 ? 1 : 0).map((lengthValue) => {
+			const sliceStart = value.length - lengthValue.value;
+			return [
+				safeMap(safeSlice(value, sliceStart), (v, index) => new Value(cloneIfNeeded(v), safeContext.itemsContexts[index + sliceStart])),
+				lengthValue.context,
+				0
+			];
+		}).join(makeLazy(() => value.length > this.minLength ? this.shrinkItemByItem(value, safeContext, 1) : this.shrinkItemByItem(value, safeContext, value.length))).join(value.length > this.minLength ? makeLazy(() => {
+			const subContext = {
+				shrunkOnce: false,
+				lengthContext: void 0,
+				itemsContexts: safeSlice(safeContext.itemsContexts, 1),
+				startIndex: 0
+			};
+			return this.shrinkImpl(safeSlice(value, 1), subContext).filter((v) => this.minLength <= v[0].length + 1).map((v) => {
+				return [
+					[new Value(cloneIfNeeded(value[0]), safeContext.itemsContexts[0]), ...v[0]],
+					void 0,
+					0
+				];
+			});
+		}) : Stream.nil());
+	}
+	shrink(value, context) {
+		return this.shrinkImpl(value, context).map((contextualValue) => this.wrapper(contextualValue[0], true, contextualValue[1], contextualValue[2]));
+	}
+};
+
+//#endregion
+export { ArrayArbitrary };

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

@@ -0,0 +1,122 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Stream, stream } from "../../stream/Stream.js";
+import { Value } from "../../check/arbitrary/definition/Value.js";
+import { Arbitrary } from "../../check/arbitrary/definition/Arbitrary.js";
+import { Unit64, Zero64, add64, halve64, isEqual64, isStrictlyNegative64, isStrictlyPositive64, isStrictlySmaller64, isZero64, logLike64, substract64 } from "./helpers/ArrayInt64.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/ArrayInt64Arbitrary.js
+var ArrayInt64Arbitrary = class ArrayInt64Arbitrary extends Arbitrary {
+	constructor(min, max) {
+		super();
+		this.min = min;
+		this.max = max;
+		this.biasedRanges = null;
+	}
+	generate(mrng, biasFactor) {
+		const range = this.computeGenerateRange(mrng, biasFactor);
+		const uncheckedValue = mrng.nextArrayInt(range.min, range.max);
+		if (uncheckedValue.data.length === 1) uncheckedValue.data.unshift(0);
+		return new Value(uncheckedValue, void 0);
+	}
+	computeGenerateRange(mrng, biasFactor) {
+		if (biasFactor === void 0 || mrng.nextInt(1, biasFactor) !== 1) return {
+			min: this.min,
+			max: this.max
+		};
+		const ranges = this.retrieveBiasedRanges();
+		if (ranges.length === 1) return ranges[0];
+		const id = mrng.nextInt(-2 * (ranges.length - 1), ranges.length - 2);
+		return id < 0 ? ranges[0] : ranges[id + 1];
+	}
+	canShrinkWithoutContext(value) {
+		const unsafeValue = value;
+		return typeof value === "object" && value !== null && (unsafeValue.sign === -1 || unsafeValue.sign === 1) && Array.isArray(unsafeValue.data) && unsafeValue.data.length === 2 && (isStrictlySmaller64(this.min, unsafeValue) && isStrictlySmaller64(unsafeValue, this.max) || isEqual64(this.min, unsafeValue) || isEqual64(this.max, unsafeValue));
+	}
+	shrinkArrayInt64(value, target, tryTargetAsap) {
+		const realGap = substract64(value, target);
+		function* shrinkGen() {
+			let previous = tryTargetAsap ? void 0 : target;
+			const gap = tryTargetAsap ? realGap : halve64(realGap);
+			for (let toremove = gap; !isZero64(toremove); toremove = halve64(toremove)) {
+				const next = substract64(value, toremove);
+				yield new Value(next, previous);
+				previous = next;
+			}
+		}
+		return stream(shrinkGen());
+	}
+	shrink(current, context) {
+		if (!ArrayInt64Arbitrary.isValidContext(current, context)) {
+			const target = this.defaultTarget();
+			return this.shrinkArrayInt64(current, target, true);
+		}
+		if (this.isLastChanceTry(current, context)) return Stream.of(new Value(context, void 0));
+		return this.shrinkArrayInt64(current, context, false);
+	}
+	defaultTarget() {
+		if (!isStrictlyPositive64(this.min) && !isStrictlyNegative64(this.max)) return Zero64;
+		return isStrictlyNegative64(this.min) ? this.max : this.min;
+	}
+	isLastChanceTry(current, context) {
+		if (isZero64(current)) return false;
+		if (current.sign === 1) return isEqual64(current, add64(context, Unit64)) && isStrictlyPositive64(substract64(current, this.min));
+		else return isEqual64(current, substract64(context, Unit64)) && isStrictlyNegative64(substract64(current, this.max));
+	}
+	static isValidContext(_current, context) {
+		if (context === void 0) return false;
+		if (typeof context !== "object" || context === null || !("sign" in context) || !("data" in context)) throw new Error(`Invalid context type passed to ArrayInt64Arbitrary (#1)`);
+		return true;
+	}
+	retrieveBiasedRanges() {
+		if (this.biasedRanges != null) return this.biasedRanges;
+		if (isEqual64(this.min, this.max)) {
+			this.biasedRanges = [{
+				min: this.min,
+				max: this.max
+			}];
+			return this.biasedRanges;
+		}
+		const minStrictlySmallerZero = isStrictlyNegative64(this.min);
+		const maxStrictlyGreaterZero = isStrictlyPositive64(this.max);
+		if (minStrictlySmallerZero && maxStrictlyGreaterZero) {
+			const logMin = logLike64(this.min);
+			const logMax = logLike64(this.max);
+			this.biasedRanges = [
+				{
+					min: logMin,
+					max: logMax
+				},
+				{
+					min: substract64(this.max, logMax),
+					max: this.max
+				},
+				{
+					min: this.min,
+					max: substract64(this.min, logMin)
+				}
+			];
+		} else {
+			const logGap = logLike64(substract64(this.max, this.min));
+			const arbCloseToMin = {
+				min: this.min,
+				max: add64(this.min, logGap)
+			};
+			const arbCloseToMax = {
+				min: substract64(this.max, logGap),
+				max: this.max
+			};
+			this.biasedRanges = minStrictlySmallerZero ? [arbCloseToMax, arbCloseToMin] : [arbCloseToMin, arbCloseToMax];
+		}
+		return this.biasedRanges;
+	}
+};
+function arrayInt64(min, max) {
+	const arb = new ArrayInt64Arbitrary(min, max);
+	return arb;
+}
+
+//#endregion
+export { arrayInt64 };

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

@@ -0,0 +1,63 @@
+
+      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 { Arbitrary } from "../../check/arbitrary/definition/Arbitrary.js";
+import { SBigInt } from "../../utils/globals.js";
+import { biasNumericRange, bigIntLogLike } from "./helpers/BiasNumericRange.js";
+import { shrinkBigInt } from "./helpers/ShrinkBigInt.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/BigIntArbitrary.js
+var BigIntArbitrary = class BigIntArbitrary extends Arbitrary {
+	constructor(min, max) {
+		super();
+		this.min = min;
+		this.max = max;
+	}
+	generate(mrng, biasFactor) {
+		const range = this.computeGenerateRange(mrng, biasFactor);
+		return new Value(mrng.nextBigInt(range.min, range.max), void 0);
+	}
+	computeGenerateRange(mrng, biasFactor) {
+		if (biasFactor === void 0 || mrng.nextInt(1, biasFactor) !== 1) return {
+			min: this.min,
+			max: this.max
+		};
+		const ranges = biasNumericRange(this.min, this.max, bigIntLogLike);
+		if (ranges.length === 1) return ranges[0];
+		const id = mrng.nextInt(-2 * (ranges.length - 1), ranges.length - 2);
+		return id < 0 ? ranges[0] : ranges[id + 1];
+	}
+	canShrinkWithoutContext(value) {
+		return typeof value === "bigint" && this.min <= value && value <= this.max;
+	}
+	shrink(current, context) {
+		if (!BigIntArbitrary.isValidContext(current, context)) {
+			const target = this.defaultTarget();
+			return shrinkBigInt(current, target, true);
+		}
+		if (this.isLastChanceTry(current, context)) return Stream.of(new Value(context, void 0));
+		return shrinkBigInt(current, context, false);
+	}
+	defaultTarget() {
+		if (this.min <= 0 && this.max >= 0) return SBigInt(0);
+		return this.min < 0 ? this.max : this.min;
+	}
+	isLastChanceTry(current, context) {
+		if (current > 0) return current === context + SBigInt(1) && current > this.min;
+		if (current < 0) return current === context - SBigInt(1) && current < this.max;
+		return false;
+	}
+	static isValidContext(current, context) {
+		if (context === void 0) return false;
+		if (typeof context !== "bigint") throw new Error(`Invalid context type passed to BigIntArbitrary (#1)`);
+		const differentSigns = current > 0 && context < 0 || current < 0 && context > 0;
+		if (context !== SBigInt(0) && differentSigns) throw new Error(`Invalid context value passed to BigIntArbitrary (#2)`);
+		return true;
+	}
+};
+
+//#endregion
+export { BigIntArbitrary };

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

@@ -0,0 +1,58 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Stream } from "../../stream/Stream.js";
+import { cloneMethod, hasCloneMethod } from "../../check/symbols.js";
+import { Value } from "../../check/arbitrary/definition/Value.js";
+import { Arbitrary } from "../../check/arbitrary/definition/Arbitrary.js";
+import { SSet, safeHas } from "../../utils/globals.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/_internals/ConstantArbitrary.js
+const safeObjectIs = Object.is;
+var ConstantArbitrary = class extends Arbitrary {
+	constructor(values) {
+		super();
+		this.values = values;
+	}
+	generate(mrng, _biasFactor) {
+		const idx = this.values.length === 1 ? 0 : mrng.nextInt(0, this.values.length - 1);
+		const value = this.values[idx];
+		if (!hasCloneMethod(value)) return new Value(value, idx);
+		return new Value(value, idx, () => value[cloneMethod]());
+	}
+	canShrinkWithoutContext(value) {
+		if (this.values.length === 1) return safeObjectIs(this.values[0], value);
+		if (this.fastValues === void 0) this.fastValues = new FastConstantValuesLookup(this.values);
+		return this.fastValues.has(value);
+	}
+	shrink(value, context) {
+		if (context === 0 || safeObjectIs(value, this.values[0])) return Stream.nil();
+		return Stream.of(new Value(this.values[0], 0));
+	}
+};
+var FastConstantValuesLookup = class {
+	constructor(values) {
+		this.values = values;
+		this.fastValues = new SSet(this.values);
+		let hasMinusZero = false;
+		let hasPlusZero = false;
+		if (safeHas(this.fastValues, 0)) for (let idx = 0; idx !== this.values.length; ++idx) {
+			const value = this.values[idx];
+			hasMinusZero = hasMinusZero || safeObjectIs(value, -0);
+			hasPlusZero = hasPlusZero || safeObjectIs(value, 0);
+		}
+		this.hasMinusZero = hasMinusZero;
+		this.hasPlusZero = hasPlusZero;
+	}
+	has(value) {
+		if (value === 0) {
+			if (safeObjectIs(value, 0)) return this.hasPlusZero;
+			return this.hasMinusZero;
+		}
+		return safeHas(this.fastValues, value);
+	}
+};
+
+//#endregion
+export { ConstantArbitrary };