From afa87af01c79a9baa539f2992d32154d2a4739bd Mon Sep 17 00:00:00 2001
From: Adam Mathes <adam@adammathes.com>
Date: Sat, 14 Feb 2026 14:46:37 -0800
Subject: task: delete vanilla js prototype\n\n- Removed vanilla/ directory and
 web/dist/vanilla directory\n- Updated Makefile, Dockerfile, and CI workflow
 to remove vanilla references\n- Cleaned up web/web.go to remove vanilla embed
 and routes\n- Verified build and tests pass\n\nCloses NK-2tcnmq

---
 vanilla/node_modules/ast-v8-to-istanbul/LICENSE    |  21 -
 vanilla/node_modules/ast-v8-to-istanbul/README.md  | 278 -------
 .../ast-v8-to-istanbul/dist/index.d.mts            | 568 --------------
 .../node_modules/ast-v8-to-istanbul/dist/index.mjs | 848 ---------------------
 .../node_modules/ast-v8-to-istanbul/package.json   |  71 --
 5 files changed, 1786 deletions(-)
 delete mode 100644 vanilla/node_modules/ast-v8-to-istanbul/LICENSE
 delete mode 100644 vanilla/node_modules/ast-v8-to-istanbul/README.md
 delete mode 100644 vanilla/node_modules/ast-v8-to-istanbul/dist/index.d.mts
 delete mode 100644 vanilla/node_modules/ast-v8-to-istanbul/dist/index.mjs
 delete mode 100644 vanilla/node_modules/ast-v8-to-istanbul/package.json

(limited to 'vanilla/node_modules/ast-v8-to-istanbul')

diff --git a/vanilla/node_modules/ast-v8-to-istanbul/LICENSE b/vanilla/node_modules/ast-v8-to-istanbul/LICENSE
deleted file mode 100644
index 073bd2a..0000000
--- a/vanilla/node_modules/ast-v8-to-istanbul/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Ari Perkkiö
-
-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.
diff --git a/vanilla/node_modules/ast-v8-to-istanbul/README.md b/vanilla/node_modules/ast-v8-to-istanbul/README.md
deleted file mode 100644
index e4aa256..0000000
--- a/vanilla/node_modules/ast-v8-to-istanbul/README.md
+++ /dev/null
@@ -1,278 +0,0 @@
-# `ast-v8-to-istanbul`
-
-[![Version][version-badge]][npm-url]
-[![Downloads][downloads-url]][npm-url]
-
-> - Speed of V8 coverage 🏎
-> - Accuracy of Istanbul coverage 🔍
-
-[Ignoring code](#ignoring-code) | [Source maps](#source-maps) | [Istanbul Compatibility](#istanbul-compatibility) | [Limitations](#limitations)
-
----
-
-AST-aware [`v8-to-istanbul`](https://www.npmjs.com/package/v8-to-istanbul).
-
-Unopinionated - _bring-your-own_ AST parser and source maps.
-
-Passes all 195 tests<sup>[*](#istanbul-compatibility)</sup> of [`istanbul-lib-instrument`](https://github.com/istanbuljs/istanbuljs/tree/main/packages/istanbul-lib-instrument/test/specs). ✅
-
-Test cases run against:
-- `vite/parseAst` ✅
-- `acorn` ✅
-- `oxc-parser` ✅
-- `@babel/parser` ✅
-
-See example report at https://ariperkkio.github.io/ast-v8-to-istanbul.
-
-```ts
-import { convert } from "ast-v8-to-istanbul";
-import { parseAstAsync } from "vite";
-import type { CoverageMapData } from "istanbul-lib-coverage";
-
-const data: CoverageMapData = await convert({
-  // Bring-your-own AST parser
-  ast: parseAstAsync(<code>),
-
-  // Code of the executed file (not the source file)
-  code: "function sum(a, b) {\n  return a + b ...",
-
-  // Execution wrapper offset
-  wrapperLength: 0,
-
-  // Script coverage of the executed file
-  coverage: {
-    scriptId: "123",
-    url: "file:///absolute/path/to/dist/index.js",
-    functions: [
-      {
-        functionName: "sum",
-        ranges: [{ startOffset: 223, endOffset: 261, count: 0 }],
-        isBlockCoverage: false,
-      },
-      // ... etc
-    ],
-  },
-
-  // Source map of the executed file
-  sourceMap: {
-    version: 3,
-    sources: ["../sources.ts"],
-    sourcesContent: ["export function sum(a: number, b: number) {\n..."],
-    mappings: ";AAAO,SAAS,...",
-    names: [],
-  },
-});
-```
-
-## Ignoring code
-
-### Ignoring source code
-
-#### Ignore hints
-
-See live example at https://ariperkkio.github.io/ast-v8-to-istanbul/ignore-examples.html.
-
-The typical ignore hints from `nyc` are supported: https://github.com/istanbuljs/nyc?tab=readme-ov-file#parsing-hints-ignoring-lines:
-
-> * `/* istanbul ignore if */`: ignore the next if statement.
-> * `/* istanbul ignore else */`: ignore the else portion of an if statement.
-> * `/* istanbul ignore next */`: ignore the next _thing_ in the source-code (functions, if statements, classes, you name it).
-> * `/* istanbul ignore file */`: ignore an entire source-file (this should be placed at the top of the file).
-
-In addition to `istanbul` keyword, you can use `v8`, `c8` and `node:coverage`:
-
-- `/* istanbul ignore if */`
-- `/* v8 ignore else */`
-- `/* c8 ignore file */`
-- `/* node:coverage ignore next */`
-
-Also `start` and `stop` ignore hints from original [`v8-to-istanbul`](https://www.npmjs.com/package/v8-to-istanbul) are supported.
-These ignore hints are checked from the original sources instead of transpiled code.
-
-> * `/* v8 ignore start */`: start ignoring lines
-> * `/* v8 ignore stop */`: stop ignoring lines
-> * `<!-- /* v8 ignore start */ -->`: start ignoring lines
-> * `<!-- /* v8 ignore stop */ -->`: stop ignoring lines
-> * `anything /* v8 ignore start */ anything`: start ignoring lines
-> * `anything /* v8 ignore stop */ anything`: stop ignoring lines
-
-#### Class methods
-
-The `ignore-class-method` from `nyc` is also supported: https://github.com/istanbuljs/nyc?tab=readme-ov-file#ignoring-methods
-
-> You can ignore every instance of a method simply by adding its name to the `ignore-class-method` array in your `nyc` config.
-
-```ts
-import { convert } from "ast-v8-to-istanbul";
-
-await convert({
-  ignoreClassMethods: ['render']
-});
-```
-
-#### Ignore after remapping
-
-You can ignore source code after coverage results have been remapped back to original sources using `ignoreSourceCode`.
-This is a high level API that can be exposed to end-users by tooling developers.
-
-It's mostly intended for excluding code that is incorrectly shown in coverage report when compilers add generated code in the source maps.
-
-Note that as the exclusion happens after remapping, this option is slower than [`ignoreNode`](#ignoring-generated-code) option.
-
-```ts
-function ignoreSourceCode(
-  code: string,
-  type: "function" | "statement" | "branch",
-  location: Record<"start" | "end", { line: number; column: number }>,
-): boolean | void;
-```
-
-```ts
-import { convert } from "ast-v8-to-istanbul";
-
-await convert({
-  ignoreSourceCode: (code, type, location) => {
-    // Ignore all "noop()" calls
-    if(type === "function" && code.includes("noop(")) {
-      return true;
-    }
-
-    // In Vue "<script>" tags generate code that is incorrectly left in source maps - exclude it
-    if(code === '<script>') {
-      return true;
-    }
-
-    // Ignore anything above line 5
-    return location.start.line < 5;
-  },
-});
-```
-
-### Ignoring generated code
-
-This API is mostly for developers integrating `ast-v8-to-istanbul` with other tooling.
-
-If your code transform pipeline is adding generated code that's included in the source maps, it will be included in coverage too.
-You can exclude these known patterns by defining `ignoreNode` for filtering such nodes.
-
-By returning `"ignore-this-and-nested-nodes"` from the handler, you can ignore all nested nodes too.
-This can be useful when you need to ignore everything a certain node wraps, e.g. `IfStatement`.
-
-```ts
-function ignoreNode(
-  node: Node,
-  type: "branch" | "function" | "statement"
-): boolean | "ignore-this-and-nested-nodes" | void;
-```
-
-```ts
-import { convert } from "ast-v8-to-istanbul";
-
-await convert({
-  ignoreNode: (node, type) => {
-    // Ignore all `await __vite_ssr_import__( ... )` calls that Vite SSR transform adds
-    return (
-      type === "statement" &&
-      node.type === "AwaitExpression" &&
-      node.argument.type === "CallExpression" &&
-      node.argument.callee.type === "Identifier" &&
-      node.argument.callee.name === "__vite_ssr_import__"
-    );
-  },
-});
-```
-
-## Source maps
-
-Source maps are optional and supported by various ways:
-
-- Pass directly to `convert` as argument:
-  ```ts
-  import { convert } from "ast-v8-to-istanbul";
-
-  await convert({
-    sourceMap: {
-      version: 3,
-      sources: ["../sources.ts"],
-      sourcesContent: ["export function sum(a: number, b: number) {\n..."],
-      mappings: ";AAAO,SAAS,...",
-      names: [],
-    }
-  });
-  ```
-- Include base64 encoded inline maps in `code`:
-  ```ts
-  await convert({
-    code: `\
-    function hello() {}
-    //# sourceMappingURL=data:application/json;base64,eyJzb3VyY2VzIjpbIi9zb21lL...
-    `
-  });
-  ```
-- Include inline maps with filename in `code`:
-  ```ts
-  await convert({
-    code: `\
-    function hello() {}
-    //# sourceMappingURL=some-file-on-file-system.js.map
-    `
-  });
-  ```
-- Don't use source maps at all, and pass original source code in `code`:
-  ```ts
-  await convert({
-    code: `function hello() {}`,
-    sourceMap: undefined,
-  });
-  ```
-
-## Istanbul Compatibility
-
-This project tests itself against test cases of `istanbul-lib-instrument` and verifies coverage maps are 100% identical. Some cases, like [deprecated `with()` statement](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/with) and edge cases of strict mode are skipped, as all tests are run in strict mode.
-
-100% istanbul compatibility guarantees that coverage reports between V8 and Istanbul can be merged together.
-
-<img src="https://github.com/user-attachments/assets/f74f129c-d63a-403e-8091-aefa53f6f97e" width="400" />
-
-## Limitations
-
-The way how V8 reports runtime coverage has some limitations when compared to pre-instrumented coverage:
-
-- Unable to detect uncovered `AssignmentPattern`'s if line is otherwise covered
-  - https://github.com/nodejs/node/issues/57435
-
-- Unable to detect uncovered parts when block execution stops due to function throwing:
-  - ```js
-    function first() {
-      throws()
-
-      // unreachable, but incorrectly covered
-      return "first";
-    }
-
-    const throws = ()  => { throw new Error() }
-
-    try { first(1) } catch {}
-    ```
-  - ```json
-    [
-      {
-        "ranges": [{ "startOffset": 0, "endOffset": 165, "count": 1 }],
-        "isBlockCoverage": true
-      },
-      {
-        "functionName": "first",
-        "ranges": [{ "startOffset": 0, "endOffset": 92, "count": 1 }],
-        "isBlockCoverage": true
-      },
-      {
-        "functionName": "throws",
-        "ranges": [{ "startOffset": 109, "endOffset": 137, "count": 1 }],
-        "isBlockCoverage": true
-      }
-    ]
-    ```
-
-[version-badge]: https://img.shields.io/npm/v/ast-v8-to-istanbul
-[npm-url]: https://www.npmjs.com/package/ast-v8-to-istanbul
-[downloads-url]: https://img.shields.io/npm/dm/ast-v8-to-istanbul
diff --git a/vanilla/node_modules/ast-v8-to-istanbul/dist/index.d.mts b/vanilla/node_modules/ast-v8-to-istanbul/dist/index.d.mts
deleted file mode 100644
index 9d69ea5..0000000
--- a/vanilla/node_modules/ast-v8-to-istanbul/dist/index.d.mts
+++ /dev/null
@@ -1,568 +0,0 @@
-import { EncodedSourceMap } from "@jridgewell/trace-mapping";
-import { CoverageMapData } from "istanbul-lib-coverage";
-import { Profiler } from "node:inspector";
-
-//#region node_modules/.pnpm/@types+estree@1.0.8/node_modules/@types/estree/index.d.ts
-// This definition file follows a somewhat unusual format. ESTree allows
-// runtime type checks based on the `type` parameter. In order to explain this
-// to typescript we want to use discriminated union types:
-// https://github.com/Microsoft/TypeScript/pull/9163
-//
-// For ESTree this is a bit tricky because the high level interfaces like
-// Node or Function are pulling double duty. We want to pass common fields down
-// to the interfaces that extend them (like Identifier or
-// ArrowFunctionExpression), but you can't extend a type union or enforce
-// common fields on them. So we've split the high level interfaces into two
-// types, a base type which passes down inherited fields, and a type union of
-// all types which extend the base type. Only the type union is exported, and
-// the union is how other types refer to the collection of inheriting types.
-//
-// This makes the definitions file here somewhat more difficult to maintain,
-// but it has the notable advantage of making ESTree much easier to use as
-// an end user.
-interface BaseNodeWithoutComments {
-  // Every leaf interface that extends BaseNode must specify a type property.
-  // The type property should be a string literal. For example, Identifier
-  // has: `type: "Identifier"`
-  type: string;
-  loc?: SourceLocation | null | undefined;
-  range?: [number, number] | undefined;
-}
-interface BaseNode extends BaseNodeWithoutComments {
-  leadingComments?: Comment[] | undefined;
-  trailingComments?: Comment[] | undefined;
-}
-interface NodeMap {
-  AssignmentProperty: AssignmentProperty;
-  CatchClause: CatchClause;
-  Class: Class;
-  ClassBody: ClassBody;
-  Expression: Expression;
-  Function: Function;
-  Identifier: Identifier;
-  Literal: Literal;
-  MethodDefinition: MethodDefinition;
-  ModuleDeclaration: ModuleDeclaration;
-  ModuleSpecifier: ModuleSpecifier;
-  Pattern: Pattern;
-  PrivateIdentifier: PrivateIdentifier;
-  Program: Program;
-  Property: Property;
-  PropertyDefinition: PropertyDefinition;
-  SpreadElement: SpreadElement;
-  Statement: Statement;
-  Super: Super;
-  SwitchCase: SwitchCase;
-  TemplateElement: TemplateElement;
-  VariableDeclarator: VariableDeclarator;
-}
-type Node = NodeMap[keyof NodeMap];
-interface Comment extends BaseNodeWithoutComments {
-  type: "Line" | "Block";
-  value: string;
-}
-interface SourceLocation {
-  source?: string | null | undefined;
-  start: Position;
-  end: Position;
-}
-interface Position {
-  /** >= 1 */
-  line: number;
-  /** >= 0 */
-  column: number;
-}
-interface Program extends BaseNode {
-  type: "Program";
-  sourceType: "script" | "module";
-  body: Array<Directive | Statement | ModuleDeclaration>;
-  comments?: Comment[] | undefined;
-}
-interface Directive extends BaseNode {
-  type: "ExpressionStatement";
-  expression: Literal;
-  directive: string;
-}
-interface BaseFunction extends BaseNode {
-  params: Pattern[];
-  generator?: boolean | undefined;
-  async?: boolean | undefined; // The body is either BlockStatement or Expression because arrow functions
-  // can have a body that's either. FunctionDeclarations and
-  // FunctionExpressions have only BlockStatement bodies.
-  body: BlockStatement | Expression;
-}
-type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
-type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
-interface BaseStatement extends BaseNode {}
-interface EmptyStatement extends BaseStatement {
-  type: "EmptyStatement";
-}
-interface BlockStatement extends BaseStatement {
-  type: "BlockStatement";
-  body: Statement[];
-  innerComments?: Comment[] | undefined;
-}
-interface StaticBlock extends Omit<BlockStatement, "type"> {
-  type: "StaticBlock";
-}
-interface ExpressionStatement extends BaseStatement {
-  type: "ExpressionStatement";
-  expression: Expression;
-}
-interface IfStatement extends BaseStatement {
-  type: "IfStatement";
-  test: Expression;
-  consequent: Statement;
-  alternate?: Statement | null | undefined;
-}
-interface LabeledStatement extends BaseStatement {
-  type: "LabeledStatement";
-  label: Identifier;
-  body: Statement;
-}
-interface BreakStatement extends BaseStatement {
-  type: "BreakStatement";
-  label?: Identifier | null | undefined;
-}
-interface ContinueStatement extends BaseStatement {
-  type: "ContinueStatement";
-  label?: Identifier | null | undefined;
-}
-interface WithStatement extends BaseStatement {
-  type: "WithStatement";
-  object: Expression;
-  body: Statement;
-}
-interface SwitchStatement extends BaseStatement {
-  type: "SwitchStatement";
-  discriminant: Expression;
-  cases: SwitchCase[];
-}
-interface ReturnStatement extends BaseStatement {
-  type: "ReturnStatement";
-  argument?: Expression | null | undefined;
-}
-interface ThrowStatement extends BaseStatement {
-  type: "ThrowStatement";
-  argument: Expression;
-}
-interface TryStatement extends BaseStatement {
-  type: "TryStatement";
-  block: BlockStatement;
-  handler?: CatchClause | null | undefined;
-  finalizer?: BlockStatement | null | undefined;
-}
-interface WhileStatement extends BaseStatement {
-  type: "WhileStatement";
-  test: Expression;
-  body: Statement;
-}
-interface DoWhileStatement extends BaseStatement {
-  type: "DoWhileStatement";
-  body: Statement;
-  test: Expression;
-}
-interface ForStatement extends BaseStatement {
-  type: "ForStatement";
-  init?: VariableDeclaration | Expression | null | undefined;
-  test?: Expression | null | undefined;
-  update?: Expression | null | undefined;
-  body: Statement;
-}
-interface BaseForXStatement extends BaseStatement {
-  left: VariableDeclaration | Pattern;
-  right: Expression;
-  body: Statement;
-}
-interface ForInStatement extends BaseForXStatement {
-  type: "ForInStatement";
-}
-interface DebuggerStatement extends BaseStatement {
-  type: "DebuggerStatement";
-}
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
-interface BaseDeclaration extends BaseStatement {}
-interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
-  type: "FunctionDeclaration";
-  /** It is null when a function declaration is a part of the `export default function` statement */
-  id: Identifier | null;
-  body: BlockStatement;
-}
-interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
-  id: Identifier;
-}
-interface VariableDeclaration extends BaseDeclaration {
-  type: "VariableDeclaration";
-  declarations: VariableDeclarator[];
-  kind: "var" | "let" | "const" | "using" | "await using";
-}
-interface VariableDeclarator extends BaseNode {
-  type: "VariableDeclarator";
-  id: Pattern;
-  init?: Expression | null | undefined;
-}
-interface ExpressionMap {
-  ArrayExpression: ArrayExpression;
-  ArrowFunctionExpression: ArrowFunctionExpression;
-  AssignmentExpression: AssignmentExpression;
-  AwaitExpression: AwaitExpression;
-  BinaryExpression: BinaryExpression;
-  CallExpression: CallExpression;
-  ChainExpression: ChainExpression;
-  ClassExpression: ClassExpression;
-  ConditionalExpression: ConditionalExpression;
-  FunctionExpression: FunctionExpression;
-  Identifier: Identifier;
-  ImportExpression: ImportExpression;
-  Literal: Literal;
-  LogicalExpression: LogicalExpression;
-  MemberExpression: MemberExpression;
-  MetaProperty: MetaProperty;
-  NewExpression: NewExpression;
-  ObjectExpression: ObjectExpression;
-  SequenceExpression: SequenceExpression;
-  TaggedTemplateExpression: TaggedTemplateExpression;
-  TemplateLiteral: TemplateLiteral;
-  ThisExpression: ThisExpression;
-  UnaryExpression: UnaryExpression;
-  UpdateExpression: UpdateExpression;
-  YieldExpression: YieldExpression;
-}
-type Expression = ExpressionMap[keyof ExpressionMap];
-interface BaseExpression extends BaseNode {}
-type ChainElement = SimpleCallExpression | MemberExpression;
-interface ChainExpression extends BaseExpression {
-  type: "ChainExpression";
-  expression: ChainElement;
-}
-interface ThisExpression extends BaseExpression {
-  type: "ThisExpression";
-}
-interface ArrayExpression extends BaseExpression {
-  type: "ArrayExpression";
-  elements: Array<Expression | SpreadElement | null>;
-}
-interface ObjectExpression extends BaseExpression {
-  type: "ObjectExpression";
-  properties: Array<Property | SpreadElement>;
-}
-interface PrivateIdentifier extends BaseNode {
-  type: "PrivateIdentifier";
-  name: string;
-}
-interface Property extends BaseNode {
-  type: "Property";
-  key: Expression | PrivateIdentifier;
-  value: Expression | Pattern; // Could be an AssignmentProperty
-  kind: "init" | "get" | "set";
-  method: boolean;
-  shorthand: boolean;
-  computed: boolean;
-}
-interface PropertyDefinition extends BaseNode {
-  type: "PropertyDefinition";
-  key: Expression | PrivateIdentifier;
-  value?: Expression | null | undefined;
-  computed: boolean;
-  static: boolean;
-}
-interface FunctionExpression extends BaseFunction, BaseExpression {
-  id?: Identifier | null | undefined;
-  type: "FunctionExpression";
-  body: BlockStatement;
-}
-interface SequenceExpression extends BaseExpression {
-  type: "SequenceExpression";
-  expressions: Expression[];
-}
-interface UnaryExpression extends BaseExpression {
-  type: "UnaryExpression";
-  operator: UnaryOperator;
-  prefix: true;
-  argument: Expression;
-}
-interface BinaryExpression extends BaseExpression {
-  type: "BinaryExpression";
-  operator: BinaryOperator;
-  left: Expression | PrivateIdentifier;
-  right: Expression;
-}
-interface AssignmentExpression extends BaseExpression {
-  type: "AssignmentExpression";
-  operator: AssignmentOperator;
-  left: Pattern | MemberExpression;
-  right: Expression;
-}
-interface UpdateExpression extends BaseExpression {
-  type: "UpdateExpression";
-  operator: UpdateOperator;
-  argument: Expression;
-  prefix: boolean;
-}
-interface LogicalExpression extends BaseExpression {
-  type: "LogicalExpression";
-  operator: LogicalOperator;
-  left: Expression;
-  right: Expression;
-}
-interface ConditionalExpression extends BaseExpression {
-  type: "ConditionalExpression";
-  test: Expression;
-  alternate: Expression;
-  consequent: Expression;
-}
-interface BaseCallExpression extends BaseExpression {
-  callee: Expression | Super;
-  arguments: Array<Expression | SpreadElement>;
-}
-type CallExpression = SimpleCallExpression | NewExpression;
-interface SimpleCallExpression extends BaseCallExpression {
-  type: "CallExpression";
-  optional: boolean;
-}
-interface NewExpression extends BaseCallExpression {
-  type: "NewExpression";
-}
-interface MemberExpression extends BaseExpression, BasePattern {
-  type: "MemberExpression";
-  object: Expression | Super;
-  property: Expression | PrivateIdentifier;
-  computed: boolean;
-  optional: boolean;
-}
-type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
-interface BasePattern extends BaseNode {}
-interface SwitchCase extends BaseNode {
-  type: "SwitchCase";
-  test?: Expression | null | undefined;
-  consequent: Statement[];
-}
-interface CatchClause extends BaseNode {
-  type: "CatchClause";
-  param: Pattern | null;
-  body: BlockStatement;
-}
-interface Identifier extends BaseNode, BaseExpression, BasePattern {
-  type: "Identifier";
-  name: string;
-}
-type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
-interface SimpleLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value: string | boolean | number | null;
-  raw?: string | undefined;
-}
-interface RegExpLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: RegExp | null | undefined;
-  regex: {
-    pattern: string;
-    flags: string;
-  };
-  raw?: string | undefined;
-}
-interface BigIntLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: bigint | null | undefined;
-  bigint: string;
-  raw?: string | undefined;
-}
-type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
-type LogicalOperator = "||" | "&&" | "??";
-type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
-type UpdateOperator = "++" | "--";
-interface ForOfStatement extends BaseForXStatement {
-  type: "ForOfStatement";
-  await: boolean;
-}
-interface Super extends BaseNode {
-  type: "Super";
-}
-interface SpreadElement extends BaseNode {
-  type: "SpreadElement";
-  argument: Expression;
-}
-interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
-  type: "ArrowFunctionExpression";
-  expression: boolean;
-  body: BlockStatement | Expression;
-}
-interface YieldExpression extends BaseExpression {
-  type: "YieldExpression";
-  argument?: Expression | null | undefined;
-  delegate: boolean;
-}
-interface TemplateLiteral extends BaseExpression {
-  type: "TemplateLiteral";
-  quasis: TemplateElement[];
-  expressions: Expression[];
-}
-interface TaggedTemplateExpression extends BaseExpression {
-  type: "TaggedTemplateExpression";
-  tag: Expression;
-  quasi: TemplateLiteral;
-}
-interface TemplateElement extends BaseNode {
-  type: "TemplateElement";
-  tail: boolean;
-  value: {
-    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */cooked?: string | null | undefined;
-    raw: string;
-  };
-}
-interface AssignmentProperty extends Property {
-  value: Pattern;
-  kind: "init";
-  method: boolean; // false
-}
-interface ObjectPattern extends BasePattern {
-  type: "ObjectPattern";
-  properties: Array<AssignmentProperty | RestElement>;
-}
-interface ArrayPattern extends BasePattern {
-  type: "ArrayPattern";
-  elements: Array<Pattern | null>;
-}
-interface RestElement extends BasePattern {
-  type: "RestElement";
-  argument: Pattern;
-}
-interface AssignmentPattern extends BasePattern {
-  type: "AssignmentPattern";
-  left: Pattern;
-  right: Expression;
-}
-type Class = ClassDeclaration | ClassExpression;
-interface BaseClass extends BaseNode {
-  superClass?: Expression | null | undefined;
-  body: ClassBody;
-}
-interface ClassBody extends BaseNode {
-  type: "ClassBody";
-  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
-}
-interface MethodDefinition extends BaseNode {
-  type: "MethodDefinition";
-  key: Expression | PrivateIdentifier;
-  value: FunctionExpression;
-  kind: "constructor" | "method" | "get" | "set";
-  computed: boolean;
-  static: boolean;
-}
-interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
-  type: "ClassDeclaration";
-  /** It is null when a class declaration is a part of the `export default class` statement */
-  id: Identifier | null;
-}
-interface ClassDeclaration extends MaybeNamedClassDeclaration {
-  id: Identifier;
-}
-interface ClassExpression extends BaseClass, BaseExpression {
-  type: "ClassExpression";
-  id?: Identifier | null | undefined;
-}
-interface MetaProperty extends BaseExpression {
-  type: "MetaProperty";
-  meta: Identifier;
-  property: Identifier;
-}
-type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
-interface BaseModuleDeclaration extends BaseNode {}
-type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
-interface BaseModuleSpecifier extends BaseNode {
-  local: Identifier;
-}
-interface ImportDeclaration extends BaseModuleDeclaration {
-  type: "ImportDeclaration";
-  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
-  attributes: ImportAttribute[];
-  source: Literal;
-}
-interface ImportSpecifier extends BaseModuleSpecifier {
-  type: "ImportSpecifier";
-  imported: Identifier | Literal;
-}
-interface ImportAttribute extends BaseNode {
-  type: "ImportAttribute";
-  key: Identifier | Literal;
-  value: Literal;
-}
-interface ImportExpression extends BaseExpression {
-  type: "ImportExpression";
-  source: Expression;
-  options?: Expression | null | undefined;
-}
-interface ImportDefaultSpecifier extends BaseModuleSpecifier {
-  type: "ImportDefaultSpecifier";
-}
-interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
-  type: "ImportNamespaceSpecifier";
-}
-interface ExportNamedDeclaration extends BaseModuleDeclaration {
-  type: "ExportNamedDeclaration";
-  declaration?: Declaration | null | undefined;
-  specifiers: ExportSpecifier[];
-  attributes: ImportAttribute[];
-  source?: Literal | null | undefined;
-}
-interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
-  type: "ExportSpecifier";
-  local: Identifier | Literal;
-  exported: Identifier | Literal;
-}
-interface ExportDefaultDeclaration extends BaseModuleDeclaration {
-  type: "ExportDefaultDeclaration";
-  declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
-}
-interface ExportAllDeclaration extends BaseModuleDeclaration {
-  type: "ExportAllDeclaration";
-  exported: Identifier | Literal | null;
-  attributes: ImportAttribute[];
-  source: Literal;
-}
-interface AwaitExpression extends BaseExpression {
-  type: "AwaitExpression";
-  argument: Expression;
-}
-//#endregion
-//#region src/types.d.ts
-interface Options<T = Node, Program = T & {
-  type: "Program";
-}> {
-  /** Code of the executed runtime file, not the original source file */
-  code: string;
-  /** Length of the execution wrapper, e.g. wrapper used in node:vm */
-  wrapperLength?: number;
-  /** Source map for the current file */
-  sourceMap?: Omit<EncodedSourceMap, "version"> & {
-    version: number;
-  };
-  /** ScriptCoverage for the current file */
-  coverage: Pick<Profiler.ScriptCoverage, "functions" | "url">;
-  /** AST for the transpiled file that matches the coverage results */
-  ast: Program | Promise<Program>;
-  /** Class method names to ignore for coverage, identical to https://github.com/istanbuljs/nyc?tab=readme-ov-file#ignoring-methods */
-  ignoreClassMethods?: string[];
-  /** Filter to ignore code based on AST nodes */
-  ignoreNode?: (node: T, type: "function" | "statement" | "branch") => boolean | "ignore-this-and-nested-nodes" | void;
-  /**
-   * Filter to ignore code based on source code
-   * - Note that this is slower than `ignoreNode` as exclusion happens after remapping
-   */
-  ignoreSourceCode?: (code: string, type: "function" | "statement" | "branch", location: Record<"start" | "end", {
-    line: number;
-    column: number;
-  }>) => boolean | void;
-}
-//#endregion
-//#region src/index.d.ts
-/**
- * Maps V8 `ScriptCoverage` to Istanbul's `CoverageMap`.
- * Results are identical with `istanbul-lib-instrument`.
- */
-declare function convert<T = Node, Program = T & {
-  type: "Program";
-}>(options: Options<T, Program>): Promise<CoverageMapData>;
-//#endregion
-export { Options, convert, convert as default };
\ No newline at end of file
diff --git a/vanilla/node_modules/ast-v8-to-istanbul/dist/index.mjs b/vanilla/node_modules/ast-v8-to-istanbul/dist/index.mjs
deleted file mode 100644
index 8b66bc3..0000000
--- a/vanilla/node_modules/ast-v8-to-istanbul/dist/index.mjs
+++ /dev/null
@@ -1,848 +0,0 @@
-import { asyncWalk } from "estree-walker";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { LEAST_UPPER_BOUND, TraceMap, allGeneratedPositionsFor, originalPositionFor, sourceContentFor } from "@jridgewell/trace-mapping";
-import { readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import jsTokens from "js-tokens";
-
-//#region src/ast.ts
-function getWalker() {
-	let nextIgnore = false;
-	function onIgnore(node) {
-		nextIgnore = node;
-	}
-	async function walk(ast, ignoreHints, ignoreClassMethods, visitors) {
-		return await asyncWalk(ast, {
-			async enter(node) {
-				if (nextIgnore !== false) return;
-				const hint = getIgnoreHint(node);
-				if (hint === "next") return onIgnore(node);
-				if (isSkipped(node)) onIgnore(node);
-				switch (node.type) {
-					case "FunctionDeclaration": return visitors.onFunctionDeclaration(node);
-					case "FunctionExpression":
-						if (ignoreClassMethods && node.id?.name) {
-							if (ignoreClassMethods.includes(node.id.name)) return onIgnore(node);
-						}
-						return visitors.onFunctionExpression(node);
-					case "MethodDefinition": return visitors.onMethodDefinition(node);
-					case "Property": return visitors.onProperty(node);
-					case "ArrowFunctionExpression":
-						if (node.body?.type === "ParenthesizedExpression") node.body = node.body.expression;
-						return visitors.onArrowFunctionExpression(node);
-					case "ExpressionStatement": return visitors.onExpressionStatement(node);
-					case "BreakStatement": return visitors.onBreakStatement(node);
-					case "ContinueStatement": return visitors.onContinueStatement(node);
-					case "DebuggerStatement": return visitors.onDebuggerStatement(node);
-					case "ReturnStatement": return visitors.onReturnStatement(node);
-					case "ThrowStatement": return visitors.onThrowStatement(node);
-					case "TryStatement": return visitors.onTryStatement(node);
-					case "ForStatement": return visitors.onForStatement(node);
-					case "ForInStatement": return visitors.onForInStatement(node);
-					case "ForOfStatement": return visitors.onForOfStatement(node);
-					case "WhileStatement": return visitors.onWhileStatement(node);
-					case "DoWhileStatement": return visitors.onDoWhileStatement(node);
-					case "WithStatement": return visitors.onWithStatement(node);
-					case "LabeledStatement": return visitors.onLabeledStatement(node);
-					case "VariableDeclarator": return visitors.onVariableDeclarator(node);
-					case "ClassBody": {
-						const classBody = node;
-						if (ignoreClassMethods) {
-							for (const child of classBody.body) if (child.type === "MethodDefinition" || child.type === "ClassMethod") {
-								const name = child.key.type === "Identifier" && child.key.name;
-								if (name && ignoreClassMethods.includes(name)) setSkipped(child);
-							}
-							classBody.body = classBody.body.filter((child) => !isSkipped(child));
-						}
-						return visitors.onClassBody(classBody);
-					}
-					case "IfStatement": {
-						const branches = [];
-						if (node.consequent.type !== "BlockStatement") node.consequent = {
-							type: "BlockStatement",
-							body: [node.consequent],
-							start: node.consequent.start,
-							end: node.consequent.end
-						};
-						if (node.alternate && node.alternate.type !== "BlockStatement") node.alternate = {
-							type: "BlockStatement",
-							body: [node.alternate],
-							start: node.alternate.start,
-							end: node.alternate.end
-						};
-						if (hint === "if") setSkipped(node.consequent);
-						else branches.push(node.consequent);
-						if (hint === "else" && node.alternate) setSkipped(node.alternate);
-						else if (hint !== "if" && hint !== "else") branches.push(node.alternate);
-						return visitors.onIfStatement(node, branches);
-					}
-					case "SwitchStatement": {
-						const cases = [];
-						for (const _case of node.cases) if (getIgnoreHint(_case) !== "next") cases.push(_case);
-						return visitors.onSwitchStatement(node, cases);
-					}
-					case "ConditionalExpression": {
-						const branches = [];
-						if (node.consequent.type === "ParenthesizedExpression") node.consequent = node.consequent.expression;
-						if (node.alternate.type === "ParenthesizedExpression") node.alternate = node.alternate.expression;
-						if (getIgnoreHint(node.consequent) === "next") setSkipped(node.consequent);
-						else branches.push(node.consequent);
-						if (getIgnoreHint(node.alternate) === "next") setSkipped(node.alternate);
-						else branches.push(node.alternate);
-						return visitors.onConditionalExpression(node, branches);
-					}
-					case "LogicalExpression": {
-						if (isSkipped(node)) return;
-						const branches = [];
-						function visit(child) {
-							if (child.type === "LogicalExpression") {
-								setSkipped(child);
-								if (getIgnoreHint(child) !== "next") {
-									visit(child.left);
-									return visit(child.right);
-								}
-							}
-							branches.push(child);
-						}
-						visit(node);
-						return visitors.onLogicalExpression(node, branches);
-					}
-					case "AssignmentPattern": return visitors.onAssignmentPattern(node);
-					case "ClassMethod": return visitors.onClassMethod(node);
-					case "ObjectMethod": return visitors.onObjectMethod(node);
-				}
-			},
-			async leave(node) {
-				if (node === nextIgnore) nextIgnore = false;
-			}
-		});
-		function getIgnoreHint(node) {
-			for (const hint of ignoreHints) if (hint.loc.end === node.start) return hint.type;
-			return null;
-		}
-	}
-	return {
-		walk,
-		onIgnore
-	};
-}
-const skippedNodes = /* @__PURE__ */ new WeakSet();
-function getFunctionName(node) {
-	if (node.type === "Identifier") return node.name;
-	if ("id" in node && node.id) return getFunctionName(node.id);
-}
-function setSkipped(node) {
-	skippedNodes.add(node);
-}
-function isSkipped(node) {
-	return skippedNodes.has(node);
-}
-
-//#endregion
-//#region src/coverage-map.ts
-function createCoverageMapData(filename, sourceMap) {
-	const data = {};
-	const directory = dirname(filename);
-	for (const source of sourceMap.sources) {
-		let path = filename;
-		if (source) if (source.startsWith("file://")) path = fileURLToPath(source);
-		else path = resolve(directory, source);
-		data[path] = {
-			path,
-			statementMap: {},
-			fnMap: {},
-			branchMap: {},
-			s: {},
-			f: {},
-			b: {},
-			meta: {
-				lastBranch: 0,
-				lastFunction: 0,
-				lastStatement: 0,
-				seen: {}
-			}
-		};
-	}
-	return data;
-}
-function addFunction(options) {
-	const fileCoverage = options.coverageMapData[options.filename];
-	const meta = fileCoverage.meta;
-	const key = `f:${cacheKey(options.decl)}`;
-	let index = meta.seen[key];
-	if (index == null) {
-		index = meta.lastFunction;
-		meta.lastFunction++;
-		meta.seen[key] = index;
-		fileCoverage.fnMap[index] = {
-			name: options.name || `(anonymous_${index})`,
-			decl: pickLocation(options.decl),
-			loc: pickLocation(options.loc),
-			line: options.loc.start.line
-		};
-	}
-	fileCoverage.f[index] ||= 0;
-	fileCoverage.f[index] += options.covered || 0;
-}
-function addStatement(options) {
-	const fileCoverage = options.coverageMapData[options.filename];
-	const meta = fileCoverage.meta;
-	const key = `s:${cacheKey(options.loc)}`;
-	let index = meta.seen[key];
-	if (index == null) {
-		index = meta.lastStatement;
-		meta.lastStatement++;
-		meta.seen[key] = index;
-		fileCoverage.statementMap[index] = pickLocation(options.loc);
-	}
-	fileCoverage.s[index] = options.covered || 0;
-}
-function addBranch(options) {
-	const fileCoverage = options.coverageMapData[options.filename];
-	const meta = fileCoverage.meta;
-	const key = ["b", ...options.locations.map(cacheKey)].join(":");
-	let index = meta.seen[key];
-	if (index == null) {
-		index = meta.lastBranch;
-		meta.lastBranch++;
-		meta.seen[key] = index;
-		fileCoverage.branchMap[index] = {
-			loc: pickLocation(options.loc),
-			type: options.type,
-			locations: options.locations.map((loc) => pickLocation(loc)),
-			line: options.loc.start.line
-		};
-	}
-	if (!fileCoverage.b[index]) fileCoverage.b[index] = Array(options.locations.length).fill(0);
-	options.covered?.forEach((hit, i) => {
-		fileCoverage.b[index][i] += hit;
-	});
-}
-function pickLocation(loc) {
-	return {
-		start: {
-			line: loc.start.line,
-			column: loc.start.column
-		},
-		end: {
-			line: loc.end.line,
-			column: loc.end.column
-		}
-	};
-}
-function cacheKey(loc) {
-	return `${loc.start.line}:${loc.start.column}:${loc.end.line}:${loc.end.column}`;
-}
-
-//#endregion
-//#region src/ignore-hints.ts
-const IGNORE_PATTERN = /^\s*(?:istanbul|[cv]8|node:coverage)\s+ignore\s+(if|else|next|file)(?=\W|$)/;
-const IGNORE_LINES_PATTERN = /\s*(?:istanbul|[cv]8|node:coverage)\s+ignore\s+(start|stop)(?=\W|$)/;
-const EOL_PATTERN = /\r?\n/g;
-/**
-* Parse ignore hints from **Javascript** code based on AST
-* - Most AST parsers don't emit comments in AST like Acorn does, so parse comments manually instead.
-*/
-function getIgnoreHints(code) {
-	const ignoreHints = [];
-	const tokens = jsTokens(code);
-	let current = 0;
-	let previousTokenWasIgnoreHint = false;
-	for (const token of tokens) {
-		if (previousTokenWasIgnoreHint && token.type !== "WhiteSpace" && token.type !== "LineTerminatorSequence") {
-			const previous = ignoreHints.at(-1);
-			if (previous) previous.loc.end = current;
-			previousTokenWasIgnoreHint = false;
-		}
-		if (token.type === "SingleLineComment" || token.type === "MultiLineComment") {
-			const loc = {
-				start: current,
-				end: current + token.value.length
-			};
-			const type = token.value.replace(/^\/\*\*/, "").replace(/^\/\*/, "").replace(/\*\*\/$/, "").replace(/\*\/$/, "").replace(/^\/\//, "").match(IGNORE_PATTERN)?.[1];
-			if (type === "file") return [{
-				type: "file",
-				loc: {
-					start: 0,
-					end: 0
-				}
-			}];
-			if (type === "if" || type === "else" || type === "next") {
-				ignoreHints.push({
-					type,
-					loc
-				});
-				previousTokenWasIgnoreHint = true;
-			}
-		}
-		current += token.value.length;
-	}
-	return ignoreHints;
-}
-/**
-* Parse ignore start/stop hints from **text file** based on regular expressions
-* - Does not understand what a comment is in Javascript (or JSX, Vue, Svelte)
-* - Parses source code (JS, TS, Vue, Svelte, anything) based on text search by
-*   matching for `/* <name> ignore start *\/` pattern - not by looking for real comments
-*
-* ```js
-* /* v8 ignore start *\/
-* <!-- /* v8 ignore start *\/ -->
-* <SomeFrameworkComment content="/* v8 ignore start *\/">
-* ```
-*/
-function getIgnoredLines(text) {
-	if (!text) return /* @__PURE__ */ new Set();
-	const ranges = [];
-	let lineNumber = 0;
-	for (const line of text.split(EOL_PATTERN)) {
-		lineNumber++;
-		const match = line.match(IGNORE_LINES_PATTERN);
-		if (match) {
-			if (match[1] === "stop") {
-				const previous = ranges.at(-1);
-				if (previous && previous.stop === Infinity) previous.stop = lineNumber;
-				continue;
-			}
-			ranges.push({
-				start: lineNumber,
-				stop: Infinity
-			});
-		}
-	}
-	const ignoredLines = /* @__PURE__ */ new Set();
-	for (const range of ranges) for (let line = range.start; line <= range.stop; line++) {
-		ignoredLines.add(line);
-		if (line >= lineNumber) break;
-	}
-	return ignoredLines;
-}
-
-//#endregion
-//#region src/location.ts
-const WORD_PATTERN = /(\w+|\s|[^\w\s])/g;
-const INLINE_MAP_PATTERN = /#\s*sourceMappingURL=(.*)\s*$/m;
-const BASE_64_PREFIX = "data:application/json;base64,";
-/** How often should offset calculations be cached */
-const CACHE_THRESHOLD = 250;
-var Locator = class {
-	#cache = /* @__PURE__ */ new Map();
-	#codeParts;
-	#map;
-	#directory;
-	#ignoredLines = /* @__PURE__ */ new Map();
-	constructor(code, map, directory) {
-		this.#codeParts = code.split("");
-		this.#map = map;
-		this.#directory = directory;
-	}
-	reset() {
-		this.#cache.clear();
-		this.#ignoredLines.clear();
-		this.#codeParts = [];
-	}
-	offsetToNeedle(offset) {
-		const closestThreshold = Math.floor(offset / CACHE_THRESHOLD) * CACHE_THRESHOLD;
-		const cacheHit = this.#cache.get(closestThreshold);
-		let current = cacheHit ? closestThreshold : 0;
-		let line = cacheHit?.line ?? 1;
-		let column = cacheHit?.column ?? 0;
-		for (let i = current; i <= this.#codeParts.length; i++) {
-			if (current === offset) return {
-				line,
-				column
-			};
-			if (current % CACHE_THRESHOLD === 0) this.#cache.set(current, {
-				line,
-				column
-			});
-			if (this.#codeParts[i] === "\n") {
-				line++;
-				column = 0;
-			} else column++;
-			current++;
-		}
-		return {
-			line,
-			column
-		};
-	}
-	getLoc(node) {
-		const startNeedle = this.offsetToNeedle(node.start);
-		const start = getPosition(startNeedle, this.#map);
-		if (start === null) return null;
-		const endNeedle = this.offsetToNeedle(node.end);
-		endNeedle.column -= 1;
-		let end = getPosition(endNeedle, this.#map);
-		if (end === null) {
-			for (let line = endNeedle.line; line >= startNeedle.line && end === null; line--) end = getPosition({
-				line,
-				column: Infinity
-			}, this.#map);
-			if (end === null) return null;
-		}
-		const loc = {
-			start,
-			end
-		};
-		const afterEndMappings = allGeneratedPositionsFor(this.#map, {
-			source: loc.end.filename,
-			line: loc.end.line,
-			column: loc.end.column + 1,
-			bias: LEAST_UPPER_BOUND
-		});
-		if (afterEndMappings.length === 0) loc.end.column = Infinity;
-		else for (const mapping of afterEndMappings) {
-			if (mapping.line === null) continue;
-			const original = originalPositionFor(this.#map, mapping);
-			if (original.line === loc.end.line) {
-				loc.end = {
-					...original,
-					filename: original.source
-				};
-				break;
-			}
-		}
-		const filename = loc.start.filename;
-		let ignoredLines = this.#ignoredLines.get(filename);
-		if (!ignoredLines) {
-			ignoredLines = getIgnoredLines(sourceContentFor(this.#map, filename) ?? tryReadFileSync(filename));
-			this.#ignoredLines.set(filename, ignoredLines);
-		}
-		if (ignoredLines.has(loc.start.line)) return null;
-		return loc;
-	}
-	getSourceLines(loc, filename) {
-		const index = this.#map.resolvedSources.findIndex((source) => source === filename || resolve(this.#directory, source) === filename);
-		const sourcesContent = this.#map.sourcesContent?.[index];
-		if (sourcesContent == null) return null;
-		const lines = sourcesContent.split("\n").slice(loc.start.line - 1, loc.end.line);
-		lines[0] = lines[0].slice(loc.start.column);
-		lines[lines.length - 1] = lines[lines.length - 1].slice(0, loc.end.column);
-		return lines.join("\n");
-	}
-};
-function getPosition(needle, map) {
-	let position = originalPositionFor(map, needle);
-	if (position.source == null) position = originalPositionFor(map, {
-		column: needle.column,
-		line: needle.line,
-		bias: LEAST_UPPER_BOUND
-	});
-	if (position.source == null) return null;
-	return {
-		line: position.line,
-		column: position.column,
-		filename: position.source
-	};
-}
-function createEmptySourceMap(filename, code) {
-	const mappings = [];
-	for (const [line, content] of code.split("\n").entries()) {
-		const parts = content.match(WORD_PATTERN) || [];
-		const segments = [];
-		let column = 0;
-		for (const part of parts) {
-			segments.push([
-				column,
-				0,
-				line,
-				column
-			]);
-			column += part.length;
-		}
-		mappings.push(segments);
-	}
-	return {
-		version: 3,
-		mappings,
-		file: filename,
-		sources: [filename],
-		sourcesContent: [code],
-		names: []
-	};
-}
-async function getInlineSourceMap(filename, code) {
-	const match = code.match(INLINE_MAP_PATTERN)?.[1];
-	if (!match) return null;
-	try {
-		if (match.includes(BASE_64_PREFIX)) {
-			const encoded = match.split(BASE_64_PREFIX).at(-1) || "";
-			const decoded = atob(encoded);
-			return JSON.parse(decoded);
-		}
-		const content = await readFile(resolve(dirname(filename), match), "utf-8");
-		return JSON.parse(content);
-	} catch {
-		return null;
-	}
-}
-function tryReadFileSync(filename) {
-	try {
-		return readFileSync(filename, "utf8");
-	} catch {
-		return;
-	}
-}
-
-//#endregion
-//#region src/script-coverage.ts
-function normalize(scriptCoverage) {
-	if (scriptCoverage.functions.length === 0) return [];
-	const ranges = scriptCoverage.functions.flatMap((fn) => fn.ranges.map((range) => ({
-		start: range.startOffset,
-		end: range.endOffset,
-		count: range.count,
-		area: range.endOffset - range.startOffset
-	}))).sort((a, b) => {
-		const diff = b.area - a.area;
-		if (diff !== 0) return diff;
-		return a.end - b.end;
-	});
-	let maxEnd = 0;
-	for (const r of ranges) if (r.end > maxEnd) maxEnd = r.end;
-	const hits = new Uint32Array(maxEnd + 1);
-	for (const range of ranges) hits.fill(range.count, range.start, range.end + 1);
-	const normalized = [];
-	let start = 0;
-	for (let end = 1; end <= hits.length; end++) {
-		const isLast = end === hits.length;
-		const current = isLast ? null : hits[end];
-		const previous = hits[start];
-		if (current !== previous || isLast) {
-			normalized.push({
-				start,
-				end: end - 1,
-				count: previous
-			});
-			start = end;
-		}
-	}
-	return normalized;
-}
-function getCount(offset, coverages) {
-	let low = 0;
-	let high = coverages.length - 1;
-	while (low <= high) {
-		const mid = Math.floor((low + high) / 2);
-		const coverage = coverages[mid];
-		if (coverage.start <= offset.startOffset && offset.startOffset <= coverage.end) return coverage.count;
-		else if (offset.startOffset < coverage.start) high = mid - 1;
-		else low = mid + 1;
-	}
-	return 0;
-}
-
-//#endregion
-//#region src/coverage-mapper.ts
-var CoverageMapper = class CoverageMapper {
-	constructor(locator, coverageMapData, ranges, wrapperLength, directory, onIgnoreNode, ignoreNode, ignoreSourceCode) {
-		this.locator = locator;
-		this.coverageMapData = coverageMapData;
-		this.ranges = ranges;
-		this.wrapperLength = wrapperLength;
-		this.directory = directory;
-		this.onIgnoreNode = onIgnoreNode;
-		this.ignoreNode = ignoreNode;
-		this.ignoreSourceCode = ignoreSourceCode;
-	}
-	static async create(options, onIgnoreNode) {
-		const filename = fileURLToPath(options.coverage.url);
-		const directory = dirname(filename);
-		const map = new TraceMap(options.sourceMap || await getInlineSourceMap(filename, options.code) || createEmptySourceMap(filename, options.code));
-		return new CoverageMapper(new Locator(options.code, map, directory), createCoverageMapData(filename, map), normalize(options.coverage), options.wrapperLength || 0, directory, onIgnoreNode, options.ignoreNode, options.ignoreSourceCode);
-	}
-	onFunction(node, positions) {
-		if (this.#onIgnore(node, "function")) return;
-		const loc = this.locator.getLoc(positions.loc);
-		if (loc === null) return;
-		const decl = this.locator.getLoc(positions.decl);
-		if (decl === null) return;
-		const covered = getCount({
-			startOffset: node.start + this.wrapperLength,
-			endOffset: node.end + this.wrapperLength
-		}, this.ranges);
-		if (this.ignoreSourceCode) {
-			const current = this.locator.getLoc(node) || loc;
-			const sources = this.locator.getSourceLines(current, this.#getSourceFilename(current));
-			if (sources != null && this.ignoreSourceCode(sources, "function", {
-				start: {
-					line: current.start.line,
-					column: current.start.column
-				},
-				end: {
-					line: current.end.line,
-					column: current.end.column
-				}
-			})) return;
-		}
-		addFunction({
-			coverageMapData: this.coverageMapData,
-			covered,
-			loc,
-			decl,
-			filename: this.#getSourceFilename(loc),
-			name: getFunctionName(node)
-		});
-	}
-	onStatement(node, parent) {
-		if (this.#onIgnore(parent || node, "statement")) return;
-		const loc = this.locator.getLoc(node);
-		if (loc === null) return;
-		const covered = getCount({
-			startOffset: (parent || node).start + this.wrapperLength,
-			endOffset: (parent || node).end + this.wrapperLength
-		}, this.ranges);
-		if (this.ignoreSourceCode) {
-			const current = parent && this.locator.getLoc(parent) || loc;
-			const sources = this.locator.getSourceLines(current, this.#getSourceFilename(current));
-			if (sources != null && this.ignoreSourceCode(sources, "statement", {
-				start: {
-					line: current.start.line,
-					column: current.start.column
-				},
-				end: {
-					line: current.end.line,
-					column: current.end.column
-				}
-			})) return;
-		}
-		addStatement({
-			coverageMapData: this.coverageMapData,
-			loc,
-			covered,
-			filename: this.#getSourceFilename(loc)
-		});
-	}
-	onBranch(type, node, branches) {
-		if (this.#onIgnore(node, "branch")) return;
-		const loc = this.locator.getLoc(node);
-		if (loc === null) return;
-		const locations = [];
-		const covered = [];
-		for (const branch of branches) {
-			if (!branch) {
-				locations.push({
-					start: {
-						line: void 0,
-						column: void 0
-					},
-					end: {
-						line: void 0,
-						column: void 0
-					}
-				});
-				const count = getCount({
-					startOffset: node.start + this.wrapperLength,
-					endOffset: node.end + this.wrapperLength
-				}, this.ranges);
-				const previous = covered.at(-1) || 0;
-				covered.push(count - previous);
-				continue;
-			}
-			const location = this.locator.getLoc(branch);
-			if (location !== null) locations.push(location);
-			const bias = branch.type === "BlockStatement" ? 1 : 0;
-			covered.push(getCount({
-				startOffset: branch.start + bias + this.wrapperLength,
-				endOffset: branch.end - bias + this.wrapperLength
-			}, this.ranges));
-		}
-		if (type === "if") {
-			if (locations.length > 0) locations[0] = loc;
-		}
-		if (locations.length === 0) return;
-		if (this.ignoreSourceCode) {
-			const sources = this.locator.getSourceLines(loc, this.#getSourceFilename(loc));
-			if (sources != null && this.ignoreSourceCode(sources, "branch", {
-				start: {
-					line: loc.start.line,
-					column: loc.start.column
-				},
-				end: {
-					line: loc.end.line,
-					column: loc.end.column
-				}
-			})) return;
-		}
-		addBranch({
-			coverageMapData: this.coverageMapData,
-			loc,
-			locations,
-			type,
-			covered,
-			filename: this.#getSourceFilename(loc)
-		});
-	}
-	generate() {
-		this.locator.reset();
-		return this.coverageMapData;
-	}
-	#getSourceFilename(position) {
-		const sourceFilename = position.start.filename || position.end.filename;
-		if (!sourceFilename) throw new Error(`Missing original filename for ${JSON.stringify(position, null, 2)}`);
-		if (sourceFilename.startsWith("file://")) return fileURLToPath(sourceFilename);
-		return resolve(this.directory, sourceFilename);
-	}
-	#onIgnore(node, type) {
-		if (!this.ignoreNode) return false;
-		const scope = this.ignoreNode(node, type);
-		if (scope === "ignore-this-and-nested-nodes") this.onIgnoreNode(node);
-		return scope;
-	}
-};
-
-//#endregion
-//#region src/index.ts
-/**
-* Maps V8 `ScriptCoverage` to Istanbul's `CoverageMap`.
-* Results are identical with `istanbul-lib-instrument`.
-*/
-async function convert(options) {
-	const ignoreHints = getIgnoreHints(options.code);
-	if (ignoreHints.length === 1 && ignoreHints[0].type === "file") return {};
-	const walker = getWalker();
-	const mapper = await CoverageMapper.create(options, walker.onIgnore);
-	const ast = await options.ast;
-	await walker.walk(ast, ignoreHints, options.ignoreClassMethods, {
-		onFunctionDeclaration(node) {
-			mapper.onFunction(node, {
-				loc: node.body,
-				decl: node.id || {
-					...node,
-					end: node.start + 1
-				}
-			});
-		},
-		onFunctionExpression(node) {
-			if (isCovered(node)) return;
-			mapper.onFunction(node, {
-				loc: node.body,
-				decl: node.id || {
-					...node,
-					end: node.start + 1
-				}
-			});
-		},
-		onArrowFunctionExpression(node) {
-			mapper.onFunction(node, {
-				loc: node.body,
-				decl: {
-					...node,
-					end: node.start + 1
-				}
-			});
-			if (node.body.type !== "BlockStatement") mapper.onStatement(node.body, node);
-		},
-		onMethodDefinition(node) {
-			if (node.value.type === "FunctionExpression") setCovered(node.value);
-			mapper.onFunction(node, {
-				loc: node.value.body,
-				decl: node.key
-			});
-		},
-		onProperty(node) {
-			if (node.value.type === "FunctionExpression") {
-				setCovered(node.value);
-				mapper.onFunction(node, {
-					loc: node.value.body,
-					decl: node.key
-				});
-			}
-		},
-		onClassMethod(babelNode) {
-			const node = {
-				type: "FunctionExpression",
-				start: babelNode.start,
-				end: babelNode.end,
-				body: {
-					type: "BlockStatement",
-					start: babelNode.body.start,
-					end: babelNode.body.end,
-					body: []
-				},
-				params: []
-			};
-			mapper.onFunction(node, {
-				loc: node.body,
-				decl: {
-					start: babelNode.key.start,
-					end: babelNode.key.end
-				}
-			});
-		},
-		onObjectMethod(babelNode) {
-			const node = {
-				type: "FunctionExpression",
-				start: babelNode.start,
-				end: babelNode.end,
-				body: {
-					type: "BlockStatement",
-					start: babelNode.body.start,
-					end: babelNode.body.end,
-					body: []
-				},
-				params: []
-			};
-			mapper.onFunction(node, {
-				loc: node.body,
-				decl: {
-					start: babelNode.key.start,
-					end: babelNode.key.end
-				}
-			});
-		},
-		onBreakStatement: (node) => mapper.onStatement(node),
-		onContinueStatement: (node) => mapper.onStatement(node),
-		onDebuggerStatement: (node) => mapper.onStatement(node),
-		onReturnStatement: (node) => mapper.onStatement(node),
-		onThrowStatement: (node) => mapper.onStatement(node),
-		onTryStatement: (node) => mapper.onStatement(node),
-		onForStatement: (node) => mapper.onStatement(node),
-		onForInStatement: (node) => mapper.onStatement(node),
-		onForOfStatement: (node) => mapper.onStatement(node),
-		onWhileStatement: (node) => mapper.onStatement(node),
-		onDoWhileStatement: (node) => mapper.onStatement(node),
-		onWithStatement: (node) => mapper.onStatement(node),
-		onLabeledStatement: (node) => mapper.onStatement(node),
-		onExpressionStatement(node) {
-			if (node.expression.type === "Literal" && node.expression.value === "use strict") return;
-			mapper.onStatement(node);
-		},
-		onVariableDeclarator(node) {
-			if (node.init) mapper.onStatement(node.init, node);
-		},
-		onClassBody(node) {
-			for (const child of node.body) if ((child.type === "PropertyDefinition" || child.type === "ClassProperty" || child.type === "ClassPrivateProperty") && child.value) mapper.onStatement(child.value);
-		},
-		onIfStatement(node, branches) {
-			mapper.onBranch("if", node, branches);
-			mapper.onStatement(node);
-		},
-		onConditionalExpression(node, branches) {
-			mapper.onBranch("cond-expr", node, branches);
-		},
-		onLogicalExpression(node, branches) {
-			mapper.onBranch("binary-expr", node, branches);
-		},
-		onSwitchStatement(node, cases) {
-			mapper.onBranch("switch", node, cases);
-			mapper.onStatement(node);
-		},
-		onAssignmentPattern(node) {
-			mapper.onBranch("default-arg", node, [node.right]);
-		}
-	});
-	return mapper.generate();
-}
-const coveredNodes = /* @__PURE__ */ new WeakSet();
-function setCovered(node) {
-	coveredNodes.add(node);
-}
-function isCovered(node) {
-	return coveredNodes.has(node);
-}
-
-//#endregion
-export { convert, convert as default };
\ No newline at end of file
diff --git a/vanilla/node_modules/ast-v8-to-istanbul/package.json b/vanilla/node_modules/ast-v8-to-istanbul/package.json
deleted file mode 100644
index d3cae0b..0000000
--- a/vanilla/node_modules/ast-v8-to-istanbul/package.json
+++ /dev/null
@@ -1,71 +0,0 @@
-{
-  "name": "ast-v8-to-istanbul",
-  "version": "0.3.11",
-  "description": "AST-aware v8-to-istanbul",
-  "homepage": "https://github.com/AriPerkkio/ast-v8-to-istanbul",
-  "bugs": "https://github.com/AriPerkkio/ast-v8-to-istanbul",
-  "license": "MIT",
-  "author": "Ari Perkkiö <ari.perkkio@gmail.com>",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/AriPerkkio/ast-v8-to-istanbul.git"
-  },
-  "files": [
-    "dist"
-  ],
-  "type": "module",
-  "types": "./dist/index.d.mts",
-  "exports": "./dist/index.mjs",
-  "dependencies": {
-    "@jridgewell/trace-mapping": "^0.3.31",
-    "estree-walker": "^3.0.3",
-    "js-tokens": "^10.0.0"
-  },
-  "devDependencies": {
-    "@babel/parser": "^7.28.6",
-    "@babel/types": "^7.28.6",
-    "@sveltejs/vite-plugin-svelte": "^6.2.4",
-    "@types/estree": "^1.0.8",
-    "@types/istanbul-lib-coverage": "^2.0.6",
-    "@types/istanbul-lib-instrument": "^1.7.8",
-    "@types/istanbul-lib-report": "^3.0.3",
-    "@types/istanbul-lib-source-maps": "^4.0.4",
-    "@types/istanbul-reports": "^3.0.4",
-    "@types/node": "^25.0.10",
-    "@vitejs/plugin-vue": "^6.0.3",
-    "@vitest/coverage-istanbul": "^4.0.18",
-    "@vitest/coverage-v8": "^4.0.18",
-    "acorn": "^8.15.0",
-    "gh-pages": "^6.3.0",
-    "istanbul-lib-coverage": "^3.2.2",
-    "istanbul-lib-instrument": "^6.0.3",
-    "istanbul-lib-report": "^3.0.1",
-    "istanbul-lib-source-maps": "^5.0.6",
-    "istanbul-reports": "^3.2.0",
-    "magic-string": "^0.30.21",
-    "oxc-parser": "^0.110.0",
-    "oxfmt": "^0.27.0",
-    "oxlint": "^1.42.0",
-    "oxlint-tsgolint": "^0.11.2",
-    "publint": "^0.3.17",
-    "rollup": "^4.56.0",
-    "tinyrainbow": "^3.0.3",
-    "tsdown": "^0.20.1",
-    "typescript": "^5.9.3",
-    "vite": "^7.3.1",
-    "vitest": "^4.0.18",
-    "vue": "^3.5.27",
-    "yaml": "^2.8.2"
-  },
-  "scripts": {
-    "dev": "tsdown --watch --sourcemap",
-    "build": "tsdown",
-    "deploy": "touch coverage/.nojekyll && gh-pages --dist coverage --dotfiles",
-    "test": "vitest",
-    "test:dev": "vitest --project 'vite/parseAstAsync'",
-    "lint": "oxlint --type-aware && oxfmt --check && publint",
-    "typecheck": "tsc --noEmit",
-    "debug": "open fixture-coverage/index.html istanbul-coverage/index.html",
-    "verify": "pnpm build; pnpm lint; pnpm typecheck; pnpm run test --run; pnpm bench"
-  }
-}
\ No newline at end of file
-- 
cgit v1.2.3