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

node_modules/regex/dist/esm/atomic.d.ts

@@ -0,0 +1,16 @@
+/**
+Apply transformations for atomic groups: `(?>…)`.
+@param {string} expression
+@param {import('./regex.js').PluginData} [data]
+@returns {string}
+*/
+export function atomic(expression: string, data?: import("./regex.js").PluginData): string;
+/**
+Transform posessive quantifiers into atomic groups. The posessessive quantifiers are:
+`?+`, `*+`, `++`, `{N}+`, `{N,}+`, `{N,N}+`.
+This follows Java, PCRE, Perl, and Python.
+Possessive quantifiers in Oniguruma and Onigmo are only: `?+`, `*+`, `++`.
+@param {string} expression
+@returns {string}
+*/
+export function possessive(expression: string): string;

node_modules/regex/dist/esm/backcompat.d.ts

@@ -0,0 +1,7 @@
+/**
+Applies flag v rules when using flag u, for forward compatibility.
+Assumes flag u and doesn't worry about syntax errors that are caught by it.
+@param {string} expression
+@returns {string}
+*/
+export function backcompatPlugin(expression: string): string;

node_modules/regex/dist/esm/flag-n.d.ts

@@ -0,0 +1,4 @@
+export function flagNPreprocessor(value: import("./utils.js").InterpolatedValue, runningContext: import("./utils.js").RunningContext, options: Required<import("./utils.js").RegexTagOptions>): {
+    transformed: string;
+    runningContext: import("./utils.js").RunningContext;
+};

node_modules/regex/dist/esm/flag-x.d.ts

@@ -0,0 +1,10 @@
+/**
+Remove `(?:)` token separators (most likely added by flag x) in cases where it's safe to do so.
+@param {string} expression
+@returns {string}
+*/
+export function clean(expression: string): string;
+export function flagXPreprocessor(value: import("./utils.js").InterpolatedValue, runningContext: import("./utils.js").RunningContext, options: Required<import("./utils.js").RegexTagOptions>): {
+    transformed: string;
+    runningContext: import("./utils.js").RunningContext;
+};

node_modules/regex/dist/esm/internals.d.ts

@@ -0,0 +1,2 @@
+export { atomic, possessive } from "./atomic.js";
+export { emulationGroupMarker, RegExpSubclass } from "./subclass.js";

node_modules/regex/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/regex/dist/esm/pattern.d.ts

@@ -0,0 +1,43 @@
+export class Pattern {
+    /** @param {string} value */
+    constructor(value: string);
+    /** @returns {string} */
+    toString(): string;
+    #private;
+}
+/**
+Returns a value that can be interpolated into a `regex` template string without having its special
+characters escaped.
+
+Can be called as a function or template tag:
+- `pattern(value)` - String or value coerced to string.
+- `` pattern`…` `` - Same as ``pattern(String.raw`…`)``.
+
+@overload
+@param {string | number} value
+@returns {Pattern}
+
+@overload
+@param {TemplateStringsArray} template
+@param {...string} substitutions
+@returns {Pattern}
+*/
+export function pattern(value: string | number): Pattern;
+/**
+Returns a value that can be interpolated into a `regex` template string without having its special
+characters escaped.
+
+Can be called as a function or template tag:
+- `pattern(value)` - String or value coerced to string.
+- `` pattern`…` `` - Same as ``pattern(String.raw`…`)``.
+
+@overload
+@param {string | number} value
+@returns {Pattern}
+
+@overload
+@param {TemplateStringsArray} template
+@param {...string} substitutions
+@returns {Pattern}
+*/
+export function pattern(template: TemplateStringsArray, ...substitutions: string[]): Pattern;

node_modules/regex/dist/esm/regex.d.ts

@@ -0,0 +1,96 @@
+export type InterpolatedValue = string | RegExp | Pattern | number;
+export type PluginData = {
+    flags?: string;
+    useEmulationGroups?: boolean;
+};
+export type RawTemplate = TemplateStringsArray | {
+    raw: Array<string>;
+};
+export type RegexTagOptions = {
+    flags?: string;
+    subclass?: boolean;
+    plugins?: Array<(expression: string, data: PluginData) => string>;
+    unicodeSetsPlugin?: ((expression: string, data: PluginData) => string) | null;
+    disable?: {
+        x?: boolean;
+        n?: boolean;
+        v?: boolean;
+        atomic?: boolean;
+        subroutines?: boolean;
+    };
+    force?: {
+        v?: boolean;
+    };
+};
+export type RegexTag<T> = {
+    (template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>): T;
+    (flags?: string): RegexTag<T>;
+    (options: RegexTagOptions & {
+        subclass?: false;
+    }): RegexTag<T>;
+    (options: RegexTagOptions & {
+        subclass: true;
+    }): RegexTag<RegExpSubclass>;
+};
+export type RegexFromTemplate<T> = {
+    (options: RegexTagOptions, template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>): T;
+};
+import { pattern } from './pattern.js';
+/**
+@typedef {string | RegExp | Pattern | number} InterpolatedValue
+@typedef {{
+  flags?: string;
+  useEmulationGroups?: boolean;
+}} PluginData
+@typedef {TemplateStringsArray | {raw: Array<string>}} RawTemplate
+@typedef {{
+  flags?: string;
+  subclass?: boolean;
+  plugins?: Array<(expression: string, data: PluginData) => string>;
+  unicodeSetsPlugin?: ((expression: string, data: PluginData) => string) | null;
+  disable?: {
+    x?: boolean;
+    n?: boolean;
+    v?: boolean;
+    atomic?: boolean;
+    subroutines?: boolean;
+  };
+  force?: {
+    v?: boolean;
+  };
+}} RegexTagOptions
+*/
+/**
+@template T
+@typedef RegexTag
+@type {{
+  (template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>): T;
+  (flags?: string): RegexTag<T>;
+  (options: RegexTagOptions & {subclass?: false}): RegexTag<T>;
+  (options: RegexTagOptions & {subclass: true}): RegexTag<RegExpSubclass>;
+}}
+*/
+/**
+Template tag for constructing a regex with extended syntax and context-aware interpolation of
+regexes, strings, and patterns.
+
+Can be called in several ways:
+1. `` regex`…` `` - Regex pattern as a raw string.
+2. `` regex('gi')`…` `` - To specify flags.
+3. `` regex({flags: 'gi'})`…` `` - With options.
+@type {RegexTag<RegExp>}
+*/
+export const regex: RegexTag<RegExp>;
+/**
+Returns the processed expression and flags as strings.
+@param {string} expression
+@param {RegexTagOptions} [options]
+@returns {{expression: string; flags: string;}}
+*/
+export function rewrite(expression?: string, options?: RegexTagOptions): {
+    expression: string;
+    flags: string;
+};
+import { Pattern } from './pattern.js';
+import { RegExpSubclass } from './subclass.js';
+export { pattern };

node_modules/regex/dist/esm/subclass.d.ts

@@ -0,0 +1,28 @@
+export const emulationGroupMarker: "$E$";
+/**
+Works the same as JavaScript's native `RegExp` constructor in all contexts, but automatically
+adjusts matches and subpattern indices (with flag `d`) to account for injected emulation groups.
+*/
+export class RegExpSubclass extends RegExp {
+    /**
+    @param {string | RegExpSubclass} expression
+    @param {string} [flags]
+    @param {{useEmulationGroups: boolean;}} [options]
+    */
+    constructor(expression: string | RegExpSubclass, flags?: string, options?: {
+        useEmulationGroups: boolean;
+    });
+    /**
+    @private
+    @type {Array<{
+      exclude: boolean;
+      transfer?: number;
+    }> | undefined}
+    */
+    private _captureMap;
+    /**
+    @private
+    @type {Record<number, string> | undefined}
+    */
+    private _namesByIndex;
+}

node_modules/regex/dist/esm/subroutines.d.ts

@@ -0,0 +1,12 @@
+export type NamedCapturingGroupsMap = Map<string, {
+    isUnique: boolean;
+    contents?: string;
+    groupNum?: number;
+    numCaptures?: number;
+}>;
+/**
+@param {string} expression
+@param {import('./regex.js').PluginData} [data]
+@returns {string}
+*/
+export function subroutines(expression: string, data?: import("./regex.js").PluginData): string;

node_modules/regex/dist/esm/utils-internals.d.ts

@@ -0,0 +1,9 @@
+export const noncapturingDelim: any;
+/**
+@param {string} str
+@param {number} pos
+@param {string} oldValue
+@param {string} newValue
+@returns {string}
+*/
+export function spliceStr(str: string, pos: number, oldValue: string, newValue: string): string;

node_modules/regex/dist/esm/utils.d.ts

@@ -0,0 +1,112 @@
+export type RunningContext = {
+    regexContext: string;
+    charClassContext: string;
+    charClassDepth: number;
+    lastPos: number;
+};
+export type InterpolatedValue = import("./regex.js").InterpolatedValue;
+export type RawTemplate = import("./regex.js").RawTemplate;
+export type RegexTagOptions = import("./regex.js").RegexTagOptions;
+export type Preprocessor = (value: InterpolatedValue, runningContext: RunningContext, options: Required<RegexTagOptions>) => {
+    transformed: string;
+    runningContext: RunningContext;
+};
+/**
+@param {string} expression
+@param {number} precedingCaptures
+@returns {string}
+*/
+export function adjustNumberedBackrefs(expression: string, precedingCaptures: number): string;
+export const capturingDelim: any;
+export namespace CharClassContext {
+    let DEFAULT: string;
+    let ENCLOSED_P: string;
+    let ENCLOSED_Q: string;
+    let ENCLOSED_U: string;
+    let INVALID_INCOMPLETE_TOKEN: string;
+    let RANGE: string;
+}
+export function containsCharClassUnion(charClassPattern: any): boolean;
+/**
+@param {string} expression
+@returns {number}
+*/
+export function countCaptures(expression: string): number;
+export const doublePunctuatorChars: "&!#$%*+,.:;<=>?@^`~";
+export const enclosedTokenCharClassContexts: any;
+export const enclosedTokenRegexContexts: any;
+export const envSupportsFlagGroups: boolean;
+export const envSupportsFlagV: boolean;
+/**
+Escape special characters for the given context, assuming flag v.
+@param {string} str String to escape
+@param {'DEFAULT' | 'CHAR_CLASS'} context `Context` option from lib `regex-utilities`
+@returns {string} Escaped string
+*/
+export function escapeV(str: string, context: "DEFAULT" | "CHAR_CLASS"): string;
+export function getBreakoutChar(expression: any, regexContext: any, charClassContext: any): any;
+/**
+@typedef {{
+  regexContext: string;
+  charClassContext: string;
+  charClassDepth: number;
+  lastPos: number;
+}} RunningContext
+*/
+/**
+Accepts and returns its full state so it doesn't have to reprocess parts that have already been
+seen. Assumes flag v and doesn't worry about syntax errors that are caught by it.
+@param {string} incompleteExpression
+@param {Partial<RunningContext>} [runningContext]
+@returns {RunningContext}
+*/
+export function getEndContextForIncompleteExpression(incompleteExpression: string, runningContext?: Partial<RunningContext>): RunningContext;
+export const namedCapturingDelim: any;
+/**
+@typedef {import('./regex.js').InterpolatedValue} InterpolatedValue
+@typedef {import('./regex.js').RawTemplate} RawTemplate
+@typedef {import('./regex.js').RegexTagOptions} RegexTagOptions
+@typedef {(
+  value: InterpolatedValue,
+  runningContext: RunningContext,
+  options: Required<RegexTagOptions>
+) => {
+  transformed: string;
+  runningContext: RunningContext;
+}} Preprocessor
+*/
+/**
+Returns transformed versions of a template and substitutions, using the given preprocessor. Only
+processes substitutions that are instanceof `Pattern`.
+@param {RawTemplate} template
+@param {ReadonlyArray<InterpolatedValue>} substitutions
+@param {Preprocessor} preprocessor
+@param {Required<RegexTagOptions>} options
+@returns {{template: RawTemplate; substitutions: ReadonlyArray<InterpolatedValue>;}}
+*/
+export function preprocess(template: RawTemplate, substitutions: ReadonlyArray<InterpolatedValue>, preprocessor: Preprocessor, options: Required<RegexTagOptions>): {
+    template: RawTemplate;
+    substitutions: ReadonlyArray<InterpolatedValue>;
+};
+export namespace RegexContext {
+    let DEFAULT_1: string;
+    export { DEFAULT_1 as DEFAULT };
+    export let CHAR_CLASS: string;
+    let ENCLOSED_P_1: string;
+    export { ENCLOSED_P_1 as ENCLOSED_P };
+    let ENCLOSED_U_1: string;
+    export { ENCLOSED_U_1 as ENCLOSED_U };
+    export let GROUP_NAME: string;
+    export let INTERVAL_QUANTIFIER: string;
+    let INVALID_INCOMPLETE_TOKEN_1: string;
+    export { INVALID_INCOMPLETE_TOKEN_1 as INVALID_INCOMPLETE_TOKEN };
+}
+export function sandboxLoneCharClassCaret(str: any): any;
+export function sandboxLoneDoublePunctuatorChar(str: any): any;
+/**
+Converts `\0` tokens to `\x00` in the given context.
+@param {string} str
+@param {'DEFAULT' | 'CHAR_CLASS'} [context] `Context` option from lib `regex-utilities`
+@returns {string}
+*/
+export function sandboxUnsafeNulls(str: string, context?: "DEFAULT" | "CHAR_CLASS"): string;