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

node_modules/oniguruma-to-es/dist/esm/generate.d.ts

@@ -0,0 +1,15 @@
+/**
+Generates a Regex+ compatible `pattern`, `flags`, and `options` from a Regex+ AST.
+@param {import('./transform.js').RegexAst} ast
+@param {import('.').OnigurumaToEsOptions} [options]
+@returns {{
+  pattern: string;
+  flags: string;
+  options: Object;
+}}
+*/
+export function generate(ast: import("./transform.js").RegexAst, options?: import(".").OnigurumaToEsOptions): {
+    pattern: string;
+    flags: string;
+    options: any;
+};

node_modules/oniguruma-to-es/dist/esm/index.d.ts

@@ -0,0 +1,75 @@
+export type OnigurumaToEsOptions = {
+    accuracy?: "default" | "strict";
+    avoidSubclass?: boolean;
+    flags?: string;
+    global?: boolean;
+    hasIndices?: boolean;
+    rules?: {
+        allowOrphanBackrefs?: boolean;
+        asciiWordBoundaries?: boolean;
+        captureGroup?: boolean;
+        recursionLimit?: number;
+        singleline?: boolean;
+    };
+    target?: "auto" | "ES2025" | "ES2024" | "ES2018";
+    verbose?: boolean;
+};
+import { EmulatedRegExp } from './subclass.js';
+/**
+@typedef {{
+  accuracy?: keyof Accuracy;
+  avoidSubclass?: boolean;
+  flags?: string;
+  global?: boolean;
+  hasIndices?: boolean;
+  rules?: {
+    allowOrphanBackrefs?: boolean;
+    asciiWordBoundaries?: boolean;
+    captureGroup?: boolean;
+    recursionLimit?: number;
+    singleline?: boolean;
+  };
+  target?: keyof Target;
+  verbose?: boolean;
+}} OnigurumaToEsOptions
+*/
+/**
+Accepts an Oniguruma pattern and returns the details needed to construct an equivalent JavaScript `RegExp`.
+@param {string} pattern Oniguruma regex pattern.
+@param {OnigurumaToEsOptions} [options]
+@returns {{
+  pattern: string;
+  flags: string;
+  options?: import('./subclass.js').EmulatedRegExpOptions;
+}}
+*/
+export function toDetails(pattern: string, options?: OnigurumaToEsOptions): {
+    pattern: string;
+    flags: string;
+    options?: import("./subclass.js").EmulatedRegExpOptions;
+};
+/**
+Returns an Oniguruma AST generated from an Oniguruma pattern.
+@param {string} pattern Oniguruma regex pattern.
+@param {{
+  flags?: string;
+  rules?: {
+    captureGroup?: boolean;
+  };
+}} [options]
+@returns {import('./parse.js').OnigurumaAst}
+*/
+export function toOnigurumaAst(pattern: string, options?: {
+    flags?: string;
+    rules?: {
+        captureGroup?: boolean;
+    };
+}): import("./parse.js").OnigurumaAst;
+/**
+Accepts an Oniguruma pattern and returns an equivalent JavaScript `RegExp`.
+@param {string} pattern Oniguruma regex pattern.
+@param {OnigurumaToEsOptions} [options]
+@returns {RegExp | EmulatedRegExp}
+*/
+export function toRegExp(pattern: string, options?: OnigurumaToEsOptions): RegExp | EmulatedRegExp;
+export { EmulatedRegExp };

node_modules/oniguruma-to-es/dist/esm/options.d.ts

@@ -0,0 +1,25 @@
+export namespace Accuracy {
+    let _default: "default";
+    export { _default as default };
+    export let strict: "strict";
+}
+export namespace EsVersion {
+    let ES2025: number;
+    let ES2024: number;
+    let ES2018: number;
+}
+/**
+Returns a complete set of options, with default values set for options that weren't provided.
+@param {import('.').OnigurumaToEsOptions} [options]
+@returns {Required<import('.').OnigurumaToEsOptions>}
+*/
+export function getOptions(options?: import(".").OnigurumaToEsOptions): Required<import(".").OnigurumaToEsOptions>;
+export namespace Target {
+    export let auto: "auto";
+    let ES2025_1: "ES2025";
+    export { ES2025_1 as ES2025 };
+    let ES2024_1: "ES2024";
+    export { ES2024_1 as ES2024 };
+    let ES2018_1: "ES2018";
+    export { ES2018_1 as ES2018 };
+}

node_modules/oniguruma-to-es/dist/esm/package.json

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

node_modules/oniguruma-to-es/dist/esm/parse.d.ts

@@ -0,0 +1,198 @@
+export type OnigurumaAst = {
+    type: "Regex";
+    parent: null;
+    pattern: any;
+    flags: any;
+};
+export namespace AstAbsentFunctionKinds {
+    let repeater: string;
+}
+export namespace AstAssertionKinds {
+    let line_end: string;
+    let line_start: string;
+    let lookahead: string;
+    let lookbehind: string;
+    let search_start: string;
+    let string_end: string;
+    let string_end_newline: string;
+    let string_start: string;
+    let word_boundary: string;
+}
+export const AstCharacterSetKinds: {
+    any: string;
+    digit: string;
+    dot: string;
+    hex: string;
+    non_newline: string;
+    posix: string;
+    property: string;
+    space: string;
+    word: string;
+};
+export const AstDirectiveKinds: {
+    flags: string;
+    keep: string;
+};
+export namespace AstTypes {
+    let AbsentFunction: string;
+    let Alternative: string;
+    let Assertion: string;
+    let Backreference: string;
+    let CapturingGroup: string;
+    let Character: string;
+    let CharacterClass: string;
+    let CharacterClassIntersection: string;
+    let CharacterClassRange: string;
+    let CharacterSet: string;
+    let Directive: string;
+    let Flags: string;
+    let Group: string;
+    let Pattern: string;
+    let Quantifier: string;
+    let Regex: string;
+    let Subroutine: string;
+    let VariableLengthCharacterSet: string;
+    let Recursion: string;
+}
+export namespace AstVariableLengthCharacterSetKinds {
+    let grapheme: string;
+    let newline: string;
+}
+export function createAbsentFunction(kind: any): {
+    type: string;
+    kind: any;
+    alternatives: {
+        type: string;
+        elements: any[];
+    }[];
+};
+export function createAlternative(): {
+    type: string;
+    elements: any[];
+};
+export function createAssertion(kind: any, options: any): {
+    negate: boolean;
+    type: string;
+    kind: any;
+};
+export function createBackreference(ref: any, options: any): {
+    ref: any;
+    orphan: true;
+    type: string;
+};
+export function createCapturingGroup(number: any, name: any): {
+    alternatives: {
+        type: string;
+        elements: any[];
+    }[];
+    name: any;
+    type: string;
+    number: any;
+};
+export function createCharacter(charCode: any, options: any): {
+    type: string;
+    value: any;
+};
+export function createCharacterClass(options: any): any;
+export function createCharacterClassIntersection(): any;
+export function createCharacterClassRange(min: any, max: any): {
+    type: string;
+    min: any;
+    max: any;
+};
+export function createCharacterSet(kind: any, { negate }: {
+    negate: any;
+}): {
+    type: string;
+    kind: any;
+};
+export function createFlags({ ignoreCase, dotAll, extended, digitIsAscii, spaceIsAscii, wordIsAscii }: {
+    ignoreCase: any;
+    dotAll: any;
+    extended: any;
+    digitIsAscii: any;
+    spaceIsAscii: any;
+    wordIsAscii: any;
+}): {
+    type: string;
+    ignoreCase: any;
+    dotAll: any;
+    extended: any;
+    digitIsAscii: any;
+    spaceIsAscii: any;
+    wordIsAscii: any;
+};
+export function createGroup(options: any): {
+    alternatives: {
+        type: string;
+        elements: any[];
+    }[];
+    flags: any;
+    atomic: any;
+    type: string;
+};
+export function createLookaround(options: any): {
+    type: string;
+    kind: string;
+    negate: any;
+    alternatives: {
+        type: string;
+        elements: any[];
+    }[];
+};
+export function createPattern(): {
+    type: string;
+    alternatives: {
+        type: string;
+        elements: any[];
+    }[];
+};
+export function createQuantifier(element: any, min: any, max: any, greedy?: boolean, possessive?: boolean): {
+    type: string;
+    min: any;
+    max: any;
+    greedy: boolean;
+    possessive: boolean;
+    element: any;
+};
+export function createRegex(pattern: any, flags: any): {
+    type: string;
+    pattern: any;
+    flags: any;
+};
+export function createSubroutine(ref: any): {
+    type: string;
+    ref: any;
+};
+export function createUnicodeProperty(value: any, options: any): {
+    type: string;
+    kind: string;
+    value: any;
+    negate: any;
+};
+export function createVariableLengthCharacterSet(kind: any): {
+    type: string;
+    kind: any;
+};
+/**
+@typedef {{
+  type: 'Regex';
+  parent: null;
+  pattern: Object;
+  flags: Object;
+}} OnigurumaAst
+*/
+/**
+@param {import('./tokenize.js').TokenizerResult} tokenizerResult
+@param {{
+  skipBackrefValidation?: boolean;
+  skipPropertyNameValidation?: boolean;
+  verbose?: boolean;
+}} [options]
+@returns {OnigurumaAst}
+*/
+export function parse({ tokens, flags, rules }: import("./tokenize.js").TokenizerResult, options?: {
+    skipBackrefValidation?: boolean;
+    skipPropertyNameValidation?: boolean;
+    verbose?: boolean;
+}): OnigurumaAst;

node_modules/oniguruma-to-es/dist/esm/subclass.d.ts

@@ -0,0 +1,44 @@
+export type EmulatedRegExpOptions = {
+    strategy?: string | null;
+    useEmulationGroups?: boolean;
+};
+/**
+@typedef {{
+  strategy?: string | null;
+  useEmulationGroups?: boolean;
+}} EmulatedRegExpOptions
+*/
+/**
+Works the same as JavaScript's native `RegExp` constructor in all contexts, but can be given
+results from `toDetails` to produce the same result as `toRegExp`.
+@augments RegExp
+*/
+export class EmulatedRegExp extends RegExp {
+    /**
+     @overload
+     @param {string} pattern
+     @param {string} [flags]
+     @param {EmulatedRegExpOptions} [options]
+     */
+    constructor(pattern: string, flags?: string, options?: EmulatedRegExpOptions);
+    /**
+     @overload
+     @param {EmulatedRegExp} pattern
+     @param {string} [flags]
+     */
+    constructor(pattern: EmulatedRegExp, flags?: string);
+    /**
+    Can be used to serialize the arguments used to create the instance.
+    @type {{
+      pattern: string;
+      flags: string;
+      options: EmulatedRegExpOptions;
+    }}
+    */
+    rawArgs: {
+        pattern: string;
+        flags: string;
+        options: EmulatedRegExpOptions;
+    };
+    #private;
+}

node_modules/oniguruma-to-es/dist/esm/tokenize.d.ts

@@ -0,0 +1,90 @@
+export type Token = {
+    type: "Alternator" | "Assertion" | "Backreference" | "Character" | "CharacterClassClose" | "CharacterClassHyphen" | "CharacterClassIntersector" | "CharacterClassOpen" | "CharacterSet" | "Directive" | "GroupClose" | "GroupOpen" | "Subroutine" | "Quantifier" | "VariableLengthCharacterSet" | "EscapedNumber";
+    raw: string;
+    [key: string]: string | number | boolean;
+};
+export type TokenizerResult = {
+    tokens: Array<Token>;
+    flags: {
+        dotAll: boolean;
+        extended: boolean;
+        ignoreCase: boolean;
+    };
+    rules: {
+        captureGroup: boolean;
+        singleline: boolean;
+    };
+};
+/**
+@typedef {{
+  type: keyof TokenTypes;
+  raw: string;
+  [key: string]: string | number | boolean;
+}} Token
+@typedef {{
+  tokens: Array<Token>;
+  flags: {
+    dotAll: boolean;
+    extended: boolean;
+    ignoreCase: boolean;
+  };
+  rules: {
+    captureGroup: boolean;
+    singleline: boolean;
+  };
+}} TokenizerResult
+*/
+/**
+@param {string} pattern Oniguruma pattern.
+@param {string} [flags] Oniguruma flags.
+@param {{
+  captureGroup?: boolean;
+  singleline?: boolean;
+}} [rules] Oniguruma compile-time options.
+@returns {TokenizerResult}
+*/
+export function tokenize(pattern: string, flags?: string, rules?: {
+    captureGroup?: boolean;
+    singleline?: boolean;
+}): TokenizerResult;
+export namespace TokenCharacterSetKinds {
+    let any: string;
+    let digit: string;
+    let dot: string;
+    let hex: string;
+    let non_newline: string;
+    let posix: string;
+    let property: string;
+    let space: string;
+    let word: string;
+}
+export namespace TokenDirectiveKinds {
+    let flags: string;
+    let keep: string;
+}
+export namespace TokenGroupKinds {
+    let absent_repeater: string;
+    let atomic: string;
+    let capturing: string;
+    let group: string;
+    let lookahead: string;
+    let lookbehind: string;
+}
+export namespace TokenTypes {
+    let Alternator: "Alternator";
+    let Assertion: "Assertion";
+    let Backreference: "Backreference";
+    let Character: "Character";
+    let CharacterClassClose: "CharacterClassClose";
+    let CharacterClassHyphen: "CharacterClassHyphen";
+    let CharacterClassIntersector: "CharacterClassIntersector";
+    let CharacterClassOpen: "CharacterClassOpen";
+    let CharacterSet: "CharacterSet";
+    let Directive: "Directive";
+    let GroupClose: "GroupClose";
+    let GroupOpen: "GroupOpen";
+    let Subroutine: "Subroutine";
+    let Quantifier: "Quantifier";
+    let VariableLengthCharacterSet: "VariableLengthCharacterSet";
+    let EscapedNumber: "EscapedNumber";
+}

node_modules/oniguruma-to-es/dist/esm/transform.d.ts

@@ -0,0 +1,42 @@
+export type RegexAst = {
+    type: "Regex";
+    parent: null;
+    pattern: any;
+    flags: any;
+    options: any;
+    _strategy: string | null;
+};
+/**
+@typedef {{
+  type: 'Regex';
+  parent: null;
+  pattern: Object;
+  flags: Object;
+  options: Object;
+  _strategy: string | null;
+}} RegexAst
+*/
+/**
+Transforms an Oniguruma AST in-place to a [Regex+](https://github.com/slevithan/regex) AST.
+Assumes target ES2025, expecting the generator to down-convert to the desired JS target version.
+
+Regex+'s syntax and behavior is a strict superset of native JavaScript, so the AST is very close
+to representing native ES2025 `RegExp` but with some added features (atomic groups, possessive
+quantifiers, recursion). The AST doesn't use some of Regex+'s extended features like flag x or
+subroutines because they follow PCRE behavior and work somewhat differently than in Oniguruma. The
+AST represents what's needed to precisely reproduce Oniguruma behavior using Regex+.
+@param {import('./parse.js').OnigurumaAst} ast
+@param {{
+  accuracy?: keyof Accuracy;
+  asciiWordBoundaries?: boolean;
+  avoidSubclass?: boolean;
+  bestEffortTarget?: keyof Target;
+}} [options]
+@returns {RegexAst}
+*/
+export function transform(ast: import("./parse.js").OnigurumaAst, options?: {
+    accuracy?: "default" | "strict";
+    asciiWordBoundaries?: boolean;
+    avoidSubclass?: boolean;
+    bestEffortTarget?: "auto" | "ES2025" | "ES2024" | "ES2018";
+}): RegexAst;

node_modules/oniguruma-to-es/dist/esm/traverse.d.ts

@@ -0,0 +1 @@
+export function traverse(path: any, state: any, visitor: any): void;

node_modules/oniguruma-to-es/dist/esm/unicode.d.ts

@@ -0,0 +1,8 @@
+export function getIgnoreCaseMatchChars(char: any): any[];
+export const JsUnicodeProperties: any;
+export const JsUnicodePropertiesMap: any;
+export const JsUnicodePropertiesOfStringsMap: any;
+export const PosixClassesMap: any;
+export const PosixProperties: any;
+export function slug(name: any): any;
+export const UnicodePropertiesWithSpecificCase: any;

node_modules/oniguruma-to-es/dist/esm/utils-ast.d.ts

@@ -0,0 +1,14 @@
+export function hasOnlyChild({ alternatives }: {
+    alternatives: any;
+}, kidFn: any): any;
+export function isAlwaysNonZeroLength(node: any): any;
+export function isAlwaysZeroLength({ type }: {
+    type: any;
+}): boolean;
+export function isConsumptiveGroup({ type }: {
+    type: any;
+}): boolean;
+export function isLookaround({ type, kind }: {
+    type: any;
+    kind: any;
+}): boolean;

node_modules/oniguruma-to-es/dist/esm/utils.d.ts

@@ -0,0 +1,19 @@
+export const cp: any;
+export const envSupportsFlagGroups: boolean;
+export const envSupportsFlagV: boolean;
+export function getNewCurrentFlags(current: any, { enable, disable }: {
+    enable: any;
+    disable: any;
+}): {
+    dotAll: boolean;
+    ignoreCase: boolean;
+};
+export function getOrCreate(map: any, key: any, defaultValue: any): any;
+/**
+@param {keyof Target} target
+@param {keyof Target} min
+@returns {boolean}
+*/
+export function isMinTarget(target: "auto" | "ES2025" | "ES2024" | "ES2018", min: "auto" | "ES2025" | "ES2024" | "ES2018"): boolean;
+export const r: any;
+export function throwIfNot(value: any, msg: any): any;