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/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Steven Levithan
+
+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.

node_modules/oniguruma-to-es/dist/cjs/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/cjs/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/cjs/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/cjs/package.json

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

node_modules/oniguruma-to-es/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/traverse.d.ts

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

node_modules/oniguruma-to-es/dist/cjs/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/cjs/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/cjs/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;

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;

node_modules/oniguruma-to-es/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "oniguruma-to-es",
+  "version": "2.3.0",
+  "description": "Convert Oniguruma patterns to native JavaScript RegExp",
+  "author": "Steven Levithan",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+  },
+  "browser": "./dist/index.min.js",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/slevithan/oniguruma-to-es.git"
+  },
+  "keywords": [
+    "regex",
+    "regexp",
+    "oniguruma",
+    "textmate-grammar",
+    "transpiler"
+  ],
+  "dependencies": {
+    "emoji-regex-xs": "^1.0.0",
+    "regex": "^5.1.1",
+    "regex-recursion": "^5.1.1"
+  },
+  "devDependencies": {
+    "esbuild": "^0.24.2",
+    "jasmine": "^5.5.0",
+    "typescript": "^5.7.3",
+    "vscode-oniguruma": "^2.0.1"
+  },
+  "scripts": {
+    "bundle:global": "esbuild src/index.js --global-name=OnigurumaToES --bundle --minify --sourcemap --outfile=dist/index.min.js",
+    "bundle:esm": "esbuild src/index.js --format=esm --bundle --sourcemap --external:emoji-regex-xs --external:regex --external:regex-recursion --outfile=dist/esm/index.js",
+    "bundle:cjs": "esbuild src/index.js --format=cjs --bundle --sourcemap --outfile=dist/cjs/index.js",
+    "types": "tsc src/index.js --rootDir src --declaration --allowJs --emitDeclarationOnly --outDir types",
+    "prebuild": "rm -rf dist/* types/*",
+    "build": "pnpm run bundle:global && pnpm run bundle:esm && pnpm run bundle:cjs && pnpm run types",
+    "postbuild": "node scripts/postbuild.js",
+    "pretest": "pnpm run build",
+    "test": "jasmine",
+    "onig:compare": "node scripts/onig-compare.js",
+    "onig:match": "node scripts/onig-match.js"
+  }
+}