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

node_modules/neotraverse/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2010 James Halliday and 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.

node_modules/neotraverse/README.md

@@ -0,0 +1,469 @@
+# neotraverse
+
+Traverse and transform objects by visiting every node on a recursive walk. This is a fork and TypeScript rewrite of [traverse](https://github.com/ljharb/js-traverse) with 0 dependencies and major improvements:
+
+- 🤌 1.38KB min+brotli
+- 🚥 Zero dependencies
+- 🎹 TypeScript. Throw away the `@types/traverse` package
+- ❎ No polyfills
+- 🛸 ESM-first
+- 📜 Legacy mode supporting ES5
+
+# Principles
+
+Rules this package aims to follow for an indefinite period of time:
+
+- No dependencies.
+- No polyfills.
+- ESM-first.
+- Pushing to be modern
+- Always provide a legacy mode
+- Always follow `traverse` API. There already are many packages that do this. `neotraverse` intends to be a drop-in replacement for `traverse` and provide the same API with 0 dependencies and enhanced Developer Experience.
+- All deviating changes happen in `neotraverse/modern` build.
+
+# Modern build
+
+`neotraverse/modern` provides a new class `new Traverse()`, and all methods and state is provided as first argument `ctx` (`this.update -> ctx.update`, `this.isLeaf -> ctx.isLeaf`, etc.)
+
+Before:
+
+```js
+import traverse from 'neotraverse';
+
+const obj = { a: 1, b: 2, c: [3, 4] };
+
+traverse(obj).forEach(function (x) {
+  if (x < 0) this.update(x + 128);
+});
+```
+
+After:
+
+```js
+import { Traverse } from 'neotraverse/modern';
+
+const obj = { a: 1, b: 2, c: [3, 4] };
+
+new Traverse(obj).forEach((ctx, x) => {
+  if (x < 0) ctx.update(x + 128);
+});
+```
+
+# Which build to use?
+
+`neotraverse` provides 3 builds:
+
+- default: Backwards compatible with `traverse` and provides the same API, but ESM only and compiled to ES2022 with Node 18+
+- modern: Modern build with ESM only and compiled to ES2022 with Node 18+. Provides a new class `new Traverse()`, and all methods and state is provided as first argument `ctx` (`this.update -> ctx.update`, `this.isLeaf -> ctx.isLeaf`, etc.)
+- legacy: Legacy build with ES5 and CJS, compatible with `traverse` and provides the same API.
+
+Here's a matrix of the different builds:
+
+| Build   | ESM       | CJS | Browser | Node | Polyfills | Size              |
+| ------- | --------- | --- | ------- | ---- | --------- | ----------------- |
+| default | ✅ ES2022 |     | ✅      | ✅   | ❌        | 1.54KB min+brotli |
+| modern  | ✅ ES2022 |     | ✅      | ✅   | ❌        | 1.38KB min+brotli |
+| legacy  | ✅ ES5    | ✅  | ✅      | ✅   | ❌        | 2.73KB min+brotli |
+
+If you are:
+
+## starting from scratch
+
+```ts
+import { Traverse } from 'neotraverse/modern';
+
+const obj = { a: 1, b: 2, c: [3, 4] };
+
+new Traverse(obj).forEach((ctx, x) => {
+  if (x < 0) ctx.update(x + 128); // `this` is same as `ctx` when using regular function
+});
+```
+
+## migrating from `traverse`
+
+### and you don't care about old browsers or Node versions:
+
+Use default build for no breaking changes, and a modern build for better developer experience.
+
+```ts
+import traverse from 'neotraverse';
+
+const obj = { a: 1, b: 2, c: [3, 4] };
+
+traverse(obj).forEach(function (x) {
+  if (x < 0) this.update(x + 128);
+});
+```
+
+### and you care about old browsers or Node versions:
+
+Use legacy build for compatibility with old browsers and Node versions.
+
+```js
+const traverse = require('neotraverse/legacy');
+```
+
+ESM:
+
+```js
+import traverse from 'neotraverse/legacy';
+```
+
+# examples
+
+## transform negative numbers in-place
+
+negative.js
+
+```js
+import { Traverse } from 'neotraverse/modern';
+const obj = [5, 6, -3, [7, 8, -2, 1], { f: 10, g: -13 }];
+
+new Traverse(obj).forEach(function (ctx, x) {
+  if (x < 0) ctx.update(x + 128);
+});
+
+console.dir(obj);
+```
+
+or in legacy mode:
+
+```js
+import traverse from 'neotraverse';
+// OR import traverse from 'neotraverse/legacy';
+
+const obj = [5, 6, -3, [7, 8, -2, 1], { f: 10, g: -13 }];
+
+traverse(obj).forEach(function (x) {
+  if (x < 0) this.update(x + 128);
+});
+
+// This is identical to the above
+traverse.forEach(obj, function (x) {
+  if (x < 0) this.update(x + 128);
+});
+
+console.dir(obj);
+```
+
+Output:
+
+    [ 5, 6, 125, [ 7, 8, 126, 1 ], { f: 10, g: 115 } ]
+
+## collect leaf nodes
+
+leaves.js
+
+```js
+import { Traverse } from 'neotraverse/modern';
+
+const obj = {
+  a: [1, 2, 3],
+  b: 4,
+  c: [5, 6],
+  d: { e: [7, 8], f: 9 }
+};
+
+const leaves = new Traverse(obj).reduce((ctx, acc, x) => {
+  if (ctx.isLeaf) acc.push(x);
+  return acc;
+}, []);
+
+console.dir(leaves);
+```
+
+or in legacy mode:
+
+```js
+import traverse from 'neotraverse';
+// OR import traverse from 'neotraverse/legacy';
+
+const obj = {
+  a: [1, 2, 3],
+  b: 4,
+  c: [5, 6],
+  d: { e: [7, 8], f: 9 }
+};
+
+const leaves = traverse(obj).reduce(function (acc, x) {
+  if (this.isLeaf) acc.push(x);
+  return acc;
+}, []);
+
+// Equivalent to the above
+const leavesLegacy = traverse.reduce(
+  obj,
+  function (acc, x) {
+    if (this.isLeaf) acc.push(x);
+    return acc;
+  },
+  []
+);
+
+console.dir(leaves);
+console.dir(leavesLegacy);
+```
+
+Output:
+
+    [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
+
+## scrub circular references
+
+scrub.js:
+
+```js
+import { Traverse } from 'neotraverse/modern';
+
+const obj = { a: 1, b: 2, c: [3, 4] };
+obj.c.push(obj);
+
+const scrubbed = new Traverse(obj).map(function (ctx, x) {
+  if (ctx.circular) ctx.remove();
+});
+
+console.dir(scrubbed);
+```
+
+or in legacy mode:
+
+```js
+import traverse from 'neotraverse';
+// OR import traverse from 'neotraverse/legacy';
+
+const obj = { a: 1, b: 2, c: [3, 4] };
+obj.c.push(obj);
+
+const scrubbed = traverse(obj).map(function (x) {
+  if (this.circular) this.remove();
+});
+
+// Equivalent to the above
+const scrubbedLegacy = traverse.map(obj, function (x) {
+  if (this.circular) this.remove();
+});
+
+console.dir(scrubbed);
+console.dir(scrubbedLegacy);
+```
+
+output:
+
+    { a: 1, b: 2, c: [ 3, 4 ] }
+
+## commonjs
+
+neotraverse/legacy is compatible with commonjs and provides the same API as `traverse`, acting as a drop-in replacement:
+
+```js
+const traverse = require('neotraverse/legacy');
+```
+
+## esm
+
+```js
+import { Traverse } from 'neotraverse/modern';
+```
+
+```js
+import traverse from 'neotraverse';
+```
+
+# Differences from `traverse`
+
+- ESM-first
+- ES2022, Node 18+
+- Types included by default. No need to install `@types/traverse`
+- Works as-is in all major browsers and Deno
+- No polyfills
+- `new Traverse()` class instead of regular old `traverse()`
+- Legacy mode supporting `ES5` and `CJS`
+
+There is a legacy mode that provides the same API as `traverse`, acting as a drop-in replacement:
+
+```js
+import traverse from 'neotraverse';
+
+const obj = { a: 1, b: 2, c: [3, 4] };
+
+traverse(obj).forEach(function (x) {
+  if (x < 0) this.update(x + 128);
+});
+```
+
+If you want to support really old browsers or NodeJS, supporting ES5, there's `neotraverse/legacy` which is compatible with ES5 and provides the same API as `traverse`, acting as a drop-in replacement for older browsers:
+
+```js
+import traverse from 'neotraverse/legacy';
+
+const obj = { a: 1, b: 2, c: [3, 4] };
+
+traverse(obj).forEach(function (x) {
+  if (x < 0) this.update(x + 128);
+});
+```
+
+# Migrating from `traverse`
+
+### Step 1: Install `neotraverse`
+
+```sh
+npm install neotraverse
+npm uninstall traverse @types/traverse # Remove the old dependencies
+```
+
+### Step 2: Replace `traverse` with `neotraverse`
+
+```diff
+-import traverse from 'traverse';
++import traverse from 'neotraverse';
+
+const obj = { a: 1, b: 2, c: [3, 4] };
+
+-traverse(obj).forEach(function (x) {
++traverse(obj).forEach(function (x) {
+  if (x < 0) this.update(x + 128);
+});
+```
+
+Optionally, there's also a legacy mode that provides the same API as `traverse`, acting as a drop-in replacement:
+
+```js
+import traverse from 'neotraverse/legacy';
+
+const obj = { a: 1, b: 2, c: [3, 4] };
+
+traverse(obj).forEach(function (x) {
+  if (x < 0) this.update(x + 128);
+});
+```
+
+### Step 3(Optional): Bundle time aliasing
+
+If you use Vite, you can aliss `traverse` to `neotravers/legacy` in your `vite.config.js`:
+
+```js
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      traverse: 'neotraverse' // or 'neotraverse/legacy'
+    }
+  }
+});
+```
+
+# methods
+
+Each method that takes an `fn` uses the context documented below in the context section.
+
+## .map(fn)
+
+Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `ctx.update(value)`(modern) or `this.update(value)`(legacy).
+
+## .forEach(fn)
+
+Execute `fn` for each node in the object but unlike `.map()`, when `ctx.update()`(modern) or `this.update()`(legacy) is called it updates the object in-place.
+
+## .reduce(fn, acc)
+
+For each node in the object, perform a [left-fold](<http://en.wikipedia.org/wiki/Fold_(higher-order_function)>) with the return value of `fn(acc, node)`.
+
+If `acc` isn't specified, `acc` is set to the root object for the first step and the root element is skipped.
+
+## .paths()
+
+Return an `Array` of every possible non-cyclic path in the object. Paths are `Array`s of string keys.
+
+## .nodes()
+
+Return an `Array` of every node in the object.
+
+## .clone()
+
+Create a deep clone of the object.
+
+## .get(path)
+
+Get the element at the array `path`.
+
+## .set(path, value)
+
+Set the element at the array `path` to `value`.
+
+## .has(path)
+
+Return whether the element at the array `path` exists.
+
+# context
+
+Each method that takes a callback has a context (its `ctx` object, or `this` object in legacy mode) with these attributes:
+
+## this.node
+
+The present node on the recursive walk
+
+## this.path
+
+An array of string keys from the root to the present node
+
+## this.parent
+
+The context of the node's parent. This is `undefined` for the root node.
+
+## this.key
+
+The name of the key of the present node in its parent. This is `undefined` for the root node.
+
+## this.isRoot, this.notRoot
+
+Whether the present node is the root node
+
+## this.isLeaf, this.notLeaf
+
+Whether or not the present node is a leaf node (has no children)
+
+## this.level
+
+Depth of the node within the traversal
+
+## this.circular
+
+If the node equals one of its parents, the `circular` attribute is set to the context of that parent and the traversal progresses no deeper.
+
+## this.update(value, stopHere=false)
+
+Set a new value for the present node.
+
+All the elements in `value` will be recursively traversed unless `stopHere` is true.
+
+## this.remove(stopHere=false)
+
+Remove the current element from the output. If the node is in an Array it will be spliced off. Otherwise it will be deleted from its parent.
+
+## this.delete(stopHere=false)
+
+Delete the current element from its parent in the output. Calls `delete` even on Arrays.
+
+## this.before(fn)
+
+Call this function before any of the children are traversed.
+
+You can assign into `ctx.keys`(modern) or `this.keys`(legacy) here to traverse in a custom order.
+
+## this.after(fn)
+
+Call this function after any of the children are traversed.
+
+## this.pre(fn)
+
+Call this function before each of the children are traversed.
+
+## this.post(fn)
+
+Call this function after each of the children are traversed.
+
+# license
+
+MIT

node_modules/neotraverse/dist/index.d.ts

@@ -0,0 +1,199 @@
+interface TraverseOptions {
+    /**
+     * If true, does not alter the original object
+     */
+    immutable?: boolean;
+    /**
+     * If false, removes all symbols from traversed objects
+     *
+     * @default false
+     */
+    includeSymbols?: boolean;
+}
+interface TraverseContext {
+    /**
+     * The present node on the recursive walk
+     */
+    node: any;
+    /**
+     * An array of string keys from the root to the present node
+     */
+    path: PropertyKey[];
+    /**
+     * The context of the node's parent.
+     * This is `undefined` for the root node.
+     */
+    parent: TraverseContext | undefined;
+    /**
+     * The contexts of the node's parents.
+     */
+    parents: TraverseContext[];
+    /**
+     * The name of the key of the present node in its parent.
+     * This is `undefined` for the root node.
+     */
+    key: PropertyKey | undefined;
+    /**
+     * Whether the present node is the root node
+     */
+    isRoot: boolean;
+    /**
+     * Whether the present node is not the root node
+     */
+    notRoot: boolean;
+    /**
+     * Whether the present node is the last node
+     */
+    isLast: boolean;
+    /**
+     * Whether the present node is the first node
+     */
+    isFirst: boolean;
+    /**
+     * Whether or not the present node is a leaf node (has no children)
+     */
+    isLeaf: boolean;
+    /**
+     * Whether or not the present node is not a leaf node (has children)
+     */
+    notLeaf: boolean;
+    /**
+     * Depth of the node within the traversal
+     */
+    level: number;
+    /**
+     * If the node equals one of its parents, the `circular` attribute is set to the context of that parent and the traversal progresses no deeper.
+     */
+    circular: TraverseContext | undefined;
+    /**
+     * Set a new value for the present node.
+     *
+     * All the elements in `value` will be recursively traversed unless `stopHere` is true (false by default).
+     */
+    update(value: any, stopHere?: boolean): void;
+    /**
+     * Remove the current element from the output. If the node is in an Array it will be spliced off. Otherwise it will be deleted from its parent.
+     */
+    remove(stopHere?: boolean): void;
+    /**
+     * Delete the current element from its parent in the output. Calls `delete` even on Arrays.
+     */
+    delete(stopHere?: boolean): void;
+    /**
+     * Object keys of the node.
+     */
+    keys: PropertyKey[] | null;
+    /**
+     * Call this function before all of the children are traversed.
+     * You can assign into `this.keys` here to traverse in a custom order.
+     */
+    before(callback: (this: TraverseContext, value: any) => void): void;
+    /**
+     * Call this function after all of the children are traversed.
+     */
+    after(callback: (this: TraverseContext, value: any) => void): void;
+    /**
+     * Call this function before each of the children are traversed.
+     */
+    pre(callback: (this: TraverseContext, child: any, key: any) => void): void;
+    /**
+     * Call this function after each of the children are traversed.
+     */
+    post(callback: (this: TraverseContext, child: any) => void): void;
+    /**
+     * Stops traversal entirely.
+     */
+    stop(): void;
+    /**
+     * Prevents traversing descendents of the current node.
+     */
+    block(): void;
+}
+/** @deprecated Import `Traverse` from `neotraverse/modern` instead */
+declare class Traverse {
+    #private;
+    constructor(obj: any, options?: TraverseOptions);
+    /**
+     * Get the element at the array `path`.
+     */
+    get(paths: PropertyKey[]): any;
+    /**
+     * Return whether the element at the array `path` exists.
+     */
+    has(paths: PropertyKey[]): boolean;
+    /**
+     * Set the element at the array `path` to `value`.
+     */
+    set(path: PropertyKey[], value: any): any;
+    /**
+     * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+     */
+    map(cb: (this: TraverseContext, v: any) => void): any;
+    /**
+     * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+     */
+    forEach(cb: (this: TraverseContext, v: any) => void): any;
+    /**
+     * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+     *
+     * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+     */
+    reduce(cb: (this: TraverseContext, acc: any, v: any) => void, init?: any): any;
+    /**
+     * Return an `Array` of every possible non-cyclic path in the object.
+     * Paths are `Array`s of string keys.
+     */
+    paths(): PropertyKey[][];
+    /**
+     * Return an `Array` of every node in the object.
+     */
+    nodes(): any[];
+    /**
+     * Create a deep clone of the object.
+     */
+    clone(): any;
+}
+declare const traverse: {
+    (obj: any, options?: TraverseOptions): Traverse;
+    /**
+     * Get the element at the array `path`.
+     */
+    get(obj: any, paths: PropertyKey[], options?: TraverseOptions): any;
+    /**
+     * Set the element at the array `path` to `value`.
+     */
+    set(obj: any, path: PropertyKey[], value: any, options?: TraverseOptions): any;
+    /**
+     * Return whether the element at the array `path` exists.
+     */
+    has(obj: any, paths: PropertyKey[], options?: TraverseOptions): boolean;
+    /**
+     * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+     */
+    map(obj: any, cb: (this: TraverseContext, v: any) => void, options?: TraverseOptions): any;
+    /**
+     * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+     */
+    forEach(obj: any, cb: (this: TraverseContext, v: any) => void, options?: TraverseOptions): any;
+    /**
+     * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+     *
+     * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+     */
+    reduce(obj: any, cb: (this: TraverseContext, acc: any, v: any) => void, init?: any, options?: TraverseOptions): any;
+    /**
+     * Return an `Array` of every possible non-cyclic path in the object.
+     * Paths are `Array`s of string keys.
+     */
+    paths(obj: any, options?: TraverseOptions): PropertyKey[][];
+    /**
+     * Return an `Array` of every node in the object.
+     */
+    nodes(obj: any, options?: TraverseOptions): any[];
+    /**
+     * Create a deep clone of the object.
+     */
+    clone(obj: any, options?: TraverseOptions): any;
+};
+
+export { Traverse, type TraverseContext, type TraverseOptions, traverse as default };

node_modules/neotraverse/dist/index.js

@@ -0,0 +1,358 @@
+// src/index.ts
+var to_string = (obj) => Object.prototype.toString.call(obj);
+var is_typed_array = (value) => ArrayBuffer.isView(value) && !(value instanceof DataView);
+var is_date = (obj) => to_string(obj) === "[object Date]";
+var is_regexp = (obj) => to_string(obj) === "[object RegExp]";
+var is_error = (obj) => to_string(obj) === "[object Error]";
+var is_boolean = (obj) => to_string(obj) === "[object Boolean]";
+var is_number = (obj) => to_string(obj) === "[object Number]";
+var is_string = (obj) => to_string(obj) === "[object String]";
+var is_array = Array.isArray;
+var gopd = Object.getOwnPropertyDescriptor;
+var is_property_enumerable = Object.prototype.propertyIsEnumerable;
+var get_own_property_symbols = Object.getOwnPropertySymbols;
+var has_own_property = Object.prototype.hasOwnProperty;
+function own_enumerable_keys(obj) {
+  const res = Object.keys(obj);
+  const symbols = get_own_property_symbols(obj);
+  for (let i = 0; i < symbols.length; i++) {
+    if (is_property_enumerable.call(obj, symbols[i])) {
+      res.push(symbols[i]);
+    }
+  }
+  return res;
+}
+function is_writable(object, key) {
+  return !gopd(object, key)?.writable;
+}
+function copy(src, options) {
+  if (typeof src === "object" && src !== null) {
+    let dst;
+    if (is_array(src)) {
+      dst = [];
+    } else if (is_date(src)) {
+      dst = new Date(src.getTime ? src.getTime() : src);
+    } else if (is_regexp(src)) {
+      dst = new RegExp(src);
+    } else if (is_error(src)) {
+      dst = { message: src.message };
+    } else if (is_boolean(src) || is_number(src) || is_string(src)) {
+      dst = Object(src);
+    } else if (is_typed_array(src)) {
+      return src.slice();
+    } else {
+      dst = Object.create(Object.getPrototypeOf(src));
+    }
+    const iterator_function = options.includeSymbols ? own_enumerable_keys : Object.keys;
+    for (const key of iterator_function(src)) {
+      dst[key] = src[key];
+    }
+    return dst;
+  }
+  return src;
+}
+var empty_null = {
+  includeSymbols: false,
+  immutable: false
+};
+function walk(root, cb, options = empty_null) {
+  const path = [];
+  const parents = [];
+  let alive = true;
+  const iterator_function = options.includeSymbols ? own_enumerable_keys : Object.keys;
+  const immutable = !!options.immutable;
+  return function walker(node_) {
+    const node = immutable ? copy(node_, options) : node_;
+    const modifiers = {};
+    let keep_going = true;
+    const state = {
+      node,
+      node_,
+      path: [].concat(path),
+      parent: parents[parents.length - 1],
+      parents,
+      key: path[path.length - 1],
+      isRoot: path.length === 0,
+      level: path.length,
+      circular: void 0,
+      isLeaf: false,
+      notLeaf: true,
+      notRoot: true,
+      isFirst: false,
+      isLast: false,
+      update: function(x, stopHere = false) {
+        if (!state.isRoot) {
+          state.parent.node[state.key] = x;
+        }
+        state.node = x;
+        if (stopHere) {
+          keep_going = false;
+        }
+      },
+      delete: function(stopHere) {
+        delete state.parent.node[state.key];
+        if (stopHere) {
+          keep_going = false;
+        }
+      },
+      remove: function(stopHere) {
+        if (is_array(state.parent.node)) {
+          state.parent.node.splice(state.key, 1);
+        } else {
+          delete state.parent.node[state.key];
+        }
+        if (stopHere) {
+          keep_going = false;
+        }
+      },
+      keys: null,
+      before: function(f) {
+        modifiers.before = f;
+      },
+      after: function(f) {
+        modifiers.after = f;
+      },
+      pre: function(f) {
+        modifiers.pre = f;
+      },
+      post: function(f) {
+        modifiers.post = f;
+      },
+      stop: function() {
+        alive = false;
+      },
+      block: function() {
+        keep_going = false;
+      }
+    };
+    if (!alive) {
+      return state;
+    }
+    function update_state() {
+      if (typeof state.node === "object" && state.node !== null) {
+        if (!state.keys || state.node_ !== state.node) {
+          state.keys = iterator_function(state.node);
+        }
+        state.isLeaf = state.keys.length === 0;
+        for (let i = 0; i < parents.length; i++) {
+          if (parents[i].node_ === node_) {
+            state.circular = parents[i];
+            break;
+          }
+        }
+      } else {
+        state.isLeaf = true;
+        state.keys = null;
+      }
+      state.notLeaf = !state.isLeaf;
+      state.notRoot = !state.isRoot;
+    }
+    update_state();
+    const ret = cb.call(state, state.node);
+    if (ret !== void 0 && state.update) {
+      state.update(ret);
+    }
+    if (modifiers.before) {
+      modifiers.before.call(state, state.node);
+    }
+    if (!keep_going) {
+      return state;
+    }
+    if (typeof state.node === "object" && state.node !== null && !state.circular) {
+      parents.push(state);
+      update_state();
+      for (const [index, key] of Object.entries(state.keys ?? [])) {
+        path.push(key);
+        if (modifiers.pre) {
+          modifiers.pre.call(state, state.node[key], key);
+        }
+        const child = walker(state.node[key]);
+        if (immutable && has_own_property.call(state.node, key) && !is_writable(state.node, key)) {
+          state.node[key] = child.node;
+        }
+        child.isLast = state.keys?.length ? +index === state.keys.length - 1 : false;
+        child.isFirst = +index === 0;
+        if (modifiers.post) {
+          modifiers.post.call(state, child);
+        }
+        path.pop();
+      }
+      parents.pop();
+    }
+    if (modifiers.after) {
+      modifiers.after.call(state, state.node);
+    }
+    return state;
+  }(root).node;
+}
+var Traverse = class {
+  // ! Have to keep these public as legacy mode requires them
+  #value;
+  #options;
+  constructor(obj, options = empty_null) {
+    this.#value = obj;
+    this.#options = options;
+  }
+  /**
+   * Get the element at the array `path`.
+   */
+  get(paths) {
+    let node = this.#value;
+    for (let i = 0; node && i < paths.length; i++) {
+      const key = paths[i];
+      if (!has_own_property.call(node, key) || !this.#options.includeSymbols && typeof key === "symbol") {
+        return void 0;
+      }
+      node = node[key];
+    }
+    return node;
+  }
+  /**
+   * Return whether the element at the array `path` exists.
+   */
+  has(paths) {
+    let node = this.#value;
+    for (let i = 0; node && i < paths.length; i++) {
+      const key = paths[i];
+      if (!has_own_property.call(node, key) || !this.#options.includeSymbols && typeof key === "symbol") {
+        return false;
+      }
+      node = node[key];
+    }
+    return true;
+  }
+  /**
+   * Set the element at the array `path` to `value`.
+   */
+  set(path, value) {
+    let node = this.#value;
+    let i = 0;
+    for (i = 0; i < path.length - 1; i++) {
+      const key = path[i];
+      if (!has_own_property.call(node, key)) {
+        node[key] = {};
+      }
+      node = node[key];
+    }
+    node[path[i]] = value;
+    return value;
+  }
+  /**
+   * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+   */
+  map(cb) {
+    return walk(this.#value, cb, {
+      immutable: true,
+      includeSymbols: !!this.#options.includeSymbols
+    });
+  }
+  /**
+   * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+   */
+  forEach(cb) {
+    this.#value = walk(this.#value, cb, this.#options);
+    return this.#value;
+  }
+  /**
+   * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+   *
+   * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+   */
+  reduce(cb, init) {
+    const skip = arguments.length === 1;
+    let acc = skip ? this.#value : init;
+    this.forEach(function(x) {
+      if (!this.isRoot || !skip) {
+        acc = cb.call(this, acc, x);
+      }
+    });
+    return acc;
+  }
+  /**
+   * Return an `Array` of every possible non-cyclic path in the object.
+   * Paths are `Array`s of string keys.
+   */
+  paths() {
+    const acc = [];
+    this.forEach(function() {
+      acc.push(this.path);
+    });
+    return acc;
+  }
+  /**
+   * Return an `Array` of every node in the object.
+   */
+  nodes() {
+    const acc = [];
+    this.forEach(function() {
+      acc.push(this.node);
+    });
+    return acc;
+  }
+  /**
+   * Create a deep clone of the object.
+   */
+  clone() {
+    const parents = [];
+    const nodes = [];
+    const options = this.#options;
+    if (is_typed_array(this.#value)) {
+      return this.#value.slice();
+    }
+    return function clone(src) {
+      for (let i = 0; i < parents.length; i++) {
+        if (parents[i] === src) {
+          return nodes[i];
+        }
+      }
+      if (typeof src === "object" && src !== null) {
+        const dst = copy(src, options);
+        parents.push(src);
+        nodes.push(dst);
+        const iteratorFunction = options.includeSymbols ? own_enumerable_keys : Object.keys;
+        for (const key of iteratorFunction(src)) {
+          dst[key] = clone(src[key]);
+        }
+        parents.pop();
+        nodes.pop();
+        return dst;
+      }
+      return src;
+    }(this.#value);
+  }
+};
+var traverse = (obj, options) => {
+  return new Traverse(obj, options);
+};
+traverse.get = (obj, paths, options) => {
+  return new Traverse(obj, options).get(paths);
+};
+traverse.set = (obj, path, value, options) => {
+  return new Traverse(obj, options).set(path, value);
+};
+traverse.has = (obj, paths, options) => {
+  return new Traverse(obj, options).has(paths);
+};
+traverse.map = (obj, cb, options) => {
+  return new Traverse(obj, options).map(cb);
+};
+traverse.forEach = (obj, cb, options) => {
+  return new Traverse(obj, options).forEach(cb);
+};
+traverse.reduce = (obj, cb, init, options) => {
+  return new Traverse(obj, options).reduce(cb, init);
+};
+traverse.paths = (obj, options) => {
+  return new Traverse(obj, options).paths();
+};
+traverse.nodes = (obj, options) => {
+  return new Traverse(obj, options).nodes();
+};
+traverse.clone = (obj, options) => {
+  return new Traverse(obj, options).clone();
+};
+var src_default = traverse;
+export {
+  Traverse,
+  src_default as default
+};

node_modules/neotraverse/dist/legacy/legacy.cjs

@@ -0,0 +1,602 @@
+"use strict";
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = function(msg) {
+    throw TypeError(msg);
+};
+var __export = function(target, all) {
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true
+    });
+};
+var __copyProps = function(to, from, except, desc) {
+    if (from && (typeof from === "undefined" ? "undefined" : _type_of(from)) === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toCommonJS = function(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
+};
+var __accessCheck = function(obj, member, msg) {
+    return member.has(obj) || __typeError("Cannot " + msg);
+};
+var __privateGet = function(obj, member, getter) {
+    return __accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = function(obj, member, value) {
+    return member.has(obj) ? __typeError("Cannot add the same private member more than once") : _instanceof(member, WeakSet) ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = function(obj, member, value, setter) {
+    return __accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value;
+};
+// src/legacy.cts
+var legacy_exports = {};
+__export(legacy_exports, {
+    default: function() {
+        return src_default;
+    }
+});
+module.exports = __toCommonJS(legacy_exports);
+// src/index.ts
+var to_string = function(obj) {
+    return Object.prototype.toString.call(obj);
+};
+var is_typed_array = function(value) {
+    return ArrayBuffer.isView(value) && !_instanceof(value, DataView);
+};
+var is_date = function(obj) {
+    return to_string(obj) === "[object Date]";
+};
+var is_regexp = function(obj) {
+    return to_string(obj) === "[object RegExp]";
+};
+var is_error = function(obj) {
+    return to_string(obj) === "[object Error]";
+};
+var is_boolean = function(obj) {
+    return to_string(obj) === "[object Boolean]";
+};
+var is_number = function(obj) {
+    return to_string(obj) === "[object Number]";
+};
+var is_string = function(obj) {
+    return to_string(obj) === "[object String]";
+};
+var is_array = Array.isArray;
+var gopd = Object.getOwnPropertyDescriptor;
+var is_property_enumerable = Object.prototype.propertyIsEnumerable;
+var get_own_property_symbols = Object.getOwnPropertySymbols;
+var has_own_property = Object.prototype.hasOwnProperty;
+function own_enumerable_keys(obj) {
+    var res = Object.keys(obj);
+    var symbols = get_own_property_symbols(obj);
+    for(var i = 0; i < symbols.length; i++){
+        if (is_property_enumerable.call(obj, symbols[i])) {
+            res.push(symbols[i]);
+        }
+    }
+    return res;
+}
+function is_writable(object, key) {
+    var _gopd;
+    return !((_gopd = gopd(object, key)) === null || _gopd === void 0 ? void 0 : _gopd.writable);
+}
+function copy(src, options) {
+    if ((typeof src === "undefined" ? "undefined" : _type_of(src)) === "object" && src !== null) {
+        var dst;
+        if (is_array(src)) {
+            dst = [];
+        } else if (is_date(src)) {
+            dst = new Date(src.getTime ? src.getTime() : src);
+        } else if (is_regexp(src)) {
+            dst = new RegExp(src);
+        } else if (is_error(src)) {
+            dst = {
+                message: src.message
+            };
+        } else if (is_boolean(src) || is_number(src) || is_string(src)) {
+            dst = Object(src);
+        } else if (is_typed_array(src)) {
+            return src.slice();
+        } else {
+            dst = Object.create(Object.getPrototypeOf(src));
+        }
+        var iterator_function = options.includeSymbols ? own_enumerable_keys : Object.keys;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = iterator_function(src)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var key = _step.value;
+                dst[key] = src[key];
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        return dst;
+    }
+    return src;
+}
+var empty_null = {
+    includeSymbols: false,
+    immutable: false
+};
+function walk(root, cb) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : empty_null;
+    var path = [];
+    var parents = [];
+    var alive = true;
+    var iterator_function = options.includeSymbols ? own_enumerable_keys : Object.keys;
+    var immutable = !!options.immutable;
+    return function walker(node_) {
+        var node = immutable ? copy(node_, options) : node_;
+        var modifiers = {};
+        var keep_going = true;
+        var state = {
+            node: node,
+            node_: node_,
+            path: [].concat(path),
+            parent: parents[parents.length - 1],
+            parents: parents,
+            key: path[path.length - 1],
+            isRoot: path.length === 0,
+            level: path.length,
+            circular: void 0,
+            isLeaf: false,
+            notLeaf: true,
+            notRoot: true,
+            isFirst: false,
+            isLast: false,
+            update: function update(x) {
+                var stopHere = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+                if (!state.isRoot) {
+                    state.parent.node[state.key] = x;
+                }
+                state.node = x;
+                if (stopHere) {
+                    keep_going = false;
+                }
+            },
+            delete: function _delete(stopHere) {
+                delete state.parent.node[state.key];
+                if (stopHere) {
+                    keep_going = false;
+                }
+            },
+            remove: function remove(stopHere) {
+                if (is_array(state.parent.node)) {
+                    state.parent.node.splice(state.key, 1);
+                } else {
+                    delete state.parent.node[state.key];
+                }
+                if (stopHere) {
+                    keep_going = false;
+                }
+            },
+            keys: null,
+            before: function before(f) {
+                modifiers.before = f;
+            },
+            after: function after(f) {
+                modifiers.after = f;
+            },
+            pre: function pre(f) {
+                modifiers.pre = f;
+            },
+            post: function post(f) {
+                modifiers.post = f;
+            },
+            stop: function stop() {
+                alive = false;
+            },
+            block: function block() {
+                keep_going = false;
+            }
+        };
+        if (!alive) {
+            return state;
+        }
+        function update_state() {
+            if (_type_of(state.node) === "object" && state.node !== null) {
+                if (!state.keys || state.node_ !== state.node) {
+                    state.keys = iterator_function(state.node);
+                }
+                state.isLeaf = state.keys.length === 0;
+                for(var i = 0; i < parents.length; i++){
+                    if (parents[i].node_ === node_) {
+                        state.circular = parents[i];
+                        break;
+                    }
+                }
+            } else {
+                state.isLeaf = true;
+                state.keys = null;
+            }
+            state.notLeaf = !state.isLeaf;
+            state.notRoot = !state.isRoot;
+        }
+        update_state();
+        var ret = cb.call(state, state.node);
+        if (ret !== void 0 && state.update) {
+            state.update(ret);
+        }
+        if (modifiers.before) {
+            modifiers.before.call(state, state.node);
+        }
+        if (!keep_going) {
+            return state;
+        }
+        if (_type_of(state.node) === "object" && state.node !== null && !state.circular) {
+            parents.push(state);
+            update_state();
+            var _state_keys;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = Object.entries((_state_keys = state.keys) !== null && _state_keys !== void 0 ? _state_keys : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var _step_value = _sliced_to_array(_step.value, 2), index = _step_value[0], key = _step_value[1];
+                    var _state_keys1;
+                    path.push(key);
+                    if (modifiers.pre) {
+                        modifiers.pre.call(state, state.node[key], key);
+                    }
+                    var child = walker(state.node[key]);
+                    if (immutable && has_own_property.call(state.node, key) && !is_writable(state.node, key)) {
+                        state.node[key] = child.node;
+                    }
+                    child.isLast = ((_state_keys1 = state.keys) === null || _state_keys1 === void 0 ? void 0 : _state_keys1.length) ? +index === state.keys.length - 1 : false;
+                    child.isFirst = +index === 0;
+                    if (modifiers.post) {
+                        modifiers.post.call(state, child);
+                    }
+                    path.pop();
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            parents.pop();
+        }
+        if (modifiers.after) {
+            modifiers.after.call(state, state.node);
+        }
+        return state;
+    }(root).node;
+}
+var _value, _options;
+var Traverse = /*#__PURE__*/ function() {
+    function Traverse(obj) {
+        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : empty_null;
+        _class_call_check(this, Traverse);
+        // ! Have to keep these public as legacy mode requires them
+        __privateAdd(this, _value);
+        __privateAdd(this, _options);
+        __privateSet(this, _value, obj);
+        __privateSet(this, _options, options);
+    }
+    _create_class(Traverse, [
+        {
+            /**
+   * Get the element at the array `path`.
+   */ key: "get",
+            value: function get(paths) {
+                var node = __privateGet(this, _value);
+                for(var i = 0; node && i < paths.length; i++){
+                    var key = paths[i];
+                    if (!has_own_property.call(node, key) || !__privateGet(this, _options).includeSymbols && (typeof key === "undefined" ? "undefined" : _type_of(key)) === "symbol") {
+                        return void 0;
+                    }
+                    node = node[key];
+                }
+                return node;
+            }
+        },
+        {
+            /**
+   * Return whether the element at the array `path` exists.
+   */ key: "has",
+            value: function has(paths) {
+                var node = __privateGet(this, _value);
+                for(var i = 0; node && i < paths.length; i++){
+                    var key = paths[i];
+                    if (!has_own_property.call(node, key) || !__privateGet(this, _options).includeSymbols && (typeof key === "undefined" ? "undefined" : _type_of(key)) === "symbol") {
+                        return false;
+                    }
+                    node = node[key];
+                }
+                return true;
+            }
+        },
+        {
+            /**
+   * Set the element at the array `path` to `value`.
+   */ key: "set",
+            value: function set(path, value) {
+                var node = __privateGet(this, _value);
+                var i = 0;
+                for(i = 0; i < path.length - 1; i++){
+                    var key = path[i];
+                    if (!has_own_property.call(node, key)) {
+                        node[key] = {};
+                    }
+                    node = node[key];
+                }
+                node[path[i]] = value;
+                return value;
+            }
+        },
+        {
+            /**
+   * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+   */ key: "map",
+            value: function map(cb) {
+                return walk(__privateGet(this, _value), cb, {
+                    immutable: true,
+                    includeSymbols: !!__privateGet(this, _options).includeSymbols
+                });
+            }
+        },
+        {
+            /**
+   * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+   */ key: "forEach",
+            value: function forEach(cb) {
+                __privateSet(this, _value, walk(__privateGet(this, _value), cb, __privateGet(this, _options)));
+                return __privateGet(this, _value);
+            }
+        },
+        {
+            /**
+   * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+   *
+   * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+   */ key: "reduce",
+            value: function reduce(cb, init) {
+                var skip = arguments.length === 1;
+                var acc = skip ? __privateGet(this, _value) : init;
+                this.forEach(function(x) {
+                    if (!this.isRoot || !skip) {
+                        acc = cb.call(this, acc, x);
+                    }
+                });
+                return acc;
+            }
+        },
+        {
+            /**
+   * Return an `Array` of every possible non-cyclic path in the object.
+   * Paths are `Array`s of string keys.
+   */ key: "paths",
+            value: function paths() {
+                var acc = [];
+                this.forEach(function() {
+                    acc.push(this.path);
+                });
+                return acc;
+            }
+        },
+        {
+            /**
+   * Return an `Array` of every node in the object.
+   */ key: "nodes",
+            value: function nodes() {
+                var acc = [];
+                this.forEach(function() {
+                    acc.push(this.node);
+                });
+                return acc;
+            }
+        },
+        {
+            /**
+   * Create a deep clone of the object.
+   */ key: "clone",
+            value: function clone() {
+                var parents = [];
+                var nodes = [];
+                var options = __privateGet(this, _options);
+                if (is_typed_array(__privateGet(this, _value))) {
+                    return __privateGet(this, _value).slice();
+                }
+                return function clone(src) {
+                    for(var i = 0; i < parents.length; i++){
+                        if (parents[i] === src) {
+                            return nodes[i];
+                        }
+                    }
+                    if ((typeof src === "undefined" ? "undefined" : _type_of(src)) === "object" && src !== null) {
+                        var dst = copy(src, options);
+                        parents.push(src);
+                        nodes.push(dst);
+                        var iteratorFunction = options.includeSymbols ? own_enumerable_keys : Object.keys;
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = iteratorFunction(src)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var key = _step.value;
+                                dst[key] = clone(src[key]);
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        parents.pop();
+                        nodes.pop();
+                        return dst;
+                    }
+                    return src;
+                }(__privateGet(this, _value));
+            }
+        }
+    ]);
+    return Traverse;
+}();
+_value = new WeakMap();
+_options = new WeakMap();
+var traverse = function(obj, options) {
+    return new Traverse(obj, options);
+};
+traverse.get = function(obj, paths, options) {
+    return new Traverse(obj, options).get(paths);
+};
+traverse.set = function(obj, path, value, options) {
+    return new Traverse(obj, options).set(path, value);
+};
+traverse.has = function(obj, paths, options) {
+    return new Traverse(obj, options).has(paths);
+};
+traverse.map = function(obj, cb, options) {
+    return new Traverse(obj, options).map(cb);
+};
+traverse.forEach = function(obj, cb, options) {
+    return new Traverse(obj, options).forEach(cb);
+};
+traverse.reduce = function(obj, cb, init, options) {
+    return new Traverse(obj, options).reduce(cb, init);
+};
+traverse.paths = function(obj, options) {
+    return new Traverse(obj, options).paths();
+};
+traverse.nodes = function(obj, options) {
+    return new Traverse(obj, options).nodes();
+};
+traverse.clone = function(obj, options) {
+    return new Traverse(obj, options).clone();
+};
+var src_default = traverse;
+// src/legacy.cts
+module.exports = src_default;

node_modules/neotraverse/dist/legacy/legacy.d.cts

@@ -0,0 +1,199 @@
+interface TraverseOptions {
+    /**
+     * If true, does not alter the original object
+     */
+    immutable?: boolean;
+    /**
+     * If false, removes all symbols from traversed objects
+     *
+     * @default false
+     */
+    includeSymbols?: boolean;
+}
+interface TraverseContext {
+    /**
+     * The present node on the recursive walk
+     */
+    node: any;
+    /**
+     * An array of string keys from the root to the present node
+     */
+    path: PropertyKey[];
+    /**
+     * The context of the node's parent.
+     * This is `undefined` for the root node.
+     */
+    parent: TraverseContext | undefined;
+    /**
+     * The contexts of the node's parents.
+     */
+    parents: TraverseContext[];
+    /**
+     * The name of the key of the present node in its parent.
+     * This is `undefined` for the root node.
+     */
+    key: PropertyKey | undefined;
+    /**
+     * Whether the present node is the root node
+     */
+    isRoot: boolean;
+    /**
+     * Whether the present node is not the root node
+     */
+    notRoot: boolean;
+    /**
+     * Whether the present node is the last node
+     */
+    isLast: boolean;
+    /**
+     * Whether the present node is the first node
+     */
+    isFirst: boolean;
+    /**
+     * Whether or not the present node is a leaf node (has no children)
+     */
+    isLeaf: boolean;
+    /**
+     * Whether or not the present node is not a leaf node (has children)
+     */
+    notLeaf: boolean;
+    /**
+     * Depth of the node within the traversal
+     */
+    level: number;
+    /**
+     * If the node equals one of its parents, the `circular` attribute is set to the context of that parent and the traversal progresses no deeper.
+     */
+    circular: TraverseContext | undefined;
+    /**
+     * Set a new value for the present node.
+     *
+     * All the elements in `value` will be recursively traversed unless `stopHere` is true (false by default).
+     */
+    update(value: any, stopHere?: boolean): void;
+    /**
+     * Remove the current element from the output. If the node is in an Array it will be spliced off. Otherwise it will be deleted from its parent.
+     */
+    remove(stopHere?: boolean): void;
+    /**
+     * Delete the current element from its parent in the output. Calls `delete` even on Arrays.
+     */
+    delete(stopHere?: boolean): void;
+    /**
+     * Object keys of the node.
+     */
+    keys: PropertyKey[] | null;
+    /**
+     * Call this function before all of the children are traversed.
+     * You can assign into `this.keys` here to traverse in a custom order.
+     */
+    before(callback: (this: TraverseContext, value: any) => void): void;
+    /**
+     * Call this function after all of the children are traversed.
+     */
+    after(callback: (this: TraverseContext, value: any) => void): void;
+    /**
+     * Call this function before each of the children are traversed.
+     */
+    pre(callback: (this: TraverseContext, child: any, key: any) => void): void;
+    /**
+     * Call this function after each of the children are traversed.
+     */
+    post(callback: (this: TraverseContext, child: any) => void): void;
+    /**
+     * Stops traversal entirely.
+     */
+    stop(): void;
+    /**
+     * Prevents traversing descendents of the current node.
+     */
+    block(): void;
+}
+/** @deprecated Import `Traverse` from `neotraverse/modern` instead */
+declare class Traverse {
+    #private;
+    constructor(obj: any, options?: TraverseOptions);
+    /**
+     * Get the element at the array `path`.
+     */
+    get(paths: PropertyKey[]): any;
+    /**
+     * Return whether the element at the array `path` exists.
+     */
+    has(paths: PropertyKey[]): boolean;
+    /**
+     * Set the element at the array `path` to `value`.
+     */
+    set(path: PropertyKey[], value: any): any;
+    /**
+     * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+     */
+    map(cb: (this: TraverseContext, v: any) => void): any;
+    /**
+     * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+     */
+    forEach(cb: (this: TraverseContext, v: any) => void): any;
+    /**
+     * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+     *
+     * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+     */
+    reduce(cb: (this: TraverseContext, acc: any, v: any) => void, init?: any): any;
+    /**
+     * Return an `Array` of every possible non-cyclic path in the object.
+     * Paths are `Array`s of string keys.
+     */
+    paths(): PropertyKey[][];
+    /**
+     * Return an `Array` of every node in the object.
+     */
+    nodes(): any[];
+    /**
+     * Create a deep clone of the object.
+     */
+    clone(): any;
+}
+declare const traverse: {
+    (obj: any, options?: TraverseOptions): Traverse;
+    /**
+     * Get the element at the array `path`.
+     */
+    get(obj: any, paths: PropertyKey[], options?: TraverseOptions): any;
+    /**
+     * Set the element at the array `path` to `value`.
+     */
+    set(obj: any, path: PropertyKey[], value: any, options?: TraverseOptions): any;
+    /**
+     * Return whether the element at the array `path` exists.
+     */
+    has(obj: any, paths: PropertyKey[], options?: TraverseOptions): boolean;
+    /**
+     * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+     */
+    map(obj: any, cb: (this: TraverseContext, v: any) => void, options?: TraverseOptions): any;
+    /**
+     * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+     */
+    forEach(obj: any, cb: (this: TraverseContext, v: any) => void, options?: TraverseOptions): any;
+    /**
+     * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+     *
+     * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+     */
+    reduce(obj: any, cb: (this: TraverseContext, acc: any, v: any) => void, init?: any, options?: TraverseOptions): any;
+    /**
+     * Return an `Array` of every possible non-cyclic path in the object.
+     * Paths are `Array`s of string keys.
+     */
+    paths(obj: any, options?: TraverseOptions): PropertyKey[][];
+    /**
+     * Return an `Array` of every node in the object.
+     */
+    nodes(obj: any, options?: TraverseOptions): any[];
+    /**
+     * Create a deep clone of the object.
+     */
+    clone(obj: any, options?: TraverseOptions): any;
+};
+
+export { type TraverseContext, type TraverseOptions, traverse as default };

node_modules/neotraverse/dist/legacy/legacy.d.ts

@@ -0,0 +1,199 @@
+interface TraverseOptions {
+    /**
+     * If true, does not alter the original object
+     */
+    immutable?: boolean;
+    /**
+     * If false, removes all symbols from traversed objects
+     *
+     * @default false
+     */
+    includeSymbols?: boolean;
+}
+interface TraverseContext {
+    /**
+     * The present node on the recursive walk
+     */
+    node: any;
+    /**
+     * An array of string keys from the root to the present node
+     */
+    path: PropertyKey[];
+    /**
+     * The context of the node's parent.
+     * This is `undefined` for the root node.
+     */
+    parent: TraverseContext | undefined;
+    /**
+     * The contexts of the node's parents.
+     */
+    parents: TraverseContext[];
+    /**
+     * The name of the key of the present node in its parent.
+     * This is `undefined` for the root node.
+     */
+    key: PropertyKey | undefined;
+    /**
+     * Whether the present node is the root node
+     */
+    isRoot: boolean;
+    /**
+     * Whether the present node is not the root node
+     */
+    notRoot: boolean;
+    /**
+     * Whether the present node is the last node
+     */
+    isLast: boolean;
+    /**
+     * Whether the present node is the first node
+     */
+    isFirst: boolean;
+    /**
+     * Whether or not the present node is a leaf node (has no children)
+     */
+    isLeaf: boolean;
+    /**
+     * Whether or not the present node is not a leaf node (has children)
+     */
+    notLeaf: boolean;
+    /**
+     * Depth of the node within the traversal
+     */
+    level: number;
+    /**
+     * If the node equals one of its parents, the `circular` attribute is set to the context of that parent and the traversal progresses no deeper.
+     */
+    circular: TraverseContext | undefined;
+    /**
+     * Set a new value for the present node.
+     *
+     * All the elements in `value` will be recursively traversed unless `stopHere` is true (false by default).
+     */
+    update(value: any, stopHere?: boolean): void;
+    /**
+     * Remove the current element from the output. If the node is in an Array it will be spliced off. Otherwise it will be deleted from its parent.
+     */
+    remove(stopHere?: boolean): void;
+    /**
+     * Delete the current element from its parent in the output. Calls `delete` even on Arrays.
+     */
+    delete(stopHere?: boolean): void;
+    /**
+     * Object keys of the node.
+     */
+    keys: PropertyKey[] | null;
+    /**
+     * Call this function before all of the children are traversed.
+     * You can assign into `this.keys` here to traverse in a custom order.
+     */
+    before(callback: (this: TraverseContext, value: any) => void): void;
+    /**
+     * Call this function after all of the children are traversed.
+     */
+    after(callback: (this: TraverseContext, value: any) => void): void;
+    /**
+     * Call this function before each of the children are traversed.
+     */
+    pre(callback: (this: TraverseContext, child: any, key: any) => void): void;
+    /**
+     * Call this function after each of the children are traversed.
+     */
+    post(callback: (this: TraverseContext, child: any) => void): void;
+    /**
+     * Stops traversal entirely.
+     */
+    stop(): void;
+    /**
+     * Prevents traversing descendents of the current node.
+     */
+    block(): void;
+}
+/** @deprecated Import `Traverse` from `neotraverse/modern` instead */
+declare class Traverse {
+    #private;
+    constructor(obj: any, options?: TraverseOptions);
+    /**
+     * Get the element at the array `path`.
+     */
+    get(paths: PropertyKey[]): any;
+    /**
+     * Return whether the element at the array `path` exists.
+     */
+    has(paths: PropertyKey[]): boolean;
+    /**
+     * Set the element at the array `path` to `value`.
+     */
+    set(path: PropertyKey[], value: any): any;
+    /**
+     * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+     */
+    map(cb: (this: TraverseContext, v: any) => void): any;
+    /**
+     * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+     */
+    forEach(cb: (this: TraverseContext, v: any) => void): any;
+    /**
+     * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+     *
+     * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+     */
+    reduce(cb: (this: TraverseContext, acc: any, v: any) => void, init?: any): any;
+    /**
+     * Return an `Array` of every possible non-cyclic path in the object.
+     * Paths are `Array`s of string keys.
+     */
+    paths(): PropertyKey[][];
+    /**
+     * Return an `Array` of every node in the object.
+     */
+    nodes(): any[];
+    /**
+     * Create a deep clone of the object.
+     */
+    clone(): any;
+}
+declare const traverse: {
+    (obj: any, options?: TraverseOptions): Traverse;
+    /**
+     * Get the element at the array `path`.
+     */
+    get(obj: any, paths: PropertyKey[], options?: TraverseOptions): any;
+    /**
+     * Set the element at the array `path` to `value`.
+     */
+    set(obj: any, path: PropertyKey[], value: any, options?: TraverseOptions): any;
+    /**
+     * Return whether the element at the array `path` exists.
+     */
+    has(obj: any, paths: PropertyKey[], options?: TraverseOptions): boolean;
+    /**
+     * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+     */
+    map(obj: any, cb: (this: TraverseContext, v: any) => void, options?: TraverseOptions): any;
+    /**
+     * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+     */
+    forEach(obj: any, cb: (this: TraverseContext, v: any) => void, options?: TraverseOptions): any;
+    /**
+     * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+     *
+     * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+     */
+    reduce(obj: any, cb: (this: TraverseContext, acc: any, v: any) => void, init?: any, options?: TraverseOptions): any;
+    /**
+     * Return an `Array` of every possible non-cyclic path in the object.
+     * Paths are `Array`s of string keys.
+     */
+    paths(obj: any, options?: TraverseOptions): PropertyKey[][];
+    /**
+     * Return an `Array` of every node in the object.
+     */
+    nodes(obj: any, options?: TraverseOptions): any[];
+    /**
+     * Create a deep clone of the object.
+     */
+    clone(obj: any, options?: TraverseOptions): any;
+};
+
+export { type TraverseContext, type TraverseOptions, traverse as default };

node_modules/neotraverse/dist/legacy/legacy.mjs

@@ -0,0 +1,549 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var __typeError = function(msg) {
+    throw TypeError(msg);
+};
+var __accessCheck = function(obj, member, msg) {
+    return member.has(obj) || __typeError("Cannot " + msg);
+};
+var __privateGet = function(obj, member, getter) {
+    return __accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = function(obj, member, value) {
+    return member.has(obj) ? __typeError("Cannot add the same private member more than once") : _instanceof(member, WeakSet) ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = function(obj, member, value, setter) {
+    return __accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value;
+};
+// src/index.ts
+var to_string = function(obj) {
+    return Object.prototype.toString.call(obj);
+};
+var is_typed_array = function(value) {
+    return ArrayBuffer.isView(value) && !_instanceof(value, DataView);
+};
+var is_date = function(obj) {
+    return to_string(obj) === "[object Date]";
+};
+var is_regexp = function(obj) {
+    return to_string(obj) === "[object RegExp]";
+};
+var is_error = function(obj) {
+    return to_string(obj) === "[object Error]";
+};
+var is_boolean = function(obj) {
+    return to_string(obj) === "[object Boolean]";
+};
+var is_number = function(obj) {
+    return to_string(obj) === "[object Number]";
+};
+var is_string = function(obj) {
+    return to_string(obj) === "[object String]";
+};
+var is_array = Array.isArray;
+var gopd = Object.getOwnPropertyDescriptor;
+var is_property_enumerable = Object.prototype.propertyIsEnumerable;
+var get_own_property_symbols = Object.getOwnPropertySymbols;
+var has_own_property = Object.prototype.hasOwnProperty;
+function own_enumerable_keys(obj) {
+    var res = Object.keys(obj);
+    var symbols = get_own_property_symbols(obj);
+    for(var i = 0; i < symbols.length; i++){
+        if (is_property_enumerable.call(obj, symbols[i])) {
+            res.push(symbols[i]);
+        }
+    }
+    return res;
+}
+function is_writable(object, key) {
+    var _gopd;
+    return !((_gopd = gopd(object, key)) === null || _gopd === void 0 ? void 0 : _gopd.writable);
+}
+function copy(src, options) {
+    if ((typeof src === "undefined" ? "undefined" : _type_of(src)) === "object" && src !== null) {
+        var dst;
+        if (is_array(src)) {
+            dst = [];
+        } else if (is_date(src)) {
+            dst = new Date(src.getTime ? src.getTime() : src);
+        } else if (is_regexp(src)) {
+            dst = new RegExp(src);
+        } else if (is_error(src)) {
+            dst = {
+                message: src.message
+            };
+        } else if (is_boolean(src) || is_number(src) || is_string(src)) {
+            dst = Object(src);
+        } else if (is_typed_array(src)) {
+            return src.slice();
+        } else {
+            dst = Object.create(Object.getPrototypeOf(src));
+        }
+        var iterator_function = options.includeSymbols ? own_enumerable_keys : Object.keys;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = iterator_function(src)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var key = _step.value;
+                dst[key] = src[key];
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        return dst;
+    }
+    return src;
+}
+var empty_null = {
+    includeSymbols: false,
+    immutable: false
+};
+function walk(root, cb) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : empty_null;
+    var path = [];
+    var parents = [];
+    var alive = true;
+    var iterator_function = options.includeSymbols ? own_enumerable_keys : Object.keys;
+    var immutable = !!options.immutable;
+    return function walker(node_) {
+        var node = immutable ? copy(node_, options) : node_;
+        var modifiers = {};
+        var keep_going = true;
+        var state = {
+            node: node,
+            node_: node_,
+            path: [].concat(path),
+            parent: parents[parents.length - 1],
+            parents: parents,
+            key: path[path.length - 1],
+            isRoot: path.length === 0,
+            level: path.length,
+            circular: void 0,
+            isLeaf: false,
+            notLeaf: true,
+            notRoot: true,
+            isFirst: false,
+            isLast: false,
+            update: function update(x) {
+                var stopHere = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+                if (!state.isRoot) {
+                    state.parent.node[state.key] = x;
+                }
+                state.node = x;
+                if (stopHere) {
+                    keep_going = false;
+                }
+            },
+            delete: function _delete(stopHere) {
+                delete state.parent.node[state.key];
+                if (stopHere) {
+                    keep_going = false;
+                }
+            },
+            remove: function remove(stopHere) {
+                if (is_array(state.parent.node)) {
+                    state.parent.node.splice(state.key, 1);
+                } else {
+                    delete state.parent.node[state.key];
+                }
+                if (stopHere) {
+                    keep_going = false;
+                }
+            },
+            keys: null,
+            before: function before(f) {
+                modifiers.before = f;
+            },
+            after: function after(f) {
+                modifiers.after = f;
+            },
+            pre: function pre(f) {
+                modifiers.pre = f;
+            },
+            post: function post(f) {
+                modifiers.post = f;
+            },
+            stop: function stop() {
+                alive = false;
+            },
+            block: function block() {
+                keep_going = false;
+            }
+        };
+        if (!alive) {
+            return state;
+        }
+        function update_state() {
+            if (_type_of(state.node) === "object" && state.node !== null) {
+                if (!state.keys || state.node_ !== state.node) {
+                    state.keys = iterator_function(state.node);
+                }
+                state.isLeaf = state.keys.length === 0;
+                for(var i = 0; i < parents.length; i++){
+                    if (parents[i].node_ === node_) {
+                        state.circular = parents[i];
+                        break;
+                    }
+                }
+            } else {
+                state.isLeaf = true;
+                state.keys = null;
+            }
+            state.notLeaf = !state.isLeaf;
+            state.notRoot = !state.isRoot;
+        }
+        update_state();
+        var ret = cb.call(state, state.node);
+        if (ret !== void 0 && state.update) {
+            state.update(ret);
+        }
+        if (modifiers.before) {
+            modifiers.before.call(state, state.node);
+        }
+        if (!keep_going) {
+            return state;
+        }
+        if (_type_of(state.node) === "object" && state.node !== null && !state.circular) {
+            parents.push(state);
+            update_state();
+            var _state_keys;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = Object.entries((_state_keys = state.keys) !== null && _state_keys !== void 0 ? _state_keys : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var _step_value = _sliced_to_array(_step.value, 2), index = _step_value[0], key = _step_value[1];
+                    var _state_keys1;
+                    path.push(key);
+                    if (modifiers.pre) {
+                        modifiers.pre.call(state, state.node[key], key);
+                    }
+                    var child = walker(state.node[key]);
+                    if (immutable && has_own_property.call(state.node, key) && !is_writable(state.node, key)) {
+                        state.node[key] = child.node;
+                    }
+                    child.isLast = ((_state_keys1 = state.keys) === null || _state_keys1 === void 0 ? void 0 : _state_keys1.length) ? +index === state.keys.length - 1 : false;
+                    child.isFirst = +index === 0;
+                    if (modifiers.post) {
+                        modifiers.post.call(state, child);
+                    }
+                    path.pop();
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            parents.pop();
+        }
+        if (modifiers.after) {
+            modifiers.after.call(state, state.node);
+        }
+        return state;
+    }(root).node;
+}
+var _value, _options;
+var Traverse = /*#__PURE__*/ function() {
+    "use strict";
+    function Traverse(obj) {
+        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : empty_null;
+        _class_call_check(this, Traverse);
+        // ! Have to keep these public as legacy mode requires them
+        __privateAdd(this, _value);
+        __privateAdd(this, _options);
+        __privateSet(this, _value, obj);
+        __privateSet(this, _options, options);
+    }
+    _create_class(Traverse, [
+        {
+            /**
+   * Get the element at the array `path`.
+   */ key: "get",
+            value: function get(paths) {
+                var node = __privateGet(this, _value);
+                for(var i = 0; node && i < paths.length; i++){
+                    var key = paths[i];
+                    if (!has_own_property.call(node, key) || !__privateGet(this, _options).includeSymbols && (typeof key === "undefined" ? "undefined" : _type_of(key)) === "symbol") {
+                        return void 0;
+                    }
+                    node = node[key];
+                }
+                return node;
+            }
+        },
+        {
+            /**
+   * Return whether the element at the array `path` exists.
+   */ key: "has",
+            value: function has(paths) {
+                var node = __privateGet(this, _value);
+                for(var i = 0; node && i < paths.length; i++){
+                    var key = paths[i];
+                    if (!has_own_property.call(node, key) || !__privateGet(this, _options).includeSymbols && (typeof key === "undefined" ? "undefined" : _type_of(key)) === "symbol") {
+                        return false;
+                    }
+                    node = node[key];
+                }
+                return true;
+            }
+        },
+        {
+            /**
+   * Set the element at the array `path` to `value`.
+   */ key: "set",
+            value: function set(path, value) {
+                var node = __privateGet(this, _value);
+                var i = 0;
+                for(i = 0; i < path.length - 1; i++){
+                    var key = path[i];
+                    if (!has_own_property.call(node, key)) {
+                        node[key] = {};
+                    }
+                    node = node[key];
+                }
+                node[path[i]] = value;
+                return value;
+            }
+        },
+        {
+            /**
+   * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+   */ key: "map",
+            value: function map(cb) {
+                return walk(__privateGet(this, _value), cb, {
+                    immutable: true,
+                    includeSymbols: !!__privateGet(this, _options).includeSymbols
+                });
+            }
+        },
+        {
+            /**
+   * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+   */ key: "forEach",
+            value: function forEach(cb) {
+                __privateSet(this, _value, walk(__privateGet(this, _value), cb, __privateGet(this, _options)));
+                return __privateGet(this, _value);
+            }
+        },
+        {
+            /**
+   * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+   *
+   * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+   */ key: "reduce",
+            value: function reduce(cb, init) {
+                var skip = arguments.length === 1;
+                var acc = skip ? __privateGet(this, _value) : init;
+                this.forEach(function(x) {
+                    if (!this.isRoot || !skip) {
+                        acc = cb.call(this, acc, x);
+                    }
+                });
+                return acc;
+            }
+        },
+        {
+            /**
+   * Return an `Array` of every possible non-cyclic path in the object.
+   * Paths are `Array`s of string keys.
+   */ key: "paths",
+            value: function paths() {
+                var acc = [];
+                this.forEach(function() {
+                    acc.push(this.path);
+                });
+                return acc;
+            }
+        },
+        {
+            /**
+   * Return an `Array` of every node in the object.
+   */ key: "nodes",
+            value: function nodes() {
+                var acc = [];
+                this.forEach(function() {
+                    acc.push(this.node);
+                });
+                return acc;
+            }
+        },
+        {
+            /**
+   * Create a deep clone of the object.
+   */ key: "clone",
+            value: function clone() {
+                var parents = [];
+                var nodes = [];
+                var options = __privateGet(this, _options);
+                if (is_typed_array(__privateGet(this, _value))) {
+                    return __privateGet(this, _value).slice();
+                }
+                return function clone(src) {
+                    for(var i = 0; i < parents.length; i++){
+                        if (parents[i] === src) {
+                            return nodes[i];
+                        }
+                    }
+                    if ((typeof src === "undefined" ? "undefined" : _type_of(src)) === "object" && src !== null) {
+                        var dst = copy(src, options);
+                        parents.push(src);
+                        nodes.push(dst);
+                        var iteratorFunction = options.includeSymbols ? own_enumerable_keys : Object.keys;
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = iteratorFunction(src)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var key = _step.value;
+                                dst[key] = clone(src[key]);
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        parents.pop();
+                        nodes.pop();
+                        return dst;
+                    }
+                    return src;
+                }(__privateGet(this, _value));
+            }
+        }
+    ]);
+    return Traverse;
+}();
+_value = new WeakMap();
+_options = new WeakMap();
+var traverse = function(obj, options) {
+    return new Traverse(obj, options);
+};
+traverse.get = function(obj, paths, options) {
+    return new Traverse(obj, options).get(paths);
+};
+traverse.set = function(obj, path, value, options) {
+    return new Traverse(obj, options).set(path, value);
+};
+traverse.has = function(obj, paths, options) {
+    return new Traverse(obj, options).has(paths);
+};
+traverse.map = function(obj, cb, options) {
+    return new Traverse(obj, options).map(cb);
+};
+traverse.forEach = function(obj, cb, options) {
+    return new Traverse(obj, options).forEach(cb);
+};
+traverse.reduce = function(obj, cb, init, options) {
+    return new Traverse(obj, options).reduce(cb, init);
+};
+traverse.paths = function(obj, options) {
+    return new Traverse(obj, options).paths();
+};
+traverse.nodes = function(obj, options) {
+    return new Traverse(obj, options).nodes();
+};
+traverse.clone = function(obj, options) {
+    return new Traverse(obj, options).clone();
+};
+var src_default = traverse;
+// src/legacy.cts
+
+export { src_default as default };

node_modules/neotraverse/dist/min/index.js

@@ -0,0 +1 @@
+var e=e=>Object.prototype.toString.call(e),t=e=>ArrayBuffer.isView(e)&&!(e instanceof DataView),o=t=>"[object Date]"===e(t),n=t=>"[object RegExp]"===e(t),s=t=>"[object Error]"===e(t),r=t=>"[object Boolean]"===e(t),l=t=>"[object Number]"===e(t),c=t=>"[object String]"===e(t),i=Array.isArray,a=Object.getOwnPropertyDescriptor,u=Object.prototype.propertyIsEnumerable,f=Object.getOwnPropertySymbols,p=Object.prototype.hasOwnProperty;function h(e){const t=Object.keys(e),o=f(e);for(let n=0;n<o.length;n++)u.call(e,o[n])&&t.push(o[n]);return t}function d(e,t){return!a(e,t)?.writable}function b(e,a){if("object"==typeof e&&null!==e){let u;if(i(e))u=[];else if(o(e))u=new Date(e.getTime?e.getTime():e);else if(n(e))u=new RegExp(e);else if(s(e))u={message:e.message};else if(r(e)||l(e)||c(e))u=Object(e);else{if(t(e))return e.slice();u=Object.create(Object.getPrototypeOf(e))}const f=a.includeSymbols?h:Object.keys;for(const t of f(e))u[t]=e[t];return u}return e}var y={includeSymbols:!1,immutable:!1};function g(e,t,o=y){const n=[],s=[];let r=!0;const l=o.includeSymbols?h:Object.keys,c=!!o.immutable;return function e(a){const u=c?b(a,o):a,f={};let h=!0;const y={node:u,node_:a,path:[].concat(n),parent:s[s.length-1],parents:s,key:n[n.length-1],isRoot:0===n.length,level:n.length,circular:void 0,isLeaf:!1,notLeaf:!0,notRoot:!0,isFirst:!1,isLast:!1,update:function(e,t=!1){y.isRoot||(y.parent.node[y.key]=e),y.node=e,t&&(h=!1)},delete:function(e){delete y.parent.node[y.key],e&&(h=!1)},remove:function(e){i(y.parent.node)?y.parent.node.splice(y.key,1):delete y.parent.node[y.key],e&&(h=!1)},keys:null,before:function(e){f.before=e},after:function(e){f.after=e},pre:function(e){f.pre=e},post:function(e){f.post=e},stop:function(){r=!1},block:function(){h=!1}};if(!r)return y;function g(){if("object"==typeof y.node&&null!==y.node){y.keys&&y.node_===y.node||(y.keys=l(y.node)),y.isLeaf=0===y.keys.length;for(let e=0;e<s.length;e++)if(s[e].node_===a){y.circular=s[e];break}}else y.isLeaf=!0,y.keys=null;y.notLeaf=!y.isLeaf,y.notRoot=!y.isRoot}g();const m=t.call(y,y.node);if(void 0!==m&&y.update&&y.update(m),f.before&&f.before.call(y,y.node),!h)return y;if("object"==typeof y.node&&null!==y.node&&!y.circular){s.push(y),g();for(const[t,o]of Object.entries(y.keys??[])){n.push(o),f.pre&&f.pre.call(y,y.node[o],o);const s=e(y.node[o]);c&&p.call(y.node,o)&&!d(y.node,o)&&(y.node[o]=s.node),s.isLast=!!y.keys?.length&&+t==y.keys.length-1,s.isFirst=0==+t,f.post&&f.post.call(y,s),n.pop()}s.pop()}return f.after&&f.after.call(y,y.node),y}(e).node}var m=class{#e;#t;constructor(e,t=y){this.#e=e,this.#t=t}get(e){let t=this.#e;for(let o=0;t&&o<e.length;o++){const n=e[o];if(!p.call(t,n)||!this.#t.includeSymbols&&"symbol"==typeof n)return;t=t[n]}return t}has(e){let t=this.#e;for(let o=0;t&&o<e.length;o++){const n=e[o];if(!p.call(t,n)||!this.#t.includeSymbols&&"symbol"==typeof n)return!1;t=t[n]}return!0}set(e,t){let o=this.#e,n=0;for(n=0;n<e.length-1;n++){const t=e[n];p.call(o,t)||(o[t]={}),o=o[t]}return o[e[n]]=t,t}map(e){return g(this.#e,e,{immutable:!0,includeSymbols:!!this.#t.includeSymbols})}forEach(e){return this.#e=g(this.#e,e,this.#t),this.#e}reduce(e,t){const o=1===arguments.length;let n=o?this.#e:t;return this.forEach((function(t){this.isRoot&&o||(n=e.call(this,n,t))})),n}paths(){const e=[];return this.forEach((function(){e.push(this.path)})),e}nodes(){const e=[];return this.forEach((function(){e.push(this.node)})),e}clone(){const e=[],o=[],n=this.#t;return t(this.#e)?this.#e.slice():function t(s){for(let t=0;t<e.length;t++)if(e[t]===s)return o[t];if("object"==typeof s&&null!==s){const r=b(s,n);e.push(s),o.push(r);const l=n.includeSymbols?h:Object.keys;for(const e of l(s))r[e]=t(s[e]);return e.pop(),o.pop(),r}return s}(this.#e)}},j=(e,t)=>new m(e,t);j.get=(e,t,o)=>new m(e,o).get(t),j.set=(e,t,o,n)=>new m(e,n).set(t,o),j.has=(e,t,o)=>new m(e,o).has(t),j.map=(e,t,o)=>new m(e,o).map(t),j.forEach=(e,t,o)=>new m(e,o).forEach(t),j.reduce=(e,t,o,n)=>new m(e,n).reduce(t,o),j.paths=(e,t)=>new m(e,t).paths(),j.nodes=(e,t)=>new m(e,t).nodes(),j.clone=(e,t)=>new m(e,t).clone();var v=j;export{m as Traverse,v as default};

node_modules/neotraverse/dist/modern/min/modern.js

@@ -0,0 +1 @@
+var e=e=>Object.prototype.toString.call(e),t=e=>ArrayBuffer.isView(e)&&!(e instanceof DataView),o=t=>"[object Date]"===e(t),n=t=>"[object RegExp]"===e(t),r=t=>"[object Error]"===e(t),s=t=>"[object Boolean]"===e(t),l=t=>"[object Number]"===e(t),i=t=>"[object String]"===e(t),c=Array.isArray,u=Object.getOwnPropertyDescriptor,a=Object.prototype.propertyIsEnumerable,f=Object.getOwnPropertySymbols,p=Object.prototype.hasOwnProperty,h=Object.keys;function d(e){const t=h(e),o=f(e);for(let n=0;n<o.length;n++)a.call(e,o[n])&&t.push(o[n]);return t}function b(e,t){return!u(e,t)?.writable}function y(e,u){if("object"==typeof e&&null!==e){let a;if(c(e))a=[];else if(o(e))a=new Date(e.getTime?e.getTime():e);else if(n(e))a=new RegExp(e);else if(r(e))a={message:e.message};else if(s(e)||l(e)||i(e))a=Object(e);else{if(t(e))return e.slice();a=Object.create(Object.getPrototypeOf(e))}const f=u.includeSymbols?d:h;for(const t of f(e))a[t]=e[t];return a}return e}var g={includeSymbols:!1,immutable:!1};function m(e,t,o=g){const n=[],r=[];let s=!0;const l=o.includeSymbols?d:h,i=!!o.immutable;return function e(u){const a=i?y(u,o):u,f={};let h=!0;const d={node:a,node_:u,path:[].concat(n),parent:r[r.length-1],parents:r,key:n[n.length-1],isRoot:0===n.length,level:n.length,circular:void 0,isLeaf:!1,notLeaf:!0,notRoot:!0,isFirst:!1,isLast:!1,update:function(e,t=!1){d.isRoot||(d.parent.node[d.key]=e),d.node=e,t&&(h=!1)},delete:function(e){delete d.parent.node[d.key],e&&(h=!1)},remove:function(e){c(d.parent.node)?d.parent.node.splice(d.key,1):delete d.parent.node[d.key],e&&(h=!1)},keys:null,before:function(e){f.before=e},after:function(e){f.after=e},pre:function(e){f.pre=e},post:function(e){f.post=e},stop:function(){s=!1},block:function(){h=!1}};if(!s)return d;function g(){if("object"==typeof d.node&&null!==d.node){d.keys&&d.node_===d.node||(d.keys=l(d.node)),d.isLeaf=0===d.keys.length;for(let e=0;e<r.length;e++)if(r[e].node_===u){d.circular=r[e];break}}else d.isLeaf=!0,d.keys=null;d.notLeaf=!d.isLeaf,d.notRoot=!d.isRoot}g();const m=t(d,d.node);if(void 0!==m&&d.update&&d.update(m),f.before&&f.before(d,d.node),!h)return d;if("object"==typeof d.node&&null!==d.node&&!d.circular){r.push(d),g();for(const[t,o]of Object.entries(d.keys??[])){n.push(o),f.pre&&f.pre(d,d.node[o],o);const r=e(d.node[o]);i&&p.call(d.node,o)&&!b(d.node,o)&&(d.node[o]=r.node),r.isLast=!!d.keys?.length&&+t==d.keys.length-1,r.isFirst=0==+t,f.post&&f.post(d,r),n.pop()}r.pop()}return f.after&&f.after(d,d.node),d}(e).node}var j=class{#e;#t;constructor(e,t=g){this.#e=e,this.#t=t}get(e){let t=this.#e;for(let o=0;t&&o<e.length;o++){const n=e[o];if(!p.call(t,n)||!this.#t.includeSymbols&&"symbol"==typeof n)return;t=t[n]}return t}has(e){let t=this.#e;for(let o=0;t&&o<e.length;o++){const n=e[o];if(!p.call(t,n)||!this.#t.includeSymbols&&"symbol"==typeof n)return!1;t=t[n]}return!0}set(e,t){let o=this.#e,n=0;for(n=0;n<e.length-1;n++){const t=e[n];p.call(o,t)||(o[t]={}),o=o[t]}return o[e[n]]=t,t}map(e){return m(this.#e,e,{immutable:!0,includeSymbols:!!this.#t.includeSymbols})}forEach(e){return this.#e=m(this.#e,e,this.#t),this.#e}reduce(e,t){const o=1===arguments.length;let n=o?this.#e:t;return this.forEach(((t,r)=>{t.isRoot&&o||(n=e(t,n,r))})),n}paths(){const e=[];return this.forEach((t=>{e.push(t.path)})),e}nodes(){const e=[];return this.forEach((t=>{e.push(t.node)})),e}clone(){const e=[],o=[],n=this.#t;return t(this.#e)?this.#e.slice():function t(r){for(let t=0;t<e.length;t++)if(e[t]===r)return o[t];if("object"==typeof r&&null!==r){const s=y(r,n);e.push(r),o.push(s);const l=n.includeSymbols?d:h;for(const e of l(r))s[e]=t(r[e]);return e.pop(),o.pop(),s}return r}(this.#e)}};export{j as Traverse};

node_modules/neotraverse/dist/modern/modern.d.ts

@@ -0,0 +1,156 @@
+interface TraverseOptions {
+    /**
+     * If true, does not alter the original object
+     */
+    immutable?: boolean;
+    /**
+     * If false, removes all symbols from traversed objects
+     *
+     * @default false
+     */
+    includeSymbols?: boolean;
+}
+interface TraverseContext {
+    /**
+     * The present node on the recursive walk
+     */
+    node: any;
+    /**
+     * An array of string keys from the root to the present node
+     */
+    path: PropertyKey[];
+    /**
+     * The context of the node's parent.
+     * This is `undefined` for the root node.
+     */
+    parent: TraverseContext | undefined;
+    /**
+     * The contexts of the node's parents.
+     */
+    parents: TraverseContext[];
+    /**
+     * The name of the key of the present node in its parent.
+     * This is `undefined` for the root node.
+     */
+    key: PropertyKey | undefined;
+    /**
+     * Whether the present node is the root node
+     */
+    isRoot: boolean;
+    /**
+     * Whether the present node is not the root node
+     */
+    notRoot: boolean;
+    /**
+     * Whether the present node is the last node
+     */
+    isLast: boolean;
+    /**
+     * Whether the present node is the first node
+     */
+    isFirst: boolean;
+    /**
+     * Whether or not the present node is a leaf node (has no children)
+     */
+    isLeaf: boolean;
+    /**
+     * Whether or not the present node is not a leaf node (has children)
+     */
+    notLeaf: boolean;
+    /**
+     * Depth of the node within the traversal
+     */
+    level: number;
+    /**
+     * If the node equals one of its parents, the `circular` attribute is set to the context of that parent and the traversal progresses no deeper.
+     */
+    circular: TraverseContext | undefined;
+    /**
+     * Set a new value for the present node.
+     *
+     * All the elements in `value` will be recursively traversed unless `stopHere` is true (false by default).
+     */
+    update(value: any, stopHere?: boolean): void;
+    /**
+     * Remove the current element from the output. If the node is in an Array it will be spliced off. Otherwise it will be deleted from its parent.
+     */
+    remove(stopHere?: boolean): void;
+    /**
+     * Delete the current element from its parent in the output. Calls `delete` even on Arrays.
+     */
+    delete(stopHere?: boolean): void;
+    /**
+     * Object keys of the node.
+     */
+    keys: PropertyKey[] | null;
+    /**
+     * Call this function before all of the children are traversed.
+     * You can assign into `ctx.keys` here to traverse in a custom order.
+     */
+    before(callback: (ctx: TraverseContext, value: any) => void): void;
+    /**
+     * Call this function after all of the children are traversed.
+     */
+    after(callback: (ctx: TraverseContext, value: any) => void): void;
+    /**
+     * Call this function before each of the children are traversed.
+     */
+    pre(callback: (ctx: TraverseContext, child: any, key: any) => void): void;
+    /**
+     * Call this function after each of the children are traversed.
+     */
+    post(callback: (ctx: TraverseContext, child: any) => void): void;
+    /**
+     * Stops traversal entirely.
+     */
+    stop(): void;
+    /**
+     * Prevents traversing descendents of the current node.
+     */
+    block(): void;
+}
+declare class Traverse {
+    #private;
+    constructor(obj: any, options?: TraverseOptions);
+    /**
+     * Get the element at the array `path`.
+     */
+    get(paths: PropertyKey[]): any;
+    /**
+     * Return whether the element at the array `path` exists.
+     */
+    has(paths: PropertyKey[]): boolean;
+    /**
+     * Set the element at the array `path` to `value`.
+     */
+    set(path: PropertyKey[], value: any): any;
+    /**
+     * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+     */
+    map(cb: (ctx: TraverseContext, v: any) => void): any;
+    /**
+     * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+     */
+    forEach(cb: (ctx: TraverseContext, v: any) => void): any;
+    /**
+     * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+     *
+     * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+     */
+    reduce(cb: (ctx: TraverseContext, acc: any, v: any) => void, init?: any): any;
+    /**
+     * Return an `Array` of every possible non-cyclic path in the object.
+     * Paths are `Array`s of string keys.
+     */
+    paths(): PropertyKey[][];
+    /**
+     * Return an `Array` of every node in the object.
+     */
+    nodes(): any[];
+    /**
+     * Create a deep clone of the object.
+     */
+    clone(): any;
+}
+
+export { Traverse, type TraverseContext, type TraverseOptions };

node_modules/neotraverse/dist/modern/modern.js

@@ -0,0 +1,326 @@
+// src/modern.ts
+var to_string = (obj) => Object.prototype.toString.call(obj);
+var is_typed_array = (value) => ArrayBuffer.isView(value) && !(value instanceof DataView);
+var is_date = (obj) => to_string(obj) === "[object Date]";
+var is_regexp = (obj) => to_string(obj) === "[object RegExp]";
+var is_error = (obj) => to_string(obj) === "[object Error]";
+var is_boolean = (obj) => to_string(obj) === "[object Boolean]";
+var is_number = (obj) => to_string(obj) === "[object Number]";
+var is_string = (obj) => to_string(obj) === "[object String]";
+var is_array = Array.isArray;
+var gopd = Object.getOwnPropertyDescriptor;
+var is_property_enumerable = Object.prototype.propertyIsEnumerable;
+var get_own_property_symbols = Object.getOwnPropertySymbols;
+var has_own_property = Object.prototype.hasOwnProperty;
+var object_keys = Object.keys;
+function own_enumerable_keys(obj) {
+  const res = object_keys(obj);
+  const symbols = get_own_property_symbols(obj);
+  for (let i = 0; i < symbols.length; i++) {
+    if (is_property_enumerable.call(obj, symbols[i])) {
+      res.push(symbols[i]);
+    }
+  }
+  return res;
+}
+function is_writable(object, key) {
+  return !gopd(object, key)?.writable;
+}
+function copy(src, options) {
+  if (typeof src === "object" && src !== null) {
+    let dst;
+    if (is_array(src)) {
+      dst = [];
+    } else if (is_date(src)) {
+      dst = new Date(src.getTime ? src.getTime() : src);
+    } else if (is_regexp(src)) {
+      dst = new RegExp(src);
+    } else if (is_error(src)) {
+      dst = { message: src.message };
+    } else if (is_boolean(src) || is_number(src) || is_string(src)) {
+      dst = Object(src);
+    } else if (is_typed_array(src)) {
+      return src.slice();
+    } else {
+      dst = Object.create(Object.getPrototypeOf(src));
+    }
+    const iterator_function = options.includeSymbols ? own_enumerable_keys : object_keys;
+    for (const key of iterator_function(src)) {
+      dst[key] = src[key];
+    }
+    return dst;
+  }
+  return src;
+}
+var empty_null = {
+  includeSymbols: false,
+  immutable: false
+};
+function walk(root, cb, options = empty_null) {
+  const path = [];
+  const parents = [];
+  let alive = true;
+  const iterator_function = options.includeSymbols ? own_enumerable_keys : object_keys;
+  const immutable = !!options.immutable;
+  return function walker(node_) {
+    const node = immutable ? copy(node_, options) : node_;
+    const modifiers = {};
+    let keep_going = true;
+    const state = {
+      node,
+      node_,
+      path: [].concat(path),
+      parent: parents[parents.length - 1],
+      parents,
+      key: path[path.length - 1],
+      isRoot: path.length === 0,
+      level: path.length,
+      circular: void 0,
+      isLeaf: false,
+      notLeaf: true,
+      notRoot: true,
+      isFirst: false,
+      isLast: false,
+      update: function(x, stopHere = false) {
+        if (!state.isRoot) {
+          state.parent.node[state.key] = x;
+        }
+        state.node = x;
+        if (stopHere) {
+          keep_going = false;
+        }
+      },
+      delete: function(stopHere) {
+        delete state.parent.node[state.key];
+        if (stopHere) {
+          keep_going = false;
+        }
+      },
+      remove: function(stopHere) {
+        if (is_array(state.parent.node)) {
+          state.parent.node.splice(state.key, 1);
+        } else {
+          delete state.parent.node[state.key];
+        }
+        if (stopHere) {
+          keep_going = false;
+        }
+      },
+      keys: null,
+      before: function(f) {
+        modifiers.before = f;
+      },
+      after: function(f) {
+        modifiers.after = f;
+      },
+      pre: function(f) {
+        modifiers.pre = f;
+      },
+      post: function(f) {
+        modifiers.post = f;
+      },
+      stop: function() {
+        alive = false;
+      },
+      block: function() {
+        keep_going = false;
+      }
+    };
+    if (!alive) {
+      return state;
+    }
+    function update_state() {
+      if (typeof state.node === "object" && state.node !== null) {
+        if (!state.keys || state.node_ !== state.node) {
+          state.keys = iterator_function(state.node);
+        }
+        state.isLeaf = state.keys.length === 0;
+        for (let i = 0; i < parents.length; i++) {
+          if (parents[i].node_ === node_) {
+            state.circular = parents[i];
+            break;
+          }
+        }
+      } else {
+        state.isLeaf = true;
+        state.keys = null;
+      }
+      state.notLeaf = !state.isLeaf;
+      state.notRoot = !state.isRoot;
+    }
+    update_state();
+    const ret = cb(state, state.node);
+    if (ret !== void 0 && state.update) {
+      state.update(ret);
+    }
+    if (modifiers.before) {
+      modifiers.before(state, state.node);
+    }
+    if (!keep_going) {
+      return state;
+    }
+    if (typeof state.node === "object" && state.node !== null && !state.circular) {
+      parents.push(state);
+      update_state();
+      for (const [index, key] of Object.entries(state.keys ?? [])) {
+        path.push(key);
+        if (modifiers.pre) {
+          modifiers.pre(state, state.node[key], key);
+        }
+        const child = walker(state.node[key]);
+        if (immutable && has_own_property.call(state.node, key) && !is_writable(state.node, key)) {
+          state.node[key] = child.node;
+        }
+        child.isLast = state.keys?.length ? +index === state.keys.length - 1 : false;
+        child.isFirst = +index === 0;
+        if (modifiers.post) {
+          modifiers.post(state, child);
+        }
+        path.pop();
+      }
+      parents.pop();
+    }
+    if (modifiers.after) {
+      modifiers.after(state, state.node);
+    }
+    return state;
+  }(root).node;
+}
+var Traverse = class {
+  #value;
+  #options;
+  constructor(obj, options = empty_null) {
+    this.#value = obj;
+    this.#options = options;
+  }
+  /**
+   * Get the element at the array `path`.
+   */
+  get(paths) {
+    let node = this.#value;
+    for (let i = 0; node && i < paths.length; i++) {
+      const key = paths[i];
+      if (!has_own_property.call(node, key) || !this.#options.includeSymbols && typeof key === "symbol") {
+        return void 0;
+      }
+      node = node[key];
+    }
+    return node;
+  }
+  /**
+   * Return whether the element at the array `path` exists.
+   */
+  has(paths) {
+    let node = this.#value;
+    for (let i = 0; node && i < paths.length; i++) {
+      const key = paths[i];
+      if (!has_own_property.call(node, key) || !this.#options.includeSymbols && typeof key === "symbol") {
+        return false;
+      }
+      node = node[key];
+    }
+    return true;
+  }
+  /**
+   * Set the element at the array `path` to `value`.
+   */
+  set(path, value) {
+    let node = this.#value;
+    let i = 0;
+    for (i = 0; i < path.length - 1; i++) {
+      const key = path[i];
+      if (!has_own_property.call(node, key)) {
+        node[key] = {};
+      }
+      node = node[key];
+    }
+    node[path[i]] = value;
+    return value;
+  }
+  /**
+   * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+   */
+  map(cb) {
+    return walk(this.#value, cb, {
+      immutable: true,
+      includeSymbols: !!this.#options.includeSymbols
+    });
+  }
+  /**
+   * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+   */
+  forEach(cb) {
+    this.#value = walk(this.#value, cb, this.#options);
+    return this.#value;
+  }
+  /**
+   * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+   *
+   * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+   */
+  reduce(cb, init) {
+    const skip = arguments.length === 1;
+    let acc = skip ? this.#value : init;
+    this.forEach((ctx, x) => {
+      if (!ctx.isRoot || !skip) {
+        acc = cb(ctx, acc, x);
+      }
+    });
+    return acc;
+  }
+  /**
+   * Return an `Array` of every possible non-cyclic path in the object.
+   * Paths are `Array`s of string keys.
+   */
+  paths() {
+    const acc = [];
+    this.forEach((ctx) => {
+      acc.push(ctx.path);
+    });
+    return acc;
+  }
+  /**
+   * Return an `Array` of every node in the object.
+   */
+  nodes() {
+    const acc = [];
+    this.forEach((ctx) => {
+      acc.push(ctx.node);
+    });
+    return acc;
+  }
+  /**
+   * Create a deep clone of the object.
+   */
+  clone() {
+    const parents = [];
+    const nodes = [];
+    const options = this.#options;
+    if (is_typed_array(this.#value)) {
+      return this.#value.slice();
+    }
+    return function clone(src) {
+      for (let i = 0; i < parents.length; i++) {
+        if (parents[i] === src) {
+          return nodes[i];
+        }
+      }
+      if (typeof src === "object" && src !== null) {
+        const dst = copy(src, options);
+        parents.push(src);
+        nodes.push(dst);
+        const iteratorFunction = options.includeSymbols ? own_enumerable_keys : object_keys;
+        for (const key of iteratorFunction(src)) {
+          dst[key] = clone(src[key]);
+        }
+        parents.pop();
+        nodes.pop();
+        return dst;
+      }
+      return src;
+    }(this.#value);
+  }
+};
+export {
+  Traverse
+};

node_modules/neotraverse/legacy.d.ts

@@ -0,0 +1,199 @@
+interface TraverseOptions {
+    /**
+     * If true, does not alter the original object
+     */
+    immutable?: boolean;
+    /**
+     * If false, removes all symbols from traversed objects
+     *
+     * @default false
+     */
+    includeSymbols?: boolean;
+}
+interface TraverseContext {
+    /**
+     * The present node on the recursive walk
+     */
+    node: any;
+    /**
+     * An array of string keys from the root to the present node
+     */
+    path: PropertyKey[];
+    /**
+     * The context of the node's parent.
+     * This is `undefined` for the root node.
+     */
+    parent: TraverseContext | undefined;
+    /**
+     * The contexts of the node's parents.
+     */
+    parents: TraverseContext[];
+    /**
+     * The name of the key of the present node in its parent.
+     * This is `undefined` for the root node.
+     */
+    key: PropertyKey | undefined;
+    /**
+     * Whether the present node is the root node
+     */
+    isRoot: boolean;
+    /**
+     * Whether the present node is not the root node
+     */
+    notRoot: boolean;
+    /**
+     * Whether the present node is the last node
+     */
+    isLast: boolean;
+    /**
+     * Whether the present node is the first node
+     */
+    isFirst: boolean;
+    /**
+     * Whether or not the present node is a leaf node (has no children)
+     */
+    isLeaf: boolean;
+    /**
+     * Whether or not the present node is not a leaf node (has children)
+     */
+    notLeaf: boolean;
+    /**
+     * Depth of the node within the traversal
+     */
+    level: number;
+    /**
+     * If the node equals one of its parents, the `circular` attribute is set to the context of that parent and the traversal progresses no deeper.
+     */
+    circular: TraverseContext | undefined;
+    /**
+     * Set a new value for the present node.
+     *
+     * All the elements in `value` will be recursively traversed unless `stopHere` is true (false by default).
+     */
+    update(value: any, stopHere?: boolean): void;
+    /**
+     * Remove the current element from the output. If the node is in an Array it will be spliced off. Otherwise it will be deleted from its parent.
+     */
+    remove(stopHere?: boolean): void;
+    /**
+     * Delete the current element from its parent in the output. Calls `delete` even on Arrays.
+     */
+    delete(stopHere?: boolean): void;
+    /**
+     * Object keys of the node.
+     */
+    keys: PropertyKey[] | null;
+    /**
+     * Call this function before all of the children are traversed.
+     * You can assign into `this.keys` here to traverse in a custom order.
+     */
+    before(callback: (this: TraverseContext, value: any) => void): void;
+    /**
+     * Call this function after all of the children are traversed.
+     */
+    after(callback: (this: TraverseContext, value: any) => void): void;
+    /**
+     * Call this function before each of the children are traversed.
+     */
+    pre(callback: (this: TraverseContext, child: any, key: any) => void): void;
+    /**
+     * Call this function after each of the children are traversed.
+     */
+    post(callback: (this: TraverseContext, child: any) => void): void;
+    /**
+     * Stops traversal entirely.
+     */
+    stop(): void;
+    /**
+     * Prevents traversing descendents of the current node.
+     */
+    block(): void;
+}
+/** @deprecated Import `Traverse` from `neotraverse/modern` instead */
+declare class Traverse {
+    #private;
+    constructor(obj: any, options?: TraverseOptions);
+    /**
+     * Get the element at the array `path`.
+     */
+    get(paths: PropertyKey[]): any;
+    /**
+     * Return whether the element at the array `path` exists.
+     */
+    has(paths: PropertyKey[]): boolean;
+    /**
+     * Set the element at the array `path` to `value`.
+     */
+    set(path: PropertyKey[], value: any): any;
+    /**
+     * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+     */
+    map(cb: (this: TraverseContext, v: any) => void): any;
+    /**
+     * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+     */
+    forEach(cb: (this: TraverseContext, v: any) => void): any;
+    /**
+     * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+     *
+     * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+     */
+    reduce(cb: (this: TraverseContext, acc: any, v: any) => void, init?: any): any;
+    /**
+     * Return an `Array` of every possible non-cyclic path in the object.
+     * Paths are `Array`s of string keys.
+     */
+    paths(): PropertyKey[][];
+    /**
+     * Return an `Array` of every node in the object.
+     */
+    nodes(): any[];
+    /**
+     * Create a deep clone of the object.
+     */
+    clone(): any;
+}
+declare const traverse: {
+    (obj: any, options?: TraverseOptions): Traverse;
+    /**
+     * Get the element at the array `path`.
+     */
+    get(obj: any, paths: PropertyKey[], options?: TraverseOptions): any;
+    /**
+     * Set the element at the array `path` to `value`.
+     */
+    set(obj: any, path: PropertyKey[], value: any, options?: TraverseOptions): any;
+    /**
+     * Return whether the element at the array `path` exists.
+     */
+    has(obj: any, paths: PropertyKey[], options?: TraverseOptions): boolean;
+    /**
+     * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+     */
+    map(obj: any, cb: (this: TraverseContext, v: any) => void, options?: TraverseOptions): any;
+    /**
+     * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+     */
+    forEach(obj: any, cb: (this: TraverseContext, v: any) => void, options?: TraverseOptions): any;
+    /**
+     * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+     *
+     * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+     */
+    reduce(obj: any, cb: (this: TraverseContext, acc: any, v: any) => void, init?: any, options?: TraverseOptions): any;
+    /**
+     * Return an `Array` of every possible non-cyclic path in the object.
+     * Paths are `Array`s of string keys.
+     */
+    paths(obj: any, options?: TraverseOptions): PropertyKey[][];
+    /**
+     * Return an `Array` of every node in the object.
+     */
+    nodes(obj: any, options?: TraverseOptions): any[];
+    /**
+     * Create a deep clone of the object.
+     */
+    clone(obj: any, options?: TraverseOptions): any;
+};
+
+export { type TraverseContext, type TraverseOptions, traverse as default };

node_modules/neotraverse/legacy.js

@@ -0,0 +1,602 @@
+"use strict";
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = function(msg) {
+    throw TypeError(msg);
+};
+var __export = function(target, all) {
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true
+    });
+};
+var __copyProps = function(to, from, except, desc) {
+    if (from && (typeof from === "undefined" ? "undefined" : _type_of(from)) === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toCommonJS = function(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
+};
+var __accessCheck = function(obj, member, msg) {
+    return member.has(obj) || __typeError("Cannot " + msg);
+};
+var __privateGet = function(obj, member, getter) {
+    return __accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = function(obj, member, value) {
+    return member.has(obj) ? __typeError("Cannot add the same private member more than once") : _instanceof(member, WeakSet) ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = function(obj, member, value, setter) {
+    return __accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value;
+};
+// src/legacy.cts
+var legacy_exports = {};
+__export(legacy_exports, {
+    default: function() {
+        return src_default;
+    }
+});
+module.exports = __toCommonJS(legacy_exports);
+// src/index.ts
+var to_string = function(obj) {
+    return Object.prototype.toString.call(obj);
+};
+var is_typed_array = function(value) {
+    return ArrayBuffer.isView(value) && !_instanceof(value, DataView);
+};
+var is_date = function(obj) {
+    return to_string(obj) === "[object Date]";
+};
+var is_regexp = function(obj) {
+    return to_string(obj) === "[object RegExp]";
+};
+var is_error = function(obj) {
+    return to_string(obj) === "[object Error]";
+};
+var is_boolean = function(obj) {
+    return to_string(obj) === "[object Boolean]";
+};
+var is_number = function(obj) {
+    return to_string(obj) === "[object Number]";
+};
+var is_string = function(obj) {
+    return to_string(obj) === "[object String]";
+};
+var is_array = Array.isArray;
+var gopd = Object.getOwnPropertyDescriptor;
+var is_property_enumerable = Object.prototype.propertyIsEnumerable;
+var get_own_property_symbols = Object.getOwnPropertySymbols;
+var has_own_property = Object.prototype.hasOwnProperty;
+function own_enumerable_keys(obj) {
+    var res = Object.keys(obj);
+    var symbols = get_own_property_symbols(obj);
+    for(var i = 0; i < symbols.length; i++){
+        if (is_property_enumerable.call(obj, symbols[i])) {
+            res.push(symbols[i]);
+        }
+    }
+    return res;
+}
+function is_writable(object, key) {
+    var _gopd;
+    return !((_gopd = gopd(object, key)) === null || _gopd === void 0 ? void 0 : _gopd.writable);
+}
+function copy(src, options) {
+    if ((typeof src === "undefined" ? "undefined" : _type_of(src)) === "object" && src !== null) {
+        var dst;
+        if (is_array(src)) {
+            dst = [];
+        } else if (is_date(src)) {
+            dst = new Date(src.getTime ? src.getTime() : src);
+        } else if (is_regexp(src)) {
+            dst = new RegExp(src);
+        } else if (is_error(src)) {
+            dst = {
+                message: src.message
+            };
+        } else if (is_boolean(src) || is_number(src) || is_string(src)) {
+            dst = Object(src);
+        } else if (is_typed_array(src)) {
+            return src.slice();
+        } else {
+            dst = Object.create(Object.getPrototypeOf(src));
+        }
+        var iterator_function = options.includeSymbols ? own_enumerable_keys : Object.keys;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = iterator_function(src)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var key = _step.value;
+                dst[key] = src[key];
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        return dst;
+    }
+    return src;
+}
+var empty_null = {
+    includeSymbols: false,
+    immutable: false
+};
+function walk(root, cb) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : empty_null;
+    var path = [];
+    var parents = [];
+    var alive = true;
+    var iterator_function = options.includeSymbols ? own_enumerable_keys : Object.keys;
+    var immutable = !!options.immutable;
+    return function walker(node_) {
+        var node = immutable ? copy(node_, options) : node_;
+        var modifiers = {};
+        var keep_going = true;
+        var state = {
+            node: node,
+            node_: node_,
+            path: [].concat(path),
+            parent: parents[parents.length - 1],
+            parents: parents,
+            key: path[path.length - 1],
+            isRoot: path.length === 0,
+            level: path.length,
+            circular: void 0,
+            isLeaf: false,
+            notLeaf: true,
+            notRoot: true,
+            isFirst: false,
+            isLast: false,
+            update: function update(x) {
+                var stopHere = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+                if (!state.isRoot) {
+                    state.parent.node[state.key] = x;
+                }
+                state.node = x;
+                if (stopHere) {
+                    keep_going = false;
+                }
+            },
+            delete: function _delete(stopHere) {
+                delete state.parent.node[state.key];
+                if (stopHere) {
+                    keep_going = false;
+                }
+            },
+            remove: function remove(stopHere) {
+                if (is_array(state.parent.node)) {
+                    state.parent.node.splice(state.key, 1);
+                } else {
+                    delete state.parent.node[state.key];
+                }
+                if (stopHere) {
+                    keep_going = false;
+                }
+            },
+            keys: null,
+            before: function before(f) {
+                modifiers.before = f;
+            },
+            after: function after(f) {
+                modifiers.after = f;
+            },
+            pre: function pre(f) {
+                modifiers.pre = f;
+            },
+            post: function post(f) {
+                modifiers.post = f;
+            },
+            stop: function stop() {
+                alive = false;
+            },
+            block: function block() {
+                keep_going = false;
+            }
+        };
+        if (!alive) {
+            return state;
+        }
+        function update_state() {
+            if (_type_of(state.node) === "object" && state.node !== null) {
+                if (!state.keys || state.node_ !== state.node) {
+                    state.keys = iterator_function(state.node);
+                }
+                state.isLeaf = state.keys.length === 0;
+                for(var i = 0; i < parents.length; i++){
+                    if (parents[i].node_ === node_) {
+                        state.circular = parents[i];
+                        break;
+                    }
+                }
+            } else {
+                state.isLeaf = true;
+                state.keys = null;
+            }
+            state.notLeaf = !state.isLeaf;
+            state.notRoot = !state.isRoot;
+        }
+        update_state();
+        var ret = cb.call(state, state.node);
+        if (ret !== void 0 && state.update) {
+            state.update(ret);
+        }
+        if (modifiers.before) {
+            modifiers.before.call(state, state.node);
+        }
+        if (!keep_going) {
+            return state;
+        }
+        if (_type_of(state.node) === "object" && state.node !== null && !state.circular) {
+            parents.push(state);
+            update_state();
+            var _state_keys;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = Object.entries((_state_keys = state.keys) !== null && _state_keys !== void 0 ? _state_keys : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var _step_value = _sliced_to_array(_step.value, 2), index = _step_value[0], key = _step_value[1];
+                    var _state_keys1;
+                    path.push(key);
+                    if (modifiers.pre) {
+                        modifiers.pre.call(state, state.node[key], key);
+                    }
+                    var child = walker(state.node[key]);
+                    if (immutable && has_own_property.call(state.node, key) && !is_writable(state.node, key)) {
+                        state.node[key] = child.node;
+                    }
+                    child.isLast = ((_state_keys1 = state.keys) === null || _state_keys1 === void 0 ? void 0 : _state_keys1.length) ? +index === state.keys.length - 1 : false;
+                    child.isFirst = +index === 0;
+                    if (modifiers.post) {
+                        modifiers.post.call(state, child);
+                    }
+                    path.pop();
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            parents.pop();
+        }
+        if (modifiers.after) {
+            modifiers.after.call(state, state.node);
+        }
+        return state;
+    }(root).node;
+}
+var _value, _options;
+var Traverse = /*#__PURE__*/ function() {
+    function Traverse(obj) {
+        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : empty_null;
+        _class_call_check(this, Traverse);
+        // ! Have to keep these public as legacy mode requires them
+        __privateAdd(this, _value);
+        __privateAdd(this, _options);
+        __privateSet(this, _value, obj);
+        __privateSet(this, _options, options);
+    }
+    _create_class(Traverse, [
+        {
+            /**
+   * Get the element at the array `path`.
+   */ key: "get",
+            value: function get(paths) {
+                var node = __privateGet(this, _value);
+                for(var i = 0; node && i < paths.length; i++){
+                    var key = paths[i];
+                    if (!has_own_property.call(node, key) || !__privateGet(this, _options).includeSymbols && (typeof key === "undefined" ? "undefined" : _type_of(key)) === "symbol") {
+                        return void 0;
+                    }
+                    node = node[key];
+                }
+                return node;
+            }
+        },
+        {
+            /**
+   * Return whether the element at the array `path` exists.
+   */ key: "has",
+            value: function has(paths) {
+                var node = __privateGet(this, _value);
+                for(var i = 0; node && i < paths.length; i++){
+                    var key = paths[i];
+                    if (!has_own_property.call(node, key) || !__privateGet(this, _options).includeSymbols && (typeof key === "undefined" ? "undefined" : _type_of(key)) === "symbol") {
+                        return false;
+                    }
+                    node = node[key];
+                }
+                return true;
+            }
+        },
+        {
+            /**
+   * Set the element at the array `path` to `value`.
+   */ key: "set",
+            value: function set(path, value) {
+                var node = __privateGet(this, _value);
+                var i = 0;
+                for(i = 0; i < path.length - 1; i++){
+                    var key = path[i];
+                    if (!has_own_property.call(node, key)) {
+                        node[key] = {};
+                    }
+                    node = node[key];
+                }
+                node[path[i]] = value;
+                return value;
+            }
+        },
+        {
+            /**
+   * Execute `fn` for each node in the object and return a new object with the results of the walk. To update nodes in the result use `this.update(value)`.
+   */ key: "map",
+            value: function map(cb) {
+                return walk(__privateGet(this, _value), cb, {
+                    immutable: true,
+                    includeSymbols: !!__privateGet(this, _options).includeSymbols
+                });
+            }
+        },
+        {
+            /**
+   * Execute `fn` for each node in the object but unlike `.map()`, when `this.update()` is called it updates the object in-place.
+   */ key: "forEach",
+            value: function forEach(cb) {
+                __privateSet(this, _value, walk(__privateGet(this, _value), cb, __privateGet(this, _options)));
+                return __privateGet(this, _value);
+            }
+        },
+        {
+            /**
+   * For each node in the object, perform a [left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function)) with the return value of `fn(acc, node)`.
+   *
+   * If `init` isn't specified, `init` is set to the root object for the first step and the root element is skipped.
+   */ key: "reduce",
+            value: function reduce(cb, init) {
+                var skip = arguments.length === 1;
+                var acc = skip ? __privateGet(this, _value) : init;
+                this.forEach(function(x) {
+                    if (!this.isRoot || !skip) {
+                        acc = cb.call(this, acc, x);
+                    }
+                });
+                return acc;
+            }
+        },
+        {
+            /**
+   * Return an `Array` of every possible non-cyclic path in the object.
+   * Paths are `Array`s of string keys.
+   */ key: "paths",
+            value: function paths() {
+                var acc = [];
+                this.forEach(function() {
+                    acc.push(this.path);
+                });
+                return acc;
+            }
+        },
+        {
+            /**
+   * Return an `Array` of every node in the object.
+   */ key: "nodes",
+            value: function nodes() {
+                var acc = [];
+                this.forEach(function() {
+                    acc.push(this.node);
+                });
+                return acc;
+            }
+        },
+        {
+            /**
+   * Create a deep clone of the object.
+   */ key: "clone",
+            value: function clone() {
+                var parents = [];
+                var nodes = [];
+                var options = __privateGet(this, _options);
+                if (is_typed_array(__privateGet(this, _value))) {
+                    return __privateGet(this, _value).slice();
+                }
+                return function clone(src) {
+                    for(var i = 0; i < parents.length; i++){
+                        if (parents[i] === src) {
+                            return nodes[i];
+                        }
+                    }
+                    if ((typeof src === "undefined" ? "undefined" : _type_of(src)) === "object" && src !== null) {
+                        var dst = copy(src, options);
+                        parents.push(src);
+                        nodes.push(dst);
+                        var iteratorFunction = options.includeSymbols ? own_enumerable_keys : Object.keys;
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = iteratorFunction(src)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var key = _step.value;
+                                dst[key] = clone(src[key]);
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        parents.pop();
+                        nodes.pop();
+                        return dst;
+                    }
+                    return src;
+                }(__privateGet(this, _value));
+            }
+        }
+    ]);
+    return Traverse;
+}();
+_value = new WeakMap();
+_options = new WeakMap();
+var traverse = function(obj, options) {
+    return new Traverse(obj, options);
+};
+traverse.get = function(obj, paths, options) {
+    return new Traverse(obj, options).get(paths);
+};
+traverse.set = function(obj, path, value, options) {
+    return new Traverse(obj, options).set(path, value);
+};
+traverse.has = function(obj, paths, options) {
+    return new Traverse(obj, options).has(paths);
+};
+traverse.map = function(obj, cb, options) {
+    return new Traverse(obj, options).map(cb);
+};
+traverse.forEach = function(obj, cb, options) {
+    return new Traverse(obj, options).forEach(cb);
+};
+traverse.reduce = function(obj, cb, init, options) {
+    return new Traverse(obj, options).reduce(cb, init);
+};
+traverse.paths = function(obj, options) {
+    return new Traverse(obj, options).paths();
+};
+traverse.nodes = function(obj, options) {
+    return new Traverse(obj, options).nodes();
+};
+traverse.clone = function(obj, options) {
+    return new Traverse(obj, options).clone();
+};
+var src_default = traverse;
+// src/legacy.cts
+module.exports = src_default;

node_modules/neotraverse/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "neotraverse",
+  "version": "0.6.18",
+  "description": "traverse and transform objects by visiting every node on a recursive walk",
+  "main": "dist/legacy/legacy.cjs",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "legacy.*"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": {
+        "production": "./dist/min/index.js",
+        "development": "./dist/index.js",
+        "default": "./dist/index.js"
+      },
+      "default": "./dist/min/index.js"
+    },
+    "./modern": {
+      "types": "./dist/modern/modern.d.ts",
+      "import": {
+        "production": "./dist/modern/min/modern.js",
+        "development": "./dist/modern/modern.js",
+        "default": "./dist/modern/modern.js"
+      },
+      "default": "./dist/modern/modern.js"
+    },
+    "./legacy": {
+      "require": {
+        "types": "./dist/legacy/legacy.d.cts",
+        "default": "./dist/legacy/legacy.cjs"
+      },
+      "import": {
+        "types": "./dist/legacy/legacy.d.ts",
+        "default": "./dist/legacy/legacy.mjs"
+      },
+      "default": "./dist/legacy/legacy.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PuruVJ/neotraverse.git"
+  },
+  "homepage": "https://github.com/PuruVJ/neotraverse",
+  "keywords": [
+    "traverse",
+    "walk",
+    "recursive",
+    "map",
+    "forEach",
+    "deep",
+    "clone"
+  ],
+  "author": {
+    "name": "Puru Vijay, James Halliday"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">= 10"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.7",
+    "@swc/core": "^1.6.13",
+    "@types/node": "^20.14.10",
+    "terser": "^5.31.2",
+    "tsup": "^8.1.0",
+    "typescript": "^5.5.3",
+    "vitest": "^2.0.1"
+  },
+  "scripts": {
+    "compile": "tsup && cp dist/legacy/legacy.cjs legacy.js && cp dist/legacy/legacy.d.cts legacy.d.ts",
+    "test": "vitest run",
+    "pub": "pnpm run compile && npm publish --access public --no-git-checks",
+    "changeset": "changeset",
+    "ci:version": "changeset version",
+    "ci:release": "changeset publish"
+  }
+}