kuvio
Version:
Create string patterns and derive things from them, such as regexes
1,453 lines (1,419 loc) • 113 kB
JavaScript
"use strict";
(() => {
var __defProp = Object.defineProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/check/precondition/PreconditionFailure.js
var PreconditionFailure = class extends Error {
constructor(interruptExecution = false) {
super();
this.interruptExecution = interruptExecution;
this.footprint = PreconditionFailure.SharedFootPrint;
}
static isFailure(err) {
return err != null && err.footprint === PreconditionFailure.SharedFootPrint;
}
};
PreconditionFailure.SharedFootPrint = Symbol("fast-check/PreconditionFailure");
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/stream/StreamHelpers.js
var Nil = class {
[Symbol.iterator]() {
return this;
}
next(value) {
return { value, done: true };
}
};
Nil.nil = new Nil();
function nilHelper() {
return Nil.nil;
}
function* mapHelper(g, f) {
for (const v of g) {
yield f(v);
}
}
function* flatMapHelper(g, f) {
for (const v of g) {
yield* f(v);
}
}
function* filterHelper(g, f) {
for (const v of g) {
if (f(v)) {
yield v;
}
}
}
function* takeNHelper(g, n) {
for (let i = 0; i < n; ++i) {
const cur = g.next();
if (cur.done) {
break;
}
yield cur.value;
}
}
function* takeWhileHelper(g, f) {
let cur = g.next();
while (!cur.done && f(cur.value)) {
yield cur.value;
cur = g.next();
}
}
function* joinHelper(g, others) {
for (let cur = g.next(); !cur.done; cur = g.next()) {
yield cur.value;
}
for (const s of others) {
for (let cur = s.next(); !cur.done; cur = s.next()) {
yield cur.value;
}
}
}
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/stream/Stream.js
var safeSymbolIterator = Symbol.iterator;
var Stream = class {
static nil() {
return new Stream(nilHelper());
}
static of(...elements) {
return new Stream(elements[safeSymbolIterator]());
}
constructor(g) {
this.g = g;
}
next() {
return this.g.next();
}
[safeSymbolIterator]() {
return this.g;
}
map(f) {
return new Stream(mapHelper(this.g, f));
}
flatMap(f) {
return new Stream(flatMapHelper(this.g, f));
}
dropWhile(f) {
let foundEligible = false;
function* helper(v) {
if (foundEligible || !f(v)) {
foundEligible = true;
yield v;
}
}
return this.flatMap(helper);
}
drop(n) {
if (n <= 0) {
return this;
}
let idx = 0;
function helper() {
return idx++ < n;
}
return this.dropWhile(helper);
}
takeWhile(f) {
return new Stream(takeWhileHelper(this.g, f));
}
take(n) {
return new Stream(takeNHelper(this.g, n));
}
filter(f) {
return new Stream(filterHelper(this.g, f));
}
every(f) {
for (const v of this.g) {
if (!f(v)) {
return false;
}
}
return true;
}
has(f) {
for (const v of this.g) {
if (f(v)) {
return [true, v];
}
}
return [false, null];
}
join(...others) {
return new Stream(joinHelper(this.g, others));
}
getNthOrLast(nth) {
let remaining = nth;
let last = null;
for (const v of this.g) {
if (remaining-- === 0)
return v;
last = v;
}
return last;
}
};
function stream(g) {
return new Stream(g);
}
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/check/symbols.js
var cloneMethod = Symbol("fast-check/cloneMethod");
function hasCloneMethod(instance) {
return instance !== null && (typeof instance === "object" || typeof instance === "function") && cloneMethod in instance && typeof instance[cloneMethod] === "function";
}
function cloneIfNeeded(instance) {
return hasCloneMethod(instance) ? instance[cloneMethod]() : instance;
}
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/check/arbitrary/definition/Value.js
var safeObjectDefineProperty = Object.defineProperty;
var Value = class {
constructor(value_, context2, customGetValue = void 0) {
this.value_ = value_;
this.context = context2;
this.hasToBeCloned = customGetValue !== void 0 || hasCloneMethod(value_);
this.readOnce = false;
if (this.hasToBeCloned) {
safeObjectDefineProperty(this, "value", { get: customGetValue !== void 0 ? customGetValue : this.getValue });
} else {
this.value = value_;
}
}
getValue() {
if (this.hasToBeCloned) {
if (!this.readOnce) {
this.readOnce = true;
return this.value_;
}
return this.value_[cloneMethod]();
}
return this.value_;
}
};
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/check/arbitrary/definition/Arbitrary.js
var safeObjectAssign = Object.assign;
var Arbitrary = class {
filter(refinement) {
return new FilterArbitrary(this, refinement);
}
map(mapper, unmapper) {
return new MapArbitrary(this, mapper, unmapper);
}
chain(chainer) {
return new ChainArbitrary(this, chainer);
}
noShrink() {
return new NoShrinkArbitrary(this);
}
noBias() {
return new NoBiasArbitrary(this);
}
};
var ChainArbitrary = class extends Arbitrary {
constructor(arb, chainer) {
super();
this.arb = arb;
this.chainer = chainer;
}
generate(mrng, biasFactor) {
const clonedMrng = mrng.clone();
const src = this.arb.generate(mrng, biasFactor);
return this.valueChainer(src, mrng, clonedMrng, biasFactor);
}
canShrinkWithoutContext(value) {
return false;
}
shrink(value, context2) {
if (this.isSafeContext(context2)) {
return (!context2.stoppedForOriginal ? this.arb.shrink(context2.originalValue, context2.originalContext).map((v) => this.valueChainer(v, context2.clonedMrng.clone(), context2.clonedMrng, context2.originalBias)) : Stream.nil()).join(context2.chainedArbitrary.shrink(value, context2.chainedContext).map((dst) => {
const newContext = safeObjectAssign(safeObjectAssign({}, context2), {
chainedContext: dst.context,
stoppedForOriginal: true
});
return new Value(dst.value_, newContext);
}));
}
return Stream.nil();
}
valueChainer(v, generateMrng, clonedMrng, biasFactor) {
const chainedArbitrary = this.chainer(v.value_);
const dst = chainedArbitrary.generate(generateMrng, biasFactor);
const context2 = {
originalBias: biasFactor,
originalValue: v.value_,
originalContext: v.context,
stoppedForOriginal: false,
chainedArbitrary,
chainedContext: dst.context,
clonedMrng
};
return new Value(dst.value_, context2);
}
isSafeContext(context2) {
return context2 != null && typeof context2 === "object" && "originalBias" in context2 && "originalValue" in context2 && "originalContext" in context2 && "stoppedForOriginal" in context2 && "chainedArbitrary" in context2 && "chainedContext" in context2 && "clonedMrng" in context2;
}
};
var MapArbitrary = class extends Arbitrary {
constructor(arb, mapper, unmapper) {
super();
this.arb = arb;
this.mapper = mapper;
this.unmapper = unmapper;
this.bindValueMapper = (v) => this.valueMapper(v);
}
generate(mrng, biasFactor) {
const g = this.arb.generate(mrng, biasFactor);
return this.valueMapper(g);
}
canShrinkWithoutContext(value) {
if (this.unmapper !== void 0) {
try {
const unmapped = this.unmapper(value);
return this.arb.canShrinkWithoutContext(unmapped);
} catch (_err) {
return false;
}
}
return false;
}
shrink(value, context2) {
if (this.isSafeContext(context2)) {
return this.arb.shrink(context2.originalValue, context2.originalContext).map(this.bindValueMapper);
}
if (this.unmapper !== void 0) {
const unmapped = this.unmapper(value);
return this.arb.shrink(unmapped, void 0).map(this.bindValueMapper);
}
return Stream.nil();
}
mapperWithCloneIfNeeded(v) {
const sourceValue = v.value;
const mappedValue = this.mapper(sourceValue);
if (v.hasToBeCloned && (typeof mappedValue === "object" && mappedValue !== null || typeof mappedValue === "function") && Object.isExtensible(mappedValue) && !hasCloneMethod(mappedValue)) {
Object.defineProperty(mappedValue, cloneMethod, { get: () => () => this.mapperWithCloneIfNeeded(v)[0] });
}
return [mappedValue, sourceValue];
}
valueMapper(v) {
const [mappedValue, sourceValue] = this.mapperWithCloneIfNeeded(v);
const context2 = { originalValue: sourceValue, originalContext: v.context };
return new Value(mappedValue, context2);
}
isSafeContext(context2) {
return context2 != null && typeof context2 === "object" && "originalValue" in context2 && "originalContext" in context2;
}
};
var FilterArbitrary = class extends Arbitrary {
constructor(arb, refinement) {
super();
this.arb = arb;
this.refinement = refinement;
this.bindRefinementOnValue = (v) => this.refinementOnValue(v);
}
generate(mrng, biasFactor) {
while (true) {
const g = this.arb.generate(mrng, biasFactor);
if (this.refinementOnValue(g)) {
return g;
}
}
}
canShrinkWithoutContext(value) {
return this.arb.canShrinkWithoutContext(value) && this.refinement(value);
}
shrink(value, context2) {
return this.arb.shrink(value, context2).filter(this.bindRefinementOnValue);
}
refinementOnValue(v) {
return this.refinement(v.value);
}
};
var NoShrinkArbitrary = class extends Arbitrary {
constructor(arb) {
super();
this.arb = arb;
}
generate(mrng, biasFactor) {
return this.arb.generate(mrng, biasFactor);
}
canShrinkWithoutContext(value) {
return this.arb.canShrinkWithoutContext(value);
}
shrink(_value, _context) {
return Stream.nil();
}
noShrink() {
return this;
}
};
var NoBiasArbitrary = class extends Arbitrary {
constructor(arb) {
super();
this.arb = arb;
}
generate(mrng, _biasFactor) {
return this.arb.generate(mrng, void 0);
}
canShrinkWithoutContext(value) {
return this.arb.canShrinkWithoutContext(value);
}
shrink(value, context2) {
return this.arb.shrink(value, context2);
}
noBias() {
return this;
}
};
function isArbitrary(instance) {
return typeof instance === "object" && instance !== null && "generate" in instance && "shrink" in instance && "canShrinkWithoutContext" in instance;
}
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/utils/apply.js
var untouchedApply = Function.prototype.apply;
var ApplySymbol = Symbol("apply");
function safeExtractApply(f) {
try {
return f.apply;
} catch (err) {
return void 0;
}
}
function safeApplyHacky(f, instance, args) {
const ff = f;
ff[ApplySymbol] = untouchedApply;
const out = ff[ApplySymbol](instance, args);
delete ff[ApplySymbol];
return out;
}
function safeApply(f, instance, args) {
if (safeExtractApply(f) === untouchedApply) {
return f.apply(instance, args);
}
return safeApplyHacky(f, instance, args);
}
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/utils/globals.js
var SArray = typeof Array !== "undefined" ? Array : void 0;
var SError = typeof Error !== "undefined" ? Error : void 0;
var SString = typeof String !== "undefined" ? String : void 0;
var SencodeURIComponent = typeof encodeURIComponent !== "undefined" ? encodeURIComponent : void 0;
var untouchedForEach = Array.prototype.forEach;
var untouchedIndexOf = Array.prototype.indexOf;
var untouchedJoin = Array.prototype.join;
var untouchedMap = Array.prototype.map;
var untouchedFilter = Array.prototype.filter;
var untouchedPush = Array.prototype.push;
var untouchedPop = Array.prototype.pop;
var untouchedSplice = Array.prototype.splice;
var untouchedSlice = Array.prototype.slice;
var untouchedSort = Array.prototype.sort;
function extractIndexOf(instance) {
try {
return instance.indexOf;
} catch (err) {
return void 0;
}
}
function extractJoin(instance) {
try {
return instance.join;
} catch (err) {
return void 0;
}
}
function extractMap(instance) {
try {
return instance.map;
} catch (err) {
return void 0;
}
}
function extractFilter(instance) {
try {
return instance.filter;
} catch (err) {
return void 0;
}
}
function extractPush(instance) {
try {
return instance.push;
} catch (err) {
return void 0;
}
}
function extractSlice(instance) {
try {
return instance.slice;
} catch (err) {
return void 0;
}
}
function safeIndexOf(instance, ...args) {
if (extractIndexOf(instance) === untouchedIndexOf) {
return instance.indexOf(...args);
}
return safeApply(untouchedIndexOf, instance, args);
}
function safeJoin(instance, ...args) {
if (extractJoin(instance) === untouchedJoin) {
return instance.join(...args);
}
return safeApply(untouchedJoin, instance, args);
}
function safeMap(instance, fn) {
if (extractMap(instance) === untouchedMap) {
return instance.map(fn);
}
return safeApply(untouchedMap, instance, [fn]);
}
function safeFilter(instance, predicate) {
if (extractFilter(instance) === untouchedFilter) {
return instance.filter(predicate);
}
return safeApply(untouchedFilter, instance, [predicate]);
}
function safePush(instance, ...args) {
if (extractPush(instance) === untouchedPush) {
return instance.push(...args);
}
return safeApply(untouchedPush, instance, args);
}
function safeSlice(instance, ...args) {
if (extractSlice(instance) === untouchedSlice) {
return instance.slice(...args);
}
return safeApply(untouchedSlice, instance, args);
}
var untouchedGetTime = Date.prototype.getTime;
var untouchedToISOString = Date.prototype.toISOString;
function extractGetTime(instance) {
try {
return instance.getTime;
} catch (err) {
return void 0;
}
}
function extractToISOString(instance) {
try {
return instance.toISOString;
} catch (err) {
return void 0;
}
}
function safeGetTime(instance) {
if (extractGetTime(instance) === untouchedGetTime) {
return instance.getTime();
}
return safeApply(untouchedGetTime, instance, []);
}
function safeToISOString(instance) {
if (extractToISOString(instance) === untouchedToISOString) {
return instance.toISOString();
}
return safeApply(untouchedToISOString, instance, []);
}
var untouchedAdd = Set.prototype.add;
var untouchedSplit = String.prototype.split;
var untouchedStartsWith = String.prototype.startsWith;
var untouchedEndsWith = String.prototype.endsWith;
var untouchedSubstring = String.prototype.substring;
var untouchedToLowerCase = String.prototype.toLowerCase;
var untouchedToUpperCase = String.prototype.toUpperCase;
var untouchedPadStart = String.prototype.padStart;
var untouchedCharCodeAt = String.prototype.charCodeAt;
var untouchedReplace = String.prototype.replace;
function extractSplit(instance) {
try {
return instance.split;
} catch (err) {
return void 0;
}
}
function extractCharCodeAt(instance) {
try {
return instance.charCodeAt;
} catch (err) {
return void 0;
}
}
function safeSplit(instance, ...args) {
if (extractSplit(instance) === untouchedSplit) {
return instance.split(...args);
}
return safeApply(untouchedSplit, instance, args);
}
function safeCharCodeAt(instance, index) {
if (extractCharCodeAt(instance) === untouchedCharCodeAt) {
return instance.charCodeAt(index);
}
return safeApply(untouchedCharCodeAt, instance, [index]);
}
var untouchedNumberToString = Number.prototype.toString;
function extractNumberToString(instance) {
try {
return instance.toString;
} catch (err) {
return void 0;
}
}
function safeNumberToString(instance, ...args) {
if (extractNumberToString(instance) === untouchedNumberToString) {
return instance.toString(...args);
}
return safeApply(untouchedNumberToString, instance, args);
}
var untouchedToString = Object.prototype.toString;
function safeToString(instance) {
return safeApply(untouchedToString, instance, []);
}
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/stream/LazyIterableIterator.js
var LazyIterableIterator = class {
constructor(producer) {
this.producer = producer;
}
[Symbol.iterator]() {
if (this.it === void 0) {
this.it = this.producer();
}
return this.it;
}
next() {
if (this.it === void 0) {
this.it = this.producer();
}
return this.it.next();
}
};
function makeLazy(producer) {
return new LazyIterableIterator(producer);
}
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/arbitrary/_internals/TupleArbitrary.js
var safeArrayIsArray = Array.isArray;
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/check/property/IRawProperty.js
var safeMathLog = Math.log;
function runIdToFrequency(runId) {
return 2 + ~~(safeMathLog(runId + 1) * 0.4342944819032518);
}
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/check/runner/configuration/GlobalParameters.js
var globalParameters = {};
function readConfigureGlobal() {
return globalParameters;
}
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/arbitrary/_internals/helpers/NoUndefinedAsContext.js
var 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);
}
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/check/property/AsyncProperty.generic.js
var AsyncProperty = class {
constructor(arb, predicate) {
this.arb = arb;
this.predicate = predicate;
const { asyncBeforeEach, asyncAfterEach, beforeEach, afterEach } = readConfigureGlobal() || {};
if (asyncBeforeEach !== void 0 && beforeEach !== void 0) {
throw SError(`Global "asyncBeforeEach" and "beforeEach" parameters can't be set at the same time when running async properties`);
}
if (asyncAfterEach !== void 0 && afterEach !== void 0) {
throw SError(`Global "asyncAfterEach" and "afterEach" parameters can't be set at the same time when running async properties`);
}
this.beforeEachHook = asyncBeforeEach || beforeEach || AsyncProperty.dummyHook;
this.afterEachHook = asyncAfterEach || afterEach || AsyncProperty.dummyHook;
}
isAsync() {
return true;
}
generate(mrng, runId) {
const value = this.arb.generate(mrng, runId != null ? runIdToFrequency(runId) : void 0);
return noUndefinedAsContext(value);
}
shrink(value) {
if (value.context === void 0 && !this.arb.canShrinkWithoutContext(value.value_)) {
return Stream.nil();
}
const safeContext = value.context !== UndefinedContextPlaceholder ? value.context : void 0;
return this.arb.shrink(value.value_, safeContext).map(noUndefinedAsContext);
}
async runBeforeEach() {
await this.beforeEachHook();
}
async runAfterEach() {
await this.afterEachHook();
}
async run(v, dontRunHook) {
if (!dontRunHook) {
await this.beforeEachHook();
}
try {
const output = await this.predicate(v);
return output == null || output === true ? null : {
error: new SError("Property failed by returning false"),
errorMessage: "Error: Property failed by returning false"
};
} catch (err) {
if (PreconditionFailure.isFailure(err))
return err;
if (err instanceof SError && err.stack) {
return { error: err, errorMessage: err.stack };
}
return { error: err, errorMessage: SString(err) };
} finally {
if (!dontRunHook) {
await this.afterEachHook();
}
}
}
beforeEach(hookFunction) {
const previousBeforeEachHook = this.beforeEachHook;
this.beforeEachHook = () => hookFunction(previousBeforeEachHook);
return this;
}
afterEach(hookFunction) {
const previousAfterEachHook = this.afterEachHook;
this.afterEachHook = () => hookFunction(previousAfterEachHook);
return this;
}
};
AsyncProperty.dummyHook = () => {
};
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/check/property/Property.generic.js
var Property = class {
constructor(arb, predicate) {
this.arb = arb;
this.predicate = predicate;
const { beforeEach = Property.dummyHook, afterEach = Property.dummyHook, asyncBeforeEach, asyncAfterEach } = readConfigureGlobal() || {};
if (asyncBeforeEach !== void 0) {
throw SError(`"asyncBeforeEach" can't be set when running synchronous properties`);
}
if (asyncAfterEach !== void 0) {
throw SError(`"asyncAfterEach" can't be set when running synchronous properties`);
}
this.beforeEachHook = beforeEach;
this.afterEachHook = afterEach;
}
isAsync() {
return false;
}
generate(mrng, runId) {
const value = this.arb.generate(mrng, runId != null ? runIdToFrequency(runId) : void 0);
return noUndefinedAsContext(value);
}
shrink(value) {
if (value.context === void 0 && !this.arb.canShrinkWithoutContext(value.value_)) {
return Stream.nil();
}
const safeContext = value.context !== UndefinedContextPlaceholder ? value.context : void 0;
return this.arb.shrink(value.value_, safeContext).map(noUndefinedAsContext);
}
runBeforeEach() {
this.beforeEachHook();
}
runAfterEach() {
this.afterEachHook();
}
run(v, dontRunHook) {
if (!dontRunHook) {
this.beforeEachHook();
}
try {
const output = this.predicate(v);
return output == null || output === true ? null : {
error: new SError("Property failed by returning false"),
errorMessage: "Error: Property failed by returning false"
};
} catch (err) {
if (PreconditionFailure.isFailure(err))
return err;
if (err instanceof SError && err.stack) {
return { error: err, errorMessage: err.stack };
}
return { error: err, errorMessage: SString(err) };
} finally {
if (!dontRunHook) {
this.afterEachHook();
}
}
}
beforeEach(hookFunction) {
const previousBeforeEachHook = this.beforeEachHook;
this.beforeEachHook = () => hookFunction(previousBeforeEachHook);
return this;
}
afterEach(hookFunction) {
const previousAfterEachHook = this.afterEachHook;
this.afterEachHook = () => hookFunction(previousAfterEachHook);
return this;
}
};
Property.dummyHook = () => {
};
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/pure-rand-default.js
var pure_rand_default_exports = {};
__export(pure_rand_default_exports, {
__commitHash: () => __commitHash,
__type: () => __type,
__version: () => __version,
congruential32: () => congruential32,
generateN: () => generateN,
mersenne: () => MersenneTwister_default,
skipN: () => skipN,
uniformArrayIntDistribution: () => uniformArrayIntDistribution,
uniformBigIntDistribution: () => uniformBigIntDistribution,
uniformIntDistribution: () => uniformIntDistribution,
unsafeGenerateN: () => unsafeGenerateN,
unsafeSkipN: () => unsafeSkipN,
unsafeUniformArrayIntDistribution: () => unsafeUniformArrayIntDistribution,
unsafeUniformBigIntDistribution: () => unsafeUniformBigIntDistribution,
unsafeUniformIntDistribution: () => unsafeUniformIntDistribution,
xoroshiro128plus: () => xoroshiro128plus,
xorshift128plus: () => xorshift128plus
});
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/generator/RandomGenerator.js
function unsafeGenerateN(rng, num) {
var out = [];
for (var idx = 0; idx != num; ++idx) {
out.push(rng.unsafeNext());
}
return out;
}
function generateN(rng, num) {
var nextRng = rng.clone();
var out = unsafeGenerateN(nextRng, num);
return [out, nextRng];
}
function unsafeSkipN(rng, num) {
for (var idx = 0; idx != num; ++idx) {
rng.unsafeNext();
}
}
function skipN(rng, num) {
var nextRng = rng.clone();
unsafeSkipN(nextRng, num);
return nextRng;
}
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/generator/LinearCongruential.js
var MULTIPLIER = 214013;
var INCREMENT = 2531011;
var MASK = 4294967295;
var MASK_2 = (1 << 31) - 1;
var computeNextSeed = function(seed) {
return seed * MULTIPLIER + INCREMENT & MASK;
};
var computeValueFromNextSeed = function(nextseed) {
return (nextseed & MASK_2) >> 16;
};
var LinearCongruential32 = function() {
function LinearCongruential322(seed) {
this.seed = seed;
}
LinearCongruential322.prototype.clone = function() {
return new LinearCongruential322(this.seed);
};
LinearCongruential322.prototype.next = function() {
var nextRng = new LinearCongruential322(this.seed);
var out = nextRng.unsafeNext();
return [out, nextRng];
};
LinearCongruential322.prototype.unsafeNext = function() {
var s1 = computeNextSeed(this.seed);
var v1 = computeValueFromNextSeed(s1);
var s2 = computeNextSeed(s1);
var v2 = computeValueFromNextSeed(s2);
this.seed = computeNextSeed(s2);
var v3 = computeValueFromNextSeed(this.seed);
var vnext = v3 + (v2 + (v1 << 15) << 15);
return vnext | 0;
};
return LinearCongruential322;
}();
var congruential32 = function(seed) {
return new LinearCongruential32(seed);
};
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/generator/MersenneTwister.js
var MersenneTwister = function() {
function MersenneTwister2(states, index) {
this.states = states;
this.index = index;
}
MersenneTwister2.twist = function(prev) {
var mt = prev.slice();
for (var idx = 0; idx !== MersenneTwister2.N - MersenneTwister2.M; ++idx) {
var y_1 = (mt[idx] & MersenneTwister2.MASK_UPPER) + (mt[idx + 1] & MersenneTwister2.MASK_LOWER);
mt[idx] = mt[idx + MersenneTwister2.M] ^ y_1 >>> 1 ^ -(y_1 & 1) & MersenneTwister2.A;
}
for (var idx = MersenneTwister2.N - MersenneTwister2.M; idx !== MersenneTwister2.N - 1; ++idx) {
var y_2 = (mt[idx] & MersenneTwister2.MASK_UPPER) + (mt[idx + 1] & MersenneTwister2.MASK_LOWER);
mt[idx] = mt[idx + MersenneTwister2.M - MersenneTwister2.N] ^ y_2 >>> 1 ^ -(y_2 & 1) & MersenneTwister2.A;
}
var y = (mt[MersenneTwister2.N - 1] & MersenneTwister2.MASK_UPPER) + (mt[0] & MersenneTwister2.MASK_LOWER);
mt[MersenneTwister2.N - 1] = mt[MersenneTwister2.M - 1] ^ y >>> 1 ^ -(y & 1) & MersenneTwister2.A;
return mt;
};
MersenneTwister2.seeded = function(seed) {
var out = Array(MersenneTwister2.N);
out[0] = seed;
for (var idx = 1; idx !== MersenneTwister2.N; ++idx) {
var xored = out[idx - 1] ^ out[idx - 1] >>> 30;
out[idx] = Math.imul(MersenneTwister2.F, xored) + idx | 0;
}
return out;
};
MersenneTwister2.from = function(seed) {
return new MersenneTwister2(MersenneTwister2.twist(MersenneTwister2.seeded(seed)), 0);
};
MersenneTwister2.prototype.clone = function() {
return new MersenneTwister2(this.states, this.index);
};
MersenneTwister2.prototype.next = function() {
var nextRng = new MersenneTwister2(this.states, this.index);
var out = nextRng.unsafeNext();
return [out, nextRng];
};
MersenneTwister2.prototype.unsafeNext = function() {
var y = this.states[this.index];
y ^= this.states[this.index] >>> MersenneTwister2.U;
y ^= y << MersenneTwister2.S & MersenneTwister2.B;
y ^= y << MersenneTwister2.T & MersenneTwister2.C;
y ^= y >>> MersenneTwister2.L;
if (++this.index >= MersenneTwister2.N) {
this.states = MersenneTwister2.twist(this.states);
this.index = 0;
}
return y;
};
MersenneTwister2.N = 624;
MersenneTwister2.M = 397;
MersenneTwister2.R = 31;
MersenneTwister2.A = 2567483615;
MersenneTwister2.F = 1812433253;
MersenneTwister2.U = 11;
MersenneTwister2.S = 7;
MersenneTwister2.B = 2636928640;
MersenneTwister2.T = 15;
MersenneTwister2.C = 4022730752;
MersenneTwister2.L = 18;
MersenneTwister2.MASK_LOWER = Math.pow(2, MersenneTwister2.R) - 1;
MersenneTwister2.MASK_UPPER = Math.pow(2, MersenneTwister2.R);
return MersenneTwister2;
}();
function MersenneTwister_default(seed) {
return MersenneTwister.from(seed);
}
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/generator/XorShift.js
var XorShift128Plus = function() {
function XorShift128Plus2(s01, s00, s11, s10) {
this.s01 = s01;
this.s00 = s00;
this.s11 = s11;
this.s10 = s10;
}
XorShift128Plus2.prototype.clone = function() {
return new XorShift128Plus2(this.s01, this.s00, this.s11, this.s10);
};
XorShift128Plus2.prototype.next = function() {
var nextRng = new XorShift128Plus2(this.s01, this.s00, this.s11, this.s10);
var out = nextRng.unsafeNext();
return [out, nextRng];
};
XorShift128Plus2.prototype.unsafeNext = function() {
var a0 = this.s00 ^ this.s00 << 23;
var a1 = this.s01 ^ (this.s01 << 23 | this.s00 >>> 9);
var b0 = a0 ^ this.s10 ^ (a0 >>> 18 | a1 << 14) ^ (this.s10 >>> 5 | this.s11 << 27);
var b1 = a1 ^ this.s11 ^ a1 >>> 18 ^ this.s11 >>> 5;
var out = this.s00 + this.s10 | 0;
this.s01 = this.s11;
this.s00 = this.s10;
this.s11 = b1;
this.s10 = b0;
return out;
};
XorShift128Plus2.prototype.jump = function() {
var nextRng = new XorShift128Plus2(this.s01, this.s00, this.s11, this.s10);
nextRng.unsafeJump();
return nextRng;
};
XorShift128Plus2.prototype.unsafeJump = function() {
var ns01 = 0;
var ns00 = 0;
var ns11 = 0;
var ns10 = 0;
var jump = [1667051007, 2321340297, 1548169110, 304075285];
for (var i = 0; i !== 4; ++i) {
for (var mask = 1; mask; mask <<= 1) {
if (jump[i] & mask) {
ns01 ^= this.s01;
ns00 ^= this.s00;
ns11 ^= this.s11;
ns10 ^= this.s10;
}
this.unsafeNext();
}
}
this.s01 = ns01;
this.s00 = ns00;
this.s11 = ns11;
this.s10 = ns10;
};
return XorShift128Plus2;
}();
var xorshift128plus = function(seed) {
return new XorShift128Plus(-1, ~seed, seed | 0, 0);
};
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/generator/XoroShiro.js
var XoroShiro128Plus = function() {
function XoroShiro128Plus2(s01, s00, s11, s10) {
this.s01 = s01;
this.s00 = s00;
this.s11 = s11;
this.s10 = s10;
}
XoroShiro128Plus2.prototype.clone = function() {
return new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10);
};
XoroShiro128Plus2.prototype.next = function() {
var nextRng = new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10);
var out = nextRng.unsafeNext();
return [out, nextRng];
};
XoroShiro128Plus2.prototype.unsafeNext = function() {
var out = this.s00 + this.s10 | 0;
var a0 = this.s10 ^ this.s00;
var a1 = this.s11 ^ this.s01;
var s00 = this.s00;
var s01 = this.s01;
this.s00 = s00 << 24 ^ s01 >>> 8 ^ a0 ^ a0 << 16;
this.s01 = s01 << 24 ^ s00 >>> 8 ^ a1 ^ (a1 << 16 | a0 >>> 16);
this.s10 = a1 << 5 ^ a0 >>> 27;
this.s11 = a0 << 5 ^ a1 >>> 27;
return out;
};
XoroShiro128Plus2.prototype.jump = function() {
var nextRng = new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10);
nextRng.unsafeJump();
return nextRng;
};
XoroShiro128Plus2.prototype.unsafeJump = function() {
var ns01 = 0;
var ns00 = 0;
var ns11 = 0;
var ns10 = 0;
var jump = [3639956645, 3750757012, 1261568508, 386426335];
for (var i = 0; i !== 4; ++i) {
for (var mask = 1; mask; mask <<= 1) {
if (jump[i] & mask) {
ns01 ^= this.s01;
ns00 ^= this.s00;
ns11 ^= this.s11;
ns10 ^= this.s10;
}
this.unsafeNext();
}
}
this.s01 = ns01;
this.s00 = ns00;
this.s11 = ns11;
this.s10 = ns10;
};
return XoroShiro128Plus2;
}();
var xoroshiro128plus = function(seed) {
return new XoroShiro128Plus(-1, ~seed, seed | 0, 0);
};
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/distribution/internals/ArrayInt.js
function addArrayIntToNew(arrayIntA, arrayIntB) {
if (arrayIntA.sign !== arrayIntB.sign) {
return substractArrayIntToNew(arrayIntA, { sign: -arrayIntB.sign, data: arrayIntB.data });
}
var data = [];
var reminder = 0;
var dataA = arrayIntA.data;
var dataB = arrayIntB.data;
for (var indexA = dataA.length - 1, indexB = dataB.length - 1; indexA >= 0 || indexB >= 0; --indexA, --indexB) {
var vA = indexA >= 0 ? dataA[indexA] : 0;
var vB = indexB >= 0 ? dataB[indexB] : 0;
var current = vA + vB + reminder;
data.push(current >>> 0);
reminder = ~~(current / 4294967296);
}
if (reminder !== 0) {
data.push(reminder);
}
return { sign: arrayIntA.sign, data: data.reverse() };
}
function addOneToPositiveArrayInt(arrayInt) {
arrayInt.sign = 1;
var data = arrayInt.data;
for (var index = data.length - 1; index >= 0; --index) {
if (data[index] === 4294967295) {
data[index] = 0;
} else {
data[index] += 1;
return arrayInt;
}
}
data.unshift(1);
return arrayInt;
}
function isStrictlySmaller(dataA, dataB) {
var maxLength = Math.max(dataA.length, dataB.length);
for (var index = 0; index < maxLength; ++index) {
var indexA = index + dataA.length - maxLength;
var indexB = index + dataB.length - maxLength;
var vA = indexA >= 0 ? dataA[indexA] : 0;
var vB = indexB >= 0 ? dataB[indexB] : 0;
if (vA < vB)
return true;
if (vA > vB)
return false;
}
return false;
}
function substractArrayIntToNew(arrayIntA, arrayIntB) {
if (arrayIntA.sign !== arrayIntB.sign) {
return addArrayIntToNew(arrayIntA, { sign: -arrayIntB.sign, data: arrayIntB.data });
}
var dataA = arrayIntA.data;
var dataB = arrayIntB.data;
if (isStrictlySmaller(dataA, dataB)) {
var out = substractArrayIntToNew(arrayIntB, arrayIntA);
out.sign = -out.sign;
return out;
}
var data = [];
var reminder = 0;
for (var indexA = dataA.length - 1, indexB = dataB.length - 1; indexA >= 0 || indexB >= 0; --indexA, --indexB) {
var vA = indexA >= 0 ? dataA[indexA] : 0;
var vB = indexB >= 0 ? dataB[indexB] : 0;
var current = vA - vB - reminder;
data.push(current >>> 0);
reminder = current < 0 ? 1 : 0;
}
return { sign: arrayIntA.sign, data: data.reverse() };
}
function trimArrayIntInplace(arrayInt) {
var data = arrayInt.data;
var firstNonZero = 0;
for (; firstNonZero !== data.length && data[firstNonZero] === 0; ++firstNonZero) {
}
if (firstNonZero === data.length) {
arrayInt.sign = 1;
arrayInt.data = [0];
return arrayInt;
}
data.splice(0, firstNonZero);
return arrayInt;
}
function fromNumberToArrayInt64(out, n) {
if (n < 0) {
var posN = -n;
out.sign = -1;
out.data[0] = ~~(posN / 4294967296);
out.data[1] = posN >>> 0;
} else {
out.sign = 1;
out.data[0] = ~~(n / 4294967296);
out.data[1] = n >>> 0;
}
return out;
}
function substractArrayInt64(out, arrayIntA, arrayIntB) {
var lowA = arrayIntA.data[1];
var highA = arrayIntA.data[0];
var signA = arrayIntA.sign;
var lowB = arrayIntB.data[1];
var highB = arrayIntB.data[0];
var signB = arrayIntB.sign;
out.sign = 1;
if (signA === 1 && signB === -1) {
var low_1 = lowA + lowB;
var high = highA + highB + (low_1 > 4294967295 ? 1 : 0);
out.data[0] = high >>> 0;
out.data[1] = low_1 >>> 0;
return out;
}
var lowFirst = lowA;
var highFirst = highA;
var lowSecond = lowB;
var highSecond = highB;
if (signA === -1) {
lowFirst = lowB;
highFirst = highB;
lowSecond = lowA;
highSecond = highA;
}
var reminderLow = 0;
var low = lowFirst - lowSecond;
if (low < 0) {
reminderLow = 1;
low = low >>> 0;
}
out.data[0] = highFirst - highSecond - reminderLow;
out.data[1] = low;
return out;
}
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/distribution/internals/UnsafeUniformIntDistributionInternal.js
function unsafeUniformIntDistributionInternal(rangeSize, rng) {
var MaxAllowed = rangeSize > 2 ? ~~(4294967296 / rangeSize) * rangeSize : 4294967296;
var deltaV = rng.unsafeNext() + 2147483648;
while (deltaV >= MaxAllowed) {
deltaV = rng.unsafeNext() + 2147483648;
}
return deltaV % rangeSize;
}
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/distribution/internals/UnsafeUniformArrayIntDistributionInternal.js
function unsafeUniformArrayIntDistributionInternal(out, rangeSize, rng) {
var rangeLength = rangeSize.length;
while (true) {
for (var index = 0; index !== rangeLength; ++index) {
var indexRangeSize = index === 0 ? rangeSize[0] + 1 : 4294967296;
var g = unsafeUniformIntDistributionInternal(indexRangeSize, rng);
out[index] = g;
}
for (var index = 0; index !== rangeLength; ++index) {
var current = out[index];
var currentInRange = rangeSize[index];
if (current < currentInRange) {
return out;
} else if (current > currentInRange) {
break;
}
}
}
}
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformArrayIntDistribution.js
function unsafeUniformArrayIntDistribution(from, to, rng) {
var rangeSize = trimArrayIntInplace(addOneToPositiveArrayInt(substractArrayIntToNew(to, from)));
var emptyArrayIntData = rangeSize.data.slice(0);
var g = unsafeUniformArrayIntDistributionInternal(emptyArrayIntData, rangeSize.data, rng);
return trimArrayIntInplace(addArrayIntToNew({ sign: 1, data: g }, from));
}
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/distribution/UniformArrayIntDistribution.js
function uniformArrayIntDistribution(from, to, rng) {
if (rng != null) {
var nextRng = rng.clone();
return [unsafeUniformArrayIntDistribution(from, to, nextRng), nextRng];
}
return function(rng2) {
var nextRng2 = rng2.clone();
return [unsafeUniformArrayIntDistribution(from, to, nextRng2), nextRng2];
};
}
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformBigIntDistribution.js
var SBigInt = typeof BigInt !== "undefined" ? BigInt : void 0;
function unsafeUniformBigIntDistribution(from, to, rng) {
var diff = to - from + SBigInt(1);
var MinRng = SBigInt(-2147483648);
var NumValues = SBigInt(4294967296);
var FinalNumValues = NumValues;
var NumIterations = 1;
while (FinalNumValues < diff) {
FinalNumValues *= NumValues;
++NumIterations;
}
var MaxAcceptedRandom = FinalNumValues - FinalNumValues % diff;
while (true) {
var value = SBigInt(0);
for (var num = 0; num !== NumIterations; ++num) {
var out = rng.unsafeNext();
value = NumValues * value + (SBigInt(out) - MinRng);
}
if (value < MaxAcceptedRandom) {
var inDiff = value % diff;
return inDiff + from;
}
}
}
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/distribution/UniformBigIntDistribution.js
function uniformBigIntDistribution(from, to, rng) {
if (rng != null) {
var nextRng = rng.clone();
return [unsafeUniformBigIntDistribution(from, to, nextRng), nextRng];
}
return function(rng2) {
var nextRng2 = rng2.clone();
return [unsafeUniformBigIntDistribution(from, to, nextRng2), nextRng2];
};
}
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformIntDistribution.js
var safeNumberMaxSafeInteger = Number.MAX_SAFE_INTEGER;
var sharedA = { sign: 1, data: [0, 0] };
var sharedB = { sign: 1, data: [0, 0] };
var sharedC = { sign: 1, data: [0, 0] };
var sharedData = [0, 0];
function uniformLargeIntInternal(from, to, rangeSize, rng) {
var rangeSizeArrayIntValue = rangeSize <= safeNumberMaxSafeInteger ? fromNumberToArrayInt64(sharedC, rangeSize) : substractArrayInt64(sharedC, fromNumberToArrayInt64(sharedA, to), fromNumberToArrayInt64(sharedB, from));
if (rangeSizeArrayIntValue.data[1] === 4294967295) {
rangeSizeArrayIntValue.data[0] += 1;
rangeSizeArrayIntValue.data[1] = 0;
} else {
rangeSizeArrayIntValue.data[1] += 1;
}
unsafeUniformArrayIntDistributionInternal(sharedData, rangeSizeArrayIntValue.data, rng);
return sharedData[0] * 4294967296 + sharedData[1] + from;
}
function unsafeUniformIntDistribution(from, to, rng) {
var rangeSize = to - from;
if (rangeSize <= 4294967295) {
var g = unsafeUniformIntDistributionInternal(rangeSize + 1, rng);
return g + from;
}
return uniformLargeIntInternal(from, to, rangeSize, rng);
}
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/distribution/UniformIntDistribution.js
function uniformIntDistribution(from, to, rng) {
if (rng != null) {
var nextRng = rng.clone();
return [unsafeUniformIntDistribution(from, to, nextRng), nextRng];
}
return function(rng2) {
var nextRng2 = rng2.clone();
return [unsafeUniformIntDistribution(from, to, nextRng2), nextRng2];
};
}
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/pure-rand-default.js
var __type = "module";
var __version = "6.0.1";
var __commitHash = "349e8d3113633ba2bbbb5a6ec129b7f665dd3112";
// node_modules/.pnpm/pure-rand@6.0.1/node_modules/pure-rand/lib/esm/pure-rand.js
var pure_rand_default = pure_rand_default_exports;
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/check/runner/configuration/VerbosityLevel.js
var VerbosityLevel;
(function(VerbosityLevel2) {
VerbosityLevel2[VerbosityLevel2["None"] = 0] = "None";
VerbosityLevel2[VerbosityLevel2["Verbose"] = 1] = "Verbose";
VerbosityLevel2[VerbosityLevel2["VeryVerbose"] = 2] = "VeryVerbose";
})(VerbosityLevel || (VerbosityLevel = {}));
// node_modules/.pnpm/fast-check@3.8.1/node_modules/fast-check/lib/esm/check/runner/configuration/QualifiedParameters.js
var safeDateNow = Date.now;
var safeMathRandom = Math.random;
var QualifiedParameters = class {
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.readOrDefault(p, "timeout", null);
this.skipAllAfterTimeLimit = QualifiedParameters.readOrDefault(p, "skipAllAfterTimeLimit", null);
this.interruptAfterTimeLimit = 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[