feat(auth): implement user authentication system

backend/node_modules/jest/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

backend/node_modules/jest/README.md

@@ -0,0 +1,11 @@
+# Jest
+
+🃏 Delightful JavaScript Testing
+
+- **👩🏻‍💻 Developer Ready**: Complete and ready to set-up JavaScript testing solution. Works out of the box for any React project.
+
+- **🏃🏽 Instant Feedback**: Failed tests run first. Fast interactive mode can switch between running all tests or only test files related to changed files.
+
+- **📸 Snapshot Testing**: Jest can [capture snapshots](https://jestjs.io/docs/snapshot-testing) of React trees or other serializable values to simplify UI testing.
+
+Read More: https://jestjs.io/

backend/node_modules/jest/bin/jest.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+const importLocal = require('import-local');
+
+if (!importLocal(__filename)) {
+  require('jest-cli/bin/jest');
+}

backend/node_modules/jest/build/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type {Config as Config_2} from '@jest/types';
+import {createTestScheduler} from '@jest/core';
+import {getVersion} from '@jest/core';
+import {run} from 'jest-cli';
+import {runCLI} from '@jest/core';
+import {SearchSource} from '@jest/core';
+
+export declare type Config = Config_2.InitialOptions;
+
+export {createTestScheduler};
+
+export {getVersion};
+
+export {run};
+
+export {runCLI};
+
+export {SearchSource};
+
+export {};

backend/node_modules/jest/build/index.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+Object.defineProperty(exports, 'SearchSource', {
+  enumerable: true,
+  get: function () {
+    return _core().SearchSource;
+  }
+});
+Object.defineProperty(exports, 'createTestScheduler', {
+  enumerable: true,
+  get: function () {
+    return _core().createTestScheduler;
+  }
+});
+Object.defineProperty(exports, 'getVersion', {
+  enumerable: true,
+  get: function () {
+    return _core().getVersion;
+  }
+});
+Object.defineProperty(exports, 'run', {
+  enumerable: true,
+  get: function () {
+    return _jestCli().run;
+  }
+});
+Object.defineProperty(exports, 'runCLI', {
+  enumerable: true,
+  get: function () {
+    return _core().runCLI;
+  }
+});
+function _core() {
+  const data = require('@jest/core');
+  _core = function () {
+    return data;
+  };
+  return data;
+}
+function _jestCli() {
+  const data = require('jest-cli');
+  _jestCli = function () {
+    return data;
+  };
+  return data;
+}

backend/node_modules/jest/node_modules/@jest/schemas/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

backend/node_modules/jest/node_modules/@jest/schemas/README.md

@@ -0,0 +1,3 @@
+# `@jest/schemas`
+
+Experimental and currently incomplete module for JSON schemas for [Jest's](https://jestjs.io/) configuration.

backend/node_modules/jest/node_modules/@jest/schemas/build/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import {Static} from '@sinclair/typebox';
+import {TBoolean} from '@sinclair/typebox';
+import {TNull} from '@sinclair/typebox';
+import {TNumber} from '@sinclair/typebox';
+import {TObject} from '@sinclair/typebox';
+import {TReadonlyOptional} from '@sinclair/typebox';
+import {TString} from '@sinclair/typebox';
+
+declare const RawSnapshotFormat: TObject<{
+  callToJSON: TReadonlyOptional<TBoolean>;
+  compareKeys: TReadonlyOptional<TNull>;
+  escapeRegex: TReadonlyOptional<TBoolean>;
+  escapeString: TReadonlyOptional<TBoolean>;
+  highlight: TReadonlyOptional<TBoolean>;
+  indent: TReadonlyOptional<TNumber>;
+  maxDepth: TReadonlyOptional<TNumber>;
+  maxWidth: TReadonlyOptional<TNumber>;
+  min: TReadonlyOptional<TBoolean>;
+  printBasicPrototype: TReadonlyOptional<TBoolean>;
+  printFunctionName: TReadonlyOptional<TBoolean>;
+  theme: TReadonlyOptional<
+    TObject<{
+      comment: TReadonlyOptional<TString<string>>;
+      content: TReadonlyOptional<TString<string>>;
+      prop: TReadonlyOptional<TString<string>>;
+      tag: TReadonlyOptional<TString<string>>;
+      value: TReadonlyOptional<TString<string>>;
+    }>
+  >;
+}>;
+
+export declare const SnapshotFormat: TObject<{
+  callToJSON: TReadonlyOptional<TBoolean>;
+  compareKeys: TReadonlyOptional<TNull>;
+  escapeRegex: TReadonlyOptional<TBoolean>;
+  escapeString: TReadonlyOptional<TBoolean>;
+  highlight: TReadonlyOptional<TBoolean>;
+  indent: TReadonlyOptional<TNumber>;
+  maxDepth: TReadonlyOptional<TNumber>;
+  maxWidth: TReadonlyOptional<TNumber>;
+  min: TReadonlyOptional<TBoolean>;
+  printBasicPrototype: TReadonlyOptional<TBoolean>;
+  printFunctionName: TReadonlyOptional<TBoolean>;
+  theme: TReadonlyOptional<
+    TObject<{
+      comment: TReadonlyOptional<TString<string>>;
+      content: TReadonlyOptional<TString<string>>;
+      prop: TReadonlyOptional<TString<string>>;
+      tag: TReadonlyOptional<TString<string>>;
+      value: TReadonlyOptional<TString<string>>;
+    }>
+  >;
+}>;
+
+export declare type SnapshotFormat = Static<typeof RawSnapshotFormat>;
+
+export {};

backend/node_modules/jest/node_modules/@jest/schemas/build/index.js

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.SnapshotFormat = void 0;
+function _typebox() {
+  const data = require('@sinclair/typebox');
+  _typebox = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+const RawSnapshotFormat = _typebox().Type.Partial(
+  _typebox().Type.Object({
+    callToJSON: _typebox().Type.Readonly(_typebox().Type.Boolean()),
+    compareKeys: _typebox().Type.Readonly(_typebox().Type.Null()),
+    escapeRegex: _typebox().Type.Readonly(_typebox().Type.Boolean()),
+    escapeString: _typebox().Type.Readonly(_typebox().Type.Boolean()),
+    highlight: _typebox().Type.Readonly(_typebox().Type.Boolean()),
+    indent: _typebox().Type.Readonly(
+      _typebox().Type.Number({
+        minimum: 0
+      })
+    ),
+    maxDepth: _typebox().Type.Readonly(
+      _typebox().Type.Number({
+        minimum: 0
+      })
+    ),
+    maxWidth: _typebox().Type.Readonly(
+      _typebox().Type.Number({
+        minimum: 0
+      })
+    ),
+    min: _typebox().Type.Readonly(_typebox().Type.Boolean()),
+    printBasicPrototype: _typebox().Type.Readonly(_typebox().Type.Boolean()),
+    printFunctionName: _typebox().Type.Readonly(_typebox().Type.Boolean()),
+    theme: _typebox().Type.Readonly(
+      _typebox().Type.Partial(
+        _typebox().Type.Object({
+          comment: _typebox().Type.Readonly(_typebox().Type.String()),
+          content: _typebox().Type.Readonly(_typebox().Type.String()),
+          prop: _typebox().Type.Readonly(_typebox().Type.String()),
+          tag: _typebox().Type.Readonly(_typebox().Type.String()),
+          value: _typebox().Type.Readonly(_typebox().Type.String())
+        })
+      )
+    )
+  })
+);
+const SnapshotFormat = _typebox().Type.Strict(RawSnapshotFormat);
+exports.SnapshotFormat = SnapshotFormat;

backend/node_modules/jest/node_modules/@jest/schemas/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@jest/schemas",
+  "version": "29.6.3",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jestjs/jest.git",
+    "directory": "packages/jest-schemas"
+  },
+  "license": "MIT",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.27.8"
+  },
+  "engines": {
+    "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "fb7d95c8af6e0d65a8b65348433d8a0ea0725b5b"
+}

backend/node_modules/jest/node_modules/@jest/types/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

backend/node_modules/jest/node_modules/@jest/types/README.md

@@ -0,0 +1,30 @@
+# @jest/types
+
+This package contains shared types of Jest's packages.
+
+If you are looking for types of [Jest globals](https://jestjs.io/docs/api), you can import them from `@jest/globals` package:
+
+```ts
+import {describe, expect, it} from '@jest/globals';
+
+describe('my tests', () => {
+  it('works', () => {
+    expect(1).toBe(1);
+  });
+});
+```
+
+If you prefer to omit imports, a similar result can be achieved installing the [@types/jest](https://npmjs.com/package/@types/jest) package. Note that this is a third party library maintained at [DefinitelyTyped](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/jest) and may not cover the latest Jest features.
+
+Another use-case for `@types/jest` is a typed Jest config as those types are not provided by Jest out of the box:
+
+```ts
+// jest.config.ts
+import {Config} from '@jest/types';
+
+const config: Config.InitialOptions = {
+  // some typed config
+};
+
+export default config;
+```

backend/node_modules/jest/node_modules/@jest/types/build/Circus.js

@@ -0,0 +1 @@
+'use strict';

backend/node_modules/jest/node_modules/@jest/types/build/Config.js

@@ -0,0 +1 @@
+'use strict';

backend/node_modules/jest/node_modules/@jest/types/build/Global.js

@@ -0,0 +1 @@
+'use strict';

backend/node_modules/jest/node_modules/@jest/types/build/TestResult.js

@@ -0,0 +1 @@
+'use strict';

backend/node_modules/jest/node_modules/@jest/types/build/Transform.js

@@ -0,0 +1 @@
+'use strict';

backend/node_modules/jest/node_modules/@jest/types/build/index.js

@@ -0,0 +1 @@
+'use strict';

backend/node_modules/jest/node_modules/@jest/types/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@jest/types",
+  "version": "29.6.3",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jestjs/jest.git",
+    "directory": "packages/jest-types"
+  },
+  "engines": {
+    "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+  },
+  "license": "MIT",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@jest/schemas": "^29.6.3",
+    "@types/istanbul-lib-coverage": "^2.0.0",
+    "@types/istanbul-reports": "^3.0.0",
+    "@types/node": "*",
+    "@types/yargs": "^17.0.8",
+    "chalk": "^4.0.0"
+  },
+  "devDependencies": {
+    "@tsd/typescript": "^5.0.4",
+    "tsd-lite": "^0.7.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "fb7d95c8af6e0d65a8b65348433d8a0ea0725b5b"
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/compiler/compiler.d.ts

@@ -0,0 +1,35 @@
+import * as Types from '../typebox';
+import { ValueErrorIterator } from '../errors/index';
+export type CheckFunction = (value: unknown) => boolean;
+export declare class TypeCheck<T extends Types.TSchema> {
+    private readonly schema;
+    private readonly references;
+    private readonly checkFunc;
+    private readonly code;
+    constructor(schema: T, references: Types.TSchema[], checkFunc: CheckFunction, code: string);
+    /** Returns the generated assertion code used to validate this type. */
+    Code(): string;
+    /** Returns an iterator for each error in this value. */
+    Errors(value: unknown): ValueErrorIterator;
+    /** Returns true if the value matches the compiled type. */
+    Check(value: unknown): value is Types.Static<T>;
+}
+export declare class TypeCompilerUnknownTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class TypeCompilerDereferenceError extends Error {
+    readonly schema: Types.TRef;
+    constructor(schema: Types.TRef);
+}
+export declare class TypeCompilerTypeGuardError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+/** Compiles Types for Runtime Type Checking */
+export declare namespace TypeCompiler {
+    /** Returns the generated assertion code used to validate this type. */
+    function Code<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): string;
+    /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
+    function Compile<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): TypeCheck<T>;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/compiler/compiler.js

@@ -0,0 +1,577 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/compiler
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeCompiler = exports.TypeCompilerTypeGuardError = exports.TypeCompilerDereferenceError = exports.TypeCompilerUnknownTypeError = exports.TypeCheck = void 0;
+const Types = require("../typebox");
+const index_1 = require("../errors/index");
+const index_2 = require("../system/index");
+const hash_1 = require("../value/hash");
+// -------------------------------------------------------------------
+// TypeCheck
+// -------------------------------------------------------------------
+class TypeCheck {
+    constructor(schema, references, checkFunc, code) {
+        this.schema = schema;
+        this.references = references;
+        this.checkFunc = checkFunc;
+        this.code = code;
+    }
+    /** Returns the generated assertion code used to validate this type. */
+    Code() {
+        return this.code;
+    }
+    /** Returns an iterator for each error in this value. */
+    Errors(value) {
+        return index_1.ValueErrors.Errors(this.schema, this.references, value);
+    }
+    /** Returns true if the value matches the compiled type. */
+    Check(value) {
+        return this.checkFunc(value);
+    }
+}
+exports.TypeCheck = TypeCheck;
+// -------------------------------------------------------------------
+// Character
+// -------------------------------------------------------------------
+var Character;
+(function (Character) {
+    function DollarSign(code) {
+        return code === 36;
+    }
+    Character.DollarSign = DollarSign;
+    function IsUnderscore(code) {
+        return code === 95;
+    }
+    Character.IsUnderscore = IsUnderscore;
+    function IsAlpha(code) {
+        return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+    }
+    Character.IsAlpha = IsAlpha;
+    function IsNumeric(code) {
+        return code >= 48 && code <= 57;
+    }
+    Character.IsNumeric = IsNumeric;
+})(Character || (Character = {}));
+// -------------------------------------------------------------------
+// MemberExpression
+// -------------------------------------------------------------------
+var MemberExpression;
+(function (MemberExpression) {
+    function IsFirstCharacterNumeric(value) {
+        if (value.length === 0)
+            return false;
+        return Character.IsNumeric(value.charCodeAt(0));
+    }
+    function IsAccessor(value) {
+        if (IsFirstCharacterNumeric(value))
+            return false;
+        for (let i = 0; i < value.length; i++) {
+            const code = value.charCodeAt(i);
+            const check = Character.IsAlpha(code) || Character.IsNumeric(code) || Character.DollarSign(code) || Character.IsUnderscore(code);
+            if (!check)
+                return false;
+        }
+        return true;
+    }
+    function EscapeHyphen(key) {
+        return key.replace(/'/g, "\\'");
+    }
+    function Encode(object, key) {
+        return IsAccessor(key) ? `${object}.${key}` : `${object}['${EscapeHyphen(key)}']`;
+    }
+    MemberExpression.Encode = Encode;
+})(MemberExpression || (MemberExpression = {}));
+// -------------------------------------------------------------------
+// Identifier
+// -------------------------------------------------------------------
+var Identifier;
+(function (Identifier) {
+    function Encode($id) {
+        const buffer = [];
+        for (let i = 0; i < $id.length; i++) {
+            const code = $id.charCodeAt(i);
+            if (Character.IsNumeric(code) || Character.IsAlpha(code)) {
+                buffer.push($id.charAt(i));
+            }
+            else {
+                buffer.push(`_${code}_`);
+            }
+        }
+        return buffer.join('').replace(/__/g, '_');
+    }
+    Identifier.Encode = Encode;
+})(Identifier || (Identifier = {}));
+// -------------------------------------------------------------------
+// TypeCompiler
+// -------------------------------------------------------------------
+class TypeCompilerUnknownTypeError extends Error {
+    constructor(schema) {
+        super('TypeCompiler: Unknown type');
+        this.schema = schema;
+    }
+}
+exports.TypeCompilerUnknownTypeError = TypeCompilerUnknownTypeError;
+class TypeCompilerDereferenceError extends Error {
+    constructor(schema) {
+        super(`TypeCompiler: Unable to dereference schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.TypeCompilerDereferenceError = TypeCompilerDereferenceError;
+class TypeCompilerTypeGuardError extends Error {
+    constructor(schema) {
+        super('TypeCompiler: Preflight validation check failed to guard for the given schema');
+        this.schema = schema;
+    }
+}
+exports.TypeCompilerTypeGuardError = TypeCompilerTypeGuardError;
+/** Compiles Types for Runtime Type Checking */
+var TypeCompiler;
+(function (TypeCompiler) {
+    // -------------------------------------------------------------------
+    // Guards
+    // -------------------------------------------------------------------
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    function IsNumber(value) {
+        return typeof value === 'number' && globalThis.Number.isFinite(value);
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    // -------------------------------------------------------------------
+    // Polices
+    // -------------------------------------------------------------------
+    function IsExactOptionalProperty(value, key, expression) {
+        return index_2.TypeSystem.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`;
+    }
+    function IsObjectCheck(value) {
+        return !index_2.TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
+    }
+    function IsRecordCheck(value) {
+        return !index_2.TypeSystem.AllowArrayObjects
+            ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
+            : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`;
+    }
+    function IsNumberCheck(value) {
+        return !index_2.TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
+    }
+    function IsVoidCheck(value) {
+        return index_2.TypeSystem.AllowVoidNull ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
+    }
+    // -------------------------------------------------------------------
+    // Types
+    // -------------------------------------------------------------------
+    function* Any(schema, references, value) {
+        yield 'true';
+    }
+    function* Array(schema, references, value) {
+        const expression = CreateExpression(schema.items, references, 'value');
+        yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`;
+        if (IsNumber(schema.minItems))
+            yield `${value}.length >= ${schema.minItems}`;
+        if (IsNumber(schema.maxItems))
+            yield `${value}.length <= ${schema.maxItems}`;
+        if (schema.uniqueItems === true)
+            yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`;
+    }
+    function* BigInt(schema, references, value) {
+        yield `(typeof ${value} === 'bigint')`;
+        if (IsBigInt(schema.multipleOf))
+            yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
+        if (IsBigInt(schema.exclusiveMinimum))
+            yield `${value} > BigInt(${schema.exclusiveMinimum})`;
+        if (IsBigInt(schema.exclusiveMaximum))
+            yield `${value} < BigInt(${schema.exclusiveMaximum})`;
+        if (IsBigInt(schema.minimum))
+            yield `${value} >= BigInt(${schema.minimum})`;
+        if (IsBigInt(schema.maximum))
+            yield `${value} <= BigInt(${schema.maximum})`;
+    }
+    function* Boolean(schema, references, value) {
+        yield `typeof ${value} === 'boolean'`;
+    }
+    function* Constructor(schema, references, value) {
+        yield* Visit(schema.returns, references, `${value}.prototype`);
+    }
+    function* Date(schema, references, value) {
+        yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
+        if (IsNumber(schema.exclusiveMinimumTimestamp))
+            yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
+        if (IsNumber(schema.exclusiveMaximumTimestamp))
+            yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
+        if (IsNumber(schema.minimumTimestamp))
+            yield `${value}.getTime() >= ${schema.minimumTimestamp}`;
+        if (IsNumber(schema.maximumTimestamp))
+            yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
+    }
+    function* Function(schema, references, value) {
+        yield `typeof ${value} === 'function'`;
+    }
+    function* Integer(schema, references, value) {
+        yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
+        if (IsNumber(schema.multipleOf))
+            yield `(${value} % ${schema.multipleOf}) === 0`;
+        if (IsNumber(schema.exclusiveMinimum))
+            yield `${value} > ${schema.exclusiveMinimum}`;
+        if (IsNumber(schema.exclusiveMaximum))
+            yield `${value} < ${schema.exclusiveMaximum}`;
+        if (IsNumber(schema.minimum))
+            yield `${value} >= ${schema.minimum}`;
+        if (IsNumber(schema.maximum))
+            yield `${value} <= ${schema.maximum}`;
+    }
+    function* Intersect(schema, references, value) {
+        if (schema.unevaluatedProperties === undefined) {
+            const expressions = schema.allOf.map((schema) => CreateExpression(schema, references, value));
+            yield `${expressions.join(' && ')}`;
+        }
+        else if (schema.unevaluatedProperties === false) {
+            // prettier-ignore
+            const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ');
+            const expressions = schema.allOf.map((schema) => CreateExpression(schema, references, value));
+            const expression1 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key))`;
+            yield `${expressions.join(' && ')} && ${expression1}`;
+        }
+        else if (typeof schema.unevaluatedProperties === 'object') {
+            // prettier-ignore
+            const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ');
+            const expressions = schema.allOf.map((schema) => CreateExpression(schema, references, value));
+            const expression1 = CreateExpression(schema.unevaluatedProperties, references, 'value[key]');
+            const expression2 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key) || ${expression1})`;
+            yield `${expressions.join(' && ')} && ${expression2}`;
+        }
+    }
+    function* Literal(schema, references, value) {
+        if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
+            yield `${value} === ${schema.const}`;
+        }
+        else {
+            yield `${value} === '${schema.const}'`;
+        }
+    }
+    function* Never(schema, references, value) {
+        yield `false`;
+    }
+    function* Not(schema, references, value) {
+        const left = CreateExpression(schema.allOf[0].not, references, value);
+        const right = CreateExpression(schema.allOf[1], references, value);
+        yield `!${left} && ${right}`;
+    }
+    function* Null(schema, references, value) {
+        yield `${value} === null`;
+    }
+    function* Number(schema, references, value) {
+        yield IsNumberCheck(value);
+        if (IsNumber(schema.multipleOf))
+            yield `(${value} % ${schema.multipleOf}) === 0`;
+        if (IsNumber(schema.exclusiveMinimum))
+            yield `${value} > ${schema.exclusiveMinimum}`;
+        if (IsNumber(schema.exclusiveMaximum))
+            yield `${value} < ${schema.exclusiveMaximum}`;
+        if (IsNumber(schema.minimum))
+            yield `${value} >= ${schema.minimum}`;
+        if (IsNumber(schema.maximum))
+            yield `${value} <= ${schema.maximum}`;
+    }
+    function* Object(schema, references, value) {
+        yield IsObjectCheck(value);
+        if (IsNumber(schema.minProperties))
+            yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
+        if (IsNumber(schema.maxProperties))
+            yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
+        const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
+        for (const knownKey of knownKeys) {
+            const memberExpression = MemberExpression.Encode(value, knownKey);
+            const property = schema.properties[knownKey];
+            if (schema.required && schema.required.includes(knownKey)) {
+                yield* Visit(property, references, memberExpression);
+                if (Types.ExtendsUndefined.Check(property))
+                    yield `('${knownKey}' in ${value})`;
+            }
+            else {
+                const expression = CreateExpression(property, references, memberExpression);
+                yield IsExactOptionalProperty(value, knownKey, expression);
+            }
+        }
+        if (schema.additionalProperties === false) {
+            if (schema.required && schema.required.length === knownKeys.length) {
+                yield `Object.getOwnPropertyNames(${value}).length === ${knownKeys.length}`;
+            }
+            else {
+                const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
+                yield `Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key))`;
+            }
+        }
+        if (typeof schema.additionalProperties === 'object') {
+            const expression = CreateExpression(schema.additionalProperties, references, 'value[key]');
+            const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
+            yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
+        }
+    }
+    function* Promise(schema, references, value) {
+        yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
+    }
+    function* Record(schema, references, value) {
+        yield IsRecordCheck(value);
+        if (IsNumber(schema.minProperties))
+            yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
+        if (IsNumber(schema.maxProperties))
+            yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
+        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
+        const local = PushLocal(`new RegExp(/${keyPattern}/)`);
+        yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`;
+        const expression = CreateExpression(valueSchema, references, 'value');
+        yield `Object.values(${value}).every(value => ${expression})`;
+    }
+    function* Ref(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new TypeCompilerDereferenceError(schema);
+        const target = references[index];
+        // Reference: If we have seen this reference before we can just yield and return
+        // the function call. If this isn't the case we defer to visit to generate and
+        // set the function for subsequent passes. Consider for refactor.
+        if (state_local_function_names.has(schema.$ref))
+            return yield `${CreateFunctionName(schema.$ref)}(${value})`;
+        yield* Visit(target, references, value);
+    }
+    function* String(schema, references, value) {
+        yield `(typeof ${value} === 'string')`;
+        if (IsNumber(schema.minLength))
+            yield `${value}.length >= ${schema.minLength}`;
+        if (IsNumber(schema.maxLength))
+            yield `${value}.length <= ${schema.maxLength}`;
+        if (schema.pattern !== undefined) {
+            const local = PushLocal(`${new RegExp(schema.pattern)};`);
+            yield `${local}.test(${value})`;
+        }
+        if (schema.format !== undefined) {
+            yield `format('${schema.format}', ${value})`;
+        }
+    }
+    function* Symbol(schema, references, value) {
+        yield `(typeof ${value} === 'symbol')`;
+    }
+    function* TemplateLiteral(schema, references, value) {
+        yield `(typeof ${value} === 'string')`;
+        const local = PushLocal(`${new RegExp(schema.pattern)};`);
+        yield `${local}.test(${value})`;
+    }
+    function* This(schema, references, value) {
+        const func = CreateFunctionName(schema.$ref);
+        yield `${func}(${value})`;
+    }
+    function* Tuple(schema, references, value) {
+        yield `(Array.isArray(${value}))`;
+        if (schema.items === undefined)
+            return yield `${value}.length === 0`;
+        yield `(${value}.length === ${schema.maxItems})`;
+        for (let i = 0; i < schema.items.length; i++) {
+            const expression = CreateExpression(schema.items[i], references, `${value}[${i}]`);
+            yield `${expression}`;
+        }
+    }
+    function* Undefined(schema, references, value) {
+        yield `${value} === undefined`;
+    }
+    function* Union(schema, references, value) {
+        const expressions = schema.anyOf.map((schema) => CreateExpression(schema, references, value));
+        yield `(${expressions.join(' || ')})`;
+    }
+    function* Uint8Array(schema, references, value) {
+        yield `${value} instanceof Uint8Array`;
+        if (IsNumber(schema.maxByteLength))
+            yield `(${value}.length <= ${schema.maxByteLength})`;
+        if (IsNumber(schema.minByteLength))
+            yield `(${value}.length >= ${schema.minByteLength})`;
+    }
+    function* Unknown(schema, references, value) {
+        yield 'true';
+    }
+    function* Void(schema, references, value) {
+        yield IsVoidCheck(value);
+    }
+    function* UserDefined(schema, references, value) {
+        const schema_key = `schema_key_${state_remote_custom_types.size}`;
+        state_remote_custom_types.set(schema_key, schema);
+        yield `custom('${schema[Types.Kind]}', '${schema_key}', ${value})`;
+    }
+    function* Visit(schema, references, value) {
+        const references_ = IsString(schema.$id) ? [...references, schema] : references;
+        const schema_ = schema;
+        // Reference: Referenced schemas can originate from either additional schemas
+        // or inline in the schema itself. Ideally the recursive path should align to
+        // reference path. Consider for refactor.
+        if (IsString(schema.$id) && !state_local_function_names.has(schema.$id)) {
+            state_local_function_names.add(schema.$id);
+            const name = CreateFunctionName(schema.$id);
+            const body = CreateFunction(name, schema, references, 'value');
+            PushFunction(body);
+            yield `${name}(${value})`;
+            return;
+        }
+        switch (schema_[Types.Kind]) {
+            case 'Any':
+                return yield* Any(schema_, references_, value);
+            case 'Array':
+                return yield* Array(schema_, references_, value);
+            case 'BigInt':
+                return yield* BigInt(schema_, references_, value);
+            case 'Boolean':
+                return yield* Boolean(schema_, references_, value);
+            case 'Constructor':
+                return yield* Constructor(schema_, references_, value);
+            case 'Date':
+                return yield* Date(schema_, references_, value);
+            case 'Function':
+                return yield* Function(schema_, references_, value);
+            case 'Integer':
+                return yield* Integer(schema_, references_, value);
+            case 'Intersect':
+                return yield* Intersect(schema_, references_, value);
+            case 'Literal':
+                return yield* Literal(schema_, references_, value);
+            case 'Never':
+                return yield* Never(schema_, references_, value);
+            case 'Not':
+                return yield* Not(schema_, references_, value);
+            case 'Null':
+                return yield* Null(schema_, references_, value);
+            case 'Number':
+                return yield* Number(schema_, references_, value);
+            case 'Object':
+                return yield* Object(schema_, references_, value);
+            case 'Promise':
+                return yield* Promise(schema_, references_, value);
+            case 'Record':
+                return yield* Record(schema_, references_, value);
+            case 'Ref':
+                return yield* Ref(schema_, references_, value);
+            case 'String':
+                return yield* String(schema_, references_, value);
+            case 'Symbol':
+                return yield* Symbol(schema_, references_, value);
+            case 'TemplateLiteral':
+                return yield* TemplateLiteral(schema_, references_, value);
+            case 'This':
+                return yield* This(schema_, references_, value);
+            case 'Tuple':
+                return yield* Tuple(schema_, references_, value);
+            case 'Undefined':
+                return yield* Undefined(schema_, references_, value);
+            case 'Union':
+                return yield* Union(schema_, references_, value);
+            case 'Uint8Array':
+                return yield* Uint8Array(schema_, references_, value);
+            case 'Unknown':
+                return yield* Unknown(schema_, references_, value);
+            case 'Void':
+                return yield* Void(schema_, references_, value);
+            default:
+                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+                    throw new TypeCompilerUnknownTypeError(schema);
+                return yield* UserDefined(schema_, references_, value);
+        }
+    }
+    // -------------------------------------------------------------------
+    // Compiler State
+    // -------------------------------------------------------------------
+    const state_local_variables = new Set(); // local variables and functions
+    const state_local_function_names = new Set(); // local function names used call ref validators
+    const state_remote_custom_types = new Map(); // remote custom types used during compilation
+    function ResetCompiler() {
+        state_local_variables.clear();
+        state_local_function_names.clear();
+        state_remote_custom_types.clear();
+    }
+    function CreateExpression(schema, references, value) {
+        return `(${[...Visit(schema, references, value)].join(' && ')})`;
+    }
+    function CreateFunctionName($id) {
+        return `check_${Identifier.Encode($id)}`;
+    }
+    function CreateFunction(name, schema, references, value) {
+        const expression = [...Visit(schema, references, value)].map((condition) => `    ${condition}`).join(' &&\n');
+        return `function ${name}(value) {\n  return (\n${expression}\n )\n}`;
+    }
+    function PushFunction(functionBody) {
+        state_local_variables.add(functionBody);
+    }
+    function PushLocal(expression) {
+        const local = `local_${state_local_variables.size}`;
+        state_local_variables.add(`const ${local} = ${expression}`);
+        return local;
+    }
+    function GetLocals() {
+        return [...state_local_variables.values()];
+    }
+    // -------------------------------------------------------------------
+    // Compile
+    // -------------------------------------------------------------------
+    function Build(schema, references) {
+        ResetCompiler();
+        const check = CreateFunction('check', schema, references, 'value');
+        const locals = GetLocals();
+        return `${locals.join('\n')}\nreturn ${check}`;
+    }
+    /** Returns the generated assertion code used to validate this type. */
+    function Code(schema, references = []) {
+        if (!Types.TypeGuard.TSchema(schema))
+            throw new TypeCompilerTypeGuardError(schema);
+        for (const schema of references)
+            if (!Types.TypeGuard.TSchema(schema))
+                throw new TypeCompilerTypeGuardError(schema);
+        return Build(schema, references);
+    }
+    TypeCompiler.Code = Code;
+    /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
+    function Compile(schema, references = []) {
+        const code = Code(schema, references);
+        const custom_schemas = new Map(state_remote_custom_types);
+        const compiledFunction = globalThis.Function('custom', 'format', 'hash', code);
+        const checkFunction = compiledFunction((kind, schema_key, value) => {
+            if (!Types.TypeRegistry.Has(kind) || !custom_schemas.has(schema_key))
+                return false;
+            const schema = custom_schemas.get(schema_key);
+            const func = Types.TypeRegistry.Get(kind);
+            return func(schema, value);
+        }, (format, value) => {
+            if (!Types.FormatRegistry.Has(format))
+                return false;
+            const func = Types.FormatRegistry.Get(format);
+            return func(value);
+        }, (value) => {
+            return hash_1.ValueHash.Create(value);
+        });
+        return new TypeCheck(schema, references, checkFunction, code);
+    }
+    TypeCompiler.Compile = Compile;
+})(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/compiler/index.d.ts

@@ -0,0 +1,2 @@
+export { ValueError, ValueErrorType } from '../errors/index';
+export * from './compiler';

backend/node_modules/jest/node_modules/@sinclair/typebox/compiler/index.js

@@ -0,0 +1,47 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/compiler
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueErrorType = void 0;
+var index_1 = require("../errors/index");
+Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
+__exportStar(require("./compiler"), exports);

backend/node_modules/jest/node_modules/@sinclair/typebox/errors/errors.d.ts

@@ -0,0 +1,88 @@
+import * as Types from '../typebox';
+export declare enum ValueErrorType {
+    Array = 0,
+    ArrayMinItems = 1,
+    ArrayMaxItems = 2,
+    ArrayUniqueItems = 3,
+    BigInt = 4,
+    BigIntMultipleOf = 5,
+    BigIntExclusiveMinimum = 6,
+    BigIntExclusiveMaximum = 7,
+    BigIntMinimum = 8,
+    BigIntMaximum = 9,
+    Boolean = 10,
+    Date = 11,
+    DateExclusiveMinimumTimestamp = 12,
+    DateExclusiveMaximumTimestamp = 13,
+    DateMinimumTimestamp = 14,
+    DateMaximumTimestamp = 15,
+    Function = 16,
+    Integer = 17,
+    IntegerMultipleOf = 18,
+    IntegerExclusiveMinimum = 19,
+    IntegerExclusiveMaximum = 20,
+    IntegerMinimum = 21,
+    IntegerMaximum = 22,
+    Intersect = 23,
+    IntersectUnevaluatedProperties = 24,
+    Literal = 25,
+    Never = 26,
+    Not = 27,
+    Null = 28,
+    Number = 29,
+    NumberMultipleOf = 30,
+    NumberExclusiveMinimum = 31,
+    NumberExclusiveMaximum = 32,
+    NumberMinumum = 33,
+    NumberMaximum = 34,
+    Object = 35,
+    ObjectMinProperties = 36,
+    ObjectMaxProperties = 37,
+    ObjectAdditionalProperties = 38,
+    ObjectRequiredProperties = 39,
+    Promise = 40,
+    RecordKeyNumeric = 41,
+    RecordKeyString = 42,
+    String = 43,
+    StringMinLength = 44,
+    StringMaxLength = 45,
+    StringPattern = 46,
+    StringFormatUnknown = 47,
+    StringFormat = 48,
+    Symbol = 49,
+    TupleZeroLength = 50,
+    TupleLength = 51,
+    Undefined = 52,
+    Union = 53,
+    Uint8Array = 54,
+    Uint8ArrayMinByteLength = 55,
+    Uint8ArrayMaxByteLength = 56,
+    Void = 57,
+    Custom = 58
+}
+export interface ValueError {
+    type: ValueErrorType;
+    schema: Types.TSchema;
+    path: string;
+    value: unknown;
+    message: string;
+}
+export declare class ValueErrorIterator {
+    private readonly iterator;
+    constructor(iterator: IterableIterator<ValueError>);
+    [Symbol.iterator](): IterableIterator<ValueError>;
+    /** Returns the first value error or undefined if no errors */
+    First(): ValueError | undefined;
+}
+export declare class ValueErrorsUnknownTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueErrorsDereferenceError extends Error {
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
+}
+/** Provides functionality to generate a sequence of errors against a TypeBox type.  */
+export declare namespace ValueErrors {
+    function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): ValueErrorIterator;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/errors/errors.js

@@ -0,0 +1,609 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueErrors = exports.ValueErrorsDereferenceError = exports.ValueErrorsUnknownTypeError = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/errors
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+const Types = require("../typebox");
+const index_1 = require("../system/index");
+const hash_1 = require("../value/hash");
+// -------------------------------------------------------------------
+// ValueErrorType
+// -------------------------------------------------------------------
+var ValueErrorType;
+(function (ValueErrorType) {
+    ValueErrorType[ValueErrorType["Array"] = 0] = "Array";
+    ValueErrorType[ValueErrorType["ArrayMinItems"] = 1] = "ArrayMinItems";
+    ValueErrorType[ValueErrorType["ArrayMaxItems"] = 2] = "ArrayMaxItems";
+    ValueErrorType[ValueErrorType["ArrayUniqueItems"] = 3] = "ArrayUniqueItems";
+    ValueErrorType[ValueErrorType["BigInt"] = 4] = "BigInt";
+    ValueErrorType[ValueErrorType["BigIntMultipleOf"] = 5] = "BigIntMultipleOf";
+    ValueErrorType[ValueErrorType["BigIntExclusiveMinimum"] = 6] = "BigIntExclusiveMinimum";
+    ValueErrorType[ValueErrorType["BigIntExclusiveMaximum"] = 7] = "BigIntExclusiveMaximum";
+    ValueErrorType[ValueErrorType["BigIntMinimum"] = 8] = "BigIntMinimum";
+    ValueErrorType[ValueErrorType["BigIntMaximum"] = 9] = "BigIntMaximum";
+    ValueErrorType[ValueErrorType["Boolean"] = 10] = "Boolean";
+    ValueErrorType[ValueErrorType["Date"] = 11] = "Date";
+    ValueErrorType[ValueErrorType["DateExclusiveMinimumTimestamp"] = 12] = "DateExclusiveMinimumTimestamp";
+    ValueErrorType[ValueErrorType["DateExclusiveMaximumTimestamp"] = 13] = "DateExclusiveMaximumTimestamp";
+    ValueErrorType[ValueErrorType["DateMinimumTimestamp"] = 14] = "DateMinimumTimestamp";
+    ValueErrorType[ValueErrorType["DateMaximumTimestamp"] = 15] = "DateMaximumTimestamp";
+    ValueErrorType[ValueErrorType["Function"] = 16] = "Function";
+    ValueErrorType[ValueErrorType["Integer"] = 17] = "Integer";
+    ValueErrorType[ValueErrorType["IntegerMultipleOf"] = 18] = "IntegerMultipleOf";
+    ValueErrorType[ValueErrorType["IntegerExclusiveMinimum"] = 19] = "IntegerExclusiveMinimum";
+    ValueErrorType[ValueErrorType["IntegerExclusiveMaximum"] = 20] = "IntegerExclusiveMaximum";
+    ValueErrorType[ValueErrorType["IntegerMinimum"] = 21] = "IntegerMinimum";
+    ValueErrorType[ValueErrorType["IntegerMaximum"] = 22] = "IntegerMaximum";
+    ValueErrorType[ValueErrorType["Intersect"] = 23] = "Intersect";
+    ValueErrorType[ValueErrorType["IntersectUnevaluatedProperties"] = 24] = "IntersectUnevaluatedProperties";
+    ValueErrorType[ValueErrorType["Literal"] = 25] = "Literal";
+    ValueErrorType[ValueErrorType["Never"] = 26] = "Never";
+    ValueErrorType[ValueErrorType["Not"] = 27] = "Not";
+    ValueErrorType[ValueErrorType["Null"] = 28] = "Null";
+    ValueErrorType[ValueErrorType["Number"] = 29] = "Number";
+    ValueErrorType[ValueErrorType["NumberMultipleOf"] = 30] = "NumberMultipleOf";
+    ValueErrorType[ValueErrorType["NumberExclusiveMinimum"] = 31] = "NumberExclusiveMinimum";
+    ValueErrorType[ValueErrorType["NumberExclusiveMaximum"] = 32] = "NumberExclusiveMaximum";
+    ValueErrorType[ValueErrorType["NumberMinumum"] = 33] = "NumberMinumum";
+    ValueErrorType[ValueErrorType["NumberMaximum"] = 34] = "NumberMaximum";
+    ValueErrorType[ValueErrorType["Object"] = 35] = "Object";
+    ValueErrorType[ValueErrorType["ObjectMinProperties"] = 36] = "ObjectMinProperties";
+    ValueErrorType[ValueErrorType["ObjectMaxProperties"] = 37] = "ObjectMaxProperties";
+    ValueErrorType[ValueErrorType["ObjectAdditionalProperties"] = 38] = "ObjectAdditionalProperties";
+    ValueErrorType[ValueErrorType["ObjectRequiredProperties"] = 39] = "ObjectRequiredProperties";
+    ValueErrorType[ValueErrorType["Promise"] = 40] = "Promise";
+    ValueErrorType[ValueErrorType["RecordKeyNumeric"] = 41] = "RecordKeyNumeric";
+    ValueErrorType[ValueErrorType["RecordKeyString"] = 42] = "RecordKeyString";
+    ValueErrorType[ValueErrorType["String"] = 43] = "String";
+    ValueErrorType[ValueErrorType["StringMinLength"] = 44] = "StringMinLength";
+    ValueErrorType[ValueErrorType["StringMaxLength"] = 45] = "StringMaxLength";
+    ValueErrorType[ValueErrorType["StringPattern"] = 46] = "StringPattern";
+    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 47] = "StringFormatUnknown";
+    ValueErrorType[ValueErrorType["StringFormat"] = 48] = "StringFormat";
+    ValueErrorType[ValueErrorType["Symbol"] = 49] = "Symbol";
+    ValueErrorType[ValueErrorType["TupleZeroLength"] = 50] = "TupleZeroLength";
+    ValueErrorType[ValueErrorType["TupleLength"] = 51] = "TupleLength";
+    ValueErrorType[ValueErrorType["Undefined"] = 52] = "Undefined";
+    ValueErrorType[ValueErrorType["Union"] = 53] = "Union";
+    ValueErrorType[ValueErrorType["Uint8Array"] = 54] = "Uint8Array";
+    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 55] = "Uint8ArrayMinByteLength";
+    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 56] = "Uint8ArrayMaxByteLength";
+    ValueErrorType[ValueErrorType["Void"] = 57] = "Void";
+    ValueErrorType[ValueErrorType["Custom"] = 58] = "Custom";
+})(ValueErrorType = exports.ValueErrorType || (exports.ValueErrorType = {}));
+// -------------------------------------------------------------------
+// ValueErrorIterator
+// -------------------------------------------------------------------
+class ValueErrorIterator {
+    constructor(iterator) {
+        this.iterator = iterator;
+    }
+    [Symbol.iterator]() {
+        return this.iterator;
+    }
+    /** Returns the first value error or undefined if no errors */
+    First() {
+        const next = this.iterator.next();
+        return next.done ? undefined : next.value;
+    }
+}
+exports.ValueErrorIterator = ValueErrorIterator;
+// -------------------------------------------------------------------
+// ValueErrors
+// -------------------------------------------------------------------
+class ValueErrorsUnknownTypeError extends Error {
+    constructor(schema) {
+        super('ValueErrors: Unknown type');
+        this.schema = schema;
+    }
+}
+exports.ValueErrorsUnknownTypeError = ValueErrorsUnknownTypeError;
+class ValueErrorsDereferenceError extends Error {
+    constructor(schema) {
+        super(`ValueErrors: Unable to dereference schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.ValueErrorsDereferenceError = ValueErrorsDereferenceError;
+/** Provides functionality to generate a sequence of errors against a TypeBox type.  */
+var ValueErrors;
+(function (ValueErrors) {
+    // ----------------------------------------------------------------------
+    // Guards
+    // ----------------------------------------------------------------------
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    function IsInteger(value) {
+        return globalThis.Number.isInteger(value);
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsDefined(value) {
+        return value !== undefined;
+    }
+    // ----------------------------------------------------------------------
+    // Policies
+    // ----------------------------------------------------------------------
+    function IsExactOptionalProperty(value, key) {
+        return index_1.TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
+    }
+    function IsObject(value) {
+        const result = typeof value === 'object' && value !== null;
+        return index_1.TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value);
+    }
+    function IsRecordObject(value) {
+        return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array);
+    }
+    function IsNumber(value) {
+        const result = typeof value === 'number';
+        return index_1.TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value);
+    }
+    function IsVoid(value) {
+        const result = value === undefined;
+        return index_1.TypeSystem.AllowVoidNull ? result || value === null : result;
+    }
+    // ----------------------------------------------------------------------
+    // Types
+    // ----------------------------------------------------------------------
+    function* Any(schema, references, path, value) { }
+    function* Array(schema, references, path, value) {
+        if (!globalThis.Array.isArray(value)) {
+            return yield { type: ValueErrorType.Array, schema, path, value, message: `Expected array` };
+        }
+        if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
+            yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` };
+        }
+        if (IsDefined(schema.maxItems) && !(value.length <= schema.maxItems)) {
+            yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` };
+        }
+        // prettier-ignore
+        if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
+            const hashed = hash_1.ValueHash.Create(element);
+            if (set.has(hashed)) {
+                return false;
+            }
+            else {
+                set.add(hashed);
+            }
+        } return true; })())) {
+            yield { type: ValueErrorType.ArrayUniqueItems, schema, path, value, message: `Expected array elements to be unique` };
+        }
+        for (let i = 0; i < value.length; i++) {
+            yield* Visit(schema.items, references, `${path}/${i}`, value[i]);
+        }
+    }
+    function* BigInt(schema, references, path, value) {
+        if (!IsBigInt(value)) {
+            return yield { type: ValueErrorType.BigInt, schema, path, value, message: `Expected bigint` };
+        }
+        if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === globalThis.BigInt(0))) {
+            yield { type: ValueErrorType.BigIntMultipleOf, schema, path, value, message: `Expected bigint to be a multiple of ${schema.multipleOf}` };
+        }
+        if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+            yield { type: ValueErrorType.BigIntExclusiveMinimum, schema, path, value, message: `Expected bigint to be greater than ${schema.exclusiveMinimum}` };
+        }
+        if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+            yield { type: ValueErrorType.BigIntExclusiveMaximum, schema, path, value, message: `Expected bigint to be less than ${schema.exclusiveMaximum}` };
+        }
+        if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
+            yield { type: ValueErrorType.BigIntMinimum, schema, path, value, message: `Expected bigint to be greater or equal to ${schema.minimum}` };
+        }
+        if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
+            yield { type: ValueErrorType.BigIntMaximum, schema, path, value, message: `Expected bigint to be less or equal to ${schema.maximum}` };
+        }
+    }
+    function* Boolean(schema, references, path, value) {
+        if (!(typeof value === 'boolean')) {
+            return yield { type: ValueErrorType.Boolean, schema, path, value, message: `Expected boolean` };
+        }
+    }
+    function* Constructor(schema, references, path, value) {
+        yield* Visit(schema.returns, references, path, value.prototype);
+    }
+    function* Date(schema, references, path, value) {
+        if (!(value instanceof globalThis.Date)) {
+            return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` };
+        }
+        if (!globalThis.isFinite(value.getTime())) {
+            return yield { type: ValueErrorType.Date, schema, path, value, message: `Invalid Date` };
+        }
+        if (IsDefined(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+            yield { type: ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` };
+        }
+        if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+            yield { type: ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less than ${schema.exclusiveMaximum}` };
+        }
+        if (IsDefined(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
+            yield { type: ValueErrorType.DateMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater or equal to ${schema.minimum}` };
+        }
+        if (IsDefined(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
+            yield { type: ValueErrorType.DateMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less or equal to ${schema.maximum}` };
+        }
+    }
+    function* Function(schema, references, path, value) {
+        if (!(typeof value === 'function')) {
+            return yield { type: ValueErrorType.Function, schema, path, value, message: `Expected function` };
+        }
+    }
+    function* Integer(schema, references, path, value) {
+        if (!IsInteger(value)) {
+            return yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` };
+        }
+        if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+            yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` };
+        }
+        if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+            yield { type: ValueErrorType.IntegerExclusiveMinimum, schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` };
+        }
+        if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+            yield { type: ValueErrorType.IntegerExclusiveMaximum, schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` };
+        }
+        if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
+            yield { type: ValueErrorType.IntegerMinimum, schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` };
+        }
+        if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
+            yield { type: ValueErrorType.IntegerMaximum, schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` };
+        }
+    }
+    function* Intersect(schema, references, path, value) {
+        for (const subschema of schema.allOf) {
+            const next = Visit(subschema, references, path, value).next();
+            if (!next.done) {
+                yield next.value;
+                yield { type: ValueErrorType.Intersect, schema, path, value, message: `Expected all sub schemas to be valid` };
+                return;
+            }
+        }
+        if (schema.unevaluatedProperties === false) {
+            const schemaKeys = Types.KeyResolver.Resolve(schema);
+            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
+            for (const valueKey of valueKeys) {
+                if (!schemaKeys.includes(valueKey)) {
+                    yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Unexpected property` };
+                }
+            }
+        }
+        if (typeof schema.unevaluatedProperties === 'object') {
+            const schemaKeys = Types.KeyResolver.Resolve(schema);
+            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
+            for (const valueKey of valueKeys) {
+                if (!schemaKeys.includes(valueKey)) {
+                    const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next();
+                    if (!next.done) {
+                        yield next.value;
+                        yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Invalid additional property` };
+                        return;
+                    }
+                }
+            }
+        }
+    }
+    function* Literal(schema, references, path, value) {
+        if (!(value === schema.const)) {
+            const error = typeof schema.const === 'string' ? `'${schema.const}'` : schema.const;
+            return yield { type: ValueErrorType.Literal, schema, path, value, message: `Expected ${error}` };
+        }
+    }
+    function* Never(schema, references, path, value) {
+        yield { type: ValueErrorType.Never, schema, path, value, message: `Value cannot be validated` };
+    }
+    function* Not(schema, references, path, value) {
+        if (Visit(schema.allOf[0].not, references, path, value).next().done === true) {
+            yield { type: ValueErrorType.Not, schema, path, value, message: `Value should not validate` };
+        }
+        yield* Visit(schema.allOf[1], references, path, value);
+    }
+    function* Null(schema, references, path, value) {
+        if (!(value === null)) {
+            return yield { type: ValueErrorType.Null, schema, path, value, message: `Expected null` };
+        }
+    }
+    function* Number(schema, references, path, value) {
+        if (!IsNumber(value)) {
+            return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` };
+        }
+        if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+            yield { type: ValueErrorType.NumberMultipleOf, schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` };
+        }
+        if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+            yield { type: ValueErrorType.NumberExclusiveMinimum, schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` };
+        }
+        if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+            yield { type: ValueErrorType.NumberExclusiveMaximum, schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` };
+        }
+        if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
+            yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` };
+        }
+        if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
+            yield { type: ValueErrorType.NumberMinumum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
+        }
+    }
+    function* Object(schema, references, path, value) {
+        if (!IsObject(value)) {
+            return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+        }
+        if (IsDefined(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+            yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` };
+        }
+        if (IsDefined(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+            yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` };
+        }
+        const requiredKeys = globalThis.Array.isArray(schema.required) ? schema.required : [];
+        const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
+        const unknownKeys = globalThis.Object.getOwnPropertyNames(value);
+        for (const knownKey of knownKeys) {
+            const property = schema.properties[knownKey];
+            if (schema.required && schema.required.includes(knownKey)) {
+                yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey]);
+                if (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
+                    yield { type: ValueErrorType.ObjectRequiredProperties, schema: property, path: `${path}/${knownKey}`, value: undefined, message: `Expected required property` };
+                }
+            }
+            else {
+                if (IsExactOptionalProperty(value, knownKey)) {
+                    yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey]);
+                }
+            }
+        }
+        for (const requiredKey of requiredKeys) {
+            if (unknownKeys.includes(requiredKey))
+                continue;
+            yield { type: ValueErrorType.ObjectRequiredProperties, schema: schema.properties[requiredKey], path: `${path}/${requiredKey}`, value: undefined, message: `Expected required property` };
+        }
+        if (schema.additionalProperties === false) {
+            for (const valueKey of unknownKeys) {
+                if (!knownKeys.includes(valueKey)) {
+                    yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${valueKey}`, value: value[valueKey], message: `Unexpected property` };
+                }
+            }
+        }
+        if (typeof schema.additionalProperties === 'object') {
+            for (const valueKey of unknownKeys) {
+                if (knownKeys.includes(valueKey))
+                    continue;
+                yield* Visit(schema.additionalProperties, references, `${path}/${valueKey}`, value[valueKey]);
+            }
+        }
+    }
+    function* Promise(schema, references, path, value) {
+        if (!(typeof value === 'object' && typeof value.then === 'function')) {
+            yield { type: ValueErrorType.Promise, schema, path, value, message: `Expected Promise` };
+        }
+    }
+    function* Record(schema, references, path, value) {
+        if (!IsRecordObject(value)) {
+            return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected record object` };
+        }
+        if (IsDefined(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+            yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` };
+        }
+        if (IsDefined(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+            yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` };
+        }
+        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
+        const regex = new RegExp(keyPattern);
+        if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
+            const numeric = keyPattern === Types.PatternNumberExact;
+            const type = numeric ? ValueErrorType.RecordKeyNumeric : ValueErrorType.RecordKeyString;
+            const message = numeric ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings';
+            return yield { type, schema, path, value, message };
+        }
+        for (const [propKey, propValue] of globalThis.Object.entries(value)) {
+            yield* Visit(valueSchema, references, `${path}/${propKey}`, propValue);
+        }
+    }
+    function* Ref(schema, references, path, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueErrorsDereferenceError(schema);
+        const target = references[index];
+        yield* Visit(target, references, path, value);
+    }
+    function* String(schema, references, path, value) {
+        if (!IsString(value)) {
+            return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' };
+        }
+        if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
+            yield { type: ValueErrorType.StringMinLength, schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` };
+        }
+        if (IsDefined(schema.maxLength) && !(value.length <= schema.maxLength)) {
+            yield { type: ValueErrorType.StringMaxLength, schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` };
+        }
+        if (schema.pattern !== undefined) {
+            const regex = new RegExp(schema.pattern);
+            if (!regex.test(value)) {
+                yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` };
+            }
+        }
+        if (schema.format !== undefined) {
+            if (!Types.FormatRegistry.Has(schema.format)) {
+                yield { type: ValueErrorType.StringFormatUnknown, schema, path, value, message: `Unknown string format '${schema.format}'` };
+            }
+            else {
+                const format = Types.FormatRegistry.Get(schema.format);
+                if (!format(value)) {
+                    yield { type: ValueErrorType.StringFormat, schema, path, value, message: `Expected string to match format '${schema.format}'` };
+                }
+            }
+        }
+    }
+    function* Symbol(schema, references, path, value) {
+        if (!(typeof value === 'symbol')) {
+            return yield { type: ValueErrorType.Symbol, schema, path, value, message: 'Expected symbol' };
+        }
+    }
+    function* TemplateLiteral(schema, references, path, value) {
+        if (!IsString(value)) {
+            return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' };
+        }
+        const regex = new RegExp(schema.pattern);
+        if (!regex.test(value)) {
+            yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` };
+        }
+    }
+    function* This(schema, references, path, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueErrorsDereferenceError(schema);
+        const target = references[index];
+        yield* Visit(target, references, path, value);
+    }
+    function* Tuple(schema, references, path, value) {
+        if (!globalThis.Array.isArray(value)) {
+            return yield { type: ValueErrorType.Array, schema, path, value, message: 'Expected Array' };
+        }
+        if (schema.items === undefined && !(value.length === 0)) {
+            return yield { type: ValueErrorType.TupleZeroLength, schema, path, value, message: 'Expected tuple to have 0 elements' };
+        }
+        if (!(value.length === schema.maxItems)) {
+            yield { type: ValueErrorType.TupleLength, schema, path, value, message: `Expected tuple to have ${schema.maxItems} elements` };
+        }
+        if (!schema.items) {
+            return;
+        }
+        for (let i = 0; i < schema.items.length; i++) {
+            yield* Visit(schema.items[i], references, `${path}/${i}`, value[i]);
+        }
+    }
+    function* Undefined(schema, references, path, value) {
+        if (!(value === undefined)) {
+            yield { type: ValueErrorType.Undefined, schema, path, value, message: `Expected undefined` };
+        }
+    }
+    function* Union(schema, references, path, value) {
+        const errors = [];
+        for (const inner of schema.anyOf) {
+            const variantErrors = [...Visit(inner, references, path, value)];
+            if (variantErrors.length === 0)
+                return;
+            errors.push(...variantErrors);
+        }
+        if (errors.length > 0) {
+            yield { type: ValueErrorType.Union, schema, path, value, message: 'Expected value of union' };
+        }
+        for (const error of errors) {
+            yield error;
+        }
+    }
+    function* Uint8Array(schema, references, path, value) {
+        if (!(value instanceof globalThis.Uint8Array)) {
+            return yield { type: ValueErrorType.Uint8Array, schema, path, value, message: `Expected Uint8Array` };
+        }
+        if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
+            yield { type: ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` };
+        }
+        if (IsDefined(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
+            yield { type: ValueErrorType.Uint8ArrayMinByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` };
+        }
+    }
+    function* Unknown(schema, references, path, value) { }
+    function* Void(schema, references, path, value) {
+        if (!IsVoid(value)) {
+            return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected void` };
+        }
+    }
+    function* UserDefined(schema, references, path, value) {
+        const check = Types.TypeRegistry.Get(schema[Types.Kind]);
+        if (!check(schema, value)) {
+            return yield { type: ValueErrorType.Custom, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` };
+        }
+    }
+    function* Visit(schema, references, path, value) {
+        const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
+        const schema_ = schema;
+        switch (schema_[Types.Kind]) {
+            case 'Any':
+                return yield* Any(schema_, references_, path, value);
+            case 'Array':
+                return yield* Array(schema_, references_, path, value);
+            case 'BigInt':
+                return yield* BigInt(schema_, references_, path, value);
+            case 'Boolean':
+                return yield* Boolean(schema_, references_, path, value);
+            case 'Constructor':
+                return yield* Constructor(schema_, references_, path, value);
+            case 'Date':
+                return yield* Date(schema_, references_, path, value);
+            case 'Function':
+                return yield* Function(schema_, references_, path, value);
+            case 'Integer':
+                return yield* Integer(schema_, references_, path, value);
+            case 'Intersect':
+                return yield* Intersect(schema_, references_, path, value);
+            case 'Literal':
+                return yield* Literal(schema_, references_, path, value);
+            case 'Never':
+                return yield* Never(schema_, references_, path, value);
+            case 'Not':
+                return yield* Not(schema_, references_, path, value);
+            case 'Null':
+                return yield* Null(schema_, references_, path, value);
+            case 'Number':
+                return yield* Number(schema_, references_, path, value);
+            case 'Object':
+                return yield* Object(schema_, references_, path, value);
+            case 'Promise':
+                return yield* Promise(schema_, references_, path, value);
+            case 'Record':
+                return yield* Record(schema_, references_, path, value);
+            case 'Ref':
+                return yield* Ref(schema_, references_, path, value);
+            case 'String':
+                return yield* String(schema_, references_, path, value);
+            case 'Symbol':
+                return yield* Symbol(schema_, references_, path, value);
+            case 'TemplateLiteral':
+                return yield* TemplateLiteral(schema_, references_, path, value);
+            case 'This':
+                return yield* This(schema_, references_, path, value);
+            case 'Tuple':
+                return yield* Tuple(schema_, references_, path, value);
+            case 'Undefined':
+                return yield* Undefined(schema_, references_, path, value);
+            case 'Union':
+                return yield* Union(schema_, references_, path, value);
+            case 'Uint8Array':
+                return yield* Uint8Array(schema_, references_, path, value);
+            case 'Unknown':
+                return yield* Unknown(schema_, references_, path, value);
+            case 'Void':
+                return yield* Void(schema_, references_, path, value);
+            default:
+                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+                    throw new ValueErrorsUnknownTypeError(schema);
+                return yield* UserDefined(schema_, references_, path, value);
+        }
+    }
+    function Errors(schema, references, value) {
+        const iterator = Visit(schema, references, '', value);
+        return new ValueErrorIterator(iterator);
+    }
+    ValueErrors.Errors = Errors;
+})(ValueErrors = exports.ValueErrors || (exports.ValueErrors = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './errors';

backend/node_modules/jest/node_modules/@sinclair/typebox/errors/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/errors
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./errors"), exports);

backend/node_modules/jest/node_modules/@sinclair/typebox/license

@@ -0,0 +1,23 @@
+TypeBox: JSON Schema Type Builder with Static Type Resolution for TypeScript 
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

backend/node_modules/jest/node_modules/@sinclair/typebox/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@sinclair/typebox",
+  "version": "0.27.10",
+  "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
+  "keywords": [
+    "typescript",
+    "json-schema",
+    "validate",
+    "typecheck"
+  ],
+  "author": "sinclairzx81",
+  "license": "MIT",
+  "main": "./typebox.js",
+  "types": "./typebox.d.ts",
+  "exports": {
+    "./compiler": "./compiler/index.js",
+    "./errors": "./errors/index.js",
+    "./system": "./system/index.js",
+    "./value": "./value/index.js",
+    ".": "./typebox.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sinclairzx81/typebox-legacy"
+  },
+  "scripts": {
+    "clean": "hammer task clean",
+    "format": "hammer task format",
+    "start": "hammer task start",
+    "test": "hammer task test",
+    "benchmark": "hammer task benchmark",
+    "build": "hammer task build",
+    "build:native": "hammer task build_native",
+    "publish": "hammer task publish"
+  },
+  "devDependencies": {
+    "@sinclair/hammer": "^0.17.1",
+    "@typescript/native-preview": "^7.0.0-dev.20260203.1",
+    "@types/chai": "^4.3.3",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^18.19.130",
+    "ajv": "^8.12.0",
+    "ajv-formats": "^2.1.1",
+    "chai": "^4.3.6",
+    "mocha": "^9.2.2",
+    "prettier": "^2.7.1",
+    "typescript": "5.0.2"
+  }
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/system/index.d.ts

@@ -0,0 +1 @@
+export * from './system';

backend/node_modules/jest/node_modules/@sinclair/typebox/system/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/system
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./system"), exports);

backend/node_modules/jest/node_modules/@sinclair/typebox/system/system.d.ts

@@ -0,0 +1,26 @@
+import * as Types from '../typebox';
+export declare class TypeSystemDuplicateTypeKind extends Error {
+    constructor(kind: string);
+}
+export declare class TypeSystemDuplicateFormat extends Error {
+    constructor(kind: string);
+}
+/** Creates user defined types and formats and provides overrides for value checking behaviours */
+export declare namespace TypeSystem {
+    /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+    let ExactOptionalPropertyTypes: boolean;
+    /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
+    let AllowArrayObjects: boolean;
+    /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
+    let AllowNaN: boolean;
+    /** Sets whether `null` should validate for void types. The default is `false` */
+    let AllowVoidNull: boolean;
+    /** Creates a new type */
+    function Type<Type, Options = object>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => Types.TUnsafe<Type>;
+    /** Creates a new string format */
+    function Format<F extends string>(format: F, check: (value: string) => boolean): F;
+    /** @deprecated Use `TypeSystem.Type()` instead. */
+    function CreateType<Type, Options = object>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => Types.TUnsafe<Type>;
+    /** @deprecated Use `TypeSystem.Format()` instead.  */
+    function CreateFormat<F extends string>(format: F, check: (value: string) => boolean): F;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/system/system.js

@@ -0,0 +1,90 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/system
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSystem = exports.TypeSystemDuplicateFormat = exports.TypeSystemDuplicateTypeKind = void 0;
+const Types = require("../typebox");
+class TypeSystemDuplicateTypeKind extends Error {
+    constructor(kind) {
+        super(`Duplicate type kind '${kind}' detected`);
+    }
+}
+exports.TypeSystemDuplicateTypeKind = TypeSystemDuplicateTypeKind;
+class TypeSystemDuplicateFormat extends Error {
+    constructor(kind) {
+        super(`Duplicate string format '${kind}' detected`);
+    }
+}
+exports.TypeSystemDuplicateFormat = TypeSystemDuplicateFormat;
+/** Creates user defined types and formats and provides overrides for value checking behaviours */
+var TypeSystem;
+(function (TypeSystem) {
+    // ------------------------------------------------------------------------
+    // Assertion Policies
+    // ------------------------------------------------------------------------
+    /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+    TypeSystem.ExactOptionalPropertyTypes = false;
+    /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
+    TypeSystem.AllowArrayObjects = false;
+    /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
+    TypeSystem.AllowNaN = false;
+    /** Sets whether `null` should validate for void types. The default is `false` */
+    TypeSystem.AllowVoidNull = false;
+    // ------------------------------------------------------------------------
+    // String Formats and Types
+    // ------------------------------------------------------------------------
+    /** Creates a new type */
+    function Type(kind, check) {
+        if (Types.TypeRegistry.Has(kind))
+            throw new TypeSystemDuplicateTypeKind(kind);
+        Types.TypeRegistry.Set(kind, check);
+        return (options = {}) => Types.Type.Unsafe({ ...options, [Types.Kind]: kind });
+    }
+    TypeSystem.Type = Type;
+    /** Creates a new string format */
+    function Format(format, check) {
+        if (Types.FormatRegistry.Has(format))
+            throw new TypeSystemDuplicateFormat(format);
+        Types.FormatRegistry.Set(format, check);
+        return format;
+    }
+    TypeSystem.Format = Format;
+    // ------------------------------------------------------------------------
+    // Deprecated
+    // ------------------------------------------------------------------------
+    /** @deprecated Use `TypeSystem.Type()` instead. */
+    function CreateType(kind, check) {
+        return Type(kind, check);
+    }
+    TypeSystem.CreateType = CreateType;
+    /** @deprecated Use `TypeSystem.Format()` instead.  */
+    function CreateFormat(format, check) {
+        return Format(format, check);
+    }
+    TypeSystem.CreateFormat = CreateFormat;
+})(TypeSystem = exports.TypeSystem || (exports.TypeSystem = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/typebox.d.ts

@@ -0,0 +1,717 @@
+export declare const Modifier: unique symbol;
+export declare const Hint: unique symbol;
+export declare const Kind: unique symbol;
+export declare const PatternBoolean = "(true|false)";
+export declare const PatternNumber = "(0|[1-9][0-9]*)";
+export declare const PatternString = "(.*)";
+export declare const PatternBooleanExact: string;
+export declare const PatternNumberExact: string;
+export declare const PatternStringExact: string;
+export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never;
+export type TupleToUnion<T extends any[]> = {
+    [K in keyof T]: T[K];
+}[number];
+export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
+export type Assert<T, E> = T extends E ? T : never;
+export type Evaluate<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+export type Ensure<T> = T extends infer U ? U : never;
+export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>;
+export type TReadonly<T extends TSchema> = T & {
+    [Modifier]: 'Readonly';
+};
+export type TOptional<T extends TSchema> = T & {
+    [Modifier]: 'Optional';
+};
+export type TReadonlyOptional<T extends TSchema> = T & {
+    [Modifier]: 'ReadonlyOptional';
+};
+export interface SchemaOptions {
+    $schema?: string;
+    /** Id for this schema */
+    $id?: string;
+    /** Title of this schema */
+    title?: string;
+    /** Description of this schema */
+    description?: string;
+    /** Default value for this schema */
+    default?: any;
+    /** Example values matching this schema */
+    examples?: any;
+    [prop: string]: any;
+}
+export interface TKind {
+    [Kind]: string;
+}
+export interface TSchema extends SchemaOptions, TKind {
+    [Modifier]?: string;
+    [Hint]?: string;
+    params: unknown[];
+    static: unknown;
+}
+export type TAnySchema = TSchema | TAny | TArray | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
+export type TNumeric = TInteger | TNumber;
+export interface NumericOptions<N extends number | bigint> extends SchemaOptions {
+    exclusiveMaximum?: N;
+    exclusiveMinimum?: N;
+    maximum?: N;
+    minimum?: N;
+    multipleOf?: N;
+}
+export interface TAny extends TSchema {
+    [Kind]: 'Any';
+    static: any;
+}
+export interface ArrayOptions extends SchemaOptions {
+    uniqueItems?: boolean;
+    minItems?: number;
+    maxItems?: number;
+}
+export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
+    [Kind]: 'Array';
+    static: Static<T, this['params']>[];
+    type: 'array';
+    items: T;
+}
+export interface TBigInt extends TSchema, NumericOptions<bigint> {
+    [Kind]: 'BigInt';
+    static: bigint;
+    type: 'null';
+    typeOf: 'BigInt';
+}
+export interface TBoolean extends TSchema {
+    [Kind]: 'Boolean';
+    static: boolean;
+    type: 'boolean';
+}
+export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
+export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
+export type TCompositeEvaluateArray<T extends readonly TSchema[], P extends unknown[]> = {
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
+};
+export type TCompositeArray<T extends readonly TObject[]> = {
+    [K in keyof T]: T[K] extends TObject<infer P> ? P : {};
+};
+export type TCompositeProperties<I extends unknown, T extends readonly any[]> = Evaluate<T extends [infer A, ...infer B] ? TCompositeProperties<I & A, B> : I extends object ? I : {}>;
+export interface TComposite<T extends TObject[] = TObject[]> extends TObject {
+    [Hint]: 'Composite';
+    static: Evaluate<TCompositeProperties<unknown, TCompositeEvaluateArray<T, this['params']>>>;
+    properties: TCompositeProperties<unknown, TCompositeArray<T>>;
+}
+export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{
+    [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
+}];
+export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Constructor';
+    static: new (...param: TConstructorParameterArray<T, this['params']>) => Static<U, this['params']>;
+    type: 'object';
+    instanceOf: 'Constructor';
+    parameters: T;
+    returns: U;
+}
+export interface DateOptions extends SchemaOptions {
+    exclusiveMaximumTimestamp?: number;
+    exclusiveMinimumTimestamp?: number;
+    maximumTimestamp?: number;
+    minimumTimestamp?: number;
+}
+export interface TDate extends TSchema, DateOptions {
+    [Kind]: 'Date';
+    static: Date;
+    type: 'object';
+    instanceOf: 'Date';
+}
+export interface TEnumOption<T> {
+    type: 'number' | 'string';
+    const: T;
+}
+export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
+    [Kind]: 'Union';
+    static: T[keyof T];
+    anyOf: TLiteral<string | number>[];
+}
+export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = (Static<L> extends Static<R> ? T : U) extends infer O ? UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[Assert<X, TSchema>, Assert<Y, TSchema>]> : Assert<O, TSchema> : never;
+export type TExcludeTemplateLiteralResult<T extends string> = TString;
+export type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never;
+export type TExcludeArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
+    [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? never : T[K];
+}[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
+export type TExclude<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T;
+export type TExtractTemplateLiteralResult<T extends string> = TString;
+export type TExtractTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never;
+export type TExtractArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
+    [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? T[K] : never;
+}[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
+export type TExtract<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? TExtractTemplateLiteral<T, U> : T extends TUnion<infer S> ? TExtractArray<S, U> : T extends U ? T : T;
+export type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
+    [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
+}];
+export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Function';
+    static: (...param: TFunctionParameters<T, this['params']>) => Static<U, this['params']>;
+    type: 'object';
+    instanceOf: 'Function';
+    parameters: T;
+    returns: U;
+}
+export interface TInteger extends TSchema, NumericOptions<number> {
+    [Kind]: 'Integer';
+    static: number;
+    type: 'integer';
+}
+export type TUnevaluatedProperties = undefined | TSchema | boolean;
+export interface IntersectOptions extends SchemaOptions {
+    unevaluatedProperties?: TUnevaluatedProperties;
+}
+export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
+    [Kind]: 'Intersect';
+    static: TupleToIntersect<{
+        [K in keyof T]: Static<Assert<T[K], TSchema>, this['params']>;
+    }>;
+    type?: 'object';
+    allOf: [...T];
+}
+export type TKeyOfTuple<T extends TSchema> = {
+    [K in keyof Static<T>]: TLiteral<Assert<K, TLiteralValue>>;
+} extends infer U ? UnionToTuple<Exclude<{
+    [K in keyof U]: U[K];
+}[keyof U], undefined>> : never;
+export type TKeyOf<T extends TSchema = TSchema> = (T extends TRecursive<infer S> ? TKeyOfTuple<S> : T extends TComposite ? TKeyOfTuple<T> : T extends TIntersect ? TKeyOfTuple<T> : T extends TUnion ? TKeyOfTuple<T> : T extends TObject ? TKeyOfTuple<T> : T extends TRecord<infer K> ? [K] : [
+]) extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
+export type TLiteralValue = string | number | boolean;
+export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
+    [Kind]: 'Literal';
+    static: T;
+    const: T;
+}
+export interface TNever extends TSchema {
+    [Kind]: 'Never';
+    static: never;
+    not: {};
+}
+export interface TNot<Not extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Not';
+    static: Static<T>;
+    allOf: [{
+        not: Not;
+    }, T];
+}
+export interface TNull extends TSchema {
+    [Kind]: 'Null';
+    static: null;
+    type: 'null';
+}
+export interface TNumber extends TSchema, NumericOptions<number> {
+    [Kind]: 'Number';
+    static: number;
+    type: 'number';
+}
+export type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never;
+}[keyof T];
+export type ReadonlyPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never;
+}[keyof T];
+export type OptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never;
+}[keyof T];
+export type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
+export type PropertiesReducer<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
+export type PropertiesReduce<T extends TProperties, P extends unknown[]> = PropertiesReducer<T, {
+    [K in keyof T]: Static<T[K], P>;
+}>;
+export type TProperties = Record<keyof any, TSchema>;
+export type ObjectProperties<T> = T extends TObject<infer U> ? U : never;
+export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never;
+export type TAdditionalProperties = undefined | TSchema | boolean;
+export interface ObjectOptions extends SchemaOptions {
+    additionalProperties?: TAdditionalProperties;
+    minProperties?: number;
+    maxProperties?: number;
+}
+export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+    [Kind]: 'Object';
+    static: PropertiesReduce<T, this['params']>;
+    additionalProperties?: TAdditionalProperties;
+    type: 'object';
+    properties: T;
+    required?: string[];
+}
+export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{
+    [K2 in keyof T]: TOmit<Assert<T[K2], TSchema>, K>;
+}, TSchema[]>;
+export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>;
+export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : T extends TComposite<infer S> ? TComposite<TOmitArray<S, K>> : T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
+export type TParameters<T extends TFunction> = TTuple<T['parameters']>;
+export type TPartialObjectArray<T extends TObject[]> = Assert<{
+    [K in keyof T]: TPartial<Assert<T[K], TObject>>;
+}, TObject[]>;
+export type TPartialArray<T extends TSchema[]> = Assert<{
+    [K in keyof T]: TPartial<Assert<T[K], TSchema>>;
+}, TSchema[]>;
+export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
+    [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : T[K] extends TReadonly<infer U> ? TReadonlyOptional<U> : T[K] extends TOptional<infer U> ? TOptional<U> : TOptional<T[K]>;
+}, TProperties>>;
+export type TPartial<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TPartial<S>> : T extends TComposite<infer S> ? TComposite<TPartialArray<S>> : T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : T extends TUnion<infer S> ? TUnion<TPartialArray<S>> : T extends TObject<infer S> ? TObject<TPartialProperties<S>> : T;
+export type TPickArray<T extends TSchema[], K extends keyof any> = {
+    [K2 in keyof T]: TPick<Assert<T[K2], TSchema>, K>;
+};
+export type TPickProperties<T extends TProperties, K extends keyof any> = Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
+    [K in keyof R]: Assert<R[K], TSchema> extends TSchema ? R[K] : never;
+}) : never;
+export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : T extends TComposite<infer S> ? TComposite<TPickArray<S, K>> : T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : T extends TObject<infer S> ? TObject<TPickProperties<S, K>> : T;
+export interface TPromise<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Promise';
+    static: Promise<Static<T, this['params']>>;
+    type: 'object';
+    instanceOf: 'Promise';
+    item: TSchema;
+}
+export type RecordTemplateLiteralObjectType<K extends TTemplateLiteral, T extends TSchema> = Ensure<TObject<Evaluate<{
+    [_ in Static<K>]: T;
+}>>>;
+export type RecordTemplateLiteralType<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends true ? RecordTemplateLiteralObjectType<K, T> : TRecord<K, T>;
+export type RecordUnionLiteralType<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? Ensure<TObject<{
+    [X in Static<K>]: T;
+}>> : never;
+export type RecordLiteralType<K extends TLiteral<string | number>, T extends TSchema> = Ensure<TObject<{
+    [K2 in K['const']]: T;
+}>>;
+export type RecordNumberType<K extends TInteger | TNumber, T extends TSchema> = Ensure<TRecord<K, T>>;
+export type RecordStringType<K extends TString, T extends TSchema> = Ensure<TRecord<K, T>>;
+export type RecordKey = TUnion<TLiteral<string | number>[]> | TLiteral<string | number> | TTemplateLiteral | TInteger | TNumber | TString;
+export interface TRecord<K extends RecordKey = RecordKey, T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Record';
+    static: Record<Static<K>, Static<T, this['params']>>;
+    type: 'object';
+    patternProperties: {
+        [pattern: string]: T;
+    };
+    additionalProperties: false;
+}
+export interface TThis extends TSchema {
+    [Kind]: 'This';
+    static: this['params'][0];
+    $ref: string;
+}
+export type TRecursiveReduce<T extends TSchema> = Static<T, [TRecursiveReduce<T>]>;
+export interface TRecursive<T extends TSchema> extends TSchema {
+    [Hint]: 'Recursive';
+    static: TRecursiveReduce<T>;
+}
+export interface TRef<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Ref';
+    static: Static<T, this['params']>;
+    $ref: string;
+}
+export type TReturnType<T extends TFunction> = T['returns'];
+export type TRequiredArray<T extends TSchema[]> = Assert<{
+    [K in keyof T]: TRequired<Assert<T[K], TSchema>>;
+}, TSchema[]>;
+export type TRequiredProperties<T extends TProperties> = Evaluate<Assert<{
+    [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T[K] extends TReadonly<infer U> ? TReadonly<U> : T[K] extends TOptional<infer U> ? U : T[K];
+}, TProperties>>;
+export type TRequired<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TRequired<S>> : T extends TComposite<infer S> ? TComposite<TRequiredArray<S>> : T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : T extends TUnion<infer S> ? TUnion<TRequiredArray<S>> : T extends TObject<infer S> ? TObject<TRequiredProperties<S>> : T;
+export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
+export interface StringOptions<Format extends string> extends SchemaOptions {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: Format;
+    contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64';
+    contentMediaType?: string;
+}
+export interface TString<Format extends string = string> extends TSchema, StringOptions<Format> {
+    [Kind]: 'String';
+    static: string;
+    type: 'string';
+}
+export type SymbolValue = string | number | undefined;
+export interface TSymbol extends TSchema, SchemaOptions {
+    [Kind]: 'Symbol';
+    static: symbol;
+    type: 'null';
+    typeOf: 'Symbol';
+}
+export type IsTemplateLiteralFiniteCheck<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<Assert<U, TTemplateLiteralKind[]>> : T extends TUnion<infer U> ? IsTemplateLiteralFiniteArray<Assert<U, TTemplateLiteralKind[]>> : T extends TString ? false : T extends TBoolean ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TLiteral ? true : false;
+export type IsTemplateLiteralFiniteArray<T extends TTemplateLiteralKind[]> = T extends [infer L, ...infer R] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : IsTemplateLiteralFiniteArray<Assert<R, TTemplateLiteralKind[]>> : T extends [infer L] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : true : true;
+export type IsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<U> : false;
+export type TTemplateLiteralKind = TUnion | TLiteral | TInteger | TTemplateLiteral | TNumber | TBigInt | TString | TBoolean | TNever;
+export type TTemplateLiteralConst<T, Acc extends string> = T extends TUnion<infer U> ? {
+    [K in keyof U]: TTemplateLiteralUnion<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
+}[number] : T extends TTemplateLiteral ? `${Static<T>}` : T extends TLiteral<infer U> ? `${U}` : T extends TString ? `${string}` : T extends TNumber ? `${number}` : T extends TBigInt ? `${bigint}` : T extends TBoolean ? `${boolean}` : never;
+export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` : T extends [infer L] ? `${TTemplateLiteralConst<L, Acc>}${Acc}` : Acc;
+export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
+    [Kind]: 'TemplateLiteral';
+    static: TTemplateLiteralUnion<T>;
+    type: 'string';
+    pattern: string;
+}
+export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? Assert<R, TSchema[]> : never;
+export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Tuple';
+    static: {
+        [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K];
+    };
+    type: 'array';
+    items?: T;
+    additionalItems?: false;
+    minItems: number;
+    maxItems: number;
+}
+export interface TUndefined extends TSchema {
+    [Kind]: 'Undefined';
+    static: undefined;
+    type: 'null';
+    typeOf: 'Undefined';
+}
+export type TUnionOfLiteralArray<T extends TLiteral<string>[]> = {
+    [K in keyof T]: Assert<T[K], TLiteral>['const'];
+}[number];
+export type TUnionOfLiteral<T extends TUnion<TLiteral<string>[]>> = TUnionOfLiteralArray<T['anyOf']>;
+export type TUnionResult<T extends TSchema[]> = T extends [] ? TNever : T extends [infer S] ? S : TUnion<T>;
+export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = (string);
+export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Union';
+    static: {
+        [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : never;
+    }[number];
+    anyOf: T;
+}
+export interface Uint8ArrayOptions extends SchemaOptions {
+    maxByteLength?: number;
+    minByteLength?: number;
+}
+export interface TUint8Array extends TSchema, Uint8ArrayOptions {
+    [Kind]: 'Uint8Array';
+    static: Uint8Array;
+    instanceOf: 'Uint8Array';
+    type: 'object';
+}
+export interface TUnknown extends TSchema {
+    [Kind]: 'Unknown';
+    static: unknown;
+}
+export interface UnsafeOptions extends SchemaOptions {
+    [Kind]?: string;
+}
+export interface TUnsafe<T> extends TSchema {
+    [Kind]: string;
+    static: T;
+}
+export interface TVoid extends TSchema {
+    [Kind]: 'Void';
+    static: void;
+    type: 'null';
+    typeOf: 'Void';
+}
+/** Creates a TypeScript static type from a TypeBox type */
+export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
+    params: P;
+})['static'];
+export type TypeRegistryValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean;
+/** A registry for user defined types */
+export declare namespace TypeRegistry {
+    /** Returns the entries in this registry */
+    function Entries(): Map<string, TypeRegistryValidationFunction<any>>;
+    /** Clears all user defined types */
+    function Clear(): void;
+    /** Returns true if this registry contains this kind */
+    function Has(kind: string): boolean;
+    /** Sets a validation function for a user defined type */
+    function Set<TSchema = unknown>(kind: string, func: TypeRegistryValidationFunction<TSchema>): void;
+    /** Gets a custom validation function for a user defined type */
+    function Get(kind: string): TypeRegistryValidationFunction<any> | undefined;
+}
+export type FormatRegistryValidationFunction = (value: string) => boolean;
+/** A registry for user defined string formats */
+export declare namespace FormatRegistry {
+    /** Returns the entries in this registry */
+    function Entries(): Map<string, FormatRegistryValidationFunction>;
+    /** Clears all user defined string formats */
+    function Clear(): void;
+    /** Returns true if the user defined string format exists */
+    function Has(format: string): boolean;
+    /** Sets a validation function for a user defined string format */
+    function Set(format: string, func: FormatRegistryValidationFunction): void;
+    /** Gets a validation function for a user defined string format */
+    function Get(format: string): FormatRegistryValidationFunction | undefined;
+}
+export declare class TypeGuardUnknownTypeError extends Error {
+    readonly schema: unknown;
+    constructor(schema: unknown);
+}
+/** Provides functions to test if JavaScript values are TypeBox types */
+export declare namespace TypeGuard {
+    /** Returns true if the given schema is TAny */
+    function TAny(schema: unknown): schema is TAny;
+    /** Returns true if the given schema is TArray */
+    function TArray(schema: unknown): schema is TArray;
+    /** Returns true if the given schema is TBigInt */
+    function TBigInt(schema: unknown): schema is TBigInt;
+    /** Returns true if the given schema is TBoolean */
+    function TBoolean(schema: unknown): schema is TBoolean;
+    /** Returns true if the given schema is TConstructor */
+    function TConstructor(schema: unknown): schema is TConstructor;
+    /** Returns true if the given schema is TDate */
+    function TDate(schema: unknown): schema is TDate;
+    /** Returns true if the given schema is TFunction */
+    function TFunction(schema: unknown): schema is TFunction;
+    /** Returns true if the given schema is TInteger */
+    function TInteger(schema: unknown): schema is TInteger;
+    /** Returns true if the given schema is TIntersect */
+    function TIntersect(schema: unknown): schema is TIntersect;
+    /** Returns true if the given schema is TKind */
+    function TKind(schema: unknown): schema is Record<typeof Kind | string, unknown>;
+    /** Returns true if the given schema is TLiteral */
+    function TLiteral(schema: unknown): schema is TLiteral;
+    /** Returns true if the given schema is TNever */
+    function TNever(schema: unknown): schema is TNever;
+    /** Returns true if the given schema is TNot */
+    function TNot(schema: unknown): schema is TNot;
+    /** Returns true if the given schema is TNull */
+    function TNull(schema: unknown): schema is TNull;
+    /** Returns true if the given schema is TNumber */
+    function TNumber(schema: unknown): schema is TNumber;
+    /** Returns true if the given schema is TObject */
+    function TObject(schema: unknown): schema is TObject;
+    /** Returns true if the given schema is TPromise */
+    function TPromise(schema: unknown): schema is TPromise;
+    /** Returns true if the given schema is TRecord */
+    function TRecord(schema: unknown): schema is TRecord;
+    /** Returns true if the given schema is TRef */
+    function TRef(schema: unknown): schema is TRef;
+    /** Returns true if the given schema is TString */
+    function TString(schema: unknown): schema is TString;
+    /** Returns true if the given schema is TSymbol */
+    function TSymbol(schema: unknown): schema is TSymbol;
+    /** Returns true if the given schema is TTemplateLiteral */
+    function TTemplateLiteral(schema: unknown): schema is TTemplateLiteral;
+    /** Returns true if the given schema is TThis */
+    function TThis(schema: unknown): schema is TThis;
+    /** Returns true if the given schema is TTuple */
+    function TTuple(schema: unknown): schema is TTuple;
+    /** Returns true if the given schema is TUndefined */
+    function TUndefined(schema: unknown): schema is TUndefined;
+    /** Returns true if the given schema is TUnion */
+    function TUnion(schema: unknown): schema is TUnion;
+    /** Returns true if the given schema is TUnion<Literal<string>[]> */
+    function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral<string>[]>;
+    /** Returns true if the given schema is TUint8Array */
+    function TUint8Array(schema: unknown): schema is TUint8Array;
+    /** Returns true if the given schema is TUnknown */
+    function TUnknown(schema: unknown): schema is TUnknown;
+    /** Returns true if the given schema is a raw TUnsafe */
+    function TUnsafe(schema: unknown): schema is TUnsafe<unknown>;
+    /** Returns true if the given schema is TVoid */
+    function TVoid(schema: unknown): schema is TVoid;
+    /** Returns true if this schema has the ReadonlyOptional modifier */
+    function TReadonlyOptional<T extends TSchema>(schema: T): schema is TReadonlyOptional<T>;
+    /** Returns true if this schema has the Readonly modifier */
+    function TReadonly<T extends TSchema>(schema: T): schema is TReadonly<T>;
+    /** Returns true if this schema has the Optional modifier */
+    function TOptional<T extends TSchema>(schema: T): schema is TOptional<T>;
+    /** Returns true if the given schema is TSchema */
+    function TSchema(schema: unknown): schema is TSchema;
+}
+/** Fast undefined check used for properties of type undefined */
+export declare namespace ExtendsUndefined {
+    function Check(schema: TSchema): boolean;
+}
+export declare enum TypeExtendsResult {
+    Union = 0,
+    True = 1,
+    False = 2
+}
+export declare namespace TypeExtends {
+    function Extends(left: TSchema, right: TSchema): TypeExtendsResult;
+}
+/** Specialized Clone for Types */
+export declare namespace TypeClone {
+    /** Clones a type. */
+    function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T;
+}
+export declare namespace ObjectMap {
+    function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T;
+}
+export declare namespace KeyResolver {
+    function Resolve<T extends TSchema>(schema: T): string[];
+}
+export declare namespace TemplateLiteralPattern {
+    function Create(kinds: TTemplateLiteralKind[]): string;
+}
+export declare namespace TemplateLiteralResolver {
+    function Resolve(template: TTemplateLiteral): TString | TUnion | TLiteral;
+}
+export declare class TemplateLiteralParserError extends Error {
+    constructor(message: string);
+}
+export declare namespace TemplateLiteralParser {
+    type Expression = And | Or | Const;
+    type Const = {
+        type: 'const';
+        const: string;
+    };
+    type And = {
+        type: 'and';
+        expr: Expression[];
+    };
+    type Or = {
+        type: 'or';
+        expr: Expression[];
+    };
+    /** Parses a pattern and returns an expression tree */
+    function Parse(pattern: string): Expression;
+    /** Parses a pattern and strips forward and trailing ^ and $ */
+    function ParseExact(pattern: string): Expression;
+}
+export declare namespace TemplateLiteralFinite {
+    function Check(expression: TemplateLiteralParser.Expression): boolean;
+}
+export declare namespace TemplateLiteralGenerator {
+    function Generate(expression: TemplateLiteralParser.Expression): IterableIterator<string>;
+}
+export declare class TypeBuilder {
+    /** `[Utility]` Creates a schema without `static` and `params` types */
+    protected Create<T>(schema: Omit<T, 'static' | 'params'>): T;
+    /** `[Standard]` Omits compositing symbols from this schema */
+    Strict<T extends TSchema>(schema: T): T;
+}
+export declare class StandardTypeBuilder extends TypeBuilder {
+    /** `[Modifier]` Creates a Optional property */
+    Optional<T extends TSchema>(schema: T): TOptional<T>;
+    /** `[Modifier]` Creates a ReadonlyOptional property */
+    ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T>;
+    /** `[Modifier]` Creates a Readonly object or property */
+    Readonly<T extends TSchema>(schema: T): TReadonly<T>;
+    /** `[Standard]` Creates an Any type */
+    Any(options?: SchemaOptions): TAny;
+    /** `[Standard]` Creates an Array type */
+    Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
+    /** `[Standard]` Creates a Boolean type */
+    Boolean(options?: SchemaOptions): TBoolean;
+    /** `[Standard]` Creates a Composite object type. */
+    Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
+    /** `[Standard]` Creates a Enum type */
+    Enum<T extends Record<string, string | number>>(item: T, options?: SchemaOptions): TEnum<T>;
+    /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
+    Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options?: SchemaOptions): TExtends<L, R, T, U>;
+    /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
+    Exclude<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExclude<L, R>;
+    /** `[Standard]` Extracts from the left type any type that is assignable to the right */
+    Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExtract<L, R>;
+    /** `[Standard]` Creates an Integer type */
+    Integer(options?: NumericOptions<number>): TInteger;
+    /** `[Standard]` Creates a Intersect type */
+    Intersect(allOf: [], options?: SchemaOptions): TNever;
+    /** `[Standard]` Creates a Intersect type */
+    Intersect<T extends [TSchema]>(allOf: [...T], options?: SchemaOptions): T[0];
+    Intersect<T extends TSchema[]>(allOf: [...T], options?: IntersectOptions): TIntersect<T>;
+    /** `[Standard]` Creates a KeyOf type */
+    KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
+    /** `[Standard]` Creates a Literal type */
+    Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
+    /** `[Standard]` Creates a Never type */
+    Never(options?: SchemaOptions): TNever;
+    /** `[Standard]` Creates a Not type. The first argument is the disallowed type, the second is the allowed. */
+    Not<N extends TSchema, T extends TSchema>(not: N, schema: T, options?: SchemaOptions): TNot<N, T>;
+    /** `[Standard]` Creates a Null type */
+    Null(options?: SchemaOptions): TNull;
+    /** `[Standard]` Creates a Number type */
+    Number(options?: NumericOptions<number>): TNumber;
+    /** `[Standard]` Creates an Object type */
+    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+    /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+    Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>;
+    /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+    Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionOfLiteral<K>>;
+    /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+    Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>;
+    /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+    Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>;
+    /** `[Standard]` Creates a mapped type where all properties are Optional */
+    Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
+    /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+    Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>;
+    /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+    Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionOfLiteral<K>>;
+    /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+    Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>;
+    /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+    Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>;
+    /** `[Standard]` Creates a Record type */
+    Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordUnionLiteralType<K, T>;
+    /** `[Standard]` Creates a Record type */
+    Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordLiteralType<K, T>;
+    /** `[Standard]` Creates a Record type */
+    Record<K extends TTemplateLiteral, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordTemplateLiteralType<K, T>;
+    /** `[Standard]` Creates a Record type */
+    Record<K extends TInteger | TNumber, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordNumberType<K, T>;
+    /** `[Standard]` Creates a Record type */
+    Record<K extends TString, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordStringType<K, T>;
+    /** `[Standard]` Creates a Recursive type */
+    Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
+    /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
+    Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
+    /** `[Standard]` Creates a mapped type where all properties are Required */
+    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
+    /** `[Standard]` Creates a String type */
+    String<Format extends string>(options?: StringOptions<StringFormatOption | Format>): TString<Format>;
+    /** `[Standard]` Creates a template literal type */
+    TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
+    /** `[Standard]` Creates a Tuple type */
+    Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
+    /** `[Standard]` Creates a Union type */
+    Union(anyOf: [], options?: SchemaOptions): TNever;
+    /** `[Standard]` Creates a Union type */
+    Union<T extends [TSchema]>(anyOf: [...T], options?: SchemaOptions): T[0];
+    /** `[Standard]` Creates a Union type */
+    Union<T extends TSchema[]>(anyOf: [...T], options?: SchemaOptions): TUnion<T>;
+    /** `[Experimental]` Remaps a TemplateLiteral into a Union representation. This function is known to cause TS compiler crashes for finite templates with large generation counts. Use with caution. */
+    Union<T extends TTemplateLiteral>(template: T): TUnionTemplateLiteral<T>;
+    /** `[Standard]` Creates an Unknown type */
+    Unknown(options?: SchemaOptions): TUnknown;
+    /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
+    Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
+}
+export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
+    /** `[Extended]` Creates a BigInt type */
+    BigInt(options?: NumericOptions<bigint>): TBigInt;
+    /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
+    ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
+    /** `[Extended]` Creates a Constructor type */
+    Constructor<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TConstructor<TTupleIntoArray<T>, U>;
+    /** `[Extended]` Creates a Constructor type */
+    Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
+    /** `[Extended]` Creates a Date type */
+    Date(options?: DateOptions): TDate;
+    /** `[Extended]` Creates a Function type */
+    Function<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TFunction<TTupleIntoArray<T>, U>;
+    /** `[Extended]` Creates a Function type */
+    Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
+    /** `[Extended]` Extracts the InstanceType from the given Constructor */
+    InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
+    /** `[Extended]` Extracts the Parameters from the given Function type */
+    Parameters<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TParameters<T>;
+    /** `[Extended]` Creates a Promise type */
+    Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
+    /** `[Extended]` Creates a regular expression type */
+    RegEx(regex: RegExp, options?: SchemaOptions): TString;
+    /** `[Extended]` Extracts the ReturnType from the given Function */
+    ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
+    /** `[Extended]` Creates a Symbol type */
+    Symbol(options?: SchemaOptions): TSymbol;
+    /** `[Extended]` Creates a Undefined type */
+    Undefined(options?: SchemaOptions): TUndefined;
+    /** `[Extended]` Creates a Uint8Array type */
+    Uint8Array(options?: Uint8ArrayOptions): TUint8Array;
+    /** `[Extended]` Creates a Void type */
+    Void(options?: SchemaOptions): TVoid;
+}
+/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+export declare const StandardType: StandardTypeBuilder;
+/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+export declare const Type: ExtendedTypeBuilder;

backend/node_modules/jest/node_modules/@sinclair/typebox/value/cast.d.ts

@@ -0,0 +1,30 @@
+import * as Types from '../typebox';
+export declare class ValueCastReferenceTypeError extends Error {
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
+}
+export declare class ValueCastArrayUniqueItemsTypeError extends Error {
+    readonly schema: Types.TSchema;
+    readonly value: unknown;
+    constructor(schema: Types.TSchema, value: unknown);
+}
+export declare class ValueCastNeverTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueCastRecursiveTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueCastUnknownTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueCastDereferenceError extends Error {
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
+}
+export declare namespace ValueCast {
+    function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
+    function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): Types.Static<T>;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/value/cast.js

@@ -0,0 +1,372 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueCast = exports.ValueCastDereferenceError = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = exports.ValueCastReferenceTypeError = void 0;
+const Types = require("../typebox");
+const create_1 = require("./create");
+const check_1 = require("./check");
+const clone_1 = require("./clone");
+// ----------------------------------------------------------------------------------------------
+// Errors
+// ----------------------------------------------------------------------------------------------
+class ValueCastReferenceTypeError extends Error {
+    constructor(schema) {
+        super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.ValueCastReferenceTypeError = ValueCastReferenceTypeError;
+class ValueCastArrayUniqueItemsTypeError extends Error {
+    constructor(schema, value) {
+        super('ValueCast: Array cast produced invalid data due to uniqueItems constraint');
+        this.schema = schema;
+        this.value = value;
+    }
+}
+exports.ValueCastArrayUniqueItemsTypeError = ValueCastArrayUniqueItemsTypeError;
+class ValueCastNeverTypeError extends Error {
+    constructor(schema) {
+        super('ValueCast: Never types cannot be cast');
+        this.schema = schema;
+    }
+}
+exports.ValueCastNeverTypeError = ValueCastNeverTypeError;
+class ValueCastRecursiveTypeError extends Error {
+    constructor(schema) {
+        super('ValueCast.Recursive: Cannot cast recursive schemas');
+        this.schema = schema;
+    }
+}
+exports.ValueCastRecursiveTypeError = ValueCastRecursiveTypeError;
+class ValueCastUnknownTypeError extends Error {
+    constructor(schema) {
+        super('ValueCast: Unknown type');
+        this.schema = schema;
+    }
+}
+exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
+class ValueCastDereferenceError extends Error {
+    constructor(schema) {
+        super(`ValueCast: Unable to dereference schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.ValueCastDereferenceError = ValueCastDereferenceError;
+// ----------------------------------------------------------------------------------------------
+// The following will score a schema against a value. For objects, the score is the tally of
+// points awarded for each property of the value. Property points are (1.0 / propertyCount)
+// to prevent large property counts biasing results. Properties that match literal values are
+// maximally awarded as literals are typically used as union discriminator fields.
+// ----------------------------------------------------------------------------------------------
+var UnionCastCreate;
+(function (UnionCastCreate) {
+    function Score(schema, references, value) {
+        if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
+            const object = schema;
+            const keys = Object.keys(value);
+            const entries = globalThis.Object.entries(object.properties);
+            const [point, max] = [1 / entries.length, entries.length];
+            return entries.reduce((acc, [key, schema]) => {
+                const literal = schema[Types.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
+                const checks = check_1.ValueCheck.Check(schema, references, value[key]) ? point : 0;
+                const exists = keys.includes(key) ? point : 0;
+                return acc + (literal + checks + exists);
+            }, 0);
+        }
+        else {
+            return check_1.ValueCheck.Check(schema, references, value) ? 1 : 0;
+        }
+    }
+    function Select(union, references, value) {
+        let [select, best] = [union.anyOf[0], 0];
+        for (const schema of union.anyOf) {
+            const score = Score(schema, references, value);
+            if (score > best) {
+                select = schema;
+                best = score;
+            }
+        }
+        return select;
+    }
+    function Create(union, references, value) {
+        if (union.default !== undefined) {
+            return union.default;
+        }
+        else {
+            const schema = Select(union, references, value);
+            return ValueCast.Cast(schema, references, value);
+        }
+    }
+    UnionCastCreate.Create = Create;
+})(UnionCastCreate || (UnionCastCreate = {}));
+var ValueCast;
+(function (ValueCast) {
+    // ----------------------------------------------------------------------------------------------
+    // Guards
+    // ----------------------------------------------------------------------------------------------
+    function IsObject(value) {
+        return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value);
+    }
+    function IsArray(value) {
+        return typeof value === 'object' && globalThis.Array.isArray(value);
+    }
+    function IsNumber(value) {
+        return typeof value === 'number' && !isNaN(value);
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    // ----------------------------------------------------------------------------------------------
+    // Cast
+    // ----------------------------------------------------------------------------------------------
+    function Any(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    }
+    function Array(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
+            return clone_1.ValueClone.Clone(value);
+        const created = IsArray(value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+        const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...globalThis.Array.from({ length: schema.minItems - created.length }, () => null)] : created;
+        const maximum = IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
+        const casted = maximum.map((value) => Visit(schema.items, references, value));
+        if (schema.uniqueItems !== true)
+            return casted;
+        const unique = [...new Set(casted)];
+        if (!check_1.ValueCheck.Check(schema, references, unique))
+            throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
+        return unique;
+    }
+    function BigInt(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Boolean(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Constructor(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
+            return create_1.ValueCreate.Create(schema, references);
+        const required = new Set(schema.returns.required || []);
+        const result = function () { };
+        for (const [key, property] of globalThis.Object.entries(schema.returns.properties)) {
+            if (!required.has(key) && value.prototype[key] === undefined)
+                continue;
+            result.prototype[key] = Visit(property, references, value.prototype[key]);
+        }
+        return result;
+    }
+    function Date(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    }
+    function Function(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Integer(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Intersect(schema, references, value) {
+        const created = create_1.ValueCreate.Create(schema, references);
+        const mapped = IsObject(created) && IsObject(value) ? { ...created, ...value } : value;
+        return check_1.ValueCheck.Check(schema, references, mapped) ? mapped : create_1.ValueCreate.Create(schema, references);
+    }
+    function Literal(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Never(schema, references, value) {
+        throw new ValueCastNeverTypeError(schema);
+    }
+    function Not(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema.allOf[1], references);
+    }
+    function Null(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Number(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Object(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
+            return value;
+        if (value === null || typeof value !== 'object')
+            return create_1.ValueCreate.Create(schema, references);
+        const required = new Set(schema.required || []);
+        const result = {};
+        for (const [key, property] of globalThis.Object.entries(schema.properties)) {
+            if (!required.has(key) && value[key] === undefined)
+                continue;
+            result[key] = Visit(property, references, value[key]);
+        }
+        // additional schema properties
+        if (typeof schema.additionalProperties === 'object') {
+            const propertyNames = globalThis.Object.getOwnPropertyNames(schema.properties);
+            for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
+                if (propertyNames.includes(propertyName))
+                    continue;
+                result[propertyName] = Visit(schema.additionalProperties, references, value[propertyName]);
+            }
+        }
+        return result;
+    }
+    function Promise(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Record(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
+            return clone_1.ValueClone.Clone(value);
+        if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value) || value instanceof globalThis.Date)
+            return create_1.ValueCreate.Create(schema, references);
+        const subschemaPropertyName = globalThis.Object.getOwnPropertyNames(schema.patternProperties)[0];
+        const subschema = schema.patternProperties[subschemaPropertyName];
+        const result = {};
+        for (const [propKey, propValue] of globalThis.Object.entries(value)) {
+            result[propKey] = Visit(subschema, references, propValue);
+        }
+        return result;
+    }
+    function Ref(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueCastDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
+    function String(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Symbol(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    }
+    function TemplateLiteral(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    }
+    function This(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueCastDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
+    function Tuple(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
+            return clone_1.ValueClone.Clone(value);
+        if (!globalThis.Array.isArray(value))
+            return create_1.ValueCreate.Create(schema, references);
+        if (schema.items === undefined)
+            return [];
+        return schema.items.map((schema, index) => Visit(schema, references, value[index]));
+    }
+    function Undefined(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    }
+    function Union(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : UnionCastCreate.Create(schema, references, value);
+    }
+    function Uint8Array(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    }
+    function Unknown(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    }
+    function Void(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    }
+    function UserDefined(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    }
+    function Visit(schema, references, value) {
+        const references_ = IsString(schema.$id) ? [...references, schema] : references;
+        const schema_ = schema;
+        switch (schema[Types.Kind]) {
+            case 'Any':
+                return Any(schema_, references_, value);
+            case 'Array':
+                return Array(schema_, references_, value);
+            case 'BigInt':
+                return BigInt(schema_, references_, value);
+            case 'Boolean':
+                return Boolean(schema_, references_, value);
+            case 'Constructor':
+                return Constructor(schema_, references_, value);
+            case 'Date':
+                return Date(schema_, references_, value);
+            case 'Function':
+                return Function(schema_, references_, value);
+            case 'Integer':
+                return Integer(schema_, references_, value);
+            case 'Intersect':
+                return Intersect(schema_, references_, value);
+            case 'Literal':
+                return Literal(schema_, references_, value);
+            case 'Never':
+                return Never(schema_, references_, value);
+            case 'Not':
+                return Not(schema_, references_, value);
+            case 'Null':
+                return Null(schema_, references_, value);
+            case 'Number':
+                return Number(schema_, references_, value);
+            case 'Object':
+                return Object(schema_, references_, value);
+            case 'Promise':
+                return Promise(schema_, references_, value);
+            case 'Record':
+                return Record(schema_, references_, value);
+            case 'Ref':
+                return Ref(schema_, references_, value);
+            case 'String':
+                return String(schema_, references_, value);
+            case 'Symbol':
+                return Symbol(schema_, references_, value);
+            case 'TemplateLiteral':
+                return TemplateLiteral(schema_, references_, value);
+            case 'This':
+                return This(schema_, references_, value);
+            case 'Tuple':
+                return Tuple(schema_, references_, value);
+            case 'Undefined':
+                return Undefined(schema_, references_, value);
+            case 'Union':
+                return Union(schema_, references_, value);
+            case 'Uint8Array':
+                return Uint8Array(schema_, references_, value);
+            case 'Unknown':
+                return Unknown(schema_, references_, value);
+            case 'Void':
+                return Void(schema_, references_, value);
+            default:
+                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+                    throw new ValueCastUnknownTypeError(schema_);
+                return UserDefined(schema_, references_, value);
+        }
+    }
+    ValueCast.Visit = Visit;
+    function Cast(schema, references, value) {
+        return Visit(schema, references, clone_1.ValueClone.Clone(value));
+    }
+    ValueCast.Cast = Cast;
+})(ValueCast = exports.ValueCast || (exports.ValueCast = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/value/check.d.ts

@@ -0,0 +1,12 @@
+import * as Types from '../typebox';
+export declare class ValueCheckUnknownTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueCheckDereferenceError extends Error {
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
+}
+export declare namespace ValueCheck {
+    function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/value/check.js

@@ -0,0 +1,484 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueCheck = exports.ValueCheckDereferenceError = exports.ValueCheckUnknownTypeError = void 0;
+const Types = require("../typebox");
+const index_1 = require("../system/index");
+const hash_1 = require("./hash");
+// -------------------------------------------------------------------------
+// Errors
+// -------------------------------------------------------------------------
+class ValueCheckUnknownTypeError extends Error {
+    constructor(schema) {
+        super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`);
+        this.schema = schema;
+    }
+}
+exports.ValueCheckUnknownTypeError = ValueCheckUnknownTypeError;
+class ValueCheckDereferenceError extends Error {
+    constructor(schema) {
+        super(`ValueCheck: Unable to dereference schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.ValueCheckDereferenceError = ValueCheckDereferenceError;
+var ValueCheck;
+(function (ValueCheck) {
+    // ----------------------------------------------------------------------
+    // Guards
+    // ----------------------------------------------------------------------
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    function IsInteger(value) {
+        return globalThis.Number.isInteger(value);
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsDefined(value) {
+        return value !== undefined;
+    }
+    // ----------------------------------------------------------------------
+    // Policies
+    // ----------------------------------------------------------------------
+    function IsExactOptionalProperty(value, key) {
+        return index_1.TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
+    }
+    function IsObject(value) {
+        const result = typeof value === 'object' && value !== null;
+        return index_1.TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value);
+    }
+    function IsRecordObject(value) {
+        return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array);
+    }
+    function IsNumber(value) {
+        const result = typeof value === 'number';
+        return index_1.TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value);
+    }
+    function IsVoid(value) {
+        const result = value === undefined;
+        return index_1.TypeSystem.AllowVoidNull ? result || value === null : result;
+    }
+    // ----------------------------------------------------------------------
+    // Types
+    // ----------------------------------------------------------------------
+    function Any(schema, references, value) {
+        return true;
+    }
+    function Array(schema, references, value) {
+        if (!globalThis.Array.isArray(value)) {
+            return false;
+        }
+        if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
+            return false;
+        }
+        if (IsDefined(schema.maxItems) && !(value.length <= schema.maxItems)) {
+            return false;
+        }
+        // prettier-ignore
+        if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
+            const hashed = hash_1.ValueHash.Create(element);
+            if (set.has(hashed)) {
+                return false;
+            }
+            else {
+                set.add(hashed);
+            }
+        } return true; })())) {
+            return false;
+        }
+        return value.every((value) => Visit(schema.items, references, value));
+    }
+    function BigInt(schema, references, value) {
+        if (!IsBigInt(value)) {
+            return false;
+        }
+        if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === globalThis.BigInt(0))) {
+            return false;
+        }
+        if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+            return false;
+        }
+        if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+            return false;
+        }
+        if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
+            return false;
+        }
+        if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
+            return false;
+        }
+        return true;
+    }
+    function Boolean(schema, references, value) {
+        return typeof value === 'boolean';
+    }
+    function Constructor(schema, references, value) {
+        return Visit(schema.returns, references, value.prototype);
+    }
+    function Date(schema, references, value) {
+        if (!(value instanceof globalThis.Date)) {
+            return false;
+        }
+        if (!IsNumber(value.getTime())) {
+            return false;
+        }
+        if (IsDefined(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+            return false;
+        }
+        if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+            return false;
+        }
+        if (IsDefined(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
+            return false;
+        }
+        if (IsDefined(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
+            return false;
+        }
+        return true;
+    }
+    function Function(schema, references, value) {
+        return typeof value === 'function';
+    }
+    function Integer(schema, references, value) {
+        if (!IsInteger(value)) {
+            return false;
+        }
+        if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+            return false;
+        }
+        if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+            return false;
+        }
+        if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+            return false;
+        }
+        if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
+            return false;
+        }
+        if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
+            return false;
+        }
+        return true;
+    }
+    function Intersect(schema, references, value) {
+        if (!schema.allOf.every((schema) => Visit(schema, references, value))) {
+            return false;
+        }
+        else if (schema.unevaluatedProperties === false) {
+            const schemaKeys = Types.KeyResolver.Resolve(schema);
+            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
+            return valueKeys.every((key) => schemaKeys.includes(key));
+        }
+        else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
+            const schemaKeys = Types.KeyResolver.Resolve(schema);
+            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
+            return valueKeys.every((key) => schemaKeys.includes(key) || Visit(schema.unevaluatedProperties, references, value[key]));
+        }
+        else {
+            return true;
+        }
+    }
+    function Literal(schema, references, value) {
+        return value === schema.const;
+    }
+    function Never(schema, references, value) {
+        return false;
+    }
+    function Not(schema, references, value) {
+        return !Visit(schema.allOf[0].not, references, value) && Visit(schema.allOf[1], references, value);
+    }
+    function Null(schema, references, value) {
+        return value === null;
+    }
+    function Number(schema, references, value) {
+        if (!IsNumber(value)) {
+            return false;
+        }
+        if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+            return false;
+        }
+        if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+            return false;
+        }
+        if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+            return false;
+        }
+        if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
+            return false;
+        }
+        if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
+            return false;
+        }
+        return true;
+    }
+    function Object(schema, references, value) {
+        if (!IsObject(value)) {
+            return false;
+        }
+        if (IsDefined(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+            return false;
+        }
+        if (IsDefined(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+            return false;
+        }
+        const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
+        for (const knownKey of knownKeys) {
+            const property = schema.properties[knownKey];
+            if (schema.required && schema.required.includes(knownKey)) {
+                if (!Visit(property, references, value[knownKey])) {
+                    return false;
+                }
+                if (Types.ExtendsUndefined.Check(property)) {
+                    return knownKey in value;
+                }
+            }
+            else {
+                if (IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
+                    return false;
+                }
+            }
+        }
+        if (schema.additionalProperties === false) {
+            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
+            // optimization: value is valid if schemaKey length matches the valueKey length
+            if (schema.required && schema.required.length === knownKeys.length && valueKeys.length === knownKeys.length) {
+                return true;
+            }
+            else {
+                return valueKeys.every((valueKey) => knownKeys.includes(valueKey));
+            }
+        }
+        else if (typeof schema.additionalProperties === 'object') {
+            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
+            return valueKeys.every((key) => knownKeys.includes(key) || Visit(schema.additionalProperties, references, value[key]));
+        }
+        else {
+            return true;
+        }
+    }
+    function Promise(schema, references, value) {
+        return typeof value === 'object' && typeof value.then === 'function';
+    }
+    function Record(schema, references, value) {
+        if (!IsRecordObject(value)) {
+            return false;
+        }
+        if (IsDefined(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+            return false;
+        }
+        if (IsDefined(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+            return false;
+        }
+        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
+        const regex = new RegExp(keyPattern);
+        if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
+            return false;
+        }
+        for (const propValue of globalThis.Object.values(value)) {
+            if (!Visit(valueSchema, references, propValue))
+                return false;
+        }
+        return true;
+    }
+    function Ref(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueCheckDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
+    function String(schema, references, value) {
+        if (!IsString(value)) {
+            return false;
+        }
+        if (IsDefined(schema.minLength)) {
+            if (!(value.length >= schema.minLength))
+                return false;
+        }
+        if (IsDefined(schema.maxLength)) {
+            if (!(value.length <= schema.maxLength))
+                return false;
+        }
+        if (IsDefined(schema.pattern)) {
+            const regex = new RegExp(schema.pattern);
+            if (!regex.test(value))
+                return false;
+        }
+        if (IsDefined(schema.format)) {
+            if (!Types.FormatRegistry.Has(schema.format))
+                return false;
+            const func = Types.FormatRegistry.Get(schema.format);
+            return func(value);
+        }
+        return true;
+    }
+    function Symbol(schema, references, value) {
+        if (!(typeof value === 'symbol')) {
+            return false;
+        }
+        return true;
+    }
+    function TemplateLiteral(schema, references, value) {
+        if (!IsString(value)) {
+            return false;
+        }
+        return new RegExp(schema.pattern).test(value);
+    }
+    function This(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueCheckDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
+    function Tuple(schema, references, value) {
+        if (!globalThis.Array.isArray(value)) {
+            return false;
+        }
+        if (schema.items === undefined && !(value.length === 0)) {
+            return false;
+        }
+        if (!(value.length === schema.maxItems)) {
+            return false;
+        }
+        if (!schema.items) {
+            return true;
+        }
+        for (let i = 0; i < schema.items.length; i++) {
+            if (!Visit(schema.items[i], references, value[i]))
+                return false;
+        }
+        return true;
+    }
+    function Undefined(schema, references, value) {
+        return value === undefined;
+    }
+    function Union(schema, references, value) {
+        return schema.anyOf.some((inner) => Visit(inner, references, value));
+    }
+    function Uint8Array(schema, references, value) {
+        if (!(value instanceof globalThis.Uint8Array)) {
+            return false;
+        }
+        if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
+            return false;
+        }
+        if (IsDefined(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
+            return false;
+        }
+        return true;
+    }
+    function Unknown(schema, references, value) {
+        return true;
+    }
+    function Void(schema, references, value) {
+        return IsVoid(value);
+    }
+    function UserDefined(schema, references, value) {
+        if (!Types.TypeRegistry.Has(schema[Types.Kind]))
+            return false;
+        const func = Types.TypeRegistry.Get(schema[Types.Kind]);
+        return func(schema, value);
+    }
+    function Visit(schema, references, value) {
+        const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
+        const schema_ = schema;
+        switch (schema_[Types.Kind]) {
+            case 'Any':
+                return Any(schema_, references_, value);
+            case 'Array':
+                return Array(schema_, references_, value);
+            case 'BigInt':
+                return BigInt(schema_, references_, value);
+            case 'Boolean':
+                return Boolean(schema_, references_, value);
+            case 'Constructor':
+                return Constructor(schema_, references_, value);
+            case 'Date':
+                return Date(schema_, references_, value);
+            case 'Function':
+                return Function(schema_, references_, value);
+            case 'Integer':
+                return Integer(schema_, references_, value);
+            case 'Intersect':
+                return Intersect(schema_, references_, value);
+            case 'Literal':
+                return Literal(schema_, references_, value);
+            case 'Never':
+                return Never(schema_, references_, value);
+            case 'Not':
+                return Not(schema_, references_, value);
+            case 'Null':
+                return Null(schema_, references_, value);
+            case 'Number':
+                return Number(schema_, references_, value);
+            case 'Object':
+                return Object(schema_, references_, value);
+            case 'Promise':
+                return Promise(schema_, references_, value);
+            case 'Record':
+                return Record(schema_, references_, value);
+            case 'Ref':
+                return Ref(schema_, references_, value);
+            case 'String':
+                return String(schema_, references_, value);
+            case 'Symbol':
+                return Symbol(schema_, references_, value);
+            case 'TemplateLiteral':
+                return TemplateLiteral(schema_, references_, value);
+            case 'This':
+                return This(schema_, references_, value);
+            case 'Tuple':
+                return Tuple(schema_, references_, value);
+            case 'Undefined':
+                return Undefined(schema_, references_, value);
+            case 'Union':
+                return Union(schema_, references_, value);
+            case 'Uint8Array':
+                return Uint8Array(schema_, references_, value);
+            case 'Unknown':
+                return Unknown(schema_, references_, value);
+            case 'Void':
+                return Void(schema_, references_, value);
+            default:
+                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+                    throw new ValueCheckUnknownTypeError(schema_);
+                return UserDefined(schema_, references_, value);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Check
+    // -------------------------------------------------------------------------
+    function Check(schema, references, value) {
+        return Visit(schema, references, value);
+    }
+    ValueCheck.Check = Check;
+})(ValueCheck = exports.ValueCheck || (exports.ValueCheck = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/value/clone.d.ts

@@ -0,0 +1,3 @@
+export declare namespace ValueClone {
+    function Clone<T extends unknown>(value: T): T;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/value/clone.js

@@ -0,0 +1,71 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueClone = void 0;
+const is_1 = require("./is");
+var ValueClone;
+(function (ValueClone) {
+    function Array(value) {
+        return value.map((element) => Clone(element));
+    }
+    function Date(value) {
+        return new globalThis.Date(value.toISOString());
+    }
+    function Object(value) {
+        const keys = [...globalThis.Object.keys(value), ...globalThis.Object.getOwnPropertySymbols(value)];
+        return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {});
+    }
+    function TypedArray(value) {
+        return value.slice();
+    }
+    function Value(value) {
+        return value;
+    }
+    function Clone(value) {
+        if (is_1.Is.Date(value)) {
+            return Date(value);
+        }
+        else if (is_1.Is.Object(value)) {
+            return Object(value);
+        }
+        else if (is_1.Is.Array(value)) {
+            return Array(value);
+        }
+        else if (is_1.Is.TypedArray(value)) {
+            return TypedArray(value);
+        }
+        else if (is_1.Is.Value(value)) {
+            return Value(value);
+        }
+        else {
+            throw new Error('ValueClone: Unable to clone value');
+        }
+    }
+    ValueClone.Clone = Clone;
+})(ValueClone = exports.ValueClone || (exports.ValueClone = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/value/convert.d.ts

@@ -0,0 +1,13 @@
+import * as Types from '../typebox';
+export declare class ValueConvertUnknownTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueConvertDereferenceError extends Error {
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
+}
+export declare namespace ValueConvert {
+    function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown;
+    function Convert<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): unknown;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/value/convert.js

@@ -0,0 +1,372 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueConvert = exports.ValueConvertDereferenceError = exports.ValueConvertUnknownTypeError = void 0;
+const Types = require("../typebox");
+const clone_1 = require("./clone");
+const check_1 = require("./check");
+// ----------------------------------------------------------------------------------------------
+// Errors
+// ----------------------------------------------------------------------------------------------
+class ValueConvertUnknownTypeError extends Error {
+    constructor(schema) {
+        super('ValueConvert: Unknown type');
+        this.schema = schema;
+    }
+}
+exports.ValueConvertUnknownTypeError = ValueConvertUnknownTypeError;
+class ValueConvertDereferenceError extends Error {
+    constructor(schema) {
+        super(`ValueConvert: Unable to dereference schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.ValueConvertDereferenceError = ValueConvertDereferenceError;
+var ValueConvert;
+(function (ValueConvert) {
+    // ----------------------------------------------------------------------------------------------
+    // Guards
+    // ----------------------------------------------------------------------------------------------
+    function IsObject(value) {
+        return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value);
+    }
+    function IsArray(value) {
+        return typeof value === 'object' && globalThis.Array.isArray(value);
+    }
+    function IsDate(value) {
+        return typeof value === 'object' && value instanceof globalThis.Date;
+    }
+    function IsSymbol(value) {
+        return typeof value === 'symbol';
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsBoolean(value) {
+        return typeof value === 'boolean';
+    }
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    function IsNumber(value) {
+        return typeof value === 'number' && !isNaN(value);
+    }
+    function IsStringNumeric(value) {
+        return IsString(value) && !isNaN(value) && !isNaN(parseFloat(value));
+    }
+    function IsValueToString(value) {
+        return IsBigInt(value) || IsBoolean(value) || IsNumber(value);
+    }
+    function IsValueTrue(value) {
+        return value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === globalThis.BigInt('1')) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'));
+    }
+    function IsValueFalse(value) {
+        return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === globalThis.BigInt('0')) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'));
+    }
+    function IsTimeStringWithTimeZone(value) {
+        return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    }
+    function IsTimeStringWithoutTimeZone(value) {
+        return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    }
+    function IsDateTimeStringWithTimeZone(value) {
+        return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    }
+    function IsDateTimeStringWithoutTimeZone(value) {
+        return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    }
+    function IsDateString(value) {
+        return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
+    }
+    // ----------------------------------------------------------------------------------------------
+    // Convert
+    // ----------------------------------------------------------------------------------------------
+    function TryConvertLiteralString(value, target) {
+        const conversion = TryConvertString(value);
+        return conversion === target ? conversion : value;
+    }
+    function TryConvertLiteralNumber(value, target) {
+        const conversion = TryConvertNumber(value);
+        return conversion === target ? conversion : value;
+    }
+    function TryConvertLiteralBoolean(value, target) {
+        const conversion = TryConvertBoolean(value);
+        return conversion === target ? conversion : value;
+    }
+    function TryConvertLiteral(schema, value) {
+        if (typeof schema.const === 'string') {
+            return TryConvertLiteralString(value, schema.const);
+        }
+        else if (typeof schema.const === 'number') {
+            return TryConvertLiteralNumber(value, schema.const);
+        }
+        else if (typeof schema.const === 'boolean') {
+            return TryConvertLiteralBoolean(value, schema.const);
+        }
+        else {
+            return clone_1.ValueClone.Clone(value);
+        }
+    }
+    function TryConvertBoolean(value) {
+        return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
+    }
+    function TryConvertBigInt(value) {
+        return IsStringNumeric(value) ? globalThis.BigInt(parseInt(value)) : IsNumber(value) ? globalThis.BigInt(value | 0) : IsValueFalse(value) ? 0 : IsValueTrue(value) ? 1 : value;
+    }
+    function TryConvertString(value) {
+        return IsValueToString(value) ? value.toString() : value;
+    }
+    function TryConvertNumber(value) {
+        return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
+    }
+    function TryConvertInteger(value) {
+        return IsStringNumeric(value) ? parseInt(value) : IsNumber(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
+    }
+    function TryConvertNull(value) {
+        return IsString(value) && value.toLowerCase() === 'null' ? null : value;
+    }
+    function TryConvertUndefined(value) {
+        return IsString(value) && value === 'undefined' ? undefined : value;
+    }
+    function TryConvertDate(value) {
+        // note: this function may return an invalid dates for the regex tests
+        // above. Invalid dates will however be checked during the casting
+        // function and will return a epoch date if invalid. Consider better
+        // string parsing for the iso dates in future revisions.
+        return IsDate(value)
+            ? value
+            : IsNumber(value)
+                ? new globalThis.Date(value)
+                : IsValueTrue(value)
+                    ? new globalThis.Date(1)
+                    : IsValueFalse(value)
+                        ? new globalThis.Date(0)
+                        : IsStringNumeric(value)
+                            ? new globalThis.Date(parseInt(value))
+                            : IsTimeStringWithoutTimeZone(value)
+                                ? new globalThis.Date(`1970-01-01T${value}.000Z`)
+                                : IsTimeStringWithTimeZone(value)
+                                    ? new globalThis.Date(`1970-01-01T${value}`)
+                                    : IsDateTimeStringWithoutTimeZone(value)
+                                        ? new globalThis.Date(`${value}.000Z`)
+                                        : IsDateTimeStringWithTimeZone(value)
+                                            ? new globalThis.Date(value)
+                                            : IsDateString(value)
+                                                ? new globalThis.Date(`${value}T00:00:00.000Z`)
+                                                : value;
+    }
+    // ----------------------------------------------------------------------------------------------
+    // Cast
+    // ----------------------------------------------------------------------------------------------
+    function Any(schema, references, value) {
+        return value;
+    }
+    function Array(schema, references, value) {
+        if (IsArray(value)) {
+            return value.map((value) => Visit(schema.items, references, value));
+        }
+        return value;
+    }
+    function BigInt(schema, references, value) {
+        return TryConvertBigInt(value);
+    }
+    function Boolean(schema, references, value) {
+        return TryConvertBoolean(value);
+    }
+    function Constructor(schema, references, value) {
+        return clone_1.ValueClone.Clone(value);
+    }
+    function Date(schema, references, value) {
+        return TryConvertDate(value);
+    }
+    function Function(schema, references, value) {
+        return value;
+    }
+    function Integer(schema, references, value) {
+        return TryConvertInteger(value);
+    }
+    function Intersect(schema, references, value) {
+        return value;
+    }
+    function Literal(schema, references, value) {
+        return TryConvertLiteral(schema, value);
+    }
+    function Never(schema, references, value) {
+        return value;
+    }
+    function Null(schema, references, value) {
+        return TryConvertNull(value);
+    }
+    function Number(schema, references, value) {
+        return TryConvertNumber(value);
+    }
+    function Object(schema, references, value) {
+        if (IsObject(value))
+            return globalThis.Object.keys(schema.properties).reduce((acc, key) => {
+                return value[key] !== undefined ? { ...acc, [key]: Visit(schema.properties[key], references, value[key]) } : { ...acc };
+            }, value);
+        return value;
+    }
+    function Promise(schema, references, value) {
+        return value;
+    }
+    function Record(schema, references, value) {
+        const propertyKey = globalThis.Object.getOwnPropertyNames(schema.patternProperties)[0];
+        const property = schema.patternProperties[propertyKey];
+        const result = {};
+        for (const [propKey, propValue] of globalThis.Object.entries(value)) {
+            result[propKey] = Visit(property, references, propValue);
+        }
+        return result;
+    }
+    function Ref(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueConvertDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
+    function String(schema, references, value) {
+        return TryConvertString(value);
+    }
+    function Symbol(schema, references, value) {
+        return value;
+    }
+    function TemplateLiteral(schema, references, value) {
+        return value;
+    }
+    function This(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueConvertDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
+    function Tuple(schema, references, value) {
+        if (IsArray(value) && schema.items !== undefined) {
+            return value.map((value, index) => {
+                return index < schema.items.length ? Visit(schema.items[index], references, value) : value;
+            });
+        }
+        return value;
+    }
+    function Undefined(schema, references, value) {
+        return TryConvertUndefined(value);
+    }
+    function Union(schema, references, value) {
+        for (const subschema of schema.anyOf) {
+            const converted = Visit(subschema, references, value);
+            if (check_1.ValueCheck.Check(subschema, references, converted)) {
+                return converted;
+            }
+        }
+        return value;
+    }
+    function Uint8Array(schema, references, value) {
+        return value;
+    }
+    function Unknown(schema, references, value) {
+        return value;
+    }
+    function Void(schema, references, value) {
+        return value;
+    }
+    function UserDefined(schema, references, value) {
+        return value;
+    }
+    function Visit(schema, references, value) {
+        const references_ = IsString(schema.$id) ? [...references, schema] : references;
+        const schema_ = schema;
+        switch (schema[Types.Kind]) {
+            case 'Any':
+                return Any(schema_, references_, value);
+            case 'Array':
+                return Array(schema_, references_, value);
+            case 'BigInt':
+                return BigInt(schema_, references_, value);
+            case 'Boolean':
+                return Boolean(schema_, references_, value);
+            case 'Constructor':
+                return Constructor(schema_, references_, value);
+            case 'Date':
+                return Date(schema_, references_, value);
+            case 'Function':
+                return Function(schema_, references_, value);
+            case 'Integer':
+                return Integer(schema_, references_, value);
+            case 'Intersect':
+                return Intersect(schema_, references_, value);
+            case 'Literal':
+                return Literal(schema_, references_, value);
+            case 'Never':
+                return Never(schema_, references_, value);
+            case 'Null':
+                return Null(schema_, references_, value);
+            case 'Number':
+                return Number(schema_, references_, value);
+            case 'Object':
+                return Object(schema_, references_, value);
+            case 'Promise':
+                return Promise(schema_, references_, value);
+            case 'Record':
+                return Record(schema_, references_, value);
+            case 'Ref':
+                return Ref(schema_, references_, value);
+            case 'String':
+                return String(schema_, references_, value);
+            case 'Symbol':
+                return Symbol(schema_, references_, value);
+            case 'TemplateLiteral':
+                return TemplateLiteral(schema_, references_, value);
+            case 'This':
+                return This(schema_, references_, value);
+            case 'Tuple':
+                return Tuple(schema_, references_, value);
+            case 'Undefined':
+                return Undefined(schema_, references_, value);
+            case 'Union':
+                return Union(schema_, references_, value);
+            case 'Uint8Array':
+                return Uint8Array(schema_, references_, value);
+            case 'Unknown':
+                return Unknown(schema_, references_, value);
+            case 'Void':
+                return Void(schema_, references_, value);
+            default:
+                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+                    throw new ValueConvertUnknownTypeError(schema_);
+                return UserDefined(schema_, references_, value);
+        }
+    }
+    ValueConvert.Visit = Visit;
+    function Convert(schema, references, value) {
+        return Visit(schema, references, clone_1.ValueClone.Clone(value));
+    }
+    ValueConvert.Convert = Convert;
+})(ValueConvert = exports.ValueConvert || (exports.ValueConvert = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/value/create.d.ts

@@ -0,0 +1,26 @@
+import * as Types from '../typebox';
+export declare class ValueCreateUnknownTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueCreateNeverTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueCreateIntersectTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueCreateTempateLiteralTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueCreateDereferenceError extends Error {
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
+}
+export declare namespace ValueCreate {
+    /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
+    function Visit(schema: Types.TSchema, references: Types.TSchema[]): unknown;
+    function Create<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/value/create.js

@@ -0,0 +1,480 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueCreate = exports.ValueCreateDereferenceError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
+const Types = require("../typebox");
+const check_1 = require("./check");
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
+class ValueCreateUnknownTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Unknown type');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateUnknownTypeError = ValueCreateUnknownTypeError;
+class ValueCreateNeverTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Never types cannot be created');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateNeverTypeError = ValueCreateNeverTypeError;
+class ValueCreateIntersectTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Intersect produced invalid value. Consider using a default value.');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateIntersectTypeError = ValueCreateIntersectTypeError;
+class ValueCreateTempateLiteralTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Can only create template literal values from patterns that produce finite sequences. Consider using a default value.');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateTempateLiteralTypeError = ValueCreateTempateLiteralTypeError;
+class ValueCreateDereferenceError extends Error {
+    constructor(schema) {
+        super(`ValueCreate: Unable to dereference schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.ValueCreateDereferenceError = ValueCreateDereferenceError;
+// --------------------------------------------------------------------------
+// ValueCreate
+// --------------------------------------------------------------------------
+var ValueCreate;
+(function (ValueCreate) {
+    // --------------------------------------------------------
+    // Guards
+    // --------------------------------------------------------
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    // --------------------------------------------------------
+    // Types
+    // --------------------------------------------------------
+    function Any(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return {};
+        }
+    }
+    function Array(schema, references) {
+        if (schema.uniqueItems === true && schema.default === undefined) {
+            throw new Error('ValueCreate.Array: Arrays with uniqueItems require a default value');
+        }
+        else if ('default' in schema) {
+            return schema.default;
+        }
+        else if (schema.minItems !== undefined) {
+            return globalThis.Array.from({ length: schema.minItems }).map((item) => {
+                return ValueCreate.Create(schema.items, references);
+            });
+        }
+        else {
+            return [];
+        }
+    }
+    function BigInt(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return globalThis.BigInt(0);
+        }
+    }
+    function Boolean(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return false;
+        }
+    }
+    function Constructor(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            const value = ValueCreate.Create(schema.returns, references);
+            if (typeof value === 'object' && !globalThis.Array.isArray(value)) {
+                return class {
+                    constructor() {
+                        for (const [key, val] of globalThis.Object.entries(value)) {
+                            const self = this;
+                            self[key] = val;
+                        }
+                    }
+                };
+            }
+            else {
+                return class {
+                };
+            }
+        }
+    }
+    function Date(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if (schema.minimumTimestamp !== undefined) {
+            return new globalThis.Date(schema.minimumTimestamp);
+        }
+        else {
+            return new globalThis.Date(0);
+        }
+    }
+    function Function(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return () => ValueCreate.Create(schema.returns, references);
+        }
+    }
+    function Integer(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if (schema.minimum !== undefined) {
+            return schema.minimum;
+        }
+        else {
+            return 0;
+        }
+    }
+    function Intersect(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            // Note: The best we can do here is attempt to instance each sub type and apply through object assign. For non-object
+            // sub types, we just escape the assignment and just return the value. In the latter case, this is typically going to
+            // be a consequence of an illogical intersection.
+            const value = schema.allOf.reduce((acc, schema) => {
+                const next = Visit(schema, references);
+                return typeof next === 'object' ? { ...acc, ...next } : next;
+            }, {});
+            if (!check_1.ValueCheck.Check(schema, references, value))
+                throw new ValueCreateIntersectTypeError(schema);
+            return value;
+        }
+    }
+    function Literal(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return schema.const;
+        }
+    }
+    function Never(schema, references) {
+        throw new ValueCreateNeverTypeError(schema);
+    }
+    function Not(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return Visit(schema.allOf[1], references);
+        }
+    }
+    function Null(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return null;
+        }
+    }
+    function Number(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if (schema.minimum !== undefined) {
+            return schema.minimum;
+        }
+        else {
+            return 0;
+        }
+    }
+    function Object(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            const required = new Set(schema.required);
+            return (schema.default ||
+                globalThis.Object.entries(schema.properties).reduce((acc, [key, schema]) => {
+                    return required.has(key) ? { ...acc, [key]: ValueCreate.Create(schema, references) } : { ...acc };
+                }, {}));
+        }
+    }
+    function Promise(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return globalThis.Promise.resolve(ValueCreate.Create(schema.item, references));
+        }
+    }
+    function Record(schema, references) {
+        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
+            const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
+            return propertyKeys.reduce((acc, key) => {
+                return { ...acc, [key]: Create(valueSchema, references) };
+            }, {});
+        }
+        else {
+            return {};
+        }
+    }
+    function Ref(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            const index = references.findIndex((foreign) => foreign.$id === schema.$id);
+            if (index === -1)
+                throw new ValueCreateDereferenceError(schema);
+            const target = references[index];
+            return Visit(target, references);
+        }
+    }
+    function String(schema, references) {
+        if (schema.pattern !== undefined) {
+            if (!('default' in schema)) {
+                throw new Error('ValueCreate.String: String types with patterns must specify a default value');
+            }
+            else {
+                return schema.default;
+            }
+        }
+        else if (schema.format !== undefined) {
+            if (!('default' in schema)) {
+                throw new Error('ValueCreate.String: String types with formats must specify a default value');
+            }
+            else {
+                return schema.default;
+            }
+        }
+        else {
+            if ('default' in schema) {
+                return schema.default;
+            }
+            else if (schema.minLength !== undefined) {
+                return globalThis.Array.from({ length: schema.minLength })
+                    .map(() => '.')
+                    .join('');
+            }
+            else {
+                return '';
+            }
+        }
+    }
+    function Symbol(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if ('value' in schema) {
+            return globalThis.Symbol.for(schema.value);
+        }
+        else {
+            return globalThis.Symbol();
+        }
+    }
+    function TemplateLiteral(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        const expression = Types.TemplateLiteralParser.ParseExact(schema.pattern);
+        if (!Types.TemplateLiteralFinite.Check(expression))
+            throw new ValueCreateTempateLiteralTypeError(schema);
+        const sequence = Types.TemplateLiteralGenerator.Generate(expression);
+        return sequence.next().value;
+    }
+    function This(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            const index = references.findIndex((foreign) => foreign.$id === schema.$id);
+            if (index === -1)
+                throw new ValueCreateDereferenceError(schema);
+            const target = references[index];
+            return Visit(target, references);
+        }
+    }
+    function Tuple(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        if (schema.items === undefined) {
+            return [];
+        }
+        else {
+            return globalThis.Array.from({ length: schema.minItems }).map((_, index) => ValueCreate.Create(schema.items[index], references));
+        }
+    }
+    function Undefined(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return undefined;
+        }
+    }
+    function Union(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if (schema.anyOf.length === 0) {
+            throw new Error('ValueCreate.Union: Cannot create Union with zero variants');
+        }
+        else {
+            return ValueCreate.Create(schema.anyOf[0], references);
+        }
+    }
+    function Uint8Array(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if (schema.minByteLength !== undefined) {
+            return new globalThis.Uint8Array(schema.minByteLength);
+        }
+        else {
+            return new globalThis.Uint8Array(0);
+        }
+    }
+    function Unknown(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return {};
+        }
+    }
+    function Void(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return void 0;
+        }
+    }
+    function UserDefined(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            throw new Error('ValueCreate.UserDefined: User defined types must specify a default value');
+        }
+    }
+    /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
+    function Visit(schema, references) {
+        const references_ = IsString(schema.$id) ? [...references, schema] : references;
+        const schema_ = schema;
+        switch (schema_[Types.Kind]) {
+            case 'Any':
+                return Any(schema_, references_);
+            case 'Array':
+                return Array(schema_, references_);
+            case 'BigInt':
+                return BigInt(schema_, references_);
+            case 'Boolean':
+                return Boolean(schema_, references_);
+            case 'Constructor':
+                return Constructor(schema_, references_);
+            case 'Date':
+                return Date(schema_, references_);
+            case 'Function':
+                return Function(schema_, references_);
+            case 'Integer':
+                return Integer(schema_, references_);
+            case 'Intersect':
+                return Intersect(schema_, references_);
+            case 'Literal':
+                return Literal(schema_, references_);
+            case 'Never':
+                return Never(schema_, references_);
+            case 'Not':
+                return Not(schema_, references_);
+            case 'Null':
+                return Null(schema_, references_);
+            case 'Number':
+                return Number(schema_, references_);
+            case 'Object':
+                return Object(schema_, references_);
+            case 'Promise':
+                return Promise(schema_, references_);
+            case 'Record':
+                return Record(schema_, references_);
+            case 'Ref':
+                return Ref(schema_, references_);
+            case 'String':
+                return String(schema_, references_);
+            case 'Symbol':
+                return Symbol(schema_, references_);
+            case 'TemplateLiteral':
+                return TemplateLiteral(schema_, references_);
+            case 'This':
+                return This(schema_, references_);
+            case 'Tuple':
+                return Tuple(schema_, references_);
+            case 'Undefined':
+                return Undefined(schema_, references_);
+            case 'Union':
+                return Union(schema_, references_);
+            case 'Uint8Array':
+                return Uint8Array(schema_, references_);
+            case 'Unknown':
+                return Unknown(schema_, references_);
+            case 'Void':
+                return Void(schema_, references_);
+            default:
+                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+                    throw new ValueCreateUnknownTypeError(schema_);
+                return UserDefined(schema_, references_);
+        }
+    }
+    ValueCreate.Visit = Visit;
+    function Create(schema, references) {
+        return Visit(schema, references);
+    }
+    ValueCreate.Create = Create;
+})(ValueCreate = exports.ValueCreate || (exports.ValueCreate = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/value/delta.d.ts

@@ -0,0 +1,43 @@
+import { Static } from '../typebox';
+export type Insert = Static<typeof Insert>;
+export declare const Insert: import("../typebox").TObject<{
+    type: import("../typebox").TLiteral<"insert">;
+    path: import("../typebox").TString<string>;
+    value: import("../typebox").TUnknown;
+}>;
+export type Update = Static<typeof Update>;
+export declare const Update: import("../typebox").TObject<{
+    type: import("../typebox").TLiteral<"update">;
+    path: import("../typebox").TString<string>;
+    value: import("../typebox").TUnknown;
+}>;
+export type Delete = Static<typeof Delete>;
+export declare const Delete: import("../typebox").TObject<{
+    type: import("../typebox").TLiteral<"delete">;
+    path: import("../typebox").TString<string>;
+}>;
+export type Edit = Static<typeof Edit>;
+export declare const Edit: import("../typebox").TUnion<[import("../typebox").TObject<{
+    type: import("../typebox").TLiteral<"insert">;
+    path: import("../typebox").TString<string>;
+    value: import("../typebox").TUnknown;
+}>, import("../typebox").TObject<{
+    type: import("../typebox").TLiteral<"update">;
+    path: import("../typebox").TString<string>;
+    value: import("../typebox").TUnknown;
+}>, import("../typebox").TObject<{
+    type: import("../typebox").TLiteral<"delete">;
+    path: import("../typebox").TString<string>;
+}>]>;
+export declare class ValueDeltaObjectWithSymbolKeyError extends Error {
+    readonly key: unknown;
+    constructor(key: unknown);
+}
+export declare class ValueDeltaUnableToDiffUnknownValue extends Error {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare namespace ValueDelta {
+    function Diff(current: unknown, next: unknown): Edit[];
+    function Patch<T = any>(current: unknown, edits: Edit[]): T;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/value/delta.js

@@ -0,0 +1,204 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueDelta = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Edit = exports.Delete = exports.Update = exports.Insert = void 0;
+const typebox_1 = require("../typebox");
+const is_1 = require("./is");
+const clone_1 = require("./clone");
+const pointer_1 = require("./pointer");
+exports.Insert = typebox_1.Type.Object({
+    type: typebox_1.Type.Literal('insert'),
+    path: typebox_1.Type.String(),
+    value: typebox_1.Type.Unknown(),
+});
+exports.Update = typebox_1.Type.Object({
+    type: typebox_1.Type.Literal('update'),
+    path: typebox_1.Type.String(),
+    value: typebox_1.Type.Unknown(),
+});
+exports.Delete = typebox_1.Type.Object({
+    type: typebox_1.Type.Literal('delete'),
+    path: typebox_1.Type.String(),
+});
+exports.Edit = typebox_1.Type.Union([exports.Insert, exports.Update, exports.Delete]);
+// ---------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------
+class ValueDeltaObjectWithSymbolKeyError extends Error {
+    constructor(key) {
+        super('ValueDelta: Cannot diff objects with symbol keys');
+        this.key = key;
+    }
+}
+exports.ValueDeltaObjectWithSymbolKeyError = ValueDeltaObjectWithSymbolKeyError;
+class ValueDeltaUnableToDiffUnknownValue extends Error {
+    constructor(value) {
+        super('ValueDelta: Unable to create diff edits for unknown value');
+        this.value = value;
+    }
+}
+exports.ValueDeltaUnableToDiffUnknownValue = ValueDeltaUnableToDiffUnknownValue;
+// ---------------------------------------------------------------------
+// ValueDelta
+// ---------------------------------------------------------------------
+var ValueDelta;
+(function (ValueDelta) {
+    // ---------------------------------------------------------------------
+    // Edits
+    // ---------------------------------------------------------------------
+    function Update(path, value) {
+        return { type: 'update', path, value };
+    }
+    function Insert(path, value) {
+        return { type: 'insert', path, value };
+    }
+    function Delete(path) {
+        return { type: 'delete', path };
+    }
+    // ---------------------------------------------------------------------
+    // Diff
+    // ---------------------------------------------------------------------
+    function* Object(path, current, next) {
+        if (!is_1.Is.Object(next))
+            return yield Update(path, next);
+        const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)];
+        const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
+        for (const key of currentKeys) {
+            if (typeof key === 'symbol')
+                throw new ValueDeltaObjectWithSymbolKeyError(key);
+            if (next[key] === undefined && nextKeys.includes(key))
+                yield Update(`${path}/${String(key)}`, undefined);
+        }
+        for (const key of nextKeys) {
+            if (current[key] === undefined || next[key] === undefined)
+                continue;
+            if (typeof key === 'symbol')
+                throw new ValueDeltaObjectWithSymbolKeyError(key);
+            yield* Visit(`${path}/${String(key)}`, current[key], next[key]);
+        }
+        for (const key of nextKeys) {
+            if (typeof key === 'symbol')
+                throw new ValueDeltaObjectWithSymbolKeyError(key);
+            if (current[key] === undefined)
+                yield Insert(`${path}/${String(key)}`, next[key]);
+        }
+        for (const key of currentKeys.reverse()) {
+            if (typeof key === 'symbol')
+                throw new ValueDeltaObjectWithSymbolKeyError(key);
+            if (next[key] === undefined && !nextKeys.includes(key))
+                yield Delete(`${path}/${String(key)}`);
+        }
+    }
+    function* Array(path, current, next) {
+        if (!is_1.Is.Array(next))
+            return yield Update(path, next);
+        for (let i = 0; i < Math.min(current.length, next.length); i++) {
+            yield* Visit(`${path}/${i}`, current[i], next[i]);
+        }
+        for (let i = 0; i < next.length; i++) {
+            if (i < current.length)
+                continue;
+            yield Insert(`${path}/${i}`, next[i]);
+        }
+        for (let i = current.length - 1; i >= 0; i--) {
+            if (i < next.length)
+                continue;
+            yield Delete(`${path}/${i}`);
+        }
+    }
+    function* TypedArray(path, current, next) {
+        if (!is_1.Is.TypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name)
+            return yield Update(path, next);
+        for (let i = 0; i < Math.min(current.length, next.length); i++) {
+            yield* Visit(`${path}/${i}`, current[i], next[i]);
+        }
+    }
+    function* Value(path, current, next) {
+        if (current === next)
+            return;
+        yield Update(path, next);
+    }
+    function* Visit(path, current, next) {
+        if (is_1.Is.Object(current)) {
+            return yield* Object(path, current, next);
+        }
+        else if (is_1.Is.Array(current)) {
+            return yield* Array(path, current, next);
+        }
+        else if (is_1.Is.TypedArray(current)) {
+            return yield* TypedArray(path, current, next);
+        }
+        else if (is_1.Is.Value(current)) {
+            return yield* Value(path, current, next);
+        }
+        else {
+            throw new ValueDeltaUnableToDiffUnknownValue(current);
+        }
+    }
+    function Diff(current, next) {
+        return [...Visit('', current, next)];
+    }
+    ValueDelta.Diff = Diff;
+    // ---------------------------------------------------------------------
+    // Patch
+    // ---------------------------------------------------------------------
+    function IsRootUpdate(edits) {
+        return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
+    }
+    function IsIdentity(edits) {
+        return edits.length === 0;
+    }
+    function Patch(current, edits) {
+        if (IsRootUpdate(edits)) {
+            return clone_1.ValueClone.Clone(edits[0].value);
+        }
+        if (IsIdentity(edits)) {
+            return clone_1.ValueClone.Clone(current);
+        }
+        const clone = clone_1.ValueClone.Clone(current);
+        for (const edit of edits) {
+            switch (edit.type) {
+                case 'insert': {
+                    pointer_1.ValuePointer.Set(clone, edit.path, edit.value);
+                    break;
+                }
+                case 'update': {
+                    pointer_1.ValuePointer.Set(clone, edit.path, edit.value);
+                    break;
+                }
+                case 'delete': {
+                    pointer_1.ValuePointer.Delete(clone, edit.path);
+                    break;
+                }
+            }
+        }
+        return clone;
+    }
+    ValueDelta.Patch = Patch;
+})(ValueDelta = exports.ValueDelta || (exports.ValueDelta = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/value/equal.d.ts

@@ -0,0 +1,3 @@
+export declare namespace ValueEqual {
+    function Equal<T>(left: T, right: unknown): right is T;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/value/equal.js

@@ -0,0 +1,80 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueEqual = void 0;
+const is_1 = require("./is");
+var ValueEqual;
+(function (ValueEqual) {
+    function Object(left, right) {
+        if (!is_1.Is.Object(right))
+            return false;
+        const leftKeys = [...globalThis.Object.keys(left), ...globalThis.Object.getOwnPropertySymbols(left)];
+        const rightKeys = [...globalThis.Object.keys(right), ...globalThis.Object.getOwnPropertySymbols(right)];
+        if (leftKeys.length !== rightKeys.length)
+            return false;
+        return leftKeys.every((key) => Equal(left[key], right[key]));
+    }
+    function Date(left, right) {
+        return is_1.Is.Date(right) && left.getTime() === right.getTime();
+    }
+    function Array(left, right) {
+        if (!is_1.Is.Array(right) || left.length !== right.length)
+            return false;
+        return left.every((value, index) => Equal(value, right[index]));
+    }
+    function TypedArray(left, right) {
+        if (!is_1.Is.TypedArray(right) || left.length !== right.length || globalThis.Object.getPrototypeOf(left).constructor.name !== globalThis.Object.getPrototypeOf(right).constructor.name)
+            return false;
+        return left.every((value, index) => Equal(value, right[index]));
+    }
+    function Value(left, right) {
+        return left === right;
+    }
+    function Equal(left, right) {
+        if (is_1.Is.Object(left)) {
+            return Object(left, right);
+        }
+        else if (is_1.Is.Date(left)) {
+            return Date(left, right);
+        }
+        else if (is_1.Is.TypedArray(left)) {
+            return TypedArray(left, right);
+        }
+        else if (is_1.Is.Array(left)) {
+            return Array(left, right);
+        }
+        else if (is_1.Is.Value(left)) {
+            return Value(left, right);
+        }
+        else {
+            throw new Error('ValueEquals: Unable to compare value');
+        }
+    }
+    ValueEqual.Equal = Equal;
+})(ValueEqual = exports.ValueEqual || (exports.ValueEqual = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/value/hash.d.ts

@@ -0,0 +1,8 @@
+export declare class ValueHashError extends Error {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare namespace ValueHash {
+    /** Creates a FNV1A-64 non cryptographic hash of the given value */
+    function Create(value: unknown): bigint;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/value/hash.js

@@ -0,0 +1,208 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/hash
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueHash = exports.ValueHashError = void 0;
+class ValueHashError extends Error {
+    constructor(value) {
+        super(`Hash: Unable to hash value`);
+        this.value = value;
+    }
+}
+exports.ValueHashError = ValueHashError;
+var ValueHash;
+(function (ValueHash) {
+    let ByteMarker;
+    (function (ByteMarker) {
+        ByteMarker[ByteMarker["Undefined"] = 0] = "Undefined";
+        ByteMarker[ByteMarker["Null"] = 1] = "Null";
+        ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+        ByteMarker[ByteMarker["Number"] = 3] = "Number";
+        ByteMarker[ByteMarker["String"] = 4] = "String";
+        ByteMarker[ByteMarker["Object"] = 5] = "Object";
+        ByteMarker[ByteMarker["Array"] = 6] = "Array";
+        ByteMarker[ByteMarker["Date"] = 7] = "Date";
+        ByteMarker[ByteMarker["Uint8Array"] = 8] = "Uint8Array";
+        ByteMarker[ByteMarker["Symbol"] = 9] = "Symbol";
+        ByteMarker[ByteMarker["BigInt"] = 10] = "BigInt";
+    })(ByteMarker || (ByteMarker = {}));
+    // ----------------------------------------------------
+    // State
+    // ----------------------------------------------------
+    let Hash = globalThis.BigInt('14695981039346656037');
+    const [Prime, Size] = [globalThis.BigInt('1099511628211'), globalThis.BigInt('2') ** globalThis.BigInt('64')];
+    const Bytes = globalThis.Array.from({ length: 256 }).map((_, i) => globalThis.BigInt(i));
+    const F64 = new globalThis.Float64Array(1);
+    const F64In = new globalThis.DataView(F64.buffer);
+    const F64Out = new globalThis.Uint8Array(F64.buffer);
+    // ----------------------------------------------------
+    // Guards
+    // ----------------------------------------------------
+    function IsDate(value) {
+        return value instanceof globalThis.Date;
+    }
+    function IsUint8Array(value) {
+        return value instanceof globalThis.Uint8Array;
+    }
+    function IsArray(value) {
+        return globalThis.Array.isArray(value);
+    }
+    function IsBoolean(value) {
+        return typeof value === 'boolean';
+    }
+    function IsNull(value) {
+        return value === null;
+    }
+    function IsNumber(value) {
+        return typeof value === 'number';
+    }
+    function IsSymbol(value) {
+        return typeof value === 'symbol';
+    }
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    function IsObject(value) {
+        return typeof value === 'object' && value !== null && !IsArray(value) && !IsDate(value) && !IsUint8Array(value);
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsUndefined(value) {
+        return value === undefined;
+    }
+    // ----------------------------------------------------
+    // Encoding
+    // ----------------------------------------------------
+    function Array(value) {
+        FNV1A64(ByteMarker.Array);
+        for (const item of value) {
+            Visit(item);
+        }
+    }
+    function Boolean(value) {
+        FNV1A64(ByteMarker.Boolean);
+        FNV1A64(value ? 1 : 0);
+    }
+    function BigInt(value) {
+        FNV1A64(ByteMarker.BigInt);
+        F64In.setBigInt64(0, value);
+        for (const byte of F64Out) {
+            FNV1A64(byte);
+        }
+    }
+    function Date(value) {
+        FNV1A64(ByteMarker.Date);
+        Visit(value.getTime());
+    }
+    function Null(value) {
+        FNV1A64(ByteMarker.Null);
+    }
+    function Number(value) {
+        FNV1A64(ByteMarker.Number);
+        F64In.setFloat64(0, value);
+        for (const byte of F64Out) {
+            FNV1A64(byte);
+        }
+    }
+    function Object(value) {
+        FNV1A64(ByteMarker.Object);
+        for (const key of globalThis.Object.keys(value).sort()) {
+            Visit(key);
+            Visit(value[key]);
+        }
+    }
+    function String(value) {
+        FNV1A64(ByteMarker.String);
+        for (let i = 0; i < value.length; i++) {
+            FNV1A64(value.charCodeAt(i));
+        }
+    }
+    function Symbol(value) {
+        FNV1A64(ByteMarker.Symbol);
+        Visit(value.description);
+    }
+    function Uint8Array(value) {
+        FNV1A64(ByteMarker.Uint8Array);
+        for (let i = 0; i < value.length; i++) {
+            FNV1A64(value[i]);
+        }
+    }
+    function Undefined(value) {
+        return FNV1A64(ByteMarker.Undefined);
+    }
+    function Visit(value) {
+        if (IsArray(value)) {
+            Array(value);
+        }
+        else if (IsBoolean(value)) {
+            Boolean(value);
+        }
+        else if (IsBigInt(value)) {
+            BigInt(value);
+        }
+        else if (IsDate(value)) {
+            Date(value);
+        }
+        else if (IsNull(value)) {
+            Null(value);
+        }
+        else if (IsNumber(value)) {
+            Number(value);
+        }
+        else if (IsObject(value)) {
+            Object(value);
+        }
+        else if (IsString(value)) {
+            String(value);
+        }
+        else if (IsSymbol(value)) {
+            Symbol(value);
+        }
+        else if (IsUint8Array(value)) {
+            Uint8Array(value);
+        }
+        else if (IsUndefined(value)) {
+            Undefined(value);
+        }
+        else {
+            throw new ValueHashError(value);
+        }
+    }
+    function FNV1A64(byte) {
+        Hash = Hash ^ Bytes[byte];
+        Hash = (Hash * Prime) % Size;
+    }
+    /** Creates a FNV1A-64 non cryptographic hash of the given value */
+    function Create(value) {
+        Hash = globalThis.BigInt('14695981039346656037');
+        Visit(value);
+        return Hash;
+    }
+    ValueHash.Create = Create;
+})(ValueHash = exports.ValueHash || (exports.ValueHash = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/value/index.d.ts

@@ -0,0 +1,6 @@
+export { ValueError, ValueErrorIterator, ValueErrorType } from '../errors/index';
+export { ValueHash } from './hash';
+export { Edit, Insert, Update, Delete } from './delta';
+export { Mutable } from './mutate';
+export * from './pointer';
+export * from './value';

backend/node_modules/jest/node_modules/@sinclair/typebox/value/index.js

@@ -0,0 +1,56 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Delete = exports.Update = exports.Insert = exports.Edit = exports.ValueHash = exports.ValueErrorType = exports.ValueErrorIterator = void 0;
+var index_1 = require("../errors/index");
+Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
+Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
+var hash_1 = require("./hash");
+Object.defineProperty(exports, "ValueHash", { enumerable: true, get: function () { return hash_1.ValueHash; } });
+var delta_1 = require("./delta");
+Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return delta_1.Edit; } });
+Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return delta_1.Insert; } });
+Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return delta_1.Update; } });
+Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return delta_1.Delete; } });
+__exportStar(require("./pointer"), exports);
+__exportStar(require("./value"), exports);

backend/node_modules/jest/node_modules/@sinclair/typebox/value/is.d.ts

@@ -0,0 +1,11 @@
+export type ValueType = null | undefined | Function | symbol | bigint | number | boolean | string;
+export type ObjectType = Record<string | number | symbol, unknown>;
+export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+export type ArrayType = unknown[];
+export declare namespace Is {
+    function Object(value: unknown): value is ObjectType;
+    function Date(value: unknown): value is Date;
+    function Array(value: unknown): value is ArrayType;
+    function Value(value: unknown): value is ValueType;
+    function TypedArray(value: unknown): value is TypedArrayType;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/value/is.js

@@ -0,0 +1,53 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Is = void 0;
+var Is;
+(function (Is) {
+    function Object(value) {
+        return value !== null && typeof value === 'object' && !globalThis.Array.isArray(value) && !ArrayBuffer.isView(value) && !(value instanceof globalThis.Date);
+    }
+    Is.Object = Object;
+    function Date(value) {
+        return value instanceof globalThis.Date;
+    }
+    Is.Date = Date;
+    function Array(value) {
+        return globalThis.Array.isArray(value) && !ArrayBuffer.isView(value);
+    }
+    Is.Array = Array;
+    function Value(value) {
+        return value === null || value === undefined || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'bigint' || typeof value === 'number' || typeof value === 'boolean' || typeof value === 'string';
+    }
+    Is.Value = Value;
+    function TypedArray(value) {
+        return ArrayBuffer.isView(value);
+    }
+    Is.TypedArray = TypedArray;
+})(Is = exports.Is || (exports.Is = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/value/mutate.d.ts

@@ -0,0 +1,13 @@
+export declare class ValueMutateTypeMismatchError extends Error {
+    constructor();
+}
+export declare class ValueMutateInvalidRootMutationError extends Error {
+    constructor();
+}
+export type Mutable = {
+    [key: string]: unknown;
+} | unknown[];
+export declare namespace ValueMutate {
+    /** Performs a deep mutable value assignment while retaining internal references. */
+    function Mutate(current: Mutable, next: Mutable): void;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/value/mutate.js

@@ -0,0 +1,121 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueMutate = exports.ValueMutateInvalidRootMutationError = exports.ValueMutateTypeMismatchError = void 0;
+const is_1 = require("./is");
+const pointer_1 = require("./pointer");
+const clone_1 = require("./clone");
+class ValueMutateTypeMismatchError extends Error {
+    constructor() {
+        super('ValueMutate: Cannot assign due type mismatch of assignable values');
+    }
+}
+exports.ValueMutateTypeMismatchError = ValueMutateTypeMismatchError;
+class ValueMutateInvalidRootMutationError extends Error {
+    constructor() {
+        super('ValueMutate: Only object and array types can be mutated at the root level');
+    }
+}
+exports.ValueMutateInvalidRootMutationError = ValueMutateInvalidRootMutationError;
+var ValueMutate;
+(function (ValueMutate) {
+    function Object(root, path, current, next) {
+        if (!is_1.Is.Object(current)) {
+            pointer_1.ValuePointer.Set(root, path, clone_1.ValueClone.Clone(next));
+        }
+        else {
+            const currentKeys = globalThis.Object.keys(current);
+            const nextKeys = globalThis.Object.keys(next);
+            for (const currentKey of currentKeys) {
+                if (!nextKeys.includes(currentKey)) {
+                    delete current[currentKey];
+                }
+            }
+            for (const nextKey of nextKeys) {
+                if (!currentKeys.includes(nextKey)) {
+                    current[nextKey] = null;
+                }
+            }
+            for (const nextKey of nextKeys) {
+                Visit(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
+            }
+        }
+    }
+    function Array(root, path, current, next) {
+        if (!is_1.Is.Array(current)) {
+            pointer_1.ValuePointer.Set(root, path, clone_1.ValueClone.Clone(next));
+        }
+        else {
+            for (let index = 0; index < next.length; index++) {
+                Visit(root, `${path}/${index}`, current[index], next[index]);
+            }
+            current.splice(next.length);
+        }
+    }
+    function TypedArray(root, path, current, next) {
+        if (is_1.Is.TypedArray(current) && current.length === next.length) {
+            for (let i = 0; i < current.length; i++) {
+                current[i] = next[i];
+            }
+        }
+        else {
+            pointer_1.ValuePointer.Set(root, path, clone_1.ValueClone.Clone(next));
+        }
+    }
+    function Value(root, path, current, next) {
+        if (current === next)
+            return;
+        pointer_1.ValuePointer.Set(root, path, next);
+    }
+    function Visit(root, path, current, next) {
+        if (is_1.Is.Array(next)) {
+            return Array(root, path, current, next);
+        }
+        else if (is_1.Is.TypedArray(next)) {
+            return TypedArray(root, path, current, next);
+        }
+        else if (is_1.Is.Object(next)) {
+            return Object(root, path, current, next);
+        }
+        else if (is_1.Is.Value(next)) {
+            return Value(root, path, current, next);
+        }
+    }
+    /** Performs a deep mutable value assignment while retaining internal references. */
+    function Mutate(current, next) {
+        if (is_1.Is.TypedArray(current) || is_1.Is.Value(current) || is_1.Is.TypedArray(next) || is_1.Is.Value(next)) {
+            throw new ValueMutateInvalidRootMutationError();
+        }
+        if ((is_1.Is.Object(current) && is_1.Is.Array(next)) || (is_1.Is.Array(current) && is_1.Is.Object(next))) {
+            throw new ValueMutateTypeMismatchError();
+        }
+        Visit(current, '', current, next);
+    }
+    ValueMutate.Mutate = Mutate;
+})(ValueMutate = exports.ValueMutate || (exports.ValueMutate = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/value/pointer.d.ts

@@ -0,0 +1,24 @@
+export declare class ValuePointerRootSetError extends Error {
+    readonly value: unknown;
+    readonly path: string;
+    readonly update: unknown;
+    constructor(value: unknown, path: string, update: unknown);
+}
+export declare class ValuePointerRootDeleteError extends Error {
+    readonly value: unknown;
+    readonly path: string;
+    constructor(value: unknown, path: string);
+}
+/** Provides functionality to update values through RFC6901 string pointers */
+export declare namespace ValuePointer {
+    /** Formats the given pointer into navigable key components */
+    function Format(pointer: string): IterableIterator<string>;
+    /** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
+    function Set(value: any, pointer: string, update: unknown): void;
+    /** Deletes a value at the given pointer */
+    function Delete(value: any, pointer: string): void;
+    /** Returns true if a value exists at the given pointer */
+    function Has(value: any, pointer: string): boolean;
+    /** Gets the value at the given pointer */
+    function Get(value: any, pointer: string): any;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/value/pointer.js

@@ -0,0 +1,142 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValuePointer = exports.ValuePointerRootDeleteError = exports.ValuePointerRootSetError = void 0;
+class ValuePointerRootSetError extends Error {
+    constructor(value, path, update) {
+        super('ValuePointer: Cannot set root value');
+        this.value = value;
+        this.path = path;
+        this.update = update;
+    }
+}
+exports.ValuePointerRootSetError = ValuePointerRootSetError;
+class ValuePointerRootDeleteError extends Error {
+    constructor(value, path) {
+        super('ValuePointer: Cannot delete root value');
+        this.value = value;
+        this.path = path;
+    }
+}
+exports.ValuePointerRootDeleteError = ValuePointerRootDeleteError;
+/** Provides functionality to update values through RFC6901 string pointers */
+var ValuePointer;
+(function (ValuePointer) {
+    function Escape(component) {
+        return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~');
+    }
+    /** Formats the given pointer into navigable key components */
+    function* Format(pointer) {
+        if (pointer === '')
+            return;
+        let [start, end] = [0, 0];
+        for (let i = 0; i < pointer.length; i++) {
+            const char = pointer.charAt(i);
+            if (char === '/') {
+                if (i === 0) {
+                    start = i + 1;
+                }
+                else {
+                    end = i;
+                    yield Escape(pointer.slice(start, end));
+                    start = i + 1;
+                }
+            }
+            else {
+                end = i;
+            }
+        }
+        yield Escape(pointer.slice(start));
+    }
+    ValuePointer.Format = Format;
+    /** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
+    function Set(value, pointer, update) {
+        if (pointer === '')
+            throw new ValuePointerRootSetError(value, pointer, update);
+        let [owner, next, key] = [null, value, ''];
+        for (const component of Format(pointer)) {
+            if (next[component] === undefined)
+                next[component] = {};
+            owner = next;
+            next = next[component];
+            key = component;
+        }
+        owner[key] = update;
+    }
+    ValuePointer.Set = Set;
+    /** Deletes a value at the given pointer */
+    function Delete(value, pointer) {
+        if (pointer === '')
+            throw new ValuePointerRootDeleteError(value, pointer);
+        let [owner, next, key] = [null, value, ''];
+        for (const component of Format(pointer)) {
+            if (next[component] === undefined || next[component] === null)
+                return;
+            owner = next;
+            next = next[component];
+            key = component;
+        }
+        if (globalThis.Array.isArray(owner)) {
+            const index = parseInt(key);
+            owner.splice(index, 1);
+        }
+        else {
+            delete owner[key];
+        }
+    }
+    ValuePointer.Delete = Delete;
+    /** Returns true if a value exists at the given pointer */
+    function Has(value, pointer) {
+        if (pointer === '')
+            return true;
+        let [owner, next, key] = [null, value, ''];
+        for (const component of Format(pointer)) {
+            if (next[component] === undefined)
+                return false;
+            owner = next;
+            next = next[component];
+            key = component;
+        }
+        return globalThis.Object.getOwnPropertyNames(owner).includes(key);
+    }
+    ValuePointer.Has = Has;
+    /** Gets the value at the given pointer */
+    function Get(value, pointer) {
+        if (pointer === '')
+            return value;
+        let current = value;
+        for (const component of Format(pointer)) {
+            if (current[component] === undefined)
+                return undefined;
+            current = current[component];
+        }
+        return current;
+    }
+    ValuePointer.Get = Get;
+})(ValuePointer = exports.ValuePointer || (exports.ValuePointer = {}));

backend/node_modules/jest/node_modules/@sinclair/typebox/value/value.d.ts

@@ -0,0 +1,39 @@
+import * as Types from '../typebox';
+import { ValueErrorIterator } from '../errors/index';
+import { Mutable } from './mutate';
+import { Edit } from './delta';
+/** Provides functions to perform structural updates to JavaScript values */
+export declare namespace Value {
+    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
+    function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>;
+    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
+    function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>;
+    /** Creates a value from the given type */
+    function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>;
+    /** Creates a value from the given type */
+    function Create<T extends Types.TSchema>(schema: T): Types.Static<T>;
+    /** Returns true if the value matches the given type. */
+    function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>;
+    /** Returns true if the value matches the given type. */
+    function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;
+    /** Converts any type mismatched values to their target type if a conversion is possible. */
+    function Convert<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): unknown;
+    /** Converts any type mismatched values to their target type if a conversion is possible. */
+    function Convert<T extends Types.TSchema>(schema: T, value: unknown): unknown;
+    /** Returns a structural clone of the given value */
+    function Clone<T>(value: T): T;
+    /** Returns an iterator for each error in this value. */
+    function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): ValueErrorIterator;
+    /** Returns an iterator for each error in this value. */
+    function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrorIterator;
+    /** Returns true if left and right values are structurally equal */
+    function Equal<T>(left: T, right: unknown): right is T;
+    /** Returns edits to transform the current value into the next value */
+    function Diff(current: unknown, next: unknown): Edit[];
+    /** Returns a FNV1A-64 non cryptographic hash of the given value */
+    function Hash(value: unknown): bigint;
+    /** Returns a new value with edits applied to the given value */
+    function Patch<T = any>(current: unknown, edits: Edit[]): T;
+    /** Performs a deep mutable value assignment while retaining internal references. */
+    function Mutate(current: Mutable, next: Mutable): void;
+}

backend/node_modules/jest/node_modules/@sinclair/typebox/value/value.js

@@ -0,0 +1,99 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Value = void 0;
+const index_1 = require("../errors/index");
+const mutate_1 = require("./mutate");
+const hash_1 = require("./hash");
+const equal_1 = require("./equal");
+const cast_1 = require("./cast");
+const clone_1 = require("./clone");
+const convert_1 = require("./convert");
+const create_1 = require("./create");
+const check_1 = require("./check");
+const delta_1 = require("./delta");
+/** Provides functions to perform structural updates to JavaScript values */
+var Value;
+(function (Value) {
+    function Cast(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return cast_1.ValueCast.Cast(schema, references, value);
+    }
+    Value.Cast = Cast;
+    function Create(...args) {
+        const [schema, references] = args.length === 2 ? [args[0], args[1]] : [args[0], []];
+        return create_1.ValueCreate.Create(schema, references);
+    }
+    Value.Create = Create;
+    function Check(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return check_1.ValueCheck.Check(schema, references, value);
+    }
+    Value.Check = Check;
+    function Convert(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return convert_1.ValueConvert.Convert(schema, references, value);
+    }
+    Value.Convert = Convert;
+    /** Returns a structural clone of the given value */
+    function Clone(value) {
+        return clone_1.ValueClone.Clone(value);
+    }
+    Value.Clone = Clone;
+    function Errors(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return index_1.ValueErrors.Errors(schema, references, value);
+    }
+    Value.Errors = Errors;
+    /** Returns true if left and right values are structurally equal */
+    function Equal(left, right) {
+        return equal_1.ValueEqual.Equal(left, right);
+    }
+    Value.Equal = Equal;
+    /** Returns edits to transform the current value into the next value */
+    function Diff(current, next) {
+        return delta_1.ValueDelta.Diff(current, next);
+    }
+    Value.Diff = Diff;
+    /** Returns a FNV1A-64 non cryptographic hash of the given value */
+    function Hash(value) {
+        return hash_1.ValueHash.Create(value);
+    }
+    Value.Hash = Hash;
+    /** Returns a new value with edits applied to the given value */
+    function Patch(current, edits) {
+        return delta_1.ValueDelta.Patch(current, edits);
+    }
+    Value.Patch = Patch;
+    /** Performs a deep mutable value assignment while retaining internal references. */
+    function Mutate(current, next) {
+        mutate_1.ValueMutate.Mutate(current, next);
+    }
+    Value.Mutate = Mutate;
+})(Value = exports.Value || (exports.Value = {}));

backend/node_modules/jest/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "jest",
+  "description": "Delightful JavaScript Testing.",
+  "version": "29.7.0",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./package.json": "./package.json",
+    "./bin/jest": "./bin/jest.js"
+  },
+  "dependencies": {
+    "@jest/core": "^29.7.0",
+    "@jest/types": "^29.6.3",
+    "import-local": "^3.0.2",
+    "jest-cli": "^29.7.0"
+  },
+  "devDependencies": {
+    "@tsd/typescript": "^5.0.4",
+    "tsd-lite": "^0.7.0"
+  },
+  "peerDependencies": {
+    "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "node-notifier": {
+      "optional": true
+    }
+  },
+  "bin": "./bin/jest.js",
+  "engines": {
+    "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jestjs/jest.git",
+    "directory": "packages/jest"
+  },
+  "homepage": "https://jestjs.io/",
+  "license": "MIT",
+  "keywords": [
+    "ava",
+    "babel",
+    "coverage",
+    "easy",
+    "expect",
+    "facebook",
+    "immersive",
+    "instant",
+    "jasmine",
+    "jest",
+    "jsdom",
+    "mocha",
+    "mocking",
+    "painless",
+    "qunit",
+    "runner",
+    "sandboxed",
+    "snapshot",
+    "tap",
+    "tape",
+    "test",
+    "testing",
+    "typescript",
+    "watch"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630"
+}