Refactor routing in App component to enhance navigation and improve error handling by integrating dynamic routes and updating the NotFound route.

node_modules/zod/dist/esm/v3/ZodError.js

@@ -0,0 +1,132 @@
+import { util } from "./helpers/util.js";
+export const ZodIssueCode = util.arrayToEnum([
+    "invalid_type",
+    "invalid_literal",
+    "custom",
+    "invalid_union",
+    "invalid_union_discriminator",
+    "invalid_enum_value",
+    "unrecognized_keys",
+    "invalid_arguments",
+    "invalid_return_type",
+    "invalid_date",
+    "invalid_string",
+    "too_small",
+    "too_big",
+    "invalid_intersection_types",
+    "not_multiple_of",
+    "not_finite",
+]);
+export const quotelessJson = (obj) => {
+    const json = JSON.stringify(obj, null, 2);
+    return json.replace(/"([^"]+)":/g, "$1:");
+};
+export class ZodError extends Error {
+    get errors() {
+        return this.issues;
+    }
+    constructor(issues) {
+        super();
+        this.issues = [];
+        this.addIssue = (sub) => {
+            this.issues = [...this.issues, sub];
+        };
+        this.addIssues = (subs = []) => {
+            this.issues = [...this.issues, ...subs];
+        };
+        const actualProto = new.target.prototype;
+        if (Object.setPrototypeOf) {
+            // eslint-disable-next-line ban/ban
+            Object.setPrototypeOf(this, actualProto);
+        }
+        else {
+            this.__proto__ = actualProto;
+        }
+        this.name = "ZodError";
+        this.issues = issues;
+    }
+    format(_mapper) {
+        const mapper = _mapper ||
+            function (issue) {
+                return issue.message;
+            };
+        const fieldErrors = { _errors: [] };
+        const processError = (error) => {
+            for (const issue of error.issues) {
+                if (issue.code === "invalid_union") {
+                    issue.unionErrors.map(processError);
+                }
+                else if (issue.code === "invalid_return_type") {
+                    processError(issue.returnTypeError);
+                }
+                else if (issue.code === "invalid_arguments") {
+                    processError(issue.argumentsError);
+                }
+                else if (issue.path.length === 0) {
+                    fieldErrors._errors.push(mapper(issue));
+                }
+                else {
+                    let curr = fieldErrors;
+                    let i = 0;
+                    while (i < issue.path.length) {
+                        const el = issue.path[i];
+                        const terminal = i === issue.path.length - 1;
+                        if (!terminal) {
+                            curr[el] = curr[el] || { _errors: [] };
+                            // if (typeof el === "string") {
+                            //   curr[el] = curr[el] || { _errors: [] };
+                            // } else if (typeof el === "number") {
+                            //   const errorArray: any = [];
+                            //   errorArray._errors = [];
+                            //   curr[el] = curr[el] || errorArray;
+                            // }
+                        }
+                        else {
+                            curr[el] = curr[el] || { _errors: [] };
+                            curr[el]._errors.push(mapper(issue));
+                        }
+                        curr = curr[el];
+                        i++;
+                    }
+                }
+            }
+        };
+        processError(this);
+        return fieldErrors;
+    }
+    static assert(value) {
+        if (!(value instanceof ZodError)) {
+            throw new Error(`Not a ZodError: ${value}`);
+        }
+    }
+    toString() {
+        return this.message;
+    }
+    get message() {
+        return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
+    }
+    get isEmpty() {
+        return this.issues.length === 0;
+    }
+    flatten(mapper = (issue) => issue.message) {
+        const fieldErrors = {};
+        const formErrors = [];
+        for (const sub of this.issues) {
+            if (sub.path.length > 0) {
+                fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+                fieldErrors[sub.path[0]].push(mapper(sub));
+            }
+            else {
+                formErrors.push(mapper(sub));
+            }
+        }
+        return { formErrors, fieldErrors };
+    }
+    get formErrors() {
+        return this.flatten();
+    }
+}
+ZodError.create = (issues) => {
+    const error = new ZodError(issues);
+    return error;
+};

node_modules/zod/dist/esm/v3/benchmarks/datetime.js

@@ -0,0 +1,49 @@
+import Benchmark from "benchmark";
+const datetimeValidationSuite = new Benchmark.Suite("datetime");
+const DATA = "2021-01-01";
+const MONTHS_31 = new Set([1, 3, 5, 7, 8, 10, 12]);
+const MONTHS_30 = new Set([4, 6, 9, 11]);
+const simpleDatetimeRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
+const datetimeRegexNoLeapYearValidation = /^\d{4}-((0[13578]|10|12)-31|(0[13-9]|1[0-2])-30|(0[1-9]|1[0-2])-(0[1-9]|1\d|2\d))$/;
+const datetimeRegexWithLeapYearValidation = /^((\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\d|3[01])|(0[469]|11)-(0[1-9]|[12]\d|30)|(02)-(0[1-9]|1\d|2[0-8])))$/;
+datetimeValidationSuite
+    .add("new Date()", () => {
+    return !Number.isNaN(new Date(DATA).getTime());
+})
+    .add("regex (no validation)", () => {
+    return simpleDatetimeRegex.test(DATA);
+})
+    .add("regex (no leap year)", () => {
+    return datetimeRegexNoLeapYearValidation.test(DATA);
+})
+    .add("regex (w/ leap year)", () => {
+    return datetimeRegexWithLeapYearValidation.test(DATA);
+})
+    .add("capture groups + code", () => {
+    const match = DATA.match(simpleDatetimeRegex);
+    if (!match)
+        return false;
+    // Extract year, month, and day from the capture groups
+    const year = Number.parseInt(match[1], 10);
+    const month = Number.parseInt(match[2], 10); // month is 0-indexed in JavaScript Date, so subtract 1
+    const day = Number.parseInt(match[3], 10);
+    if (month === 2) {
+        if ((year % 4 === 0 && year % 100 !== 0) || year % 400 === 0) {
+            return day <= 29;
+        }
+        return day <= 28;
+    }
+    if (MONTHS_30.has(month)) {
+        return day <= 30;
+    }
+    if (MONTHS_31.has(month)) {
+        return day <= 31;
+    }
+    return false;
+})
+    .on("cycle", (e) => {
+    console.log(`${datetimeValidationSuite.name}: ${e.target}`);
+});
+export default {
+    suites: [datetimeValidationSuite],
+};

node_modules/zod/dist/esm/v3/benchmarks/discriminatedUnion.js

@@ -0,0 +1,74 @@
+import Benchmark from "benchmark";
+import { z } from "zod/v3";
+const doubleSuite = new Benchmark.Suite("z.discriminatedUnion: double");
+const manySuite = new Benchmark.Suite("z.discriminatedUnion: many");
+const aSchema = z.object({
+    type: z.literal("a"),
+});
+const objA = {
+    type: "a",
+};
+const bSchema = z.object({
+    type: z.literal("b"),
+});
+const objB = {
+    type: "b",
+};
+const cSchema = z.object({
+    type: z.literal("c"),
+});
+const objC = {
+    type: "c",
+};
+const dSchema = z.object({
+    type: z.literal("d"),
+});
+const double = z.discriminatedUnion("type", [aSchema, bSchema]);
+const many = z.discriminatedUnion("type", [aSchema, bSchema, cSchema, dSchema]);
+doubleSuite
+    .add("valid: a", () => {
+    double.parse(objA);
+})
+    .add("valid: b", () => {
+    double.parse(objB);
+})
+    .add("invalid: null", () => {
+    try {
+        double.parse(null);
+    }
+    catch (_err) { }
+})
+    .add("invalid: wrong shape", () => {
+    try {
+        double.parse(objC);
+    }
+    catch (_err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${doubleSuite.name}: ${e.target}`);
+});
+manySuite
+    .add("valid: a", () => {
+    many.parse(objA);
+})
+    .add("valid: c", () => {
+    many.parse(objC);
+})
+    .add("invalid: null", () => {
+    try {
+        many.parse(null);
+    }
+    catch (_err) { }
+})
+    .add("invalid: wrong shape", () => {
+    try {
+        many.parse({ type: "unknown" });
+    }
+    catch (_err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${manySuite.name}: ${e.target}`);
+});
+export default {
+    suites: [doubleSuite, manySuite],
+};

node_modules/zod/dist/esm/v3/benchmarks/index.js

@@ -0,0 +1,54 @@
+import datetimeBenchmarks from "./datetime.js";
+import discriminatedUnionBenchmarks from "./discriminatedUnion.js";
+import ipv4Benchmarks from "./ipv4.js";
+import objectBenchmarks from "./object.js";
+import primitiveBenchmarks from "./primitives.js";
+import realworld from "./realworld.js";
+import stringBenchmarks from "./string.js";
+import unionBenchmarks from "./union.js";
+const argv = process.argv.slice(2);
+let suites = [];
+if (!argv.length) {
+    suites = [
+        ...realworld.suites,
+        ...primitiveBenchmarks.suites,
+        ...stringBenchmarks.suites,
+        ...objectBenchmarks.suites,
+        ...unionBenchmarks.suites,
+        ...discriminatedUnionBenchmarks.suites,
+    ];
+}
+else {
+    if (argv.includes("--realworld")) {
+        suites.push(...realworld.suites);
+    }
+    if (argv.includes("--primitives")) {
+        suites.push(...primitiveBenchmarks.suites);
+    }
+    if (argv.includes("--string")) {
+        suites.push(...stringBenchmarks.suites);
+    }
+    if (argv.includes("--object")) {
+        suites.push(...objectBenchmarks.suites);
+    }
+    if (argv.includes("--union")) {
+        suites.push(...unionBenchmarks.suites);
+    }
+    if (argv.includes("--discriminatedUnion")) {
+        suites.push(...datetimeBenchmarks.suites);
+    }
+    if (argv.includes("--datetime")) {
+        suites.push(...datetimeBenchmarks.suites);
+    }
+    if (argv.includes("--ipv4")) {
+        suites.push(...ipv4Benchmarks.suites);
+    }
+}
+for (const suite of suites) {
+    suite.run({});
+}
+// exit on Ctrl-C
+process.on("SIGINT", function () {
+    console.log("Exiting...");
+    process.exit();
+});

node_modules/zod/dist/esm/v3/benchmarks/ipv4.js

@@ -0,0 +1,49 @@
+import Benchmark from "benchmark";
+const suite = new Benchmark.Suite("ipv4");
+const DATA = "127.0.0.1";
+const ipv4RegexA = /^(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))$/;
+const ipv4RegexB = /^(?:(?:(?=(25[0-5]))\1|(?=(2[0-4][0-9]))\2|(?=(1[0-9]{2}))\3|(?=([0-9]{1,2}))\4)\.){3}(?:(?=(25[0-5]))\5|(?=(2[0-4][0-9]))\6|(?=(1[0-9]{2}))\7|(?=([0-9]{1,2}))\8)$/;
+const ipv4RegexC = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
+const ipv4RegexD = /^(\b25[0-5]|\b2[0-4][0-9]|\b[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/;
+const ipv4RegexE = /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)\.){3}(25[0-5]|(2[0-4]|1\d|[1-9]|)\d)$/;
+const ipv4RegexF = /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)\.?\b){4}$/;
+const ipv4RegexG = /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)(\.(?!$)|$)){4}$/;
+const ipv4RegexH = /^((25[0-5]|(2[0-4]|1[0-9]|[1-9]|)[0-9])(\.(?!$)|$)){4}$/;
+const ipv4RegexI = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
+suite
+    .add("A", () => {
+    return ipv4RegexA.test(DATA);
+})
+    .add("B", () => {
+    return ipv4RegexB.test(DATA);
+})
+    .add("C", () => {
+    return ipv4RegexC.test(DATA);
+})
+    .add("D", () => {
+    return ipv4RegexD.test(DATA);
+})
+    .add("E", () => {
+    return ipv4RegexE.test(DATA);
+})
+    .add("F", () => {
+    return ipv4RegexF.test(DATA);
+})
+    .add("G", () => {
+    return ipv4RegexG.test(DATA);
+})
+    .add("H", () => {
+    return ipv4RegexH.test(DATA);
+})
+    .add("I", () => {
+    return ipv4RegexI.test(DATA);
+})
+    .on("cycle", (e) => {
+    console.log(`${suite.name}: ${e.target}`);
+});
+export default {
+    suites: [suite],
+};
+if (require.main === module) {
+    suite.run();
+}

node_modules/zod/dist/esm/v3/benchmarks/object.js

@@ -0,0 +1,65 @@
+import Benchmark from "benchmark";
+import { z } from "zod/v3";
+const emptySuite = new Benchmark.Suite("z.object: empty");
+const shortSuite = new Benchmark.Suite("z.object: short");
+const longSuite = new Benchmark.Suite("z.object: long");
+const empty = z.object({});
+const short = z.object({
+    string: z.string(),
+});
+const long = z.object({
+    string: z.string(),
+    number: z.number(),
+    boolean: z.boolean(),
+});
+emptySuite
+    .add("valid", () => {
+    empty.parse({});
+})
+    .add("valid: extra keys", () => {
+    empty.parse({ string: "string" });
+})
+    .add("invalid: null", () => {
+    try {
+        empty.parse(null);
+    }
+    catch (_err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${emptySuite.name}: ${e.target}`);
+});
+shortSuite
+    .add("valid", () => {
+    short.parse({ string: "string" });
+})
+    .add("valid: extra keys", () => {
+    short.parse({ string: "string", number: 42 });
+})
+    .add("invalid: null", () => {
+    try {
+        short.parse(null);
+    }
+    catch (_err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${shortSuite.name}: ${e.target}`);
+});
+longSuite
+    .add("valid", () => {
+    long.parse({ string: "string", number: 42, boolean: true });
+})
+    .add("valid: extra keys", () => {
+    long.parse({ string: "string", number: 42, boolean: true, list: [] });
+})
+    .add("invalid: null", () => {
+    try {
+        long.parse(null);
+    }
+    catch (_err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${longSuite.name}: ${e.target}`);
+});
+export default {
+    suites: [emptySuite, shortSuite, longSuite],
+};

node_modules/zod/dist/esm/v3/benchmarks/primitives.js

@@ -0,0 +1,154 @@
+import Benchmark from "benchmark";
+import { z } from "zod/v3";
+import { Mocker } from "../tests/Mocker.js";
+const val = new Mocker();
+const enumSuite = new Benchmark.Suite("z.enum");
+const enumSchema = z.enum(["a", "b", "c"]);
+enumSuite
+    .add("valid", () => {
+    enumSchema.parse("a");
+})
+    .add("invalid", () => {
+    try {
+        enumSchema.parse("x");
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.enum: ${e.target}`);
+});
+const longEnumSuite = new Benchmark.Suite("long z.enum");
+const longEnumSchema = z.enum([
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "ten",
+    "eleven",
+    "twelve",
+    "thirteen",
+    "fourteen",
+    "fifteen",
+    "sixteen",
+    "seventeen",
+]);
+longEnumSuite
+    .add("valid", () => {
+    longEnumSchema.parse("five");
+})
+    .add("invalid", () => {
+    try {
+        longEnumSchema.parse("invalid");
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`long z.enum: ${e.target}`);
+});
+const undefinedSuite = new Benchmark.Suite("z.undefined");
+const undefinedSchema = z.undefined();
+undefinedSuite
+    .add("valid", () => {
+    undefinedSchema.parse(undefined);
+})
+    .add("invalid", () => {
+    try {
+        undefinedSchema.parse(1);
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.undefined: ${e.target}`);
+});
+const literalSuite = new Benchmark.Suite("z.literal");
+const short = "short";
+const bad = "bad";
+const literalSchema = z.literal("short");
+literalSuite
+    .add("valid", () => {
+    literalSchema.parse(short);
+})
+    .add("invalid", () => {
+    try {
+        literalSchema.parse(bad);
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.literal: ${e.target}`);
+});
+const numberSuite = new Benchmark.Suite("z.number");
+const numberSchema = z.number().int();
+numberSuite
+    .add("valid", () => {
+    numberSchema.parse(1);
+})
+    .add("invalid type", () => {
+    try {
+        numberSchema.parse("bad");
+    }
+    catch (_e) { }
+})
+    .add("invalid number", () => {
+    try {
+        numberSchema.parse(0.5);
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.number: ${e.target}`);
+});
+const dateSuite = new Benchmark.Suite("z.date");
+const plainDate = z.date();
+const minMaxDate = z.date().min(new Date("2021-01-01")).max(new Date("2030-01-01"));
+dateSuite
+    .add("valid", () => {
+    plainDate.parse(new Date());
+})
+    .add("invalid", () => {
+    try {
+        plainDate.parse(1);
+    }
+    catch (_e) { }
+})
+    .add("valid min and max", () => {
+    minMaxDate.parse(new Date("2023-01-01"));
+})
+    .add("invalid min", () => {
+    try {
+        minMaxDate.parse(new Date("2019-01-01"));
+    }
+    catch (_e) { }
+})
+    .add("invalid max", () => {
+    try {
+        minMaxDate.parse(new Date("2031-01-01"));
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.date: ${e.target}`);
+});
+const symbolSuite = new Benchmark.Suite("z.symbol");
+const symbolSchema = z.symbol();
+symbolSuite
+    .add("valid", () => {
+    symbolSchema.parse(val.symbol);
+})
+    .add("invalid", () => {
+    try {
+        symbolSchema.parse(1);
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.symbol: ${e.target}`);
+});
+export default {
+    suites: [enumSuite, longEnumSuite, undefinedSuite, literalSuite, numberSuite, dateSuite, symbolSuite],
+};

node_modules/zod/dist/esm/v3/benchmarks/realworld.js

@@ -0,0 +1,51 @@
+import Benchmark from "benchmark";
+import { z } from "zod/v3";
+const shortSuite = new Benchmark.Suite("realworld");
+const People = z.array(z.object({
+    type: z.literal("person"),
+    hair: z.enum(["blue", "brown"]),
+    active: z.boolean(),
+    name: z.string(),
+    age: z.number().int(),
+    hobbies: z.array(z.string()),
+    address: z.object({
+        street: z.string(),
+        zip: z.string(),
+        country: z.string(),
+    }),
+}));
+let i = 0;
+function num() {
+    return ++i;
+}
+function str() {
+    return (++i % 100).toString(16);
+}
+function array(fn) {
+    return Array.from({ length: ++i % 10 }, () => fn());
+}
+const people = Array.from({ length: 100 }, () => {
+    return {
+        type: "person",
+        hair: i % 2 ? "blue" : "brown",
+        active: !!(i % 2),
+        name: str(),
+        age: num(),
+        hobbies: array(str),
+        address: {
+            street: str(),
+            zip: str(),
+            country: str(),
+        },
+    };
+});
+shortSuite
+    .add("valid", () => {
+    People.parse(people);
+})
+    .on("cycle", (e) => {
+    console.log(`${shortSuite.name}: ${e.target}`);
+});
+export default {
+    suites: [shortSuite],
+};

node_modules/zod/dist/esm/v3/benchmarks/string.js

@@ -0,0 +1,50 @@
+import Benchmark from "benchmark";
+import { z } from "zod/v3";
+const SUITE_NAME = "z.string";
+const suite = new Benchmark.Suite(SUITE_NAME);
+const empty = "";
+const short = "short";
+const long = "long".repeat(256);
+const manual = (str) => {
+    if (typeof str !== "string") {
+        throw new Error("Not a string");
+    }
+    return str;
+};
+const stringSchema = z.string();
+const optionalStringSchema = z.string().optional();
+const optionalNullableStringSchema = z.string().optional().nullable();
+suite
+    .add("empty string", () => {
+    stringSchema.parse(empty);
+})
+    .add("short string", () => {
+    stringSchema.parse(short);
+})
+    .add("long string", () => {
+    stringSchema.parse(long);
+})
+    .add("optional string", () => {
+    optionalStringSchema.parse(long);
+})
+    .add("nullable string", () => {
+    optionalNullableStringSchema.parse(long);
+})
+    .add("nullable (null) string", () => {
+    optionalNullableStringSchema.parse(null);
+})
+    .add("invalid: null", () => {
+    try {
+        stringSchema.parse(null);
+    }
+    catch (_err) { }
+})
+    .add("manual parser: long", () => {
+    manual(long);
+})
+    .on("cycle", (e) => {
+    console.log(`${SUITE_NAME}: ${e.target}`);
+});
+export default {
+    suites: [suite],
+};

node_modules/zod/dist/esm/v3/benchmarks/union.js

@@ -0,0 +1,74 @@
+import Benchmark from "benchmark";
+import { z } from "zod/v3";
+const doubleSuite = new Benchmark.Suite("z.union: double");
+const manySuite = new Benchmark.Suite("z.union: many");
+const aSchema = z.object({
+    type: z.literal("a"),
+});
+const objA = {
+    type: "a",
+};
+const bSchema = z.object({
+    type: z.literal("b"),
+});
+const objB = {
+    type: "b",
+};
+const cSchema = z.object({
+    type: z.literal("c"),
+});
+const objC = {
+    type: "c",
+};
+const dSchema = z.object({
+    type: z.literal("d"),
+});
+const double = z.union([aSchema, bSchema]);
+const many = z.union([aSchema, bSchema, cSchema, dSchema]);
+doubleSuite
+    .add("valid: a", () => {
+    double.parse(objA);
+})
+    .add("valid: b", () => {
+    double.parse(objB);
+})
+    .add("invalid: null", () => {
+    try {
+        double.parse(null);
+    }
+    catch (_err) { }
+})
+    .add("invalid: wrong shape", () => {
+    try {
+        double.parse(objC);
+    }
+    catch (_err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${doubleSuite.name}: ${e.target}`);
+});
+manySuite
+    .add("valid: a", () => {
+    many.parse(objA);
+})
+    .add("valid: c", () => {
+    many.parse(objC);
+})
+    .add("invalid: null", () => {
+    try {
+        many.parse(null);
+    }
+    catch (_err) { }
+})
+    .add("invalid: wrong shape", () => {
+    try {
+        many.parse({ type: "unknown" });
+    }
+    catch (_err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${manySuite.name}: ${e.target}`);
+});
+export default {
+    suites: [doubleSuite, manySuite],
+};

node_modules/zod/dist/esm/v3/errors.js

@@ -0,0 +1,9 @@
+import defaultErrorMap from "./locales/en.js";
+let overrideErrorMap = defaultErrorMap;
+export { defaultErrorMap };
+export function setErrorMap(map) {
+    overrideErrorMap = map;
+}
+export function getErrorMap() {
+    return overrideErrorMap;
+}

node_modules/zod/dist/esm/v3/external.js

@@ -0,0 +1,6 @@
+export * from "./errors.js";
+export * from "./helpers/parseUtil.js";
+export * from "./helpers/typeAliases.js";
+export * from "./helpers/util.js";
+export * from "./types.js";
+export * from "./ZodError.js";

node_modules/zod/dist/esm/v3/helpers/enumUtil.js

@@ -0,0 +1 @@
+export {};

node_modules/zod/dist/esm/v3/helpers/errorUtil.js

@@ -0,0 +1,6 @@
+export var errorUtil;
+(function (errorUtil) {
+    errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+    // biome-ignore lint:
+    errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
+})(errorUtil || (errorUtil = {}));

node_modules/zod/dist/esm/v3/helpers/parseUtil.js

@@ -0,0 +1,109 @@
+import { getErrorMap } from "../errors.js";
+import defaultErrorMap from "../locales/en.js";
+export const makeIssue = (params) => {
+    const { data, path, errorMaps, issueData } = params;
+    const fullPath = [...path, ...(issueData.path || [])];
+    const fullIssue = {
+        ...issueData,
+        path: fullPath,
+    };
+    if (issueData.message !== undefined) {
+        return {
+            ...issueData,
+            path: fullPath,
+            message: issueData.message,
+        };
+    }
+    let errorMessage = "";
+    const maps = errorMaps
+        .filter((m) => !!m)
+        .slice()
+        .reverse();
+    for (const map of maps) {
+        errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
+    }
+    return {
+        ...issueData,
+        path: fullPath,
+        message: errorMessage,
+    };
+};
+export const EMPTY_PATH = [];
+export function addIssueToContext(ctx, issueData) {
+    const overrideMap = getErrorMap();
+    const issue = makeIssue({
+        issueData: issueData,
+        data: ctx.data,
+        path: ctx.path,
+        errorMaps: [
+            ctx.common.contextualErrorMap, // contextual error map is first priority
+            ctx.schemaErrorMap, // then schema-bound map if available
+            overrideMap, // then global override map
+            overrideMap === defaultErrorMap ? undefined : defaultErrorMap, // then global default map
+        ].filter((x) => !!x),
+    });
+    ctx.common.issues.push(issue);
+}
+export class ParseStatus {
+    constructor() {
+        this.value = "valid";
+    }
+    dirty() {
+        if (this.value === "valid")
+            this.value = "dirty";
+    }
+    abort() {
+        if (this.value !== "aborted")
+            this.value = "aborted";
+    }
+    static mergeArray(status, results) {
+        const arrayValue = [];
+        for (const s of results) {
+            if (s.status === "aborted")
+                return INVALID;
+            if (s.status === "dirty")
+                status.dirty();
+            arrayValue.push(s.value);
+        }
+        return { status: status.value, value: arrayValue };
+    }
+    static async mergeObjectAsync(status, pairs) {
+        const syncPairs = [];
+        for (const pair of pairs) {
+            const key = await pair.key;
+            const value = await pair.value;
+            syncPairs.push({
+                key,
+                value,
+            });
+        }
+        return ParseStatus.mergeObjectSync(status, syncPairs);
+    }
+    static mergeObjectSync(status, pairs) {
+        const finalObject = {};
+        for (const pair of pairs) {
+            const { key, value } = pair;
+            if (key.status === "aborted")
+                return INVALID;
+            if (value.status === "aborted")
+                return INVALID;
+            if (key.status === "dirty")
+                status.dirty();
+            if (value.status === "dirty")
+                status.dirty();
+            if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
+                finalObject[key.value] = value.value;
+            }
+        }
+        return { status: status.value, value: finalObject };
+    }
+}
+export const INVALID = Object.freeze({
+    status: "aborted",
+});
+export const DIRTY = (value) => ({ status: "dirty", value });
+export const OK = (value) => ({ status: "valid", value });
+export const isAborted = (x) => x.status === "aborted";
+export const isDirty = (x) => x.status === "dirty";
+export const isValid = (x) => x.status === "valid";
+export const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;

node_modules/zod/dist/esm/v3/helpers/partialUtil.js

@@ -0,0 +1 @@
+export {};

node_modules/zod/dist/esm/v3/helpers/typeAliases.js

@@ -0,0 +1 @@
+export {};

node_modules/zod/dist/esm/v3/helpers/util.js

@@ -0,0 +1,133 @@
+export var util;
+(function (util) {
+    util.assertEqual = (_) => { };
+    function assertIs(_arg) { }
+    util.assertIs = assertIs;
+    function assertNever(_x) {
+        throw new Error();
+    }
+    util.assertNever = assertNever;
+    util.arrayToEnum = (items) => {
+        const obj = {};
+        for (const item of items) {
+            obj[item] = item;
+        }
+        return obj;
+    };
+    util.getValidEnumValues = (obj) => {
+        const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+        const filtered = {};
+        for (const k of validKeys) {
+            filtered[k] = obj[k];
+        }
+        return util.objectValues(filtered);
+    };
+    util.objectValues = (obj) => {
+        return util.objectKeys(obj).map(function (e) {
+            return obj[e];
+        });
+    };
+    util.objectKeys = typeof Object.keys === "function" // eslint-disable-line ban/ban
+        ? (obj) => Object.keys(obj) // eslint-disable-line ban/ban
+        : (object) => {
+            const keys = [];
+            for (const key in object) {
+                if (Object.prototype.hasOwnProperty.call(object, key)) {
+                    keys.push(key);
+                }
+            }
+            return keys;
+        };
+    util.find = (arr, checker) => {
+        for (const item of arr) {
+            if (checker(item))
+                return item;
+        }
+        return undefined;
+    };
+    util.isInteger = typeof Number.isInteger === "function"
+        ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
+        : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
+    function joinValues(array, separator = " | ") {
+        return array.map((val) => (typeof val === "string" ? `'${val}'` : val)).join(separator);
+    }
+    util.joinValues = joinValues;
+    util.jsonStringifyReplacer = (_, value) => {
+        if (typeof value === "bigint") {
+            return value.toString();
+        }
+        return value;
+    };
+})(util || (util = {}));
+export var objectUtil;
+(function (objectUtil) {
+    objectUtil.mergeShapes = (first, second) => {
+        return {
+            ...first,
+            ...second, // second overwrites first
+        };
+    };
+})(objectUtil || (objectUtil = {}));
+export const ZodParsedType = util.arrayToEnum([
+    "string",
+    "nan",
+    "number",
+    "integer",
+    "float",
+    "boolean",
+    "date",
+    "bigint",
+    "symbol",
+    "function",
+    "undefined",
+    "null",
+    "array",
+    "object",
+    "unknown",
+    "promise",
+    "void",
+    "never",
+    "map",
+    "set",
+]);
+export const getParsedType = (data) => {
+    const t = typeof data;
+    switch (t) {
+        case "undefined":
+            return ZodParsedType.undefined;
+        case "string":
+            return ZodParsedType.string;
+        case "number":
+            return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
+        case "boolean":
+            return ZodParsedType.boolean;
+        case "function":
+            return ZodParsedType.function;
+        case "bigint":
+            return ZodParsedType.bigint;
+        case "symbol":
+            return ZodParsedType.symbol;
+        case "object":
+            if (Array.isArray(data)) {
+                return ZodParsedType.array;
+            }
+            if (data === null) {
+                return ZodParsedType.null;
+            }
+            if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+                return ZodParsedType.promise;
+            }
+            if (typeof Map !== "undefined" && data instanceof Map) {
+                return ZodParsedType.map;
+            }
+            if (typeof Set !== "undefined" && data instanceof Set) {
+                return ZodParsedType.set;
+            }
+            if (typeof Date !== "undefined" && data instanceof Date) {
+                return ZodParsedType.date;
+            }
+            return ZodParsedType.object;
+        default:
+            return ZodParsedType.unknown;
+    }
+};

node_modules/zod/dist/esm/v3/index.js

@@ -0,0 +1,4 @@
+import * as z from "./external.js";
+export * from "./external.js";
+export { z };
+export default z;

node_modules/zod/dist/esm/v3/locales/en.js

@@ -0,0 +1,107 @@
+import { ZodIssueCode } from "../ZodError.js";
+import { util, ZodParsedType } from "../helpers/util.js";
+const errorMap = (issue, _ctx) => {
+    let message;
+    switch (issue.code) {
+        case ZodIssueCode.invalid_type:
+            if (issue.received === ZodParsedType.undefined) {
+                message = "Required";
+            }
+            else {
+                message = `Expected ${issue.expected}, received ${issue.received}`;
+            }
+            break;
+        case ZodIssueCode.invalid_literal:
+            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
+            break;
+        case ZodIssueCode.unrecognized_keys:
+            message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
+            break;
+        case ZodIssueCode.invalid_union:
+            message = `Invalid input`;
+            break;
+        case ZodIssueCode.invalid_union_discriminator:
+            message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
+            break;
+        case ZodIssueCode.invalid_enum_value:
+            message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
+            break;
+        case ZodIssueCode.invalid_arguments:
+            message = `Invalid function arguments`;
+            break;
+        case ZodIssueCode.invalid_return_type:
+            message = `Invalid function return type`;
+            break;
+        case ZodIssueCode.invalid_date:
+            message = `Invalid date`;
+            break;
+        case ZodIssueCode.invalid_string:
+            if (typeof issue.validation === "object") {
+                if ("includes" in issue.validation) {
+                    message = `Invalid input: must include "${issue.validation.includes}"`;
+                    if (typeof issue.validation.position === "number") {
+                        message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
+                    }
+                }
+                else if ("startsWith" in issue.validation) {
+                    message = `Invalid input: must start with "${issue.validation.startsWith}"`;
+                }
+                else if ("endsWith" in issue.validation) {
+                    message = `Invalid input: must end with "${issue.validation.endsWith}"`;
+                }
+                else {
+                    util.assertNever(issue.validation);
+                }
+            }
+            else if (issue.validation !== "regex") {
+                message = `Invalid ${issue.validation}`;
+            }
+            else {
+                message = "Invalid";
+            }
+            break;
+        case ZodIssueCode.too_small:
+            if (issue.type === "array")
+                message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
+            else if (issue.type === "string")
+                message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
+            else if (issue.type === "number")
+                message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
+            else if (issue.type === "date")
+                message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
+            else
+                message = "Invalid input";
+            break;
+        case ZodIssueCode.too_big:
+            if (issue.type === "array")
+                message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
+            else if (issue.type === "string")
+                message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
+            else if (issue.type === "number")
+                message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
+            else if (issue.type === "bigint")
+                message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
+            else if (issue.type === "date")
+                message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
+            else
+                message = "Invalid input";
+            break;
+        case ZodIssueCode.custom:
+            message = `Invalid input`;
+            break;
+        case ZodIssueCode.invalid_intersection_types:
+            message = `Intersection results could not be merged`;
+            break;
+        case ZodIssueCode.not_multiple_of:
+            message = `Number must be a multiple of ${issue.multipleOf}`;
+            break;
+        case ZodIssueCode.not_finite:
+            message = "Number must be finite";
+            break;
+        default:
+            message = _ctx.defaultError;
+            util.assertNever(issue);
+    }
+    return { message };
+};
+export default errorMap;

node_modules/zod/dist/esm/v3/standard-schema.js

@@ -0,0 +1 @@
+export {};

node_modules/zod/dist/esm/v3/tests/Mocker.js

@@ -0,0 +1,53 @@
+function getRandomInt(max) {
+    return Math.floor(Math.random() * Math.floor(max));
+}
+const testSymbol = Symbol("test");
+export class Mocker {
+    constructor() {
+        this.pick = (...args) => {
+            return args[getRandomInt(args.length)];
+        };
+    }
+    get string() {
+        return Math.random().toString(36).substring(7);
+    }
+    get number() {
+        return Math.random() * 100;
+    }
+    get bigint() {
+        return BigInt(Math.floor(Math.random() * 10000));
+    }
+    get boolean() {
+        return Math.random() < 0.5;
+    }
+    get date() {
+        return new Date(Math.floor(Date.now() * Math.random()));
+    }
+    get symbol() {
+        return testSymbol;
+    }
+    get null() {
+        return null;
+    }
+    get undefined() {
+        return undefined;
+    }
+    get stringOptional() {
+        return this.pick(this.string, this.undefined);
+    }
+    get stringNullable() {
+        return this.pick(this.string, this.null);
+    }
+    get numberOptional() {
+        return this.pick(this.number, this.undefined);
+    }
+    get numberNullable() {
+        return this.pick(this.number, this.null);
+    }
+    get booleanOptional() {
+        return this.pick(this.boolean, this.undefined);
+    }
+    get booleanNullable() {
+        return this.pick(this.boolean, this.null);
+    }
+}