Erster Docker-Stand

_node_modules/fast-check/lib/esm/utils/apply.js

@@ -0,0 +1,23 @@
+const untouchedApply = Function.prototype.apply;
+const ApplySymbol = Symbol('apply');
+function safeExtractApply(f) {
+    try {
+        return f.apply;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function safeApplyHacky(f, instance, args) {
+    const ff = f;
+    ff[ApplySymbol] = untouchedApply;
+    const out = ff[ApplySymbol](instance, args);
+    delete ff[ApplySymbol];
+    return out;
+}
+export function safeApply(f, instance, args) {
+    if (safeExtractApply(f) === untouchedApply) {
+        return f.apply(instance, args);
+    }
+    return safeApplyHacky(f, instance, args);
+}

_node_modules/fast-check/lib/esm/utils/globals.js

@@ -0,0 +1,503 @@
+import { safeApply } from './apply.js';
+const SArray = typeof Array !== 'undefined' ? Array : undefined;
+export { SArray as Array };
+const SBigInt = typeof BigInt !== 'undefined' ? BigInt : undefined;
+export { SBigInt as BigInt };
+const SBigInt64Array = typeof BigInt64Array !== 'undefined' ? BigInt64Array : undefined;
+export { SBigInt64Array as BigInt64Array };
+const SBigUint64Array = typeof BigUint64Array !== 'undefined' ? BigUint64Array : undefined;
+export { SBigUint64Array as BigUint64Array };
+const SBoolean = typeof Boolean !== 'undefined' ? Boolean : undefined;
+export { SBoolean as Boolean };
+const SDate = typeof Date !== 'undefined' ? Date : undefined;
+export { SDate as Date };
+const SError = typeof Error !== 'undefined' ? Error : undefined;
+export { SError as Error };
+const SFloat32Array = typeof Float32Array !== 'undefined' ? Float32Array : undefined;
+export { SFloat32Array as Float32Array };
+const SFloat64Array = typeof Float64Array !== 'undefined' ? Float64Array : undefined;
+export { SFloat64Array as Float64Array };
+const SInt8Array = typeof Int8Array !== 'undefined' ? Int8Array : undefined;
+export { SInt8Array as Int8Array };
+const SInt16Array = typeof Int16Array !== 'undefined' ? Int16Array : undefined;
+export { SInt16Array as Int16Array };
+const SInt32Array = typeof Int32Array !== 'undefined' ? Int32Array : undefined;
+export { SInt32Array as Int32Array };
+const SNumber = typeof Number !== 'undefined' ? Number : undefined;
+export { SNumber as Number };
+const SString = typeof String !== 'undefined' ? String : undefined;
+export { SString as String };
+const SSet = typeof Set !== 'undefined' ? Set : undefined;
+export { SSet as Set };
+const SUint8Array = typeof Uint8Array !== 'undefined' ? Uint8Array : undefined;
+export { SUint8Array as Uint8Array };
+const SUint8ClampedArray = typeof Uint8ClampedArray !== 'undefined' ? Uint8ClampedArray : undefined;
+export { SUint8ClampedArray as Uint8ClampedArray };
+const SUint16Array = typeof Uint16Array !== 'undefined' ? Uint16Array : undefined;
+export { SUint16Array as Uint16Array };
+const SUint32Array = typeof Uint32Array !== 'undefined' ? Uint32Array : undefined;
+export { SUint32Array as Uint32Array };
+const SencodeURIComponent = typeof encodeURIComponent !== 'undefined' ? encodeURIComponent : undefined;
+export { SencodeURIComponent as encodeURIComponent };
+const SMap = Map;
+export { SMap as Map };
+const SSymbol = Symbol;
+export { SSymbol as Symbol };
+const untouchedForEach = Array.prototype.forEach;
+const untouchedIndexOf = Array.prototype.indexOf;
+const untouchedJoin = Array.prototype.join;
+const untouchedMap = Array.prototype.map;
+const untouchedFilter = Array.prototype.filter;
+const untouchedPush = Array.prototype.push;
+const untouchedPop = Array.prototype.pop;
+const untouchedSplice = Array.prototype.splice;
+const untouchedSlice = Array.prototype.slice;
+const untouchedSort = Array.prototype.sort;
+const untouchedEvery = Array.prototype.every;
+function extractForEach(instance) {
+    try {
+        return instance.forEach;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractIndexOf(instance) {
+    try {
+        return instance.indexOf;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractJoin(instance) {
+    try {
+        return instance.join;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractMap(instance) {
+    try {
+        return instance.map;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractFilter(instance) {
+    try {
+        return instance.filter;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractPush(instance) {
+    try {
+        return instance.push;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractPop(instance) {
+    try {
+        return instance.pop;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractSplice(instance) {
+    try {
+        return instance.splice;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractSlice(instance) {
+    try {
+        return instance.slice;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractSort(instance) {
+    try {
+        return instance.sort;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractEvery(instance) {
+    try {
+        return instance.every;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+export function safeForEach(instance, fn) {
+    if (extractForEach(instance) === untouchedForEach) {
+        return instance.forEach(fn);
+    }
+    return safeApply(untouchedForEach, instance, [fn]);
+}
+export function safeIndexOf(instance, ...args) {
+    if (extractIndexOf(instance) === untouchedIndexOf) {
+        return instance.indexOf(...args);
+    }
+    return safeApply(untouchedIndexOf, instance, args);
+}
+export function safeJoin(instance, ...args) {
+    if (extractJoin(instance) === untouchedJoin) {
+        return instance.join(...args);
+    }
+    return safeApply(untouchedJoin, instance, args);
+}
+export function safeMap(instance, fn) {
+    if (extractMap(instance) === untouchedMap) {
+        return instance.map(fn);
+    }
+    return safeApply(untouchedMap, instance, [fn]);
+}
+export function safeFilter(instance, predicate) {
+    if (extractFilter(instance) === untouchedFilter) {
+        return instance.filter(predicate);
+    }
+    return safeApply(untouchedFilter, instance, [predicate]);
+}
+export function safePush(instance, ...args) {
+    if (extractPush(instance) === untouchedPush) {
+        return instance.push(...args);
+    }
+    return safeApply(untouchedPush, instance, args);
+}
+export function safePop(instance) {
+    if (extractPop(instance) === untouchedPop) {
+        return instance.pop();
+    }
+    return safeApply(untouchedPop, instance, []);
+}
+export function safeSplice(instance, ...args) {
+    if (extractSplice(instance) === untouchedSplice) {
+        return instance.splice(...args);
+    }
+    return safeApply(untouchedSplice, instance, args);
+}
+export function safeSlice(instance, ...args) {
+    if (extractSlice(instance) === untouchedSlice) {
+        return instance.slice(...args);
+    }
+    return safeApply(untouchedSlice, instance, args);
+}
+export function safeSort(instance, ...args) {
+    if (extractSort(instance) === untouchedSort) {
+        return instance.sort(...args);
+    }
+    return safeApply(untouchedSort, instance, args);
+}
+export function safeEvery(instance, ...args) {
+    if (extractEvery(instance) === untouchedEvery) {
+        return instance.every(...args);
+    }
+    return safeApply(untouchedEvery, instance, args);
+}
+const untouchedGetTime = Date.prototype.getTime;
+const untouchedToISOString = Date.prototype.toISOString;
+function extractGetTime(instance) {
+    try {
+        return instance.getTime;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractToISOString(instance) {
+    try {
+        return instance.toISOString;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+export function safeGetTime(instance) {
+    if (extractGetTime(instance) === untouchedGetTime) {
+        return instance.getTime();
+    }
+    return safeApply(untouchedGetTime, instance, []);
+}
+export function safeToISOString(instance) {
+    if (extractToISOString(instance) === untouchedToISOString) {
+        return instance.toISOString();
+    }
+    return safeApply(untouchedToISOString, instance, []);
+}
+const untouchedAdd = Set.prototype.add;
+const untouchedHas = Set.prototype.has;
+function extractAdd(instance) {
+    try {
+        return instance.add;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractHas(instance) {
+    try {
+        return instance.has;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+export function safeAdd(instance, value) {
+    if (extractAdd(instance) === untouchedAdd) {
+        return instance.add(value);
+    }
+    return safeApply(untouchedAdd, instance, [value]);
+}
+export function safeHas(instance, value) {
+    if (extractHas(instance) === untouchedHas) {
+        return instance.has(value);
+    }
+    return safeApply(untouchedHas, instance, [value]);
+}
+const untouchedSet = WeakMap.prototype.set;
+const untouchedGet = WeakMap.prototype.get;
+function extractSet(instance) {
+    try {
+        return instance.set;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractGet(instance) {
+    try {
+        return instance.get;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+export function safeSet(instance, key, value) {
+    if (extractSet(instance) === untouchedSet) {
+        return instance.set(key, value);
+    }
+    return safeApply(untouchedSet, instance, [key, value]);
+}
+export function safeGet(instance, key) {
+    if (extractGet(instance) === untouchedGet) {
+        return instance.get(key);
+    }
+    return safeApply(untouchedGet, instance, [key]);
+}
+const untouchedMapSet = Map.prototype.set;
+const untouchedMapGet = Map.prototype.get;
+function extractMapSet(instance) {
+    try {
+        return instance.set;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractMapGet(instance) {
+    try {
+        return instance.get;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+export function safeMapSet(instance, key, value) {
+    if (extractMapSet(instance) === untouchedMapSet) {
+        return instance.set(key, value);
+    }
+    return safeApply(untouchedMapSet, instance, [key, value]);
+}
+export function safeMapGet(instance, key) {
+    if (extractMapGet(instance) === untouchedMapGet) {
+        return instance.get(key);
+    }
+    return safeApply(untouchedMapGet, instance, [key]);
+}
+const untouchedSplit = String.prototype.split;
+const untouchedStartsWith = String.prototype.startsWith;
+const untouchedEndsWith = String.prototype.endsWith;
+const untouchedSubstring = String.prototype.substring;
+const untouchedToLowerCase = String.prototype.toLowerCase;
+const untouchedToUpperCase = String.prototype.toUpperCase;
+const untouchedPadStart = String.prototype.padStart;
+const untouchedCharCodeAt = String.prototype.charCodeAt;
+const untouchedNormalize = String.prototype.normalize;
+const untouchedReplace = String.prototype.replace;
+function extractSplit(instance) {
+    try {
+        return instance.split;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractStartsWith(instance) {
+    try {
+        return instance.startsWith;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractEndsWith(instance) {
+    try {
+        return instance.endsWith;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractSubstring(instance) {
+    try {
+        return instance.substring;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractToLowerCase(instance) {
+    try {
+        return instance.toLowerCase;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractToUpperCase(instance) {
+    try {
+        return instance.toUpperCase;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractPadStart(instance) {
+    try {
+        return instance.padStart;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractCharCodeAt(instance) {
+    try {
+        return instance.charCodeAt;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractNormalize(instance) {
+    try {
+        return instance.normalize;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function extractReplace(instance) {
+    try {
+        return instance.replace;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+export function safeSplit(instance, ...args) {
+    if (extractSplit(instance) === untouchedSplit) {
+        return instance.split(...args);
+    }
+    return safeApply(untouchedSplit, instance, args);
+}
+export function safeStartsWith(instance, ...args) {
+    if (extractStartsWith(instance) === untouchedStartsWith) {
+        return instance.startsWith(...args);
+    }
+    return safeApply(untouchedStartsWith, instance, args);
+}
+export function safeEndsWith(instance, ...args) {
+    if (extractEndsWith(instance) === untouchedEndsWith) {
+        return instance.endsWith(...args);
+    }
+    return safeApply(untouchedEndsWith, instance, args);
+}
+export function safeSubstring(instance, ...args) {
+    if (extractSubstring(instance) === untouchedSubstring) {
+        return instance.substring(...args);
+    }
+    return safeApply(untouchedSubstring, instance, args);
+}
+export function safeToLowerCase(instance) {
+    if (extractToLowerCase(instance) === untouchedToLowerCase) {
+        return instance.toLowerCase();
+    }
+    return safeApply(untouchedToLowerCase, instance, []);
+}
+export function safeToUpperCase(instance) {
+    if (extractToUpperCase(instance) === untouchedToUpperCase) {
+        return instance.toUpperCase();
+    }
+    return safeApply(untouchedToUpperCase, instance, []);
+}
+export function safePadStart(instance, ...args) {
+    if (extractPadStart(instance) === untouchedPadStart) {
+        return instance.padStart(...args);
+    }
+    return safeApply(untouchedPadStart, instance, args);
+}
+export function safeCharCodeAt(instance, index) {
+    if (extractCharCodeAt(instance) === untouchedCharCodeAt) {
+        return instance.charCodeAt(index);
+    }
+    return safeApply(untouchedCharCodeAt, instance, [index]);
+}
+export function safeNormalize(instance, form) {
+    if (extractNormalize(instance) === untouchedNormalize) {
+        return instance.normalize(form);
+    }
+    return safeApply(untouchedNormalize, instance, [form]);
+}
+export function safeReplace(instance, pattern, replacement) {
+    if (extractReplace(instance) === untouchedReplace) {
+        return instance.replace(pattern, replacement);
+    }
+    return safeApply(untouchedReplace, instance, [pattern, replacement]);
+}
+const untouchedNumberToString = Number.prototype.toString;
+function extractNumberToString(instance) {
+    try {
+        return instance.toString;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+export function safeNumberToString(instance, ...args) {
+    if (extractNumberToString(instance) === untouchedNumberToString) {
+        return instance.toString(...args);
+    }
+    return safeApply(untouchedNumberToString, instance, args);
+}
+const untouchedHasOwnProperty = Object.prototype.hasOwnProperty;
+const untouchedToString = Object.prototype.toString;
+export function safeHasOwnProperty(instance, v) {
+    return safeApply(untouchedHasOwnProperty, instance, [v]);
+}
+export function safeToString(instance) {
+    return safeApply(untouchedToString, instance, []);
+}

_node_modules/fast-check/lib/esm/utils/hash.js

@@ -0,0 +1,68 @@
+import { safeCharCodeAt } from './globals.js';
+const crc32Table = [
+    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832,
+    0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+    0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a,
+    0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
+    0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+    0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab,
+    0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4,
+    0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074,
+    0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525,
+    0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+    0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
+    0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76,
+    0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+    0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6,
+    0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7,
+    0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+    0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7,
+    0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
+    0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+    0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330,
+    0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
+];
+export function hash(repr) {
+    let crc = 0xffffffff;
+    for (let idx = 0; idx < repr.length; ++idx) {
+        const c = safeCharCodeAt(repr, idx);
+        if (c < 0x80) {
+            crc = crc32Table[(crc & 0xff) ^ c] ^ (crc >> 8);
+        }
+        else if (c < 0x800) {
+            crc = crc32Table[(crc & 0xff) ^ (192 | ((c >> 6) & 31))] ^ (crc >> 8);
+            crc = crc32Table[(crc & 0xff) ^ (128 | (c & 63))] ^ (crc >> 8);
+        }
+        else if (c >= 0xd800 && c < 0xe000) {
+            const cNext = safeCharCodeAt(repr, ++idx);
+            if (c >= 0xdc00 || cNext < 0xdc00 || cNext > 0xdfff || Number.isNaN(cNext)) {
+                idx -= 1;
+                crc = crc32Table[(crc & 0xff) ^ 0xef] ^ (crc >> 8);
+                crc = crc32Table[(crc & 0xff) ^ 0xbf] ^ (crc >> 8);
+                crc = crc32Table[(crc & 0xff) ^ 0xbd] ^ (crc >> 8);
+            }
+            else {
+                const c1 = (c & 1023) + 64;
+                const c2 = cNext & 1023;
+                crc = crc32Table[(crc & 0xff) ^ (240 | ((c1 >> 8) & 7))] ^ (crc >> 8);
+                crc = crc32Table[(crc & 0xff) ^ (128 | ((c1 >> 2) & 63))] ^ (crc >> 8);
+                crc = crc32Table[(crc & 0xff) ^ (128 | ((c2 >> 6) & 15) | ((c1 & 3) << 4))] ^ (crc >> 8);
+                crc = crc32Table[(crc & 0xff) ^ (128 | (c2 & 63))] ^ (crc >> 8);
+            }
+        }
+        else {
+            crc = crc32Table[(crc & 0xff) ^ (224 | ((c >> 12) & 15))] ^ (crc >> 8);
+            crc = crc32Table[(crc & 0xff) ^ (128 | ((c >> 6) & 63))] ^ (crc >> 8);
+            crc = crc32Table[(crc & 0xff) ^ (128 | (c & 63))] ^ (crc >> 8);
+        }
+    }
+    return (crc | 0) + 0x80000000;
+}

_node_modules/fast-check/lib/esm/utils/stringify.js

@@ -0,0 +1,260 @@
+import { safeFilter, safeGetTime, safeIndexOf, safeJoin, safeMap, safePush, safeToISOString, safeToString, Map, String, Symbol as StableSymbol, } from './globals.js';
+const safeArrayFrom = Array.from;
+const safeBufferIsBuffer = typeof Buffer !== 'undefined' ? Buffer.isBuffer : undefined;
+const safeJsonStringify = JSON.stringify;
+const safeNumberIsNaN = Number.isNaN;
+const safeObjectKeys = Object.keys;
+const safeObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
+const safeObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const safeObjectGetPrototypeOf = Object.getPrototypeOf;
+const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
+const safePositiveInfinity = Number.POSITIVE_INFINITY;
+export const toStringMethod = Symbol.for('fast-check/toStringMethod');
+export function hasToStringMethod(instance) {
+    return (instance !== null &&
+        (typeof instance === 'object' || typeof instance === 'function') &&
+        toStringMethod in instance &&
+        typeof instance[toStringMethod] === 'function');
+}
+export const asyncToStringMethod = Symbol.for('fast-check/asyncToStringMethod');
+export function hasAsyncToStringMethod(instance) {
+    return (instance !== null &&
+        (typeof instance === 'object' || typeof instance === 'function') &&
+        asyncToStringMethod in instance &&
+        typeof instance[asyncToStringMethod] === 'function');
+}
+const findSymbolNameRegex = /^Symbol\((.*)\)$/;
+function getSymbolDescription(s) {
+    if (s.description !== undefined)
+        return s.description;
+    const m = findSymbolNameRegex.exec(String(s));
+    return m && m[1].length ? m[1] : null;
+}
+function stringifyNumber(numValue) {
+    switch (numValue) {
+        case 0:
+            return 1 / numValue === safeNegativeInfinity ? '-0' : '0';
+        case safeNegativeInfinity:
+            return 'Number.NEGATIVE_INFINITY';
+        case safePositiveInfinity:
+            return 'Number.POSITIVE_INFINITY';
+        default:
+            return numValue === numValue ? String(numValue) : 'Number.NaN';
+    }
+}
+function isSparseArray(arr) {
+    let previousNumberedIndex = -1;
+    for (const index in arr) {
+        const numberedIndex = Number(index);
+        if (numberedIndex !== previousNumberedIndex + 1)
+            return true;
+        previousNumberedIndex = numberedIndex;
+    }
+    return previousNumberedIndex + 1 !== arr.length;
+}
+export function stringifyInternal(value, previousValues, getAsyncContent) {
+    const currentValues = [...previousValues, value];
+    if (typeof value === 'object') {
+        if (safeIndexOf(previousValues, value) !== -1) {
+            return '[cyclic]';
+        }
+    }
+    if (hasAsyncToStringMethod(value)) {
+        const content = getAsyncContent(value);
+        if (content.state === 'fulfilled') {
+            return content.value;
+        }
+    }
+    if (hasToStringMethod(value)) {
+        try {
+            return value[toStringMethod]();
+        }
+        catch (err) {
+        }
+    }
+    switch (safeToString(value)) {
+        case '[object Array]': {
+            const arr = value;
+            if (arr.length >= 50 && isSparseArray(arr)) {
+                const assignments = [];
+                for (const index in arr) {
+                    if (!safeNumberIsNaN(Number(index)))
+                        safePush(assignments, `${index}:${stringifyInternal(arr[index], currentValues, getAsyncContent)}`);
+                }
+                return assignments.length !== 0
+                    ? `Object.assign(Array(${arr.length}),{${safeJoin(assignments, ',')}})`
+                    : `Array(${arr.length})`;
+            }
+            const stringifiedArray = safeJoin(safeMap(arr, (v) => stringifyInternal(v, currentValues, getAsyncContent)), ',');
+            return arr.length === 0 || arr.length - 1 in arr ? `[${stringifiedArray}]` : `[${stringifiedArray},]`;
+        }
+        case '[object BigInt]':
+            return `${value}n`;
+        case '[object Boolean]': {
+            const unboxedToString = value == true ? 'true' : 'false';
+            return typeof value === 'boolean' ? unboxedToString : `new Boolean(${unboxedToString})`;
+        }
+        case '[object Date]': {
+            const d = value;
+            return safeNumberIsNaN(safeGetTime(d)) ? `new Date(NaN)` : `new Date(${safeJsonStringify(safeToISOString(d))})`;
+        }
+        case '[object Map]':
+            return `new Map(${stringifyInternal(Array.from(value), currentValues, getAsyncContent)})`;
+        case '[object Null]':
+            return `null`;
+        case '[object Number]':
+            return typeof value === 'number' ? stringifyNumber(value) : `new Number(${stringifyNumber(Number(value))})`;
+        case '[object Object]': {
+            try {
+                const toStringAccessor = value.toString;
+                if (typeof toStringAccessor === 'function' && toStringAccessor !== Object.prototype.toString) {
+                    return value.toString();
+                }
+            }
+            catch (err) {
+                return '[object Object]';
+            }
+            const mapper = (k) => `${k === '__proto__'
+                ? '["__proto__"]'
+                : typeof k === 'symbol'
+                    ? `[${stringifyInternal(k, currentValues, getAsyncContent)}]`
+                    : safeJsonStringify(k)}:${stringifyInternal(value[k], currentValues, getAsyncContent)}`;
+            const stringifiedProperties = [
+                ...safeMap(safeObjectKeys(value), mapper),
+                ...safeMap(safeFilter(safeObjectGetOwnPropertySymbols(value), (s) => {
+                    const descriptor = safeObjectGetOwnPropertyDescriptor(value, s);
+                    return descriptor && descriptor.enumerable;
+                }), mapper),
+            ];
+            const rawRepr = '{' + safeJoin(stringifiedProperties, ',') + '}';
+            if (safeObjectGetPrototypeOf(value) === null) {
+                return rawRepr === '{}' ? 'Object.create(null)' : `Object.assign(Object.create(null),${rawRepr})`;
+            }
+            return rawRepr;
+        }
+        case '[object Set]':
+            return `new Set(${stringifyInternal(Array.from(value), currentValues, getAsyncContent)})`;
+        case '[object String]':
+            return typeof value === 'string' ? safeJsonStringify(value) : `new String(${safeJsonStringify(value)})`;
+        case '[object Symbol]': {
+            const s = value;
+            if (StableSymbol.keyFor(s) !== undefined) {
+                return `Symbol.for(${safeJsonStringify(StableSymbol.keyFor(s))})`;
+            }
+            const desc = getSymbolDescription(s);
+            if (desc === null) {
+                return 'Symbol()';
+            }
+            const knownSymbol = desc.startsWith('Symbol.') && StableSymbol[desc.substring(7)];
+            return s === knownSymbol ? desc : `Symbol(${safeJsonStringify(desc)})`;
+        }
+        case '[object Promise]': {
+            const promiseContent = getAsyncContent(value);
+            switch (promiseContent.state) {
+                case 'fulfilled':
+                    return `Promise.resolve(${stringifyInternal(promiseContent.value, currentValues, getAsyncContent)})`;
+                case 'rejected':
+                    return `Promise.reject(${stringifyInternal(promiseContent.value, currentValues, getAsyncContent)})`;
+                case 'pending':
+                    return `new Promise(() => {/*pending*/})`;
+                case 'unknown':
+                default:
+                    return `new Promise(() => {/*unknown*/})`;
+            }
+        }
+        case '[object Error]':
+            if (value instanceof Error) {
+                return `new Error(${stringifyInternal(value.message, currentValues, getAsyncContent)})`;
+            }
+            break;
+        case '[object Undefined]':
+            return `undefined`;
+        case '[object Int8Array]':
+        case '[object Uint8Array]':
+        case '[object Uint8ClampedArray]':
+        case '[object Int16Array]':
+        case '[object Uint16Array]':
+        case '[object Int32Array]':
+        case '[object Uint32Array]':
+        case '[object Float32Array]':
+        case '[object Float64Array]':
+        case '[object BigInt64Array]':
+        case '[object BigUint64Array]': {
+            if (typeof safeBufferIsBuffer === 'function' && safeBufferIsBuffer(value)) {
+                return `Buffer.from(${stringifyInternal(safeArrayFrom(value.values()), currentValues, getAsyncContent)})`;
+            }
+            const valuePrototype = safeObjectGetPrototypeOf(value);
+            const className = valuePrototype && valuePrototype.constructor && valuePrototype.constructor.name;
+            if (typeof className === 'string') {
+                const typedArray = value;
+                const valuesFromTypedArr = typedArray.values();
+                return `${className}.from(${stringifyInternal(safeArrayFrom(valuesFromTypedArr), currentValues, getAsyncContent)})`;
+            }
+            break;
+        }
+    }
+    try {
+        return value.toString();
+    }
+    catch (_a) {
+        return safeToString(value);
+    }
+}
+export function stringify(value) {
+    return stringifyInternal(value, [], () => ({ state: 'unknown', value: undefined }));
+}
+export function possiblyAsyncStringify(value) {
+    const stillPendingMarker = StableSymbol();
+    const pendingPromisesForCache = [];
+    const cache = new Map();
+    function createDelay0() {
+        let handleId = null;
+        const cancel = () => {
+            if (handleId !== null) {
+                clearTimeout(handleId);
+            }
+        };
+        const delay = new Promise((resolve) => {
+            handleId = setTimeout(() => {
+                handleId = null;
+                resolve(stillPendingMarker);
+            }, 0);
+        });
+        return { delay, cancel };
+    }
+    const unknownState = { state: 'unknown', value: undefined };
+    const getAsyncContent = function getAsyncContent(data) {
+        const cacheKey = data;
+        if (cache.has(cacheKey)) {
+            return cache.get(cacheKey);
+        }
+        const delay0 = createDelay0();
+        const p = asyncToStringMethod in data
+            ? Promise.resolve().then(() => data[asyncToStringMethod]())
+            : data;
+        p.catch(() => { });
+        pendingPromisesForCache.push(Promise.race([p, delay0.delay]).then((successValue) => {
+            if (successValue === stillPendingMarker)
+                cache.set(cacheKey, { state: 'pending', value: undefined });
+            else
+                cache.set(cacheKey, { state: 'fulfilled', value: successValue });
+            delay0.cancel();
+        }, (errorValue) => {
+            cache.set(cacheKey, { state: 'rejected', value: errorValue });
+            delay0.cancel();
+        }));
+        cache.set(cacheKey, unknownState);
+        return unknownState;
+    };
+    function loop() {
+        const stringifiedValue = stringifyInternal(value, [], getAsyncContent);
+        if (pendingPromisesForCache.length === 0) {
+            return stringifiedValue;
+        }
+        return Promise.all(pendingPromisesForCache.splice(0)).then(loop);
+    }
+    return loop();
+}
+export async function asyncStringify(value) {
+    return Promise.resolve(possiblyAsyncStringify(value));
+}