feat: Reinitialize frontend with SvelteKit and TypeScript

- Delete old Vite+Svelte frontend
- Initialize new SvelteKit project with TypeScript
- Configure Tailwind CSS v4 + DaisyUI
- Implement JWT authentication with auto-refresh
- Create login page with form validation (Zod)
- Add protected route guards
- Update Docker configuration for single-stage build
- Add E2E tests with Playwright (6/11 passing)
- Fix Svelte 5 reactivity with $state() runes

Known issues:
- 5 E2E tests failing (timing/async issues)
- Token refresh implementation needs debugging
- Validation error display timing

frontend/node_modules/fast-check/lib/utils/apply.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeApply = safeApply;
+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;
+}
+function safeApply(f, instance, args) {
+    if (safeExtractApply(f) === untouchedApply) {
+        return f.apply(instance, args);
+    }
+    return safeApplyHacky(f, instance, args);
+}

frontend/node_modules/fast-check/lib/utils/globals.js

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

frontend/node_modules/fast-check/lib/utils/hash.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash = hash;
+const globals_1 = require("./globals");
+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,
+];
+function hash(repr) {
+    let crc = 0xffffffff;
+    for (let idx = 0; idx < repr.length; ++idx) {
+        const c = (0, globals_1.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 = (0, globals_1.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;
+}

frontend/node_modules/fast-check/lib/utils/stringify.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncToStringMethod = exports.toStringMethod = void 0;
+exports.hasToStringMethod = hasToStringMethod;
+exports.hasAsyncToStringMethod = hasAsyncToStringMethod;
+exports.stringifyInternal = stringifyInternal;
+exports.stringify = stringify;
+exports.possiblyAsyncStringify = possiblyAsyncStringify;
+exports.asyncStringify = asyncStringify;
+const globals_1 = require("./globals");
+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;
+exports.toStringMethod = Symbol.for('fast-check/toStringMethod');
+function hasToStringMethod(instance) {
+    return (instance !== null &&
+        (typeof instance === 'object' || typeof instance === 'function') &&
+        exports.toStringMethod in instance &&
+        typeof instance[exports.toStringMethod] === 'function');
+}
+exports.asyncToStringMethod = Symbol.for('fast-check/asyncToStringMethod');
+function hasAsyncToStringMethod(instance) {
+    return (instance !== null &&
+        (typeof instance === 'object' || typeof instance === 'function') &&
+        exports.asyncToStringMethod in instance &&
+        typeof instance[exports.asyncToStringMethod] === 'function');
+}
+const findSymbolNameRegex = /^Symbol\((.*)\)$/;
+function getSymbolDescription(s) {
+    if (s.description !== undefined)
+        return s.description;
+    const m = findSymbolNameRegex.exec((0, globals_1.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 ? (0, globals_1.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;
+}
+function stringifyInternal(value, previousValues, getAsyncContent) {
+    const currentValues = [...previousValues, value];
+    if (typeof value === 'object') {
+        if ((0, globals_1.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[exports.toStringMethod]();
+        }
+        catch (err) {
+        }
+    }
+    switch ((0, globals_1.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)))
+                        (0, globals_1.safePush)(assignments, `${index}:${stringifyInternal(arr[index], currentValues, getAsyncContent)}`);
+                }
+                return assignments.length !== 0
+                    ? `Object.assign(Array(${arr.length}),{${(0, globals_1.safeJoin)(assignments, ',')}})`
+                    : `Array(${arr.length})`;
+            }
+            const stringifiedArray = (0, globals_1.safeJoin)((0, globals_1.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((0, globals_1.safeGetTime)(d)) ? `new Date(NaN)` : `new Date(${safeJsonStringify((0, globals_1.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 = [
+                ...(0, globals_1.safeMap)(safeObjectKeys(value), mapper),
+                ...(0, globals_1.safeMap)((0, globals_1.safeFilter)(safeObjectGetOwnPropertySymbols(value), (s) => {
+                    const descriptor = safeObjectGetOwnPropertyDescriptor(value, s);
+                    return descriptor && descriptor.enumerable;
+                }), mapper),
+            ];
+            const rawRepr = '{' + (0, globals_1.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 (globals_1.Symbol.keyFor(s) !== undefined) {
+                return `Symbol.for(${safeJsonStringify(globals_1.Symbol.keyFor(s))})`;
+            }
+            const desc = getSymbolDescription(s);
+            if (desc === null) {
+                return 'Symbol()';
+            }
+            const knownSymbol = desc.startsWith('Symbol.') && globals_1.Symbol[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 (0, globals_1.safeToString)(value);
+    }
+}
+function stringify(value) {
+    return stringifyInternal(value, [], () => ({ state: 'unknown', value: undefined }));
+}
+function possiblyAsyncStringify(value) {
+    const stillPendingMarker = (0, globals_1.Symbol)();
+    const pendingPromisesForCache = [];
+    const cache = new globals_1.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 = exports.asyncToStringMethod in data
+            ? Promise.resolve().then(() => data[exports.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();
+}
+async function asyncStringify(value) {
+    return Promise.resolve(possiblyAsyncStringify(value));
+}