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

node_modules/vfile/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"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"}

node_modules/vfile/lib/index.js

@@ -0,0 +1,643 @@
+/**
+ * @import {Node, Point, Position} from 'unist'
+ * @import {Options as MessageOptions} from 'vfile-message'
+ * @import {Compatible, Data, Map, Options, Value} from 'vfile'
+ */
+
+/**
+ * @typedef {object & {type: string, position?: Position | undefined}} NodeLike
+ */
+
+import {VFileMessage} from 'vfile-message'
+import {minpath} from '#minpath'
+import {minproc} from '#minproc'
+import {urlToPath, isUrl} from '#minurl'
+
+/**
+ * Order of setting (least specific to most), we need this because otherwise
+ * `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a
+ * stem can be set.
+ */
+const order = /** @type {const} */ ([
+  'history',
+  'path',
+  'basename',
+  'stem',
+  'extname',
+  'dirname'
+])
+
+export class VFile {
+  /**
+   * Create a new virtual file.
+   *
+   * `options` is treated as:
+   *
+   * *   `string` or `Uint8Array` — `{value: options}`
+   * *   `URL` — `{path: options}`
+   * *   `VFile` — shallow copies its data over to the new file
+   * *   `object` — all fields are shallow copied over to the new file
+   *
+   * Path related fields are set in the following order (least specific to
+   * most specific): `history`, `path`, `basename`, `stem`, `extname`,
+   * `dirname`.
+   *
+   * You cannot set `dirname` or `extname` without setting either `history`,
+   * `path`, `basename`, or `stem` too.
+   *
+   * @param {Compatible | null | undefined} [value]
+   *   File value.
+   * @returns
+   *   New instance.
+   */
+  constructor(value) {
+    /** @type {Options | VFile} */
+    let options
+
+    if (!value) {
+      options = {}
+    } else if (isUrl(value)) {
+      options = {path: value}
+    } else if (typeof value === 'string' || isUint8Array(value)) {
+      options = {value}
+    } else {
+      options = value
+    }
+
+    /* eslint-disable no-unused-expressions */
+
+    /**
+     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).
+     *
+     * @type {string}
+     */
+    // Prevent calling `cwd` (which could be expensive) if it’s not needed;
+    // the empty string will be overridden in the next block.
+    this.cwd = 'cwd' in options ? '' : minproc.cwd()
+
+    /**
+     * Place to store custom info (default: `{}`).
+     *
+     * It’s OK to store custom data directly on the file but moving it to
+     * `data` is recommended.
+     *
+     * @type {Data}
+     */
+    this.data = {}
+
+    /**
+     * List of file paths the file moved between.
+     *
+     * The first is the original path and the last is the current path.
+     *
+     * @type {Array<string>}
+     */
+    this.history = []
+
+    /**
+     * List of messages associated with the file.
+     *
+     * @type {Array<VFileMessage>}
+     */
+    this.messages = []
+
+    /**
+     * Raw value.
+     *
+     * @type {Value}
+     */
+    this.value
+
+    // The below are non-standard, they are “well-known”.
+    // As in, used in several tools.
+    /**
+     * Source map.
+     *
+     * This type is equivalent to the `RawSourceMap` type from the `source-map`
+     * module.
+     *
+     * @type {Map | null | undefined}
+     */
+    this.map
+
+    /**
+     * Custom, non-string, compiled, representation.
+     *
+     * This is used by unified to store non-string results.
+     * One example is when turning markdown into React nodes.
+     *
+     * @type {unknown}
+     */
+    this.result
+
+    /**
+     * Whether a file was saved to disk.
+     *
+     * This is used by vfile reporters.
+     *
+     * @type {boolean}
+     */
+    this.stored
+    /* eslint-enable no-unused-expressions */
+
+    // Set path related properties in the correct order.
+    let index = -1
+
+    while (++index < order.length) {
+      const field = order[index]
+
+      // Note: we specifically use `in` instead of `hasOwnProperty` to accept
+      // `vfile`s too.
+      if (
+        field in options &&
+        options[field] !== undefined &&
+        options[field] !== null
+      ) {
+        // @ts-expect-error: TS doesn’t understand basic reality.
+        this[field] = field === 'history' ? [...options[field]] : options[field]
+      }
+    }
+
+    /** @type {string} */
+    let field
+
+    // Set non-path related properties.
+    for (field in options) {
+      // @ts-expect-error: fine to set other things.
+      if (!order.includes(field)) {
+        // @ts-expect-error: fine to set other things.
+        this[field] = options[field]
+      }
+    }
+  }
+
+  /**
+   * Get the basename (including extname) (example: `'index.min.js'`).
+   *
+   * @returns {string | undefined}
+   *   Basename.
+   */
+  get basename() {
+    return typeof this.path === 'string'
+      ? minpath.basename(this.path)
+      : undefined
+  }
+
+  /**
+   * Set basename (including extname) (`'index.min.js'`).
+   *
+   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
+   * on windows).
+   * Cannot be nullified (use `file.path = file.dirname` instead).
+   *
+   * @param {string} basename
+   *   Basename.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  set basename(basename) {
+    assertNonEmpty(basename, 'basename')
+    assertPart(basename, 'basename')
+    this.path = minpath.join(this.dirname || '', basename)
+  }
+
+  /**
+   * Get the parent path (example: `'~'`).
+   *
+   * @returns {string | undefined}
+   *   Dirname.
+   */
+  get dirname() {
+    return typeof this.path === 'string'
+      ? minpath.dirname(this.path)
+      : undefined
+  }
+
+  /**
+   * Set the parent path (example: `'~'`).
+   *
+   * Cannot be set if there’s no `path` yet.
+   *
+   * @param {string | undefined} dirname
+   *   Dirname.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  set dirname(dirname) {
+    assertPath(this.basename, 'dirname')
+    this.path = minpath.join(dirname || '', this.basename)
+  }
+
+  /**
+   * Get the extname (including dot) (example: `'.js'`).
+   *
+   * @returns {string | undefined}
+   *   Extname.
+   */
+  get extname() {
+    return typeof this.path === 'string'
+      ? minpath.extname(this.path)
+      : undefined
+  }
+
+  /**
+   * Set the extname (including dot) (example: `'.js'`).
+   *
+   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
+   * on windows).
+   * Cannot be set if there’s no `path` yet.
+   *
+   * @param {string | undefined} extname
+   *   Extname.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  set extname(extname) {
+    assertPart(extname, 'extname')
+    assertPath(this.dirname, 'extname')
+
+    if (extname) {
+      if (extname.codePointAt(0) !== 46 /* `.` */) {
+        throw new Error('`extname` must start with `.`')
+      }
+
+      if (extname.includes('.', 1)) {
+        throw new Error('`extname` cannot contain multiple dots')
+      }
+    }
+
+    this.path = minpath.join(this.dirname, this.stem + (extname || ''))
+  }
+
+  /**
+   * Get the full path (example: `'~/index.min.js'`).
+   *
+   * @returns {string}
+   *   Path.
+   */
+  get path() {
+    return this.history[this.history.length - 1]
+  }
+
+  /**
+   * Set the full path (example: `'~/index.min.js'`).
+   *
+   * Cannot be nullified.
+   * You can set a file URL (a `URL` object with a `file:` protocol) which will
+   * be turned into a path with `url.fileURLToPath`.
+   *
+   * @param {URL | string} path
+   *   Path.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  set path(path) {
+    if (isUrl(path)) {
+      path = urlToPath(path)
+    }
+
+    assertNonEmpty(path, 'path')
+
+    if (this.path !== path) {
+      this.history.push(path)
+    }
+  }
+
+  /**
+   * Get the stem (basename w/o extname) (example: `'index.min'`).
+   *
+   * @returns {string | undefined}
+   *   Stem.
+   */
+  get stem() {
+    return typeof this.path === 'string'
+      ? minpath.basename(this.path, this.extname)
+      : undefined
+  }
+
+  /**
+   * Set the stem (basename w/o extname) (example: `'index.min'`).
+   *
+   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
+   * on windows).
+   * Cannot be nullified (use `file.path = file.dirname` instead).
+   *
+   * @param {string} stem
+   *   Stem.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  set stem(stem) {
+    assertNonEmpty(stem, 'stem')
+    assertPart(stem, 'stem')
+    this.path = minpath.join(this.dirname || '', stem + (this.extname || ''))
+  }
+
+  // Normal prototypal methods.
+  /**
+   * Create a fatal message for `reason` associated with the file.
+   *
+   * The `fatal` field of the message is set to `true` (error; file not usable)
+   * and the `file` field is set to the current file path.
+   * The message is added to the `messages` field on `file`.
+   *
+   * > 🪦 **Note**: also has obsolete signatures.
+   *
+   * @overload
+   * @param {string} reason
+   * @param {MessageOptions | null | undefined} [options]
+   * @returns {never}
+   *
+   * @overload
+   * @param {string} reason
+   * @param {Node | NodeLike | null | undefined} parent
+   * @param {string | null | undefined} [origin]
+   * @returns {never}
+   *
+   * @overload
+   * @param {string} reason
+   * @param {Point | Position | null | undefined} place
+   * @param {string | null | undefined} [origin]
+   * @returns {never}
+   *
+   * @overload
+   * @param {string} reason
+   * @param {string | null | undefined} [origin]
+   * @returns {never}
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {Node | NodeLike | null | undefined} parent
+   * @param {string | null | undefined} [origin]
+   * @returns {never}
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {Point | Position | null | undefined} place
+   * @param {string | null | undefined} [origin]
+   * @returns {never}
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {string | null | undefined} [origin]
+   * @returns {never}
+   *
+   * @param {Error | VFileMessage | string} causeOrReason
+   *   Reason for message, should use markdown.
+   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+   *   Configuration (optional).
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
+   * @returns {never}
+   *   Never.
+   * @throws {VFileMessage}
+   *   Message.
+   */
+  fail(causeOrReason, optionsOrParentOrPlace, origin) {
+    // @ts-expect-error: the overloads are fine.
+    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)
+
+    message.fatal = true
+
+    throw message
+  }
+
+  /**
+   * Create an info message for `reason` associated with the file.
+   *
+   * The `fatal` field of the message is set to `undefined` (info; change
+   * likely not needed) and the `file` field is set to the current file path.
+   * The message is added to the `messages` field on `file`.
+   *
+   * > 🪦 **Note**: also has obsolete signatures.
+   *
+   * @overload
+   * @param {string} reason
+   * @param {MessageOptions | null | undefined} [options]
+   * @returns {VFileMessage}
+   *
+   * @overload
+   * @param {string} reason
+   * @param {Node | NodeLike | null | undefined} parent
+   * @param {string | null | undefined} [origin]
+   * @returns {VFileMessage}
+   *
+   * @overload
+   * @param {string} reason
+   * @param {Point | Position | null | undefined} place
+   * @param {string | null | undefined} [origin]
+   * @returns {VFileMessage}
+   *
+   * @overload
+   * @param {string} reason
+   * @param {string | null | undefined} [origin]
+   * @returns {VFileMessage}
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {Node | NodeLike | null | undefined} parent
+   * @param {string | null | undefined} [origin]
+   * @returns {VFileMessage}
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {Point | Position | null | undefined} place
+   * @param {string | null | undefined} [origin]
+   * @returns {VFileMessage}
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {string | null | undefined} [origin]
+   * @returns {VFileMessage}
+   *
+   * @param {Error | VFileMessage | string} causeOrReason
+   *   Reason for message, should use markdown.
+   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+   *   Configuration (optional).
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
+   * @returns {VFileMessage}
+   *   Message.
+   */
+  info(causeOrReason, optionsOrParentOrPlace, origin) {
+    // @ts-expect-error: the overloads are fine.
+    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)
+
+    message.fatal = undefined
+
+    return message
+  }
+
+  /**
+   * Create a message for `reason` associated with the file.
+   *
+   * The `fatal` field of the message is set to `false` (warning; change may be
+   * needed) and the `file` field is set to the current file path.
+   * The message is added to the `messages` field on `file`.
+   *
+   * > 🪦 **Note**: also has obsolete signatures.
+   *
+   * @overload
+   * @param {string} reason
+   * @param {MessageOptions | null | undefined} [options]
+   * @returns {VFileMessage}
+   *
+   * @overload
+   * @param {string} reason
+   * @param {Node | NodeLike | null | undefined} parent
+   * @param {string | null | undefined} [origin]
+   * @returns {VFileMessage}
+   *
+   * @overload
+   * @param {string} reason
+   * @param {Point | Position | null | undefined} place
+   * @param {string | null | undefined} [origin]
+   * @returns {VFileMessage}
+   *
+   * @overload
+   * @param {string} reason
+   * @param {string | null | undefined} [origin]
+   * @returns {VFileMessage}
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {Node | NodeLike | null | undefined} parent
+   * @param {string | null | undefined} [origin]
+   * @returns {VFileMessage}
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {Point | Position | null | undefined} place
+   * @param {string | null | undefined} [origin]
+   * @returns {VFileMessage}
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {string | null | undefined} [origin]
+   * @returns {VFileMessage}
+   *
+   * @param {Error | VFileMessage | string} causeOrReason
+   *   Reason for message, should use markdown.
+   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+   *   Configuration (optional).
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
+   * @returns {VFileMessage}
+   *   Message.
+   */
+  message(causeOrReason, optionsOrParentOrPlace, origin) {
+    const message = new VFileMessage(
+      // @ts-expect-error: the overloads are fine.
+      causeOrReason,
+      optionsOrParentOrPlace,
+      origin
+    )
+
+    if (this.path) {
+      message.name = this.path + ':' + message.name
+      message.file = this.path
+    }
+
+    message.fatal = false
+
+    this.messages.push(message)
+
+    return message
+  }
+
+  /**
+   * Serialize the file.
+   *
+   * > **Note**: which encodings are supported depends on the engine.
+   * > For info on Node.js, see:
+   * > <https://nodejs.org/api/util.html#whatwg-supported-encodings>.
+   *
+   * @param {string | null | undefined} [encoding='utf8']
+   *   Character encoding to understand `value` as when it’s a `Uint8Array`
+   *   (default: `'utf-8'`).
+   * @returns {string}
+   *   Serialized file.
+   */
+  toString(encoding) {
+    if (this.value === undefined) {
+      return ''
+    }
+
+    if (typeof this.value === 'string') {
+      return this.value
+    }
+
+    const decoder = new TextDecoder(encoding || undefined)
+    return decoder.decode(this.value)
+  }
+}
+
+/**
+ * Assert that `part` is not a path (as in, does not contain `path.sep`).
+ *
+ * @param {string | null | undefined} part
+ *   File path part.
+ * @param {string} name
+ *   Part name.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function assertPart(part, name) {
+  if (part && part.includes(minpath.sep)) {
+    throw new Error(
+      '`' + name + '` cannot be a path: did not expect `' + minpath.sep + '`'
+    )
+  }
+}
+
+/**
+ * Assert that `part` is not empty.
+ *
+ * @param {string | undefined} part
+ *   Thing.
+ * @param {string} name
+ *   Part name.
+ * @returns {asserts part is string}
+ *   Nothing.
+ */
+function assertNonEmpty(part, name) {
+  if (!part) {
+    throw new Error('`' + name + '` cannot be empty')
+  }
+}
+
+/**
+ * Assert `path` exists.
+ *
+ * @param {string | undefined} path
+ *   Path.
+ * @param {string} name
+ *   Dependency name.
+ * @returns {asserts path is string}
+ *   Nothing.
+ */
+function assertPath(path, name) {
+  if (!path) {
+    throw new Error('Setting `' + name + '` requires `path` to be set too')
+  }
+}
+
+/**
+ * Assert `value` is an `Uint8Array`.
+ *
+ * @param {unknown} value
+ *   thing.
+ * @returns {value is Uint8Array}
+ *   Whether `value` is an `Uint8Array`.
+ */
+function isUint8Array(value) {
+  return Boolean(
+    value &&
+      typeof value === 'object' &&
+      'byteLength' in value &&
+      'byteOffset' in value
+  )
+}

node_modules/vfile/lib/minpath.browser.d.ts

@@ -0,0 +1,47 @@
+export namespace minpath {
+    export { basename };
+    export { dirname };
+    export { extname };
+    export { join };
+    export let sep: string;
+}
+/**
+ * Get the basename from a path.
+ *
+ * @param {string} path
+ *   File path.
+ * @param {string | null | undefined} [extname]
+ *   Extension to strip.
+ * @returns {string}
+ *   Stem or basename.
+ */
+declare function basename(path: string, extname?: string | null | undefined): string;
+/**
+ * Get the dirname from a path.
+ *
+ * @param {string} path
+ *   File path.
+ * @returns {string}
+ *   File path.
+ */
+declare function dirname(path: string): string;
+/**
+ * Get an extname from a path.
+ *
+ * @param {string} path
+ *   File path.
+ * @returns {string}
+ *   Extname.
+ */
+declare function extname(path: string): string;
+/**
+ * Join segments from a path.
+ *
+ * @param {Array<string>} segments
+ *   Path segments.
+ * @returns {string}
+ *   File path.
+ */
+declare function join(...segments: Array<string>): string;
+export {};
+//# sourceMappingURL=minpath.browser.d.ts.map

node_modules/vfile/lib/minpath.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minpath.browser.d.ts","sourceRoot":"","sources":["minpath.browser.js"],"names":[],"mappings":";;;;;;;AAuDA;;;;;;;;;GASG;AACH,gCAPW,MAAM,YAEN,MAAM,GAAG,IAAI,GAAG,SAAS,GAEvB,MAAM,CAuFlB;AAED;;;;;;;GAOG;AACH,+BALW,MAAM,GAEJ,MAAM,CAmClB;AAED;;;;;;;GAOG;AACH,+BALW,MAAM,GAEJ,MAAM,CAgElB;AAED;;;;;;;GAOG;AACH,mCALW,KAAK,CAAC,MAAM,CAAC,GAEX,MAAM,CAkBlB"}

node_modules/vfile/lib/minpath.browser.js

@@ -0,0 +1,426 @@
+// A derivative work based on:
+// <https://github.com/browserify/path-browserify>.
+// Which is licensed:
+//
+// MIT License
+//
+// Copyright (c) 2013 James Halliday
+//
+// 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.
+// A derivative work based on:
+//
+// Parts of that are extracted from Node’s internal `path` module:
+// <https://github.com/nodejs/node/blob/master/lib/path.js>.
+// Which is licensed:
+//
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+export const minpath = {basename, dirname, extname, join, sep: '/'}
+
+/* eslint-disable max-depth, complexity */
+
+/**
+ * Get the basename from a path.
+ *
+ * @param {string} path
+ *   File path.
+ * @param {string | null | undefined} [extname]
+ *   Extension to strip.
+ * @returns {string}
+ *   Stem or basename.
+ */
+function basename(path, extname) {
+  if (extname !== undefined && typeof extname !== 'string') {
+    throw new TypeError('"ext" argument must be a string')
+  }
+
+  assertPath(path)
+  let start = 0
+  let end = -1
+  let index = path.length
+  /** @type {boolean | undefined} */
+  let seenNonSlash
+
+  if (
+    extname === undefined ||
+    extname.length === 0 ||
+    extname.length > path.length
+  ) {
+    while (index--) {
+      if (path.codePointAt(index) === 47 /* `/` */) {
+        // If we reached a path separator that was not part of a set of path
+        // separators at the end of the string, stop now.
+        if (seenNonSlash) {
+          start = index + 1
+          break
+        }
+      } else if (end < 0) {
+        // We saw the first non-path separator, mark this as the end of our
+        // path component.
+        seenNonSlash = true
+        end = index + 1
+      }
+    }
+
+    return end < 0 ? '' : path.slice(start, end)
+  }
+
+  if (extname === path) {
+    return ''
+  }
+
+  let firstNonSlashEnd = -1
+  let extnameIndex = extname.length - 1
+
+  while (index--) {
+    if (path.codePointAt(index) === 47 /* `/` */) {
+      // If we reached a path separator that was not part of a set of path
+      // separators at the end of the string, stop now.
+      if (seenNonSlash) {
+        start = index + 1
+        break
+      }
+    } else {
+      if (firstNonSlashEnd < 0) {
+        // We saw the first non-path separator, remember this index in case
+        // we need it if the extension ends up not matching.
+        seenNonSlash = true
+        firstNonSlashEnd = index + 1
+      }
+
+      if (extnameIndex > -1) {
+        // Try to match the explicit extension.
+        if (path.codePointAt(index) === extname.codePointAt(extnameIndex--)) {
+          if (extnameIndex < 0) {
+            // We matched the extension, so mark this as the end of our path
+            // component
+            end = index
+          }
+        } else {
+          // Extension does not match, so our result is the entire path
+          // component
+          extnameIndex = -1
+          end = firstNonSlashEnd
+        }
+      }
+    }
+  }
+
+  if (start === end) {
+    end = firstNonSlashEnd
+  } else if (end < 0) {
+    end = path.length
+  }
+
+  return path.slice(start, end)
+}
+
+/**
+ * Get the dirname from a path.
+ *
+ * @param {string} path
+ *   File path.
+ * @returns {string}
+ *   File path.
+ */
+function dirname(path) {
+  assertPath(path)
+
+  if (path.length === 0) {
+    return '.'
+  }
+
+  let end = -1
+  let index = path.length
+  /** @type {boolean | undefined} */
+  let unmatchedSlash
+
+  // Prefix `--` is important to not run on `0`.
+  while (--index) {
+    if (path.codePointAt(index) === 47 /* `/` */) {
+      if (unmatchedSlash) {
+        end = index
+        break
+      }
+    } else if (!unmatchedSlash) {
+      // We saw the first non-path separator
+      unmatchedSlash = true
+    }
+  }
+
+  return end < 0
+    ? path.codePointAt(0) === 47 /* `/` */
+      ? '/'
+      : '.'
+    : end === 1 && path.codePointAt(0) === 47 /* `/` */
+      ? '//'
+      : path.slice(0, end)
+}
+
+/**
+ * Get an extname from a path.
+ *
+ * @param {string} path
+ *   File path.
+ * @returns {string}
+ *   Extname.
+ */
+function extname(path) {
+  assertPath(path)
+
+  let index = path.length
+
+  let end = -1
+  let startPart = 0
+  let startDot = -1
+  // Track the state of characters (if any) we see before our first dot and
+  // after any path separator we find.
+  let preDotState = 0
+  /** @type {boolean | undefined} */
+  let unmatchedSlash
+
+  while (index--) {
+    const code = path.codePointAt(index)
+
+    if (code === 47 /* `/` */) {
+      // If we reached a path separator that was not part of a set of path
+      // separators at the end of the string, stop now.
+      if (unmatchedSlash) {
+        startPart = index + 1
+        break
+      }
+
+      continue
+    }
+
+    if (end < 0) {
+      // We saw the first non-path separator, mark this as the end of our
+      // extension.
+      unmatchedSlash = true
+      end = index + 1
+    }
+
+    if (code === 46 /* `.` */) {
+      // If this is our first dot, mark it as the start of our extension.
+      if (startDot < 0) {
+        startDot = index
+      } else if (preDotState !== 1) {
+        preDotState = 1
+      }
+    } else if (startDot > -1) {
+      // We saw a non-dot and non-path separator before our dot, so we should
+      // have a good chance at having a non-empty extension.
+      preDotState = -1
+    }
+  }
+
+  if (
+    startDot < 0 ||
+    end < 0 ||
+    // We saw a non-dot character immediately before the dot.
+    preDotState === 0 ||
+    // The (right-most) trimmed path component is exactly `..`.
+    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+  ) {
+    return ''
+  }
+
+  return path.slice(startDot, end)
+}
+
+/**
+ * Join segments from a path.
+ *
+ * @param {Array<string>} segments
+ *   Path segments.
+ * @returns {string}
+ *   File path.
+ */
+function join(...segments) {
+  let index = -1
+  /** @type {string | undefined} */
+  let joined
+
+  while (++index < segments.length) {
+    assertPath(segments[index])
+
+    if (segments[index]) {
+      joined =
+        joined === undefined ? segments[index] : joined + '/' + segments[index]
+    }
+  }
+
+  return joined === undefined ? '.' : normalize(joined)
+}
+
+/**
+ * Normalize a basic file path.
+ *
+ * @param {string} path
+ *   File path.
+ * @returns {string}
+ *   File path.
+ */
+// Note: `normalize` is not exposed as `path.normalize`, so some code is
+// manually removed from it.
+function normalize(path) {
+  assertPath(path)
+
+  const absolute = path.codePointAt(0) === 47 /* `/` */
+
+  // Normalize the path according to POSIX rules.
+  let value = normalizeString(path, !absolute)
+
+  if (value.length === 0 && !absolute) {
+    value = '.'
+  }
+
+  if (value.length > 0 && path.codePointAt(path.length - 1) === 47 /* / */) {
+    value += '/'
+  }
+
+  return absolute ? '/' + value : value
+}
+
+/**
+ * Resolve `.` and `..` elements in a path with directory names.
+ *
+ * @param {string} path
+ *   File path.
+ * @param {boolean} allowAboveRoot
+ *   Whether `..` can move above root.
+ * @returns {string}
+ *   File path.
+ */
+function normalizeString(path, allowAboveRoot) {
+  let result = ''
+  let lastSegmentLength = 0
+  let lastSlash = -1
+  let dots = 0
+  let index = -1
+  /** @type {number | undefined} */
+  let code
+  /** @type {number} */
+  let lastSlashIndex
+
+  while (++index <= path.length) {
+    if (index < path.length) {
+      code = path.codePointAt(index)
+    } else if (code === 47 /* `/` */) {
+      break
+    } else {
+      code = 47 /* `/` */
+    }
+
+    if (code === 47 /* `/` */) {
+      if (lastSlash === index - 1 || dots === 1) {
+        // Empty.
+      } else if (lastSlash !== index - 1 && dots === 2) {
+        if (
+          result.length < 2 ||
+          lastSegmentLength !== 2 ||
+          result.codePointAt(result.length - 1) !== 46 /* `.` */ ||
+          result.codePointAt(result.length - 2) !== 46 /* `.` */
+        ) {
+          if (result.length > 2) {
+            lastSlashIndex = result.lastIndexOf('/')
+
+            if (lastSlashIndex !== result.length - 1) {
+              if (lastSlashIndex < 0) {
+                result = ''
+                lastSegmentLength = 0
+              } else {
+                result = result.slice(0, lastSlashIndex)
+                lastSegmentLength = result.length - 1 - result.lastIndexOf('/')
+              }
+
+              lastSlash = index
+              dots = 0
+              continue
+            }
+          } else if (result.length > 0) {
+            result = ''
+            lastSegmentLength = 0
+            lastSlash = index
+            dots = 0
+            continue
+          }
+        }
+
+        if (allowAboveRoot) {
+          result = result.length > 0 ? result + '/..' : '..'
+          lastSegmentLength = 2
+        }
+      } else {
+        if (result.length > 0) {
+          result += '/' + path.slice(lastSlash + 1, index)
+        } else {
+          result = path.slice(lastSlash + 1, index)
+        }
+
+        lastSegmentLength = index - lastSlash - 1
+      }
+
+      lastSlash = index
+      dots = 0
+    } else if (code === 46 /* `.` */ && dots > -1) {
+      dots++
+    } else {
+      dots = -1
+    }
+  }
+
+  return result
+}
+
+/**
+ * Make sure `path` is a string.
+ *
+ * @param {string} path
+ *   File path.
+ * @returns {asserts path is string}
+ *   Nothing.
+ */
+function assertPath(path) {
+  if (typeof path !== 'string') {
+    throw new TypeError(
+      'Path must be a string. Received ' + JSON.stringify(path)
+    )
+  }
+}
+
+/* eslint-enable max-depth, complexity */

node_modules/vfile/lib/minpath.d.ts

@@ -0,0 +1,2 @@
+export { default as minpath } from "node:path";
+//# sourceMappingURL=minpath.d.ts.map

node_modules/vfile/lib/minpath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minpath.d.ts","sourceRoot":"","sources":["minpath.js"],"names":[],"mappings":""}

node_modules/vfile/lib/minpath.js

@@ -0,0 +1 @@
+export {default as minpath} from 'node:path'

node_modules/vfile/lib/minproc.browser.d.ts

@@ -0,0 +1,6 @@
+export namespace minproc {
+    export { cwd };
+}
+declare function cwd(): string;
+export {};
+//# sourceMappingURL=minproc.browser.d.ts.map

node_modules/vfile/lib/minproc.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minproc.browser.d.ts","sourceRoot":"","sources":["minproc.browser.js"],"names":[],"mappings":";;;AAKA,+BAEC"}

node_modules/vfile/lib/minproc.browser.js

@@ -0,0 +1,8 @@
+// Somewhat based on:
+// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.
+// But I don’t think one tiny line of code can be copyrighted. 😅
+export const minproc = {cwd}
+
+function cwd() {
+  return '/'
+}

node_modules/vfile/lib/minproc.d.ts

@@ -0,0 +1,2 @@
+export { default as minproc } from "node:process";
+//# sourceMappingURL=minproc.d.ts.map

node_modules/vfile/lib/minproc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minproc.d.ts","sourceRoot":"","sources":["minproc.js"],"names":[],"mappings":""}

node_modules/vfile/lib/minproc.js

@@ -0,0 +1 @@
+export {default as minproc} from 'node:process'

node_modules/vfile/lib/minurl.browser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @param {URL | string} path
+ *   File URL.
+ * @returns {string}
+ *   File URL.
+ */
+export function urlToPath(path: URL | string): string;
+export { isUrl } from "./minurl.shared.js";
+//# sourceMappingURL=minurl.browser.d.ts.map

node_modules/vfile/lib/minurl.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minurl.browser.d.ts","sourceRoot":"","sources":["minurl.browser.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,gCALW,GAAG,GAAG,MAAM,GAEV,MAAM,CAyBlB"}

node_modules/vfile/lib/minurl.browser.js

@@ -0,0 +1,76 @@
+import {isUrl} from './minurl.shared.js'
+
+export {isUrl} from './minurl.shared.js'
+
+// See: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js>
+
+/**
+ * @param {URL | string} path
+ *   File URL.
+ * @returns {string}
+ *   File URL.
+ */
+export function urlToPath(path) {
+  if (typeof path === 'string') {
+    path = new URL(path)
+  } else if (!isUrl(path)) {
+    /** @type {NodeJS.ErrnoException} */
+    const error = new TypeError(
+      'The "path" argument must be of type string or an instance of URL. Received `' +
+        path +
+        '`'
+    )
+    error.code = 'ERR_INVALID_ARG_TYPE'
+    throw error
+  }
+
+  if (path.protocol !== 'file:') {
+    /** @type {NodeJS.ErrnoException} */
+    const error = new TypeError('The URL must be of scheme file')
+    error.code = 'ERR_INVALID_URL_SCHEME'
+    throw error
+  }
+
+  return getPathFromURLPosix(path)
+}
+
+/**
+ * Get a path from a POSIX URL.
+ *
+ * @param {URL} url
+ *   URL.
+ * @returns {string}
+ *   File path.
+ */
+function getPathFromURLPosix(url) {
+  if (url.hostname !== '') {
+    /** @type {NodeJS.ErrnoException} */
+    const error = new TypeError(
+      'File URL host must be "localhost" or empty on darwin'
+    )
+    error.code = 'ERR_INVALID_FILE_URL_HOST'
+    throw error
+  }
+
+  const pathname = url.pathname
+  let index = -1
+
+  while (++index < pathname.length) {
+    if (
+      pathname.codePointAt(index) === 37 /* `%` */ &&
+      pathname.codePointAt(index + 1) === 50 /* `2` */
+    ) {
+      const third = pathname.codePointAt(index + 2)
+      if (third === 70 /* `F` */ || third === 102 /* `f` */) {
+        /** @type {NodeJS.ErrnoException} */
+        const error = new TypeError(
+          'File URL path must not include encoded / characters'
+        )
+        error.code = 'ERR_INVALID_FILE_URL_PATH'
+        throw error
+      }
+    }
+  }
+
+  return decodeURIComponent(pathname)
+}

node_modules/vfile/lib/minurl.d.ts

@@ -0,0 +1,3 @@
+export { fileURLToPath as urlToPath } from "node:url";
+export { isUrl } from "./minurl.shared.js";
+//# sourceMappingURL=minurl.d.ts.map

node_modules/vfile/lib/minurl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minurl.d.ts","sourceRoot":"","sources":["minurl.js"],"names":[],"mappings":""}

node_modules/vfile/lib/minurl.js

@@ -0,0 +1,2 @@
+export {fileURLToPath as urlToPath} from 'node:url'
+export {isUrl} from './minurl.shared.js'

node_modules/vfile/lib/minurl.shared.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Checks if a value has the shape of a WHATWG URL object.
+ *
+ * Using a symbol or instanceof would not be able to recognize URL objects
+ * coming from other implementations (e.g. in Electron), so instead we are
+ * checking some well known properties for a lack of a better test.
+ *
+ * We use `href` and `protocol` as they are the only properties that are
+ * easy to retrieve and calculate due to the lazy nature of the getters.
+ *
+ * We check for auth attribute to distinguish legacy url instance with
+ * WHATWG URL instance.
+ *
+ * @param {unknown} fileUrlOrPath
+ *   File path or URL.
+ * @returns {fileUrlOrPath is URL}
+ *   Whether it’s a URL.
+ */
+export function isUrl(fileUrlOrPath: unknown): fileUrlOrPath is URL;
+//# sourceMappingURL=minurl.shared.d.ts.map

node_modules/vfile/lib/minurl.shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minurl.shared.d.ts","sourceRoot":"","sources":["minurl.shared.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,qCANW,OAAO,GAEL,aAAa,IAAI,GAAG,CAehC"}

node_modules/vfile/lib/minurl.shared.js

@@ -0,0 +1,31 @@
+/**
+ * Checks if a value has the shape of a WHATWG URL object.
+ *
+ * Using a symbol or instanceof would not be able to recognize URL objects
+ * coming from other implementations (e.g. in Electron), so instead we are
+ * checking some well known properties for a lack of a better test.
+ *
+ * We use `href` and `protocol` as they are the only properties that are
+ * easy to retrieve and calculate due to the lazy nature of the getters.
+ *
+ * We check for auth attribute to distinguish legacy url instance with
+ * WHATWG URL instance.
+ *
+ * @param {unknown} fileUrlOrPath
+ *   File path or URL.
+ * @returns {fileUrlOrPath is URL}
+ *   Whether it’s a URL.
+ */
+// From: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js#L720>
+export function isUrl(fileUrlOrPath) {
+  return Boolean(
+    fileUrlOrPath !== null &&
+      typeof fileUrlOrPath === 'object' &&
+      'href' in fileUrlOrPath &&
+      fileUrlOrPath.href &&
+      'protocol' in fileUrlOrPath &&
+      fileUrlOrPath.protocol &&
+      // @ts-expect-error: indexing is fine.
+      fileUrlOrPath.auth === undefined
+  )
+}