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

node_modules/regex/src/subclass.js

@@ -0,0 +1,147 @@
+import {Context, replaceUnescaped} from 'regex-utilities';
+
+// This marker was chosen because it's impossible to match (so its extemely unlikely to be used in
+// a user-provided regex); it's not at risk of being optimized away, transformed, or flagged as an
+// error by a plugin; and it ends with an unquantifiable token
+const emulationGroupMarker = '$E$';
+// Note: Emulation groups with transfer are also supported. They look like `($N$E$…)` where `N` is
+// an integer 1 or greater. They're not used directly by Regex+ but can be used by plugins and
+// libraries that use Regex+ internals. Emulation groups with transfer are not only excluded from
+// match results, but additionally transfer their match to the group specified by `N`
+
+/**
+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.
+*/
+class RegExpSubclass extends RegExp {
+  // Avoid `#private` to allow for subclassing
+  /**
+  @private
+  @type {Array<{
+    exclude: boolean;
+    transfer?: number;
+  }> | undefined}
+  */
+  _captureMap;
+  /**
+  @private
+  @type {Record<number, string> | undefined}
+  */
+  _namesByIndex;
+  /**
+  @param {string | RegExpSubclass} expression
+  @param {string} [flags]
+  @param {{useEmulationGroups: boolean;}} [options]
+  */
+  constructor(expression, flags, options) {
+    if (expression instanceof RegExp && options) {
+      throw new Error('Cannot provide options when copying a regexp');
+    }
+    const useEmulationGroups = !!options?.useEmulationGroups;
+    const unmarked = useEmulationGroups ? unmarkEmulationGroups(expression) : null;
+    super(unmarked?.expression || expression, flags);
+    // The third argument `options` isn't provided when regexes are copied as part of the internal
+    // handling of string methods `matchAll` and `split`
+    const src = useEmulationGroups ? unmarked : (expression instanceof RegExpSubclass ? expression : null);
+    if (src) {
+      this._captureMap = src._captureMap;
+      this._namesByIndex = src._namesByIndex;
+    }
+  }
+  /**
+  Called internally by all String/RegExp methods that use regexes.
+  @override
+  @param {string} str
+  @returns {RegExpExecArray | null}
+  */
+  exec(str) {
+    const match = RegExp.prototype.exec.call(this, str);
+    if (!match || !this._captureMap) {
+      return match;
+    }
+    const matchCopy = [...match];
+    // Empty all but the first value of the array while preserving its other properties
+    match.length = 1;
+    let indicesCopy;
+    if (this.hasIndices) {
+      indicesCopy = [...match.indices];
+      match.indices.length = 1;
+    }
+    for (let i = 1; i < matchCopy.length; i++) {
+      if (this._captureMap[i].exclude) {
+        const transfer = this._captureMap[i].transfer;
+        if (transfer && match.length > transfer) {
+          match[transfer] = matchCopy[i];
+          const transferName = this._namesByIndex[transfer];
+          if (transferName) {
+            match.groups[transferName] = matchCopy[i];
+            if (this.hasIndices) {
+              match.indices.groups[transferName] = indicesCopy[i];
+            }
+          }
+          if (this.hasIndices) {
+            match.indices[transfer] = indicesCopy[i];
+          }
+        }
+      } else {
+        match.push(matchCopy[i]);
+        if (this.hasIndices) {
+          match.indices.push(indicesCopy[i]);
+        }
+      }
+    }
+    return match;
+  }
+}
+
+/**
+Build the capturing group map (with emulation groups marked to indicate their submatches shouldn't
+appear in results), and remove the markers for captures that were added to emulate extended syntax.
+@param {string} expression
+@returns {{
+  _captureMap: Array<{
+    exclude: boolean;
+    transfer?: number;
+  }>;
+  _namesByIndex: Record<number, string>;
+  expression: string;
+}}
+*/
+function unmarkEmulationGroups(expression) {
+  const marker = emulationGroupMarker.replace(/\$/g, '\\$');
+  const _captureMap = [{exclude: false}];
+  const _namesByIndex = {0: ''};
+  let realCaptureNum = 0;
+  expression = replaceUnescaped(
+    expression,
+    String.raw`\((?:(?!\?)|\?<(?![=!])(?<name>[^>]+)>)(?<mark>(?:\$(?<transfer>[1-9]\d*))?${marker})?`,
+    ({0: m, groups: {name, mark, transfer}}) => {
+      if (mark) {
+        _captureMap.push({
+          exclude: true,
+          transfer: transfer && +transfer,
+        });
+        return m.slice(0, -mark.length);
+      }
+      realCaptureNum++;
+      if (name) {
+        _namesByIndex[realCaptureNum] = name;
+      }
+      _captureMap.push({
+        exclude: false,
+      });
+      return m;
+    },
+    Context.DEFAULT
+  );
+  return {
+    _captureMap,
+    _namesByIndex,
+    expression,
+  };
+}
+
+export {
+  emulationGroupMarker,
+  RegExpSubclass,
+};