fix bugs

client/config/index.ts

@@ -1,7 +1,5 @@
 import { defineConfig } from '@tarojs/cli'
 import TsconfigPathsPlugin from 'tsconfig-paths-webpack-plugin'
-// 导入sass
-import * as sass from 'sass'
 
 import devConfig from './dev'
 import prodConfig from './prod'

client/src/app.ts

@@ -1,39 +0,0 @@
-import React from 'react'
-import { createApp } from 'react'
-import Taro from '@tarojs/taro'
-import './app.scss'
-
-/**
- * 初始化云开发环境
- */
-function initCloud() {
-  const env = 'lineforfun-dev'; // 默认环境ID
-  
-  if (process.env.TARO_ENV === 'weapp') {
-    if (!Taro.cloud) {
-      console.error('请使用 2.2.3 或以上的基础库以使用云能力');
-    } else {
-      Taro.cloud.init({
-        env,
-        traceUser: true
-      });
-      console.log('云开发初始化成功');
-    }
-  }
-}
-
-// App组件props定义
-export interface IAppProps {
-  children: React.ReactNode;
-}
-
-function App({ children }: IAppProps) {
-  // 在应用初次加载时初始化云环境
-  React.useEffect(() => {
-    initCloud();
-  }, []);
-
-  return children;
-}
-
-export default createApp(App)

client/src/app.tsx

@@ -1,5 +1,4 @@
 import React, { useEffect } from 'react';
-import { createApp } from 'react';
 import Taro from '@tarojs/taro';
 import { AppProvider } from './contexts/AppProvider';
 import './app.scss';
@@ -8,7 +7,7 @@ import './app.scss';
  * 初始化云开发环境
  */
 function initCloud() {
-  const env = 'lineforfun-dev'; // 默认环境ID
+  const env = 'lineforfun-dev';
   
   if (process.env.TARO_ENV === 'weapp') {
     if (!Taro.cloud) {
@@ -23,13 +22,7 @@ function initCloud() {
   }
 }
 
-// App组件props定义
-export interface IAppProps {
-  children: React.ReactNode;
-}
-
-function App({ children }: IAppProps) {
-  // 在应用初次加载时初始化云环境
+function App({ children }: {children: React.ReactNode}) {
   useEffect(() => {
     initCloud();
   }, []);
@@ -41,4 +34,4 @@ function App({ children }: IAppProps) {
   );
 }
 
-export default createApp(App); 
+export default App;

node_modules/.bin/browserslist

@@ -0,0 +1,17 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/browserslist@4.24.4/node_modules/browserslist/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/browserslist@4.24.4/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/browserslist@4.24.4/node_modules/browserslist/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/browserslist@4.24.4/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../.pnpm/browserslist@4.24.4/node_modules/browserslist/cli.js" "$@"
+else
+  exec node  "$basedir/../.pnpm/browserslist@4.24.4/node_modules/browserslist/cli.js" "$@"
+fi

node_modules/.bin/terser

@@ -0,0 +1,17 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/terser@5.39.0/node_modules/terser/bin/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/terser@5.39.0/node_modules/terser/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/terser@5.39.0/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/terser@5.39.0/node_modules/terser/bin/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/terser@5.39.0/node_modules/terser/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/terser@5.39.0/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../.pnpm/terser@5.39.0/node_modules/terser/bin/terser" "$@"
+else
+  exec node  "$basedir/../.pnpm/terser@5.39.0/node_modules/terser/bin/terser" "$@"
+fi

node_modules/.bin/webpack

@@ -0,0 +1,17 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/webpack@5.98.0/node_modules/webpack/bin/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/webpack@5.98.0/node_modules/webpack/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/webpack@5.98.0/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/webpack@5.98.0/node_modules/webpack/bin/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/webpack@5.98.0/node_modules/webpack/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/webpack@5.98.0/node_modules:/Users/zejiawu/Projects/miniprogram-lineforfun/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../.pnpm/webpack@5.98.0/node_modules/webpack/bin/webpack.js" "$@"
+else
+  exec node  "$basedir/../.pnpm/webpack@5.98.0/node_modules/webpack/bin/webpack.js" "$@"
+fi

node_modules/.pnpm/@jridgewell+gen-mapping@0.3.8/node_modules/@jridgewell/gen-mapping/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2022 Justin Ridgewell <jridgewell@google.com>
+
+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/.pnpm/@jridgewell+gen-mapping@0.3.8/node_modules/@jridgewell/gen-mapping/README.md

@@ -0,0 +1,227 @@
+# @jridgewell/gen-mapping
+
+> Generate source maps
+
+`gen-mapping` allows you to generate a source map during transpilation or minification.
+With a source map, you're able to trace the original location in the source file, either in Chrome's
+DevTools or using a library like [`@jridgewell/trace-mapping`][trace-mapping].
+
+You may already be familiar with the [`source-map`][source-map] package's `SourceMapGenerator`. This
+provides the same `addMapping` and `setSourceContent` API.
+
+## Installation
+
+```sh
+npm install @jridgewell/gen-mapping
+```
+
+## Usage
+
+```typescript
+import { GenMapping, addMapping, setSourceContent, toEncodedMap, toDecodedMap } from '@jridgewell/gen-mapping';
+
+const map = new GenMapping({
+  file: 'output.js',
+  sourceRoot: 'https://example.com/',
+});
+
+setSourceContent(map, 'input.js', `function foo() {}`);
+
+addMapping(map, {
+  // Lines start at line 1, columns at column 0.
+  generated: { line: 1, column: 0 },
+  source: 'input.js',
+  original: { line: 1, column: 0 },
+});
+
+addMapping(map, {
+  generated: { line: 1, column: 9 },
+  source: 'input.js',
+  original: { line: 1, column: 9 },
+  name: 'foo',
+});
+
+assert.deepEqual(toDecodedMap(map), {
+  version: 3,
+  file: 'output.js',
+  names: ['foo'],
+  sourceRoot: 'https://example.com/',
+  sources: ['input.js'],
+  sourcesContent: ['function foo() {}'],
+  mappings: [
+    [ [0, 0, 0, 0], [9, 0, 0, 9, 0] ]
+  ],
+});
+
+assert.deepEqual(toEncodedMap(map), {
+  version: 3,
+  file: 'output.js',
+  names: ['foo'],
+  sourceRoot: 'https://example.com/',
+  sources: ['input.js'],
+  sourcesContent: ['function foo() {}'],
+  mappings: 'AAAA,SAASA',
+});
+```
+
+### Smaller Sourcemaps
+
+Not everything needs to be added to a sourcemap, and needless markings can cause signficantly
+larger file sizes. `gen-mapping` exposes `maybeAddSegment`/`maybeAddMapping` APIs that will
+intelligently determine if this marking adds useful information. If not, the marking will be
+skipped.
+
+```typescript
+import { maybeAddMapping } from '@jridgewell/gen-mapping';
+
+const map = new GenMapping();
+
+// Adding a sourceless marking at the beginning of a line isn't useful.
+maybeAddMapping(map, {
+  generated: { line: 1, column: 0 },
+});
+
+// Adding a new source marking is useful.
+maybeAddMapping(map, {
+  generated: { line: 1, column: 0 },
+  source: 'input.js',
+  original: { line: 1, column: 0 },
+});
+
+// But adding another marking pointing to the exact same original location isn't, even if the
+// generated column changed.
+maybeAddMapping(map, {
+  generated: { line: 1, column: 9 },
+  source: 'input.js',
+  original: { line: 1, column: 0 },
+});
+
+assert.deepEqual(toEncodedMap(map), {
+  version: 3,
+  names: [],
+  sources: ['input.js'],
+  sourcesContent: [null],
+  mappings: 'AAAA',
+});
+```
+
+## Benchmarks
+
+```
+node v18.0.0
+
+amp.js.map
+Memory Usage:
+gen-mapping: addSegment      5852872 bytes
+gen-mapping: addMapping      7716042 bytes
+source-map-js                6143250 bytes
+source-map-0.6.1             6124102 bytes
+source-map-0.8.0             6121173 bytes
+Smallest memory usage is gen-mapping: addSegment
+
+Adding speed:
+gen-mapping:      addSegment x 441 ops/sec ±2.07% (90 runs sampled)
+gen-mapping:      addMapping x 350 ops/sec ±2.40% (86 runs sampled)
+source-map-js:    addMapping x 169 ops/sec ±2.42% (80 runs sampled)
+source-map-0.6.1: addMapping x 167 ops/sec ±2.56% (80 runs sampled)
+source-map-0.8.0: addMapping x 168 ops/sec ±2.52% (80 runs sampled)
+Fastest is gen-mapping:      addSegment
+
+Generate speed:
+gen-mapping:      decoded output x 150,824,370 ops/sec ±0.07% (102 runs sampled)
+gen-mapping:      encoded output x 663 ops/sec ±0.22% (98 runs sampled)
+source-map-js:    encoded output x 197 ops/sec ±0.45% (84 runs sampled)
+source-map-0.6.1: encoded output x 198 ops/sec ±0.33% (85 runs sampled)
+source-map-0.8.0: encoded output x 197 ops/sec ±0.06% (93 runs sampled)
+Fastest is gen-mapping:      decoded output
+
+
+***
+
+
+babel.min.js.map
+Memory Usage:
+gen-mapping: addSegment     37578063 bytes
+gen-mapping: addMapping     37212897 bytes
+source-map-js               47638527 bytes
+source-map-0.6.1            47690503 bytes
+source-map-0.8.0            47470188 bytes
+Smallest memory usage is gen-mapping: addMapping
+
+Adding speed:
+gen-mapping:      addSegment x 31.05 ops/sec ±8.31% (43 runs sampled)
+gen-mapping:      addMapping x 29.83 ops/sec ±7.36% (51 runs sampled)
+source-map-js:    addMapping x 20.73 ops/sec ±6.22% (38 runs sampled)
+source-map-0.6.1: addMapping x 20.03 ops/sec ±10.51% (38 runs sampled)
+source-map-0.8.0: addMapping x 19.30 ops/sec ±8.27% (37 runs sampled)
+Fastest is gen-mapping:      addSegment
+
+Generate speed:
+gen-mapping:      decoded output x 381,379,234 ops/sec ±0.29% (96 runs sampled)
+gen-mapping:      encoded output x 95.15 ops/sec ±2.98% (72 runs sampled)
+source-map-js:    encoded output x 15.20 ops/sec ±7.41% (33 runs sampled)
+source-map-0.6.1: encoded output x 16.36 ops/sec ±10.46% (31 runs sampled)
+source-map-0.8.0: encoded output x 16.06 ops/sec ±6.45% (31 runs sampled)
+Fastest is gen-mapping:      decoded output
+
+
+***
+
+
+preact.js.map
+Memory Usage:
+gen-mapping: addSegment       416247 bytes
+gen-mapping: addMapping       419824 bytes
+source-map-js                1024619 bytes
+source-map-0.6.1             1146004 bytes
+source-map-0.8.0             1113250 bytes
+Smallest memory usage is gen-mapping: addSegment
+
+Adding speed:
+gen-mapping:      addSegment x 13,755 ops/sec ±0.15% (98 runs sampled)
+gen-mapping:      addMapping x 13,013 ops/sec ±0.11% (101 runs sampled)
+source-map-js:    addMapping x 4,564 ops/sec ±0.21% (98 runs sampled)
+source-map-0.6.1: addMapping x 4,562 ops/sec ±0.11% (99 runs sampled)
+source-map-0.8.0: addMapping x 4,593 ops/sec ±0.11% (100 runs sampled)
+Fastest is gen-mapping:      addSegment
+
+Generate speed:
+gen-mapping:      decoded output x 379,864,020 ops/sec ±0.23% (93 runs sampled)
+gen-mapping:      encoded output x 14,368 ops/sec ±4.07% (82 runs sampled)
+source-map-js:    encoded output x 5,261 ops/sec ±0.21% (99 runs sampled)
+source-map-0.6.1: encoded output x 5,124 ops/sec ±0.58% (99 runs sampled)
+source-map-0.8.0: encoded output x 5,434 ops/sec ±0.33% (96 runs sampled)
+Fastest is gen-mapping:      decoded output
+
+
+***
+
+
+react.js.map
+Memory Usage:
+gen-mapping: addSegment       975096 bytes
+gen-mapping: addMapping      1102981 bytes
+source-map-js                2918836 bytes
+source-map-0.6.1             2885435 bytes
+source-map-0.8.0             2874336 bytes
+Smallest memory usage is gen-mapping: addSegment
+
+Adding speed:
+gen-mapping:      addSegment x 4,772 ops/sec ±0.15% (100 runs sampled)
+gen-mapping:      addMapping x 4,456 ops/sec ±0.13% (97 runs sampled)
+source-map-js:    addMapping x 1,618 ops/sec ±0.24% (97 runs sampled)
+source-map-0.6.1: addMapping x 1,622 ops/sec ±0.12% (99 runs sampled)
+source-map-0.8.0: addMapping x 1,631 ops/sec ±0.12% (100 runs sampled)
+Fastest is gen-mapping:      addSegment
+
+Generate speed:
+gen-mapping:      decoded output x 379,107,695 ops/sec ±0.07% (99 runs sampled)
+gen-mapping:      encoded output x 5,421 ops/sec ±1.60% (89 runs sampled)
+source-map-js:    encoded output x 2,113 ops/sec ±1.81% (98 runs sampled)
+source-map-0.6.1: encoded output x 2,126 ops/sec ±0.10% (100 runs sampled)
+source-map-0.8.0: encoded output x 2,176 ops/sec ±0.39% (98 runs sampled)
+Fastest is gen-mapping:      decoded output
+```
+
+[source-map]: https://www.npmjs.com/package/source-map
+[trace-mapping]: https://github.com/jridgewell/trace-mapping

node_modules/.pnpm/@jridgewell+gen-mapping@0.3.8/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs

@@ -0,0 +1,230 @@
+import { SetArray, put, remove } from '@jridgewell/set-array';
+import { encode } from '@jridgewell/sourcemap-codec';
+import { TraceMap, decodedMappings } from '@jridgewell/trace-mapping';
+
+const COLUMN = 0;
+const SOURCES_INDEX = 1;
+const SOURCE_LINE = 2;
+const SOURCE_COLUMN = 3;
+const NAMES_INDEX = 4;
+
+const NO_NAME = -1;
+/**
+ * Provides the state to generate a sourcemap.
+ */
+class GenMapping {
+    constructor({ file, sourceRoot } = {}) {
+        this._names = new SetArray();
+        this._sources = new SetArray();
+        this._sourcesContent = [];
+        this._mappings = [];
+        this.file = file;
+        this.sourceRoot = sourceRoot;
+        this._ignoreList = new SetArray();
+    }
+}
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+ * with public access modifiers.
+ */
+function cast(map) {
+    return map;
+}
+function addSegment(map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+    return addSegmentInternal(false, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
+}
+function addMapping(map, mapping) {
+    return addMappingInternal(false, map, mapping);
+}
+/**
+ * Same as `addSegment`, but will only add the segment if it generates useful information in the
+ * resulting map. This only works correctly if segments are added **in order**, meaning you should
+ * not add a segment with a lower generated line/column than one that came before.
+ */
+const maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
+    return addSegmentInternal(true, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
+};
+/**
+ * Same as `addMapping`, but will only add the mapping if it generates useful information in the
+ * resulting map. This only works correctly if mappings are added **in order**, meaning you should
+ * not add a mapping with a lower generated line/column than one that came before.
+ */
+const maybeAddMapping = (map, mapping) => {
+    return addMappingInternal(true, map, mapping);
+};
+/**
+ * Adds/removes the content of the source file to the source map.
+ */
+function setSourceContent(map, source, content) {
+    const { _sources: sources, _sourcesContent: sourcesContent } = cast(map);
+    const index = put(sources, source);
+    sourcesContent[index] = content;
+}
+function setIgnore(map, source, ignore = true) {
+    const { _sources: sources, _sourcesContent: sourcesContent, _ignoreList: ignoreList } = cast(map);
+    const index = put(sources, source);
+    if (index === sourcesContent.length)
+        sourcesContent[index] = null;
+    if (ignore)
+        put(ignoreList, index);
+    else
+        remove(ignoreList, index);
+}
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+function toDecodedMap(map) {
+    const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, _ignoreList: ignoreList, } = cast(map);
+    removeEmptyFinalLines(mappings);
+    return {
+        version: 3,
+        file: map.file || undefined,
+        names: names.array,
+        sourceRoot: map.sourceRoot || undefined,
+        sources: sources.array,
+        sourcesContent,
+        mappings,
+        ignoreList: ignoreList.array,
+    };
+}
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+function toEncodedMap(map) {
+    const decoded = toDecodedMap(map);
+    return Object.assign(Object.assign({}, decoded), { mappings: encode(decoded.mappings) });
+}
+/**
+ * Constructs a new GenMapping, using the already present mappings of the input.
+ */
+function fromMap(input) {
+    const map = new TraceMap(input);
+    const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot });
+    putAll(cast(gen)._names, map.names);
+    putAll(cast(gen)._sources, map.sources);
+    cast(gen)._sourcesContent = map.sourcesContent || map.sources.map(() => null);
+    cast(gen)._mappings = decodedMappings(map);
+    if (map.ignoreList)
+        putAll(cast(gen)._ignoreList, map.ignoreList);
+    return gen;
+}
+/**
+ * Returns an array of high-level mapping objects for every recorded segment, which could then be
+ * passed to the `source-map` library.
+ */
+function allMappings(map) {
+    const out = [];
+    const { _mappings: mappings, _sources: sources, _names: names } = cast(map);
+    for (let i = 0; i < mappings.length; i++) {
+        const line = mappings[i];
+        for (let j = 0; j < line.length; j++) {
+            const seg = line[j];
+            const generated = { line: i + 1, column: seg[COLUMN] };
+            let source = undefined;
+            let original = undefined;
+            let name = undefined;
+            if (seg.length !== 1) {
+                source = sources.array[seg[SOURCES_INDEX]];
+                original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] };
+                if (seg.length === 5)
+                    name = names.array[seg[NAMES_INDEX]];
+            }
+            out.push({ generated, source, original, name });
+        }
+    }
+    return out;
+}
+// This split declaration is only so that terser can elminiate the static initialization block.
+function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+    const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = cast(map);
+    const line = getLine(mappings, genLine);
+    const index = getColumnIndex(line, genColumn);
+    if (!source) {
+        if (skipable && skipSourceless(line, index))
+            return;
+        return insert(line, index, [genColumn]);
+    }
+    const sourcesIndex = put(sources, source);
+    const namesIndex = name ? put(names, name) : NO_NAME;
+    if (sourcesIndex === sourcesContent.length)
+        sourcesContent[sourcesIndex] = content !== null && content !== void 0 ? content : null;
+    if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
+        return;
+    }
+    return insert(line, index, name
+        ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
+        : [genColumn, sourcesIndex, sourceLine, sourceColumn]);
+}
+function getLine(mappings, index) {
+    for (let i = mappings.length; i <= index; i++) {
+        mappings[i] = [];
+    }
+    return mappings[index];
+}
+function getColumnIndex(line, genColumn) {
+    let index = line.length;
+    for (let i = index - 1; i >= 0; index = i--) {
+        const current = line[i];
+        if (genColumn >= current[COLUMN])
+            break;
+    }
+    return index;
+}
+function insert(array, index, value) {
+    for (let i = array.length; i > index; i--) {
+        array[i] = array[i - 1];
+    }
+    array[index] = value;
+}
+function removeEmptyFinalLines(mappings) {
+    const { length } = mappings;
+    let len = length;
+    for (let i = len - 1; i >= 0; len = i, i--) {
+        if (mappings[i].length > 0)
+            break;
+    }
+    if (len < length)
+        mappings.length = len;
+}
+function putAll(setarr, array) {
+    for (let i = 0; i < array.length; i++)
+        put(setarr, array[i]);
+}
+function skipSourceless(line, index) {
+    // The start of a line is already sourceless, so adding a sourceless segment to the beginning
+    // doesn't generate any useful information.
+    if (index === 0)
+        return true;
+    const prev = line[index - 1];
+    // If the previous segment is also sourceless, then adding another sourceless segment doesn't
+    // genrate any new information. Else, this segment will end the source/named segment and point to
+    // a sourceless position, which is useful.
+    return prev.length === 1;
+}
+function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
+    // A source/named segment at the start of a line gives position at that genColumn
+    if (index === 0)
+        return false;
+    const prev = line[index - 1];
+    // If the previous segment is sourceless, then we're transitioning to a source.
+    if (prev.length === 1)
+        return false;
+    // If the previous segment maps to the exact same source position, then this segment doesn't
+    // provide any new position information.
+    return (sourcesIndex === prev[SOURCES_INDEX] &&
+        sourceLine === prev[SOURCE_LINE] &&
+        sourceColumn === prev[SOURCE_COLUMN] &&
+        namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME));
+}
+function addMappingInternal(skipable, map, mapping) {
+    const { generated, source, original, name, content } = mapping;
+    if (!source) {
+        return addSegmentInternal(skipable, map, generated.line - 1, generated.column, null, null, null, null, null);
+    }
+    return addSegmentInternal(skipable, map, generated.line - 1, generated.column, source, original.line - 1, original.column, name, content);
+}
+
+export { GenMapping, addMapping, addSegment, allMappings, fromMap, maybeAddMapping, maybeAddSegment, setIgnore, setSourceContent, toDecodedMap, toEncodedMap };
+//# sourceMappingURL=gen-mapping.mjs.map

node_modules/.pnpm/@jridgewell+gen-mapping@0.3.8/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js

@@ -0,0 +1,246 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@jridgewell/set-array'), require('@jridgewell/sourcemap-codec'), require('@jridgewell/trace-mapping')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@jridgewell/set-array', '@jridgewell/sourcemap-codec', '@jridgewell/trace-mapping'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.genMapping = {}, global.setArray, global.sourcemapCodec, global.traceMapping));
+})(this, (function (exports, setArray, sourcemapCodec, traceMapping) { 'use strict';
+
+    const COLUMN = 0;
+    const SOURCES_INDEX = 1;
+    const SOURCE_LINE = 2;
+    const SOURCE_COLUMN = 3;
+    const NAMES_INDEX = 4;
+
+    const NO_NAME = -1;
+    /**
+     * Provides the state to generate a sourcemap.
+     */
+    class GenMapping {
+        constructor({ file, sourceRoot } = {}) {
+            this._names = new setArray.SetArray();
+            this._sources = new setArray.SetArray();
+            this._sourcesContent = [];
+            this._mappings = [];
+            this.file = file;
+            this.sourceRoot = sourceRoot;
+            this._ignoreList = new setArray.SetArray();
+        }
+    }
+    /**
+     * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+     * with public access modifiers.
+     */
+    function cast(map) {
+        return map;
+    }
+    function addSegment(map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+        return addSegmentInternal(false, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
+    }
+    function addMapping(map, mapping) {
+        return addMappingInternal(false, map, mapping);
+    }
+    /**
+     * Same as `addSegment`, but will only add the segment if it generates useful information in the
+     * resulting map. This only works correctly if segments are added **in order**, meaning you should
+     * not add a segment with a lower generated line/column than one that came before.
+     */
+    const maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
+        return addSegmentInternal(true, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
+    };
+    /**
+     * Same as `addMapping`, but will only add the mapping if it generates useful information in the
+     * resulting map. This only works correctly if mappings are added **in order**, meaning you should
+     * not add a mapping with a lower generated line/column than one that came before.
+     */
+    const maybeAddMapping = (map, mapping) => {
+        return addMappingInternal(true, map, mapping);
+    };
+    /**
+     * Adds/removes the content of the source file to the source map.
+     */
+    function setSourceContent(map, source, content) {
+        const { _sources: sources, _sourcesContent: sourcesContent } = cast(map);
+        const index = setArray.put(sources, source);
+        sourcesContent[index] = content;
+    }
+    function setIgnore(map, source, ignore = true) {
+        const { _sources: sources, _sourcesContent: sourcesContent, _ignoreList: ignoreList } = cast(map);
+        const index = setArray.put(sources, source);
+        if (index === sourcesContent.length)
+            sourcesContent[index] = null;
+        if (ignore)
+            setArray.put(ignoreList, index);
+        else
+            setArray.remove(ignoreList, index);
+    }
+    /**
+     * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+     * a sourcemap, or to JSON.stringify.
+     */
+    function toDecodedMap(map) {
+        const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, _ignoreList: ignoreList, } = cast(map);
+        removeEmptyFinalLines(mappings);
+        return {
+            version: 3,
+            file: map.file || undefined,
+            names: names.array,
+            sourceRoot: map.sourceRoot || undefined,
+            sources: sources.array,
+            sourcesContent,
+            mappings,
+            ignoreList: ignoreList.array,
+        };
+    }
+    /**
+     * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+     * a sourcemap, or to JSON.stringify.
+     */
+    function toEncodedMap(map) {
+        const decoded = toDecodedMap(map);
+        return Object.assign(Object.assign({}, decoded), { mappings: sourcemapCodec.encode(decoded.mappings) });
+    }
+    /**
+     * Constructs a new GenMapping, using the already present mappings of the input.
+     */
+    function fromMap(input) {
+        const map = new traceMapping.TraceMap(input);
+        const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot });
+        putAll(cast(gen)._names, map.names);
+        putAll(cast(gen)._sources, map.sources);
+        cast(gen)._sourcesContent = map.sourcesContent || map.sources.map(() => null);
+        cast(gen)._mappings = traceMapping.decodedMappings(map);
+        if (map.ignoreList)
+            putAll(cast(gen)._ignoreList, map.ignoreList);
+        return gen;
+    }
+    /**
+     * Returns an array of high-level mapping objects for every recorded segment, which could then be
+     * passed to the `source-map` library.
+     */
+    function allMappings(map) {
+        const out = [];
+        const { _mappings: mappings, _sources: sources, _names: names } = cast(map);
+        for (let i = 0; i < mappings.length; i++) {
+            const line = mappings[i];
+            for (let j = 0; j < line.length; j++) {
+                const seg = line[j];
+                const generated = { line: i + 1, column: seg[COLUMN] };
+                let source = undefined;
+                let original = undefined;
+                let name = undefined;
+                if (seg.length !== 1) {
+                    source = sources.array[seg[SOURCES_INDEX]];
+                    original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] };
+                    if (seg.length === 5)
+                        name = names.array[seg[NAMES_INDEX]];
+                }
+                out.push({ generated, source, original, name });
+            }
+        }
+        return out;
+    }
+    // This split declaration is only so that terser can elminiate the static initialization block.
+    function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+        const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = cast(map);
+        const line = getLine(mappings, genLine);
+        const index = getColumnIndex(line, genColumn);
+        if (!source) {
+            if (skipable && skipSourceless(line, index))
+                return;
+            return insert(line, index, [genColumn]);
+        }
+        const sourcesIndex = setArray.put(sources, source);
+        const namesIndex = name ? setArray.put(names, name) : NO_NAME;
+        if (sourcesIndex === sourcesContent.length)
+            sourcesContent[sourcesIndex] = content !== null && content !== void 0 ? content : null;
+        if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
+            return;
+        }
+        return insert(line, index, name
+            ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
+            : [genColumn, sourcesIndex, sourceLine, sourceColumn]);
+    }
+    function getLine(mappings, index) {
+        for (let i = mappings.length; i <= index; i++) {
+            mappings[i] = [];
+        }
+        return mappings[index];
+    }
+    function getColumnIndex(line, genColumn) {
+        let index = line.length;
+        for (let i = index - 1; i >= 0; index = i--) {
+            const current = line[i];
+            if (genColumn >= current[COLUMN])
+                break;
+        }
+        return index;
+    }
+    function insert(array, index, value) {
+        for (let i = array.length; i > index; i--) {
+            array[i] = array[i - 1];
+        }
+        array[index] = value;
+    }
+    function removeEmptyFinalLines(mappings) {
+        const { length } = mappings;
+        let len = length;
+        for (let i = len - 1; i >= 0; len = i, i--) {
+            if (mappings[i].length > 0)
+                break;
+        }
+        if (len < length)
+            mappings.length = len;
+    }
+    function putAll(setarr, array) {
+        for (let i = 0; i < array.length; i++)
+            setArray.put(setarr, array[i]);
+    }
+    function skipSourceless(line, index) {
+        // The start of a line is already sourceless, so adding a sourceless segment to the beginning
+        // doesn't generate any useful information.
+        if (index === 0)
+            return true;
+        const prev = line[index - 1];
+        // If the previous segment is also sourceless, then adding another sourceless segment doesn't
+        // genrate any new information. Else, this segment will end the source/named segment and point to
+        // a sourceless position, which is useful.
+        return prev.length === 1;
+    }
+    function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
+        // A source/named segment at the start of a line gives position at that genColumn
+        if (index === 0)
+            return false;
+        const prev = line[index - 1];
+        // If the previous segment is sourceless, then we're transitioning to a source.
+        if (prev.length === 1)
+            return false;
+        // If the previous segment maps to the exact same source position, then this segment doesn't
+        // provide any new position information.
+        return (sourcesIndex === prev[SOURCES_INDEX] &&
+            sourceLine === prev[SOURCE_LINE] &&
+            sourceColumn === prev[SOURCE_COLUMN] &&
+            namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME));
+    }
+    function addMappingInternal(skipable, map, mapping) {
+        const { generated, source, original, name, content } = mapping;
+        if (!source) {
+            return addSegmentInternal(skipable, map, generated.line - 1, generated.column, null, null, null, null, null);
+        }
+        return addSegmentInternal(skipable, map, generated.line - 1, generated.column, source, original.line - 1, original.column, name, content);
+    }
+
+    exports.GenMapping = GenMapping;
+    exports.addMapping = addMapping;
+    exports.addSegment = addSegment;
+    exports.allMappings = allMappings;
+    exports.fromMap = fromMap;
+    exports.maybeAddMapping = maybeAddMapping;
+    exports.maybeAddSegment = maybeAddSegment;
+    exports.setIgnore = setIgnore;
+    exports.setSourceContent = setSourceContent;
+    exports.toDecodedMap = toDecodedMap;
+    exports.toEncodedMap = toEncodedMap;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=gen-mapping.umd.js.map

node_modules/.pnpm/@jridgewell+gen-mapping@0.3.8/node_modules/@jridgewell/gen-mapping/dist/types/gen-mapping.d.ts

@@ -0,0 +1,88 @@
+import type { SourceMapInput } from '@jridgewell/trace-mapping';
+import type { DecodedSourceMap, EncodedSourceMap, Pos, Mapping } from './types';
+export type { DecodedSourceMap, EncodedSourceMap, Mapping };
+export declare type Options = {
+    file?: string | null;
+    sourceRoot?: string | null;
+};
+/**
+ * Provides the state to generate a sourcemap.
+ */
+export declare class GenMapping {
+    private _names;
+    private _sources;
+    private _sourcesContent;
+    private _mappings;
+    private _ignoreList;
+    file: string | null | undefined;
+    sourceRoot: string | null | undefined;
+    constructor({ file, sourceRoot }?: Options);
+}
+/**
+ * A low-level API to associate a generated position with an original source position. Line and
+ * column here are 0-based, unlike `addMapping`.
+ */
+export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source?: null, sourceLine?: null, sourceColumn?: null, name?: null, content?: null): void;
+export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name?: null, content?: string | null): void;
+export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name: string, content?: string | null): void;
+/**
+ * A high-level API to associate a generated position with an original source position. Line is
+ * 1-based, but column is 0-based, due to legacy behavior in `source-map` library.
+ */
+export declare function addMapping(map: GenMapping, mapping: {
+    generated: Pos;
+    source?: null;
+    original?: null;
+    name?: null;
+    content?: null;
+}): void;
+export declare function addMapping(map: GenMapping, mapping: {
+    generated: Pos;
+    source: string;
+    original: Pos;
+    name?: null;
+    content?: string | null;
+}): void;
+export declare function addMapping(map: GenMapping, mapping: {
+    generated: Pos;
+    source: string;
+    original: Pos;
+    name: string;
+    content?: string | null;
+}): void;
+/**
+ * Same as `addSegment`, but will only add the segment if it generates useful information in the
+ * resulting map. This only works correctly if segments are added **in order**, meaning you should
+ * not add a segment with a lower generated line/column than one that came before.
+ */
+export declare const maybeAddSegment: typeof addSegment;
+/**
+ * Same as `addMapping`, but will only add the mapping if it generates useful information in the
+ * resulting map. This only works correctly if mappings are added **in order**, meaning you should
+ * not add a mapping with a lower generated line/column than one that came before.
+ */
+export declare const maybeAddMapping: typeof addMapping;
+/**
+ * Adds/removes the content of the source file to the source map.
+ */
+export declare function setSourceContent(map: GenMapping, source: string, content: string | null): void;
+export declare function setIgnore(map: GenMapping, source: string, ignore?: boolean): void;
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function toDecodedMap(map: GenMapping): DecodedSourceMap;
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function toEncodedMap(map: GenMapping): EncodedSourceMap;
+/**
+ * Constructs a new GenMapping, using the already present mappings of the input.
+ */
+export declare function fromMap(input: SourceMapInput): GenMapping;
+/**
+ * Returns an array of high-level mapping objects for every recorded segment, which could then be
+ * passed to the `source-map` library.
+ */
+export declare function allMappings(map: GenMapping): Mapping[];

node_modules/.pnpm/@jridgewell+gen-mapping@0.3.8/node_modules/@jridgewell/gen-mapping/dist/types/sourcemap-segment.d.ts

@@ -0,0 +1,12 @@
+declare type GeneratedColumn = number;
+declare type SourcesIndex = number;
+declare type SourceLine = number;
+declare type SourceColumn = number;
+declare type NamesIndex = number;
+export declare type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+export declare const COLUMN = 0;
+export declare const SOURCES_INDEX = 1;
+export declare const SOURCE_LINE = 2;
+export declare const SOURCE_COLUMN = 3;
+export declare const NAMES_INDEX = 4;
+export {};

node_modules/.pnpm/@jridgewell+gen-mapping@0.3.8/node_modules/@jridgewell/gen-mapping/dist/types/types.d.ts

@@ -0,0 +1,36 @@
+import type { SourceMapSegment } from './sourcemap-segment';
+export interface SourceMapV3 {
+    file?: string | null;
+    names: readonly string[];
+    sourceRoot?: string;
+    sources: readonly (string | null)[];
+    sourcesContent?: readonly (string | null)[];
+    version: 3;
+    ignoreList?: readonly number[];
+}
+export interface EncodedSourceMap extends SourceMapV3 {
+    mappings: string;
+}
+export interface DecodedSourceMap extends SourceMapV3 {
+    mappings: readonly SourceMapSegment[][];
+}
+export interface Pos {
+    line: number;
+    column: number;
+}
+export declare type Mapping = {
+    generated: Pos;
+    source: undefined;
+    original: undefined;
+    name: undefined;
+} | {
+    generated: Pos;
+    source: string;
+    original: Pos;
+    name: string;
+} | {
+    generated: Pos;
+    source: string;
+    original: Pos;
+    name: undefined;
+};

node_modules/.pnpm/@jridgewell+gen-mapping@0.3.8/node_modules/@jridgewell/gen-mapping/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@jridgewell/gen-mapping",
+  "version": "0.3.8",
+  "description": "Generate source maps",
+  "keywords": [
+    "source",
+    "map"
+  ],
+  "author": "Justin Ridgewell <justin@ridgewell.name>",
+  "license": "MIT",
+  "repository": "https://github.com/jridgewell/gen-mapping",
+  "main": "dist/gen-mapping.umd.js",
+  "module": "dist/gen-mapping.mjs",
+  "types": "dist/types/gen-mapping.d.ts",
+  "exports": {
+    ".": [
+      {
+        "types": "./dist/types/gen-mapping.d.ts",
+        "browser": "./dist/gen-mapping.umd.js",
+        "require": "./dist/gen-mapping.umd.js",
+        "import": "./dist/gen-mapping.mjs"
+      },
+      "./dist/gen-mapping.umd.js"
+    ],
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "scripts": {
+    "benchmark": "run-s build:rollup benchmark:*",
+    "benchmark:install": "cd benchmark && npm install",
+    "benchmark:only": "node benchmark/index.mjs",
+    "prebuild": "rm -rf dist",
+    "build": "run-s -n build:*",
+    "build:rollup": "rollup -c rollup.config.js",
+    "build:ts": "tsc --project tsconfig.build.json",
+    "lint": "run-s -n lint:*",
+    "lint:prettier": "npm run test:lint:prettier -- --write",
+    "lint:ts": "npm run test:lint:ts -- --fix",
+    "test": "run-s -n test:lint test:only",
+    "test:debug": "mocha --inspect-brk",
+    "test:lint": "run-s -n test:lint:*",
+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
+    "test:only": "c8 mocha",
+    "test:watch": "mocha --watch",
+    "prepublishOnly": "npm run preversion",
+    "preversion": "run-s test build"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "8.3.2",
+    "@types/mocha": "9.1.1",
+    "@types/node": "17.0.29",
+    "@typescript-eslint/eslint-plugin": "5.21.0",
+    "@typescript-eslint/parser": "5.21.0",
+    "benchmark": "2.1.4",
+    "c8": "7.11.2",
+    "eslint": "8.14.0",
+    "eslint-config-prettier": "8.5.0",
+    "mocha": "9.2.2",
+    "npm-run-all": "4.1.5",
+    "prettier": "2.6.2",
+    "rollup": "2.70.2",
+    "tsx": "4.7.1",
+    "typescript": "4.6.3"
+  },
+  "dependencies": {
+    "@jridgewell/set-array": "^1.2.1",
+    "@jridgewell/sourcemap-codec": "^1.4.10",
+    "@jridgewell/trace-mapping": "^0.3.24"
+  }
+}

node_modules/.pnpm/@jridgewell+gen-mapping@0.3.8/node_modules/@jridgewell/set-array

@@ -0,0 +1 @@
+../../../@jridgewell+set-array@1.2.1/node_modules/@jridgewell/set-array

node_modules/.pnpm/@jridgewell+gen-mapping@0.3.8/node_modules/@jridgewell/sourcemap-codec

@@ -0,0 +1 @@
+../../../@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec

node_modules/.pnpm/@jridgewell+gen-mapping@0.3.8/node_modules/@jridgewell/trace-mapping

@@ -0,0 +1 @@
+../../../@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping

node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2019 Justin Ridgewell <jridgewell@google.com>
+
+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/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/README.md

@@ -0,0 +1,40 @@
+# @jridgewell/resolve-uri
+
+> Resolve a URI relative to an optional base URI
+
+Resolve any combination of absolute URIs, protocol-realtive URIs, absolute paths, or relative paths.
+
+## Installation
+
+```sh
+npm install @jridgewell/resolve-uri
+```
+
+## Usage
+
+```typescript
+function resolve(input: string, base?: string): string;
+```
+
+```js
+import resolve from '@jridgewell/resolve-uri';
+
+resolve('foo', 'https://example.com'); // => 'https://example.com/foo'
+```
+
+| Input                 | Base                    | Resolution                     | Explanation                                                  |
+|-----------------------|-------------------------|--------------------------------|--------------------------------------------------------------|
+| `https://example.com` | _any_                   | `https://example.com/`         | Input is normalized only                                     |
+| `//example.com`       | `https://base.com/`     | `https://example.com/`         | Input inherits the base's protocol                           |
+| `//example.com`       | _rest_                  | `//example.com/`               | Input is normalized only                                     |
+| `/example`            | `https://base.com/`     | `https://base.com/example`     | Input inherits the base's origin                             |
+| `/example`            | `//base.com/`           | `//base.com/example`           | Input inherits the base's host and remains protocol relative |
+| `/example`            | _rest_                  | `/example`                     | Input is normalized only                                     |
+| `example`             | `https://base.com/dir/` | `https://base.com/dir/example` | Input is joined with the base                                |
+| `example`             | `https://base.com/file` | `https://base.com/example`     | Input is joined with the base without its file               |
+| `example`             | `//base.com/dir/`       | `//base.com/dir/example`       | Input is joined with the base's last directory               |
+| `example`             | `//base.com/file`       | `//base.com/example`           | Input is joined with the base without its file               |
+| `example`             | `/base/dir/`            | `/base/dir/example`            | Input is joined with the base's last directory               |
+| `example`             | `/base/file`            | `/base/example`                | Input is joined with the base without its file               |
+| `example`             | `base/dir/`             | `base/dir/example`             | Input is joined with the base's last directory               |
+| `example`             | `base/file`             | `base/example`                 | Input is joined with the base without its file               |

node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs

@@ -0,0 +1,232 @@
+// Matches the scheme of a URL, eg "http://"
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+ * Matches the parts of a URL:
+ * 1. Scheme, including ":", guaranteed.
+ * 2. User/password, including "@", optional.
+ * 3. Host, guaranteed.
+ * 4. Port, including ":", optional.
+ * 5. Path, including "/", optional.
+ * 6. Query, including "?", optional.
+ * 7. Hash, including "#", optional.
+ */
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+ * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+ * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+ *
+ * 1. Host, optional.
+ * 2. Path, which may include "/", guaranteed.
+ * 3. Query, including "?", optional.
+ * 4. Hash, including "#", optional.
+ */
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+    return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+    return input.startsWith('//');
+}
+function isAbsolutePath(input) {
+    return input.startsWith('/');
+}
+function isFileUrl(input) {
+    return input.startsWith('file:');
+}
+function isRelative(input) {
+    return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+    const match = urlRegex.exec(input);
+    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
+}
+function parseFileUrl(input) {
+    const match = fileRegex.exec(input);
+    const path = match[2];
+    return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+    return {
+        scheme,
+        user,
+        host,
+        port,
+        path,
+        query,
+        hash,
+        type: 7 /* Absolute */,
+    };
+}
+function parseUrl(input) {
+    if (isSchemeRelativeUrl(input)) {
+        const url = parseAbsoluteUrl('http:' + input);
+        url.scheme = '';
+        url.type = 6 /* SchemeRelative */;
+        return url;
+    }
+    if (isAbsolutePath(input)) {
+        const url = parseAbsoluteUrl('http://foo.com' + input);
+        url.scheme = '';
+        url.host = '';
+        url.type = 5 /* AbsolutePath */;
+        return url;
+    }
+    if (isFileUrl(input))
+        return parseFileUrl(input);
+    if (isAbsoluteUrl(input))
+        return parseAbsoluteUrl(input);
+    const url = parseAbsoluteUrl('http://foo.com/' + input);
+    url.scheme = '';
+    url.host = '';
+    url.type = input
+        ? input.startsWith('?')
+            ? 3 /* Query */
+            : input.startsWith('#')
+                ? 2 /* Hash */
+                : 4 /* RelativePath */
+        : 1 /* Empty */;
+    return url;
+}
+function stripPathFilename(path) {
+    // If a path ends with a parent directory "..", then it's a relative path with excess parent
+    // paths. It's not a file, so we can't strip it.
+    if (path.endsWith('/..'))
+        return path;
+    const index = path.lastIndexOf('/');
+    return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+    normalizePath(base, base.type);
+    // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
+    // path).
+    if (url.path === '/') {
+        url.path = base.path;
+    }
+    else {
+        // Resolution happens relative to the base path's directory, not the file.
+        url.path = stripPathFilename(base.path) + url.path;
+    }
+}
+/**
+ * The path can have empty directories "//", unneeded parents "foo/..", or current directory
+ * "foo/.". We need to normalize to a standard representation.
+ */
+function normalizePath(url, type) {
+    const rel = type <= 4 /* RelativePath */;
+    const pieces = url.path.split('/');
+    // We need to preserve the first piece always, so that we output a leading slash. The item at
+    // pieces[0] is an empty string.
+    let pointer = 1;
+    // Positive is the number of real directories we've output, used for popping a parent directory.
+    // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
+    let positive = 0;
+    // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
+    // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
+    // real directory, we won't need to append, unless the other conditions happen again.
+    let addTrailingSlash = false;
+    for (let i = 1; i < pieces.length; i++) {
+        const piece = pieces[i];
+        // An empty directory, could be a trailing slash, or just a double "//" in the path.
+        if (!piece) {
+            addTrailingSlash = true;
+            continue;
+        }
+        // If we encounter a real directory, then we don't need to append anymore.
+        addTrailingSlash = false;
+        // A current directory, which we can always drop.
+        if (piece === '.')
+            continue;
+        // A parent directory, we need to see if there are any real directories we can pop. Else, we
+        // have an excess of parents, and we'll need to keep the "..".
+        if (piece === '..') {
+            if (positive) {
+                addTrailingSlash = true;
+                positive--;
+                pointer--;
+            }
+            else if (rel) {
+                // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
+                // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
+                pieces[pointer++] = piece;
+            }
+            continue;
+        }
+        // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
+        // any popped or dropped directories.
+        pieces[pointer++] = piece;
+        positive++;
+    }
+    let path = '';
+    for (let i = 1; i < pointer; i++) {
+        path += '/' + pieces[i];
+    }
+    if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
+        path += '/';
+    }
+    url.path = path;
+}
+/**
+ * Attempts to resolve `input` URL/path relative to `base`.
+ */
+function resolve(input, base) {
+    if (!input && !base)
+        return '';
+    const url = parseUrl(input);
+    let inputType = url.type;
+    if (base && inputType !== 7 /* Absolute */) {
+        const baseUrl = parseUrl(base);
+        const baseType = baseUrl.type;
+        switch (inputType) {
+            case 1 /* Empty */:
+                url.hash = baseUrl.hash;
+            // fall through
+            case 2 /* Hash */:
+                url.query = baseUrl.query;
+            // fall through
+            case 3 /* Query */:
+            case 4 /* RelativePath */:
+                mergePaths(url, baseUrl);
+            // fall through
+            case 5 /* AbsolutePath */:
+                // The host, user, and port are joined, you can't copy one without the others.
+                url.user = baseUrl.user;
+                url.host = baseUrl.host;
+                url.port = baseUrl.port;
+            // fall through
+            case 6 /* SchemeRelative */:
+                // The input doesn't have a schema at least, so we need to copy at least that over.
+                url.scheme = baseUrl.scheme;
+        }
+        if (baseType > inputType)
+            inputType = baseType;
+    }
+    normalizePath(url, inputType);
+    const queryHash = url.query + url.hash;
+    switch (inputType) {
+        // This is impossible, because of the empty checks at the start of the function.
+        // case UrlType.Empty:
+        case 2 /* Hash */:
+        case 3 /* Query */:
+            return queryHash;
+        case 4 /* RelativePath */: {
+            // The first char is always a "/", and we need it to be relative.
+            const path = url.path.slice(1);
+            if (!path)
+                return queryHash || '.';
+            if (isRelative(base || input) && !isRelative(path)) {
+                // If base started with a leading ".", or there is no base and input started with a ".",
+                // then we need to ensure that the relative path starts with a ".". We don't know if
+                // relative starts with a "..", though, so check before prepending.
+                return './' + path + queryHash;
+            }
+            return path + queryHash;
+        }
+        case 5 /* AbsolutePath */:
+            return url.path + queryHash;
+        default:
+            return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
+    }
+}
+
+export { resolve as default };
+//# sourceMappingURL=resolve-uri.mjs.map

node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js

@@ -0,0 +1,240 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.resolveURI = factory());
+})(this, (function () { 'use strict';
+
+    // Matches the scheme of a URL, eg "http://"
+    const schemeRegex = /^[\w+.-]+:\/\//;
+    /**
+     * Matches the parts of a URL:
+     * 1. Scheme, including ":", guaranteed.
+     * 2. User/password, including "@", optional.
+     * 3. Host, guaranteed.
+     * 4. Port, including ":", optional.
+     * 5. Path, including "/", optional.
+     * 6. Query, including "?", optional.
+     * 7. Hash, including "#", optional.
+     */
+    const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+    /**
+     * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+     * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+     *
+     * 1. Host, optional.
+     * 2. Path, which may include "/", guaranteed.
+     * 3. Query, including "?", optional.
+     * 4. Hash, including "#", optional.
+     */
+    const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+    function isAbsoluteUrl(input) {
+        return schemeRegex.test(input);
+    }
+    function isSchemeRelativeUrl(input) {
+        return input.startsWith('//');
+    }
+    function isAbsolutePath(input) {
+        return input.startsWith('/');
+    }
+    function isFileUrl(input) {
+        return input.startsWith('file:');
+    }
+    function isRelative(input) {
+        return /^[.?#]/.test(input);
+    }
+    function parseAbsoluteUrl(input) {
+        const match = urlRegex.exec(input);
+        return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
+    }
+    function parseFileUrl(input) {
+        const match = fileRegex.exec(input);
+        const path = match[2];
+        return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
+    }
+    function makeUrl(scheme, user, host, port, path, query, hash) {
+        return {
+            scheme,
+            user,
+            host,
+            port,
+            path,
+            query,
+            hash,
+            type: 7 /* Absolute */,
+        };
+    }
+    function parseUrl(input) {
+        if (isSchemeRelativeUrl(input)) {
+            const url = parseAbsoluteUrl('http:' + input);
+            url.scheme = '';
+            url.type = 6 /* SchemeRelative */;
+            return url;
+        }
+        if (isAbsolutePath(input)) {
+            const url = parseAbsoluteUrl('http://foo.com' + input);
+            url.scheme = '';
+            url.host = '';
+            url.type = 5 /* AbsolutePath */;
+            return url;
+        }
+        if (isFileUrl(input))
+            return parseFileUrl(input);
+        if (isAbsoluteUrl(input))
+            return parseAbsoluteUrl(input);
+        const url = parseAbsoluteUrl('http://foo.com/' + input);
+        url.scheme = '';
+        url.host = '';
+        url.type = input
+            ? input.startsWith('?')
+                ? 3 /* Query */
+                : input.startsWith('#')
+                    ? 2 /* Hash */
+                    : 4 /* RelativePath */
+            : 1 /* Empty */;
+        return url;
+    }
+    function stripPathFilename(path) {
+        // If a path ends with a parent directory "..", then it's a relative path with excess parent
+        // paths. It's not a file, so we can't strip it.
+        if (path.endsWith('/..'))
+            return path;
+        const index = path.lastIndexOf('/');
+        return path.slice(0, index + 1);
+    }
+    function mergePaths(url, base) {
+        normalizePath(base, base.type);
+        // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
+        // path).
+        if (url.path === '/') {
+            url.path = base.path;
+        }
+        else {
+            // Resolution happens relative to the base path's directory, not the file.
+            url.path = stripPathFilename(base.path) + url.path;
+        }
+    }
+    /**
+     * The path can have empty directories "//", unneeded parents "foo/..", or current directory
+     * "foo/.". We need to normalize to a standard representation.
+     */
+    function normalizePath(url, type) {
+        const rel = type <= 4 /* RelativePath */;
+        const pieces = url.path.split('/');
+        // We need to preserve the first piece always, so that we output a leading slash. The item at
+        // pieces[0] is an empty string.
+        let pointer = 1;
+        // Positive is the number of real directories we've output, used for popping a parent directory.
+        // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
+        let positive = 0;
+        // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
+        // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
+        // real directory, we won't need to append, unless the other conditions happen again.
+        let addTrailingSlash = false;
+        for (let i = 1; i < pieces.length; i++) {
+            const piece = pieces[i];
+            // An empty directory, could be a trailing slash, or just a double "//" in the path.
+            if (!piece) {
+                addTrailingSlash = true;
+                continue;
+            }
+            // If we encounter a real directory, then we don't need to append anymore.
+            addTrailingSlash = false;
+            // A current directory, which we can always drop.
+            if (piece === '.')
+                continue;
+            // A parent directory, we need to see if there are any real directories we can pop. Else, we
+            // have an excess of parents, and we'll need to keep the "..".
+            if (piece === '..') {
+                if (positive) {
+                    addTrailingSlash = true;
+                    positive--;
+                    pointer--;
+                }
+                else if (rel) {
+                    // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
+                    // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
+                    pieces[pointer++] = piece;
+                }
+                continue;
+            }
+            // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
+            // any popped or dropped directories.
+            pieces[pointer++] = piece;
+            positive++;
+        }
+        let path = '';
+        for (let i = 1; i < pointer; i++) {
+            path += '/' + pieces[i];
+        }
+        if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
+            path += '/';
+        }
+        url.path = path;
+    }
+    /**
+     * Attempts to resolve `input` URL/path relative to `base`.
+     */
+    function resolve(input, base) {
+        if (!input && !base)
+            return '';
+        const url = parseUrl(input);
+        let inputType = url.type;
+        if (base && inputType !== 7 /* Absolute */) {
+            const baseUrl = parseUrl(base);
+            const baseType = baseUrl.type;
+            switch (inputType) {
+                case 1 /* Empty */:
+                    url.hash = baseUrl.hash;
+                // fall through
+                case 2 /* Hash */:
+                    url.query = baseUrl.query;
+                // fall through
+                case 3 /* Query */:
+                case 4 /* RelativePath */:
+                    mergePaths(url, baseUrl);
+                // fall through
+                case 5 /* AbsolutePath */:
+                    // The host, user, and port are joined, you can't copy one without the others.
+                    url.user = baseUrl.user;
+                    url.host = baseUrl.host;
+                    url.port = baseUrl.port;
+                // fall through
+                case 6 /* SchemeRelative */:
+                    // The input doesn't have a schema at least, so we need to copy at least that over.
+                    url.scheme = baseUrl.scheme;
+            }
+            if (baseType > inputType)
+                inputType = baseType;
+        }
+        normalizePath(url, inputType);
+        const queryHash = url.query + url.hash;
+        switch (inputType) {
+            // This is impossible, because of the empty checks at the start of the function.
+            // case UrlType.Empty:
+            case 2 /* Hash */:
+            case 3 /* Query */:
+                return queryHash;
+            case 4 /* RelativePath */: {
+                // The first char is always a "/", and we need it to be relative.
+                const path = url.path.slice(1);
+                if (!path)
+                    return queryHash || '.';
+                if (isRelative(base || input) && !isRelative(path)) {
+                    // If base started with a leading ".", or there is no base and input started with a ".",
+                    // then we need to ensure that the relative path starts with a ".". We don't know if
+                    // relative starts with a "..", though, so check before prepending.
+                    return './' + path + queryHash;
+                }
+                return path + queryHash;
+            }
+            case 5 /* AbsolutePath */:
+                return url.path + queryHash;
+            default:
+                return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
+        }
+    }
+
+    return resolve;
+
+}));
+//# sourceMappingURL=resolve-uri.umd.js.map

node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/types/resolve-uri.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Attempts to resolve `input` URL/path relative to `base`.
+ */
+export default function resolve(input: string, base: string | undefined): string;

node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@jridgewell/resolve-uri",
+  "version": "3.1.2",
+  "description": "Resolve a URI relative to an optional base URI",
+  "keywords": [
+    "resolve",
+    "uri",
+    "url",
+    "path"
+  ],
+  "author": "Justin Ridgewell <justin@ridgewell.name>",
+  "license": "MIT",
+  "repository": "https://github.com/jridgewell/resolve-uri",
+  "main": "dist/resolve-uri.umd.js",
+  "module": "dist/resolve-uri.mjs",
+  "types": "dist/types/resolve-uri.d.ts",
+  "exports": {
+    ".": [
+      {
+        "types": "./dist/types/resolve-uri.d.ts",
+        "browser": "./dist/resolve-uri.umd.js",
+        "require": "./dist/resolve-uri.umd.js",
+        "import": "./dist/resolve-uri.mjs"
+      },
+      "./dist/resolve-uri.umd.js"
+    ],
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "scripts": {
+    "prebuild": "rm -rf dist",
+    "build": "run-s -n build:*",
+    "build:rollup": "rollup -c rollup.config.js",
+    "build:ts": "tsc --project tsconfig.build.json",
+    "lint": "run-s -n lint:*",
+    "lint:prettier": "npm run test:lint:prettier -- --write",
+    "lint:ts": "npm run test:lint:ts -- --fix",
+    "pretest": "run-s build:rollup",
+    "test": "run-s -n test:lint test:only",
+    "test:debug": "mocha --inspect-brk",
+    "test:lint": "run-s -n test:lint:*",
+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
+    "test:only": "mocha",
+    "test:coverage": "c8 mocha",
+    "test:watch": "mocha --watch",
+    "prepublishOnly": "npm run preversion",
+    "preversion": "run-s test build"
+  },
+  "devDependencies": {
+    "@jridgewell/resolve-uri-latest": "npm:@jridgewell/resolve-uri@*",
+    "@rollup/plugin-typescript": "8.3.0",
+    "@typescript-eslint/eslint-plugin": "5.10.0",
+    "@typescript-eslint/parser": "5.10.0",
+    "c8": "7.11.0",
+    "eslint": "8.7.0",
+    "eslint-config-prettier": "8.3.0",
+    "mocha": "9.2.0",
+    "npm-run-all": "4.1.5",
+    "prettier": "2.5.1",
+    "rollup": "2.66.0",
+    "typescript": "4.5.5"
+  }
+}

node_modules/.pnpm/@jridgewell+set-array@1.2.1/node_modules/@jridgewell/set-array/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2022 Justin Ridgewell <jridgewell@google.com>
+
+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/.pnpm/@jridgewell+set-array@1.2.1/node_modules/@jridgewell/set-array/README.md

@@ -0,0 +1,37 @@
+# @jridgewell/set-array
+
+> Like a Set, but provides the index of the `key` in the backing array
+
+This is designed to allow synchronizing a second array with the contents of the backing array, like
+how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`, and there
+are never duplicates.
+
+## Installation
+
+```sh
+npm install @jridgewell/set-array
+```
+
+## Usage
+
+```js
+import { SetArray, get, put, pop } from '@jridgewell/set-array';
+
+const sa = new SetArray();
+
+let index = put(sa, 'first');
+assert.strictEqual(index, 0);
+
+index = put(sa, 'second');
+assert.strictEqual(index, 1);
+
+assert.deepEqual(sa.array, [ 'first', 'second' ]);
+
+index = get(sa, 'first');
+assert.strictEqual(index, 0);
+
+pop(sa);
+index = get(sa, 'second');
+assert.strictEqual(index, undefined);
+assert.deepEqual(sa.array, [ 'first' ]);
+```

node_modules/.pnpm/@jridgewell+set-array@1.2.1/node_modules/@jridgewell/set-array/dist/set-array.mjs

@@ -0,0 +1,69 @@
+/**
+ * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
+ * index of the `key` in the backing array.
+ *
+ * This is designed to allow synchronizing a second array with the contents of the backing array,
+ * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
+ * and there are never duplicates.
+ */
+class SetArray {
+    constructor() {
+        this._indexes = { __proto__: null };
+        this.array = [];
+    }
+}
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the set into a type
+ * with public access modifiers.
+ */
+function cast(set) {
+    return set;
+}
+/**
+ * Gets the index associated with `key` in the backing array, if it is already present.
+ */
+function get(setarr, key) {
+    return cast(setarr)._indexes[key];
+}
+/**
+ * Puts `key` into the backing array, if it is not already present. Returns
+ * the index of the `key` in the backing array.
+ */
+function put(setarr, key) {
+    // The key may or may not be present. If it is present, it's a number.
+    const index = get(setarr, key);
+    if (index !== undefined)
+        return index;
+    const { array, _indexes: indexes } = cast(setarr);
+    const length = array.push(key);
+    return (indexes[key] = length - 1);
+}
+/**
+ * Pops the last added item out of the SetArray.
+ */
+function pop(setarr) {
+    const { array, _indexes: indexes } = cast(setarr);
+    if (array.length === 0)
+        return;
+    const last = array.pop();
+    indexes[last] = undefined;
+}
+/**
+ * Removes the key, if it exists in the set.
+ */
+function remove(setarr, key) {
+    const index = get(setarr, key);
+    if (index === undefined)
+        return;
+    const { array, _indexes: indexes } = cast(setarr);
+    for (let i = index + 1; i < array.length; i++) {
+        const k = array[i];
+        array[i - 1] = k;
+        indexes[k]--;
+    }
+    indexes[key] = undefined;
+    array.pop();
+}
+
+export { SetArray, get, pop, put, remove };
+//# sourceMappingURL=set-array.mjs.map

node_modules/.pnpm/@jridgewell+set-array@1.2.1/node_modules/@jridgewell/set-array/dist/set-array.umd.js

@@ -0,0 +1,83 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.setArray = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
+     * index of the `key` in the backing array.
+     *
+     * This is designed to allow synchronizing a second array with the contents of the backing array,
+     * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
+     * and there are never duplicates.
+     */
+    class SetArray {
+        constructor() {
+            this._indexes = { __proto__: null };
+            this.array = [];
+        }
+    }
+    /**
+     * Typescript doesn't allow friend access to private fields, so this just casts the set into a type
+     * with public access modifiers.
+     */
+    function cast(set) {
+        return set;
+    }
+    /**
+     * Gets the index associated with `key` in the backing array, if it is already present.
+     */
+    function get(setarr, key) {
+        return cast(setarr)._indexes[key];
+    }
+    /**
+     * Puts `key` into the backing array, if it is not already present. Returns
+     * the index of the `key` in the backing array.
+     */
+    function put(setarr, key) {
+        // The key may or may not be present. If it is present, it's a number.
+        const index = get(setarr, key);
+        if (index !== undefined)
+            return index;
+        const { array, _indexes: indexes } = cast(setarr);
+        const length = array.push(key);
+        return (indexes[key] = length - 1);
+    }
+    /**
+     * Pops the last added item out of the SetArray.
+     */
+    function pop(setarr) {
+        const { array, _indexes: indexes } = cast(setarr);
+        if (array.length === 0)
+            return;
+        const last = array.pop();
+        indexes[last] = undefined;
+    }
+    /**
+     * Removes the key, if it exists in the set.
+     */
+    function remove(setarr, key) {
+        const index = get(setarr, key);
+        if (index === undefined)
+            return;
+        const { array, _indexes: indexes } = cast(setarr);
+        for (let i = index + 1; i < array.length; i++) {
+            const k = array[i];
+            array[i - 1] = k;
+            indexes[k]--;
+        }
+        indexes[key] = undefined;
+        array.pop();
+    }
+
+    exports.SetArray = SetArray;
+    exports.get = get;
+    exports.pop = pop;
+    exports.put = put;
+    exports.remove = remove;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=set-array.umd.js.map

node_modules/.pnpm/@jridgewell+set-array@1.2.1/node_modules/@jridgewell/set-array/dist/types/set-array.d.ts

@@ -0,0 +1,32 @@
+declare type Key = string | number | symbol;
+/**
+ * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
+ * index of the `key` in the backing array.
+ *
+ * This is designed to allow synchronizing a second array with the contents of the backing array,
+ * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
+ * and there are never duplicates.
+ */
+export declare class SetArray<T extends Key = Key> {
+    private _indexes;
+    array: readonly T[];
+    constructor();
+}
+/**
+ * Gets the index associated with `key` in the backing array, if it is already present.
+ */
+export declare function get<T extends Key>(setarr: SetArray<T>, key: T): number | undefined;
+/**
+ * Puts `key` into the backing array, if it is not already present. Returns
+ * the index of the `key` in the backing array.
+ */
+export declare function put<T extends Key>(setarr: SetArray<T>, key: T): number;
+/**
+ * Pops the last added item out of the SetArray.
+ */
+export declare function pop<T extends Key>(setarr: SetArray<T>): void;
+/**
+ * Removes the key, if it exists in the set.
+ */
+export declare function remove<T extends Key>(setarr: SetArray<T>, key: T): void;
+export {};

node_modules/.pnpm/@jridgewell+set-array@1.2.1/node_modules/@jridgewell/set-array/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@jridgewell/set-array",
+  "version": "1.2.1",
+  "description": "Like a Set, but provides the index of the `key` in the backing array",
+  "keywords": [],
+  "author": "Justin Ridgewell <justin@ridgewell.name>",
+  "license": "MIT",
+  "repository": "https://github.com/jridgewell/set-array",
+  "main": "dist/set-array.umd.js",
+  "module": "dist/set-array.mjs",
+  "typings": "dist/types/set-array.d.ts",
+  "exports": {
+    ".": [
+      {
+        "types": "./dist/types/set-array.d.ts",
+        "browser": "./dist/set-array.umd.js",
+        "require": "./dist/set-array.umd.js",
+        "import": "./dist/set-array.mjs"
+      },
+      "./dist/set-array.umd.js"
+    ],
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "scripts": {
+    "prebuild": "rm -rf dist",
+    "build": "run-s -n build:*",
+    "build:rollup": "rollup -c rollup.config.js",
+    "build:ts": "tsc --project tsconfig.build.json",
+    "lint": "run-s -n lint:*",
+    "lint:prettier": "npm run test:lint:prettier -- --write",
+    "lint:ts": "npm run test:lint:ts -- --fix",
+    "test": "run-s -n test:lint test:only",
+    "test:debug": "mocha --inspect-brk",
+    "test:lint": "run-s -n test:lint:*",
+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
+    "test:only": "mocha",
+    "test:coverage": "c8 mocha",
+    "test:watch": "mocha --watch",
+    "prepublishOnly": "npm run preversion",
+    "preversion": "run-s test build"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "8.3.0",
+    "@types/mocha": "9.1.1",
+    "@types/node": "17.0.29",
+    "@typescript-eslint/eslint-plugin": "5.10.0",
+    "@typescript-eslint/parser": "5.10.0",
+    "c8": "7.11.0",
+    "eslint": "8.7.0",
+    "eslint-config-prettier": "8.3.0",
+    "mocha": "9.2.0",
+    "npm-run-all": "4.1.5",
+    "prettier": "2.5.1",
+    "rollup": "2.66.0",
+    "tsx": "4.7.1",
+    "typescript": "4.5.5"
+  }
+}

node_modules/.pnpm/@jridgewell+source-map@0.3.6/node_modules/@jridgewell/gen-mapping

@@ -0,0 +1 @@
+../../../@jridgewell+gen-mapping@0.3.8/node_modules/@jridgewell/gen-mapping

node_modules/.pnpm/@jridgewell+source-map@0.3.6/node_modules/@jridgewell/source-map/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2019 Justin Ridgewell <jridgewell@google.com>
+
+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/.pnpm/@jridgewell+source-map@0.3.6/node_modules/@jridgewell/source-map/README.md

@@ -0,0 +1,184 @@
+# @jridgewell/source-map
+
+> Packages `@jridgewell/trace-mapping` and `@jridgewell/gen-mapping` into the familiar source-map API
+
+This isn't the full API, but it's the core functionality. This wraps
+[@jridgewell/trace-mapping][trace-mapping] and [@jridgewell/gen-mapping][gen-mapping]
+implementations.
+
+## Installation
+
+```sh
+npm install @jridgewell/source-map
+```
+
+## Usage
+
+TODO
+
+### SourceMapConsumer
+
+```typescript
+import { SourceMapConsumer } from '@jridgewell/source-map';
+const smc = new SourceMapConsumer({
+  version: 3,
+  names: ['foo'],
+  sources: ['input.js'],
+  mappings: 'AAAAA',
+});
+```
+
+#### SourceMapConsumer.fromSourceMap(mapGenerator[, mapUrl])
+
+Transforms a `SourceMapGenerator` into a `SourceMapConsumer`.
+
+```typescript
+const smg = new SourceMapGenerator();
+
+const smc = SourceMapConsumer.fromSourceMap(map);
+smc.originalPositionFor({ line: 1, column: 0 });
+```
+
+#### SourceMapConsumer.prototype.originalPositionFor(generatedPosition)
+
+```typescript
+const smc = new SourceMapConsumer(map);
+smc.originalPositionFor({ line: 1, column: 0 });
+```
+
+#### SourceMapConsumer.prototype.mappings
+
+```typescript
+const smc = new SourceMapConsumer(map);
+smc.mappings; // AAAA
+```
+
+#### SourceMapConsumer.prototype.allGeneratedPositionsFor(originalPosition)
+
+```typescript
+const smc = new SourceMapConsumer(map);
+smc.allGeneratedpositionsfor({ line: 1, column: 5, source: "baz.ts" });
+// [
+//   { line: 2, column: 8 }
+// ]
+```
+
+#### SourceMapConsumer.prototype.eachMapping(callback[, context[, order]])
+
+> This implementation currently does not support the "order" parameter.
+> This function can only iterate in Generated order.
+
+```typescript
+const smc = new SourceMapConsumer(map);
+smc.eachMapping((mapping) => {
+// { source: 'baz.ts',
+//   generatedLine: 4,
+//   generatedColumn: 5,
+//   originalLine: 4,
+//   originalColumn: 5,
+//   name: null }
+});
+```
+
+#### SourceMapConsumer.prototype.generatedPositionFor(originalPosition)
+
+```typescript
+const smc = new SourceMapConsumer(map);
+smc.generatedPositionFor({ line: 1, column: 5, source: "baz.ts" });
+// { line: 2, column: 8 }
+```
+
+#### SourceMapConsumer.prototype.hasContentsOfAllSources()
+
+```typescript
+const smc = new SourceMapConsumer(map);
+smc.hasContentsOfAllSources();
+// true
+```
+
+#### SourceMapConsumer.prototype.sourceContentFor(source[, returnNullOnMissing])
+
+```typescript
+const smc = new SourceMapConsumer(map);
+smc.generatedPositionFor("baz.ts");
+// "export default ..."
+```
+
+#### SourceMapConsumer.prototype.version
+
+Returns the source map's version
+
+### SourceMapGenerator
+
+```typescript
+import { SourceMapGenerator } from '@jridgewell/source-map';
+const smg = new SourceMapGenerator({
+  file: 'output.js',
+  sourceRoot: 'https://example.com/',
+});
+```
+
+#### SourceMapGenerator.fromSourceMap(map)
+
+Transform a `SourceMapConsumer` into a `SourceMapGenerator`.
+
+```typescript
+const smc = new SourceMapConsumer();
+const smg = SourceMapGenerator.fromSourceMap(smc);
+```
+
+#### SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])
+
+> This method is not implemented yet
+
+#### SourceMapGenerator.prototype.addMapping(mapping)
+
+```typescript
+const smg = new SourceMapGenerator();
+smg.addMapping({
+  generated: { line: 1, column: 0 },
+  source: 'input.js',
+  original: { line: 1, column: 0 },
+  name: 'foo',
+});
+```
+
+#### SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)
+
+```typescript
+const smg = new SourceMapGenerator();
+smg.setSourceContent('input.js', 'foobar');
+```
+
+#### SourceMapGenerator.prototype.toJSON()
+
+```typescript
+const smg = new SourceMapGenerator();
+smg.toJSON(); // { version: 3, names: [], sources: [], mappings: '' }
+```
+
+#### SourceMapGenerator.prototype.toString()
+
+```typescript
+const smg = new SourceMapGenerator();
+smg.toJSON(); // "{version:3,names:[],sources:[],mappings:''}"
+```
+
+#### SourceMapGenerator.prototype.toDecodedMap()
+
+```typescript
+const smg = new SourceMapGenerator();
+smg.toDecodedMap(); // { version: 3, names: [], sources: [], mappings: [] }
+```
+
+## Known differences with other implementations
+
+This implementation has some differences with `source-map` and `source-map-js`.
+
+- `SourceMapConsumer.prototype.eachMapping()`
+  - Does not support the `order` argument
+- `SourceMapGenerator.prototype.applySourceMap()`
+  - Not implemented
+
+[trace-mapping]: https://github.com/jridgewell/trace-mapping/
+[gen-mapping]: https://github.com/jridgewell/gen-mapping/

node_modules/.pnpm/@jridgewell+source-map@0.3.6/node_modules/@jridgewell/source-map/dist/source-map.cjs

@@ -0,0 +1,95 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var traceMapping = require('@jridgewell/trace-mapping');
+var genMapping = require('@jridgewell/gen-mapping');
+
+class SourceMapConsumer {
+    constructor(map, mapUrl) {
+        const trace = (this._map = new traceMapping.AnyMap(map, mapUrl));
+        this.file = trace.file;
+        this.names = trace.names;
+        this.sourceRoot = trace.sourceRoot;
+        this.sources = trace.resolvedSources;
+        this.sourcesContent = trace.sourcesContent;
+        this.version = trace.version;
+    }
+    static fromSourceMap(map, mapUrl) {
+        // This is more performant if we receive
+        // a @jridgewell/source-map SourceMapGenerator
+        if (map.toDecodedMap) {
+            return new SourceMapConsumer(map.toDecodedMap(), mapUrl);
+        }
+        // This is a fallback for `source-map` and `source-map-js`
+        return new SourceMapConsumer(map.toJSON(), mapUrl);
+    }
+    get mappings() {
+        return traceMapping.encodedMappings(this._map);
+    }
+    originalPositionFor(needle) {
+        return traceMapping.originalPositionFor(this._map, needle);
+    }
+    generatedPositionFor(originalPosition) {
+        return traceMapping.generatedPositionFor(this._map, originalPosition);
+    }
+    allGeneratedPositionsFor(originalPosition) {
+        return traceMapping.allGeneratedPositionsFor(this._map, originalPosition);
+    }
+    hasContentsOfAllSources() {
+        if (!this.sourcesContent || this.sourcesContent.length !== this.sources.length) {
+            return false;
+        }
+        for (const content of this.sourcesContent) {
+            if (content == null) {
+                return false;
+            }
+        }
+        return true;
+    }
+    sourceContentFor(source, nullOnMissing) {
+        const sourceContent = traceMapping.sourceContentFor(this._map, source);
+        if (sourceContent != null) {
+            return sourceContent;
+        }
+        if (nullOnMissing) {
+            return null;
+        }
+        throw new Error(`"${source}" is not in the SourceMap.`);
+    }
+    eachMapping(callback, context /*, order?: number*/) {
+        // order is ignored as @jridgewell/trace-map doesn't implement it
+        traceMapping.eachMapping(this._map, context ? callback.bind(context) : callback);
+    }
+    destroy() {
+        // noop.
+    }
+}
+class SourceMapGenerator {
+    constructor(opts) {
+        // TODO :: should this be duck-typed ?
+        this._map = opts instanceof genMapping.GenMapping ? opts : new genMapping.GenMapping(opts);
+    }
+    static fromSourceMap(consumer) {
+        return new SourceMapGenerator(genMapping.fromMap(consumer));
+    }
+    addMapping(mapping) {
+        genMapping.maybeAddMapping(this._map, mapping);
+    }
+    setSourceContent(source, content) {
+        genMapping.setSourceContent(this._map, source, content);
+    }
+    toJSON() {
+        return genMapping.toEncodedMap(this._map);
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+    toDecodedMap() {
+        return genMapping.toDecodedMap(this._map);
+    }
+}
+
+exports.SourceMapConsumer = SourceMapConsumer;
+exports.SourceMapGenerator = SourceMapGenerator;
+//# sourceMappingURL=source-map.cjs.map

node_modules/.pnpm/@jridgewell+source-map@0.3.6/node_modules/@jridgewell/source-map/dist/source-map.mjs

@@ -0,0 +1,90 @@
+import { AnyMap, encodedMappings, originalPositionFor, generatedPositionFor, allGeneratedPositionsFor, sourceContentFor, eachMapping } from '@jridgewell/trace-mapping';
+import { GenMapping, fromMap, maybeAddMapping, setSourceContent, toEncodedMap, toDecodedMap } from '@jridgewell/gen-mapping';
+
+class SourceMapConsumer {
+    constructor(map, mapUrl) {
+        const trace = (this._map = new AnyMap(map, mapUrl));
+        this.file = trace.file;
+        this.names = trace.names;
+        this.sourceRoot = trace.sourceRoot;
+        this.sources = trace.resolvedSources;
+        this.sourcesContent = trace.sourcesContent;
+        this.version = trace.version;
+    }
+    static fromSourceMap(map, mapUrl) {
+        // This is more performant if we receive
+        // a @jridgewell/source-map SourceMapGenerator
+        if (map.toDecodedMap) {
+            return new SourceMapConsumer(map.toDecodedMap(), mapUrl);
+        }
+        // This is a fallback for `source-map` and `source-map-js`
+        return new SourceMapConsumer(map.toJSON(), mapUrl);
+    }
+    get mappings() {
+        return encodedMappings(this._map);
+    }
+    originalPositionFor(needle) {
+        return originalPositionFor(this._map, needle);
+    }
+    generatedPositionFor(originalPosition) {
+        return generatedPositionFor(this._map, originalPosition);
+    }
+    allGeneratedPositionsFor(originalPosition) {
+        return allGeneratedPositionsFor(this._map, originalPosition);
+    }
+    hasContentsOfAllSources() {
+        if (!this.sourcesContent || this.sourcesContent.length !== this.sources.length) {
+            return false;
+        }
+        for (const content of this.sourcesContent) {
+            if (content == null) {
+                return false;
+            }
+        }
+        return true;
+    }
+    sourceContentFor(source, nullOnMissing) {
+        const sourceContent = sourceContentFor(this._map, source);
+        if (sourceContent != null) {
+            return sourceContent;
+        }
+        if (nullOnMissing) {
+            return null;
+        }
+        throw new Error(`"${source}" is not in the SourceMap.`);
+    }
+    eachMapping(callback, context /*, order?: number*/) {
+        // order is ignored as @jridgewell/trace-map doesn't implement it
+        eachMapping(this._map, context ? callback.bind(context) : callback);
+    }
+    destroy() {
+        // noop.
+    }
+}
+class SourceMapGenerator {
+    constructor(opts) {
+        // TODO :: should this be duck-typed ?
+        this._map = opts instanceof GenMapping ? opts : new GenMapping(opts);
+    }
+    static fromSourceMap(consumer) {
+        return new SourceMapGenerator(fromMap(consumer));
+    }
+    addMapping(mapping) {
+        maybeAddMapping(this._map, mapping);
+    }
+    setSourceContent(source, content) {
+        setSourceContent(this._map, source, content);
+    }
+    toJSON() {
+        return toEncodedMap(this._map);
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+    toDecodedMap() {
+        return toDecodedMap(this._map);
+    }
+}
+
+export { SourceMapConsumer, SourceMapGenerator };
+//# sourceMappingURL=source-map.mjs.map

node_modules/.pnpm/@jridgewell+source-map@0.3.6/node_modules/@jridgewell/source-map/dist/source-map.umd.js

@@ -0,0 +1,1242 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.sourceMap = {}));
+})(this, (function (exports) { 'use strict';
+
+    const comma = ','.charCodeAt(0);
+    const semicolon = ';'.charCodeAt(0);
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    const intToChar = new Uint8Array(64); // 64 possible chars.
+    const charToInt = new Uint8Array(128); // z is 122 in ASCII
+    for (let i = 0; i < chars.length; i++) {
+        const c = chars.charCodeAt(i);
+        intToChar[i] = c;
+        charToInt[c] = i;
+    }
+    // Provide a fallback for older environments.
+    const td = typeof TextDecoder !== 'undefined'
+        ? /* #__PURE__ */ new TextDecoder()
+        : typeof Buffer !== 'undefined'
+            ? {
+                decode(buf) {
+                    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+                    return out.toString();
+                },
+            }
+            : {
+                decode(buf) {
+                    let out = '';
+                    for (let i = 0; i < buf.length; i++) {
+                        out += String.fromCharCode(buf[i]);
+                    }
+                    return out;
+                },
+            };
+    function decode(mappings) {
+        const state = new Int32Array(5);
+        const decoded = [];
+        let index = 0;
+        do {
+            const semi = indexOf(mappings, index);
+            const line = [];
+            let sorted = true;
+            let lastCol = 0;
+            state[0] = 0;
+            for (let i = index; i < semi; i++) {
+                let seg;
+                i = decodeInteger(mappings, i, state, 0); // genColumn
+                const col = state[0];
+                if (col < lastCol)
+                    sorted = false;
+                lastCol = col;
+                if (hasMoreVlq(mappings, i, semi)) {
+                    i = decodeInteger(mappings, i, state, 1); // sourcesIndex
+                    i = decodeInteger(mappings, i, state, 2); // sourceLine
+                    i = decodeInteger(mappings, i, state, 3); // sourceColumn
+                    if (hasMoreVlq(mappings, i, semi)) {
+                        i = decodeInteger(mappings, i, state, 4); // namesIndex
+                        seg = [col, state[1], state[2], state[3], state[4]];
+                    }
+                    else {
+                        seg = [col, state[1], state[2], state[3]];
+                    }
+                }
+                else {
+                    seg = [col];
+                }
+                line.push(seg);
+            }
+            if (!sorted)
+                sort(line);
+            decoded.push(line);
+            index = semi + 1;
+        } while (index <= mappings.length);
+        return decoded;
+    }
+    function indexOf(mappings, index) {
+        const idx = mappings.indexOf(';', index);
+        return idx === -1 ? mappings.length : idx;
+    }
+    function decodeInteger(mappings, pos, state, j) {
+        let value = 0;
+        let shift = 0;
+        let integer = 0;
+        do {
+            const c = mappings.charCodeAt(pos++);
+            integer = charToInt[c];
+            value |= (integer & 31) << shift;
+            shift += 5;
+        } while (integer & 32);
+        const shouldNegate = value & 1;
+        value >>>= 1;
+        if (shouldNegate) {
+            value = -0x80000000 | -value;
+        }
+        state[j] += value;
+        return pos;
+    }
+    function hasMoreVlq(mappings, i, length) {
+        if (i >= length)
+            return false;
+        return mappings.charCodeAt(i) !== comma;
+    }
+    function sort(line) {
+        line.sort(sortComparator$1);
+    }
+    function sortComparator$1(a, b) {
+        return a[0] - b[0];
+    }
+    function encode(decoded) {
+        const state = new Int32Array(5);
+        const bufLength = 1024 * 16;
+        const subLength = bufLength - 36;
+        const buf = new Uint8Array(bufLength);
+        const sub = buf.subarray(0, subLength);
+        let pos = 0;
+        let out = '';
+        for (let i = 0; i < decoded.length; i++) {
+            const line = decoded[i];
+            if (i > 0) {
+                if (pos === bufLength) {
+                    out += td.decode(buf);
+                    pos = 0;
+                }
+                buf[pos++] = semicolon;
+            }
+            if (line.length === 0)
+                continue;
+            state[0] = 0;
+            for (let j = 0; j < line.length; j++) {
+                const segment = line[j];
+                // We can push up to 5 ints, each int can take at most 7 chars, and we
+                // may push a comma.
+                if (pos > subLength) {
+                    out += td.decode(sub);
+                    buf.copyWithin(0, subLength, pos);
+                    pos -= subLength;
+                }
+                if (j > 0)
+                    buf[pos++] = comma;
+                pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
+                if (segment.length === 1)
+                    continue;
+                pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
+                pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
+                pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
+                if (segment.length === 4)
+                    continue;
+                pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
+            }
+        }
+        return out + td.decode(buf.subarray(0, pos));
+    }
+    function encodeInteger(buf, pos, state, segment, j) {
+        const next = segment[j];
+        let num = next - state[j];
+        state[j] = next;
+        num = num < 0 ? (-num << 1) | 1 : num << 1;
+        do {
+            let clamped = num & 0b011111;
+            num >>>= 5;
+            if (num > 0)
+                clamped |= 0b100000;
+            buf[pos++] = intToChar[clamped];
+        } while (num > 0);
+        return pos;
+    }
+
+    // Matches the scheme of a URL, eg "http://"
+    const schemeRegex = /^[\w+.-]+:\/\//;
+    /**
+     * Matches the parts of a URL:
+     * 1. Scheme, including ":", guaranteed.
+     * 2. User/password, including "@", optional.
+     * 3. Host, guaranteed.
+     * 4. Port, including ":", optional.
+     * 5. Path, including "/", optional.
+     * 6. Query, including "?", optional.
+     * 7. Hash, including "#", optional.
+     */
+    const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+    /**
+     * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+     * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+     *
+     * 1. Host, optional.
+     * 2. Path, which may include "/", guaranteed.
+     * 3. Query, including "?", optional.
+     * 4. Hash, including "#", optional.
+     */
+    const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+    function isAbsoluteUrl(input) {
+        return schemeRegex.test(input);
+    }
+    function isSchemeRelativeUrl(input) {
+        return input.startsWith('//');
+    }
+    function isAbsolutePath(input) {
+        return input.startsWith('/');
+    }
+    function isFileUrl(input) {
+        return input.startsWith('file:');
+    }
+    function isRelative(input) {
+        return /^[.?#]/.test(input);
+    }
+    function parseAbsoluteUrl(input) {
+        const match = urlRegex.exec(input);
+        return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
+    }
+    function parseFileUrl(input) {
+        const match = fileRegex.exec(input);
+        const path = match[2];
+        return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
+    }
+    function makeUrl(scheme, user, host, port, path, query, hash) {
+        return {
+            scheme,
+            user,
+            host,
+            port,
+            path,
+            query,
+            hash,
+            type: 7 /* Absolute */,
+        };
+    }
+    function parseUrl(input) {
+        if (isSchemeRelativeUrl(input)) {
+            const url = parseAbsoluteUrl('http:' + input);
+            url.scheme = '';
+            url.type = 6 /* SchemeRelative */;
+            return url;
+        }
+        if (isAbsolutePath(input)) {
+            const url = parseAbsoluteUrl('http://foo.com' + input);
+            url.scheme = '';
+            url.host = '';
+            url.type = 5 /* AbsolutePath */;
+            return url;
+        }
+        if (isFileUrl(input))
+            return parseFileUrl(input);
+        if (isAbsoluteUrl(input))
+            return parseAbsoluteUrl(input);
+        const url = parseAbsoluteUrl('http://foo.com/' + input);
+        url.scheme = '';
+        url.host = '';
+        url.type = input
+            ? input.startsWith('?')
+                ? 3 /* Query */
+                : input.startsWith('#')
+                    ? 2 /* Hash */
+                    : 4 /* RelativePath */
+            : 1 /* Empty */;
+        return url;
+    }
+    function stripPathFilename(path) {
+        // If a path ends with a parent directory "..", then it's a relative path with excess parent
+        // paths. It's not a file, so we can't strip it.
+        if (path.endsWith('/..'))
+            return path;
+        const index = path.lastIndexOf('/');
+        return path.slice(0, index + 1);
+    }
+    function mergePaths(url, base) {
+        normalizePath(base, base.type);
+        // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
+        // path).
+        if (url.path === '/') {
+            url.path = base.path;
+        }
+        else {
+            // Resolution happens relative to the base path's directory, not the file.
+            url.path = stripPathFilename(base.path) + url.path;
+        }
+    }
+    /**
+     * The path can have empty directories "//", unneeded parents "foo/..", or current directory
+     * "foo/.". We need to normalize to a standard representation.
+     */
+    function normalizePath(url, type) {
+        const rel = type <= 4 /* RelativePath */;
+        const pieces = url.path.split('/');
+        // We need to preserve the first piece always, so that we output a leading slash. The item at
+        // pieces[0] is an empty string.
+        let pointer = 1;
+        // Positive is the number of real directories we've output, used for popping a parent directory.
+        // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
+        let positive = 0;
+        // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
+        // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
+        // real directory, we won't need to append, unless the other conditions happen again.
+        let addTrailingSlash = false;
+        for (let i = 1; i < pieces.length; i++) {
+            const piece = pieces[i];
+            // An empty directory, could be a trailing slash, or just a double "//" in the path.
+            if (!piece) {
+                addTrailingSlash = true;
+                continue;
+            }
+            // If we encounter a real directory, then we don't need to append anymore.
+            addTrailingSlash = false;
+            // A current directory, which we can always drop.
+            if (piece === '.')
+                continue;
+            // A parent directory, we need to see if there are any real directories we can pop. Else, we
+            // have an excess of parents, and we'll need to keep the "..".
+            if (piece === '..') {
+                if (positive) {
+                    addTrailingSlash = true;
+                    positive--;
+                    pointer--;
+                }
+                else if (rel) {
+                    // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
+                    // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
+                    pieces[pointer++] = piece;
+                }
+                continue;
+            }
+            // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
+            // any popped or dropped directories.
+            pieces[pointer++] = piece;
+            positive++;
+        }
+        let path = '';
+        for (let i = 1; i < pointer; i++) {
+            path += '/' + pieces[i];
+        }
+        if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
+            path += '/';
+        }
+        url.path = path;
+    }
+    /**
+     * Attempts to resolve `input` URL/path relative to `base`.
+     */
+    function resolve$1(input, base) {
+        if (!input && !base)
+            return '';
+        const url = parseUrl(input);
+        let inputType = url.type;
+        if (base && inputType !== 7 /* Absolute */) {
+            const baseUrl = parseUrl(base);
+            const baseType = baseUrl.type;
+            switch (inputType) {
+                case 1 /* Empty */:
+                    url.hash = baseUrl.hash;
+                // fall through
+                case 2 /* Hash */:
+                    url.query = baseUrl.query;
+                // fall through
+                case 3 /* Query */:
+                case 4 /* RelativePath */:
+                    mergePaths(url, baseUrl);
+                // fall through
+                case 5 /* AbsolutePath */:
+                    // The host, user, and port are joined, you can't copy one without the others.
+                    url.user = baseUrl.user;
+                    url.host = baseUrl.host;
+                    url.port = baseUrl.port;
+                // fall through
+                case 6 /* SchemeRelative */:
+                    // The input doesn't have a schema at least, so we need to copy at least that over.
+                    url.scheme = baseUrl.scheme;
+            }
+            if (baseType > inputType)
+                inputType = baseType;
+        }
+        normalizePath(url, inputType);
+        const queryHash = url.query + url.hash;
+        switch (inputType) {
+            // This is impossible, because of the empty checks at the start of the function.
+            // case UrlType.Empty:
+            case 2 /* Hash */:
+            case 3 /* Query */:
+                return queryHash;
+            case 4 /* RelativePath */: {
+                // The first char is always a "/", and we need it to be relative.
+                const path = url.path.slice(1);
+                if (!path)
+                    return queryHash || '.';
+                if (isRelative(base || input) && !isRelative(path)) {
+                    // If base started with a leading ".", or there is no base and input started with a ".",
+                    // then we need to ensure that the relative path starts with a ".". We don't know if
+                    // relative starts with a "..", though, so check before prepending.
+                    return './' + path + queryHash;
+                }
+                return path + queryHash;
+            }
+            case 5 /* AbsolutePath */:
+                return url.path + queryHash;
+            default:
+                return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
+        }
+    }
+
+    function resolve(input, base) {
+        // The base is always treated as a directory, if it's not empty.
+        // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
+        // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
+        if (base && !base.endsWith('/'))
+            base += '/';
+        return resolve$1(input, base);
+    }
+
+    /**
+     * Removes everything after the last "/", but leaves the slash.
+     */
+    function stripFilename(path) {
+        if (!path)
+            return '';
+        const index = path.lastIndexOf('/');
+        return path.slice(0, index + 1);
+    }
+
+    const COLUMN$1 = 0;
+    const SOURCES_INDEX$1 = 1;
+    const SOURCE_LINE$1 = 2;
+    const SOURCE_COLUMN$1 = 3;
+    const NAMES_INDEX$1 = 4;
+    const REV_GENERATED_LINE = 1;
+    const REV_GENERATED_COLUMN = 2;
+
+    function maybeSort(mappings, owned) {
+        const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+        if (unsortedIndex === mappings.length)
+            return mappings;
+        // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
+        // not, we do not want to modify the consumer's input array.
+        if (!owned)
+            mappings = mappings.slice();
+        for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+            mappings[i] = sortSegments(mappings[i], owned);
+        }
+        return mappings;
+    }
+    function nextUnsortedSegmentLine(mappings, start) {
+        for (let i = start; i < mappings.length; i++) {
+            if (!isSorted(mappings[i]))
+                return i;
+        }
+        return mappings.length;
+    }
+    function isSorted(line) {
+        for (let j = 1; j < line.length; j++) {
+            if (line[j][COLUMN$1] < line[j - 1][COLUMN$1]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function sortSegments(line, owned) {
+        if (!owned)
+            line = line.slice();
+        return line.sort(sortComparator);
+    }
+    function sortComparator(a, b) {
+        return a[COLUMN$1] - b[COLUMN$1];
+    }
+
+    let found = false;
+    /**
+     * A binary search implementation that returns the index if a match is found.
+     * If no match is found, then the left-index (the index associated with the item that comes just
+     * before the desired index) is returned. To maintain proper sort order, a splice would happen at
+     * the next index:
+     *
+     * ```js
+     * const array = [1, 3];
+     * const needle = 2;
+     * const index = binarySearch(array, needle, (item, needle) => item - needle);
+     *
+     * assert.equal(index, 0);
+     * array.splice(index + 1, 0, needle);
+     * assert.deepEqual(array, [1, 2, 3]);
+     * ```
+     */
+    function binarySearch(haystack, needle, low, high) {
+        while (low <= high) {
+            const mid = low + ((high - low) >> 1);
+            const cmp = haystack[mid][COLUMN$1] - needle;
+            if (cmp === 0) {
+                found = true;
+                return mid;
+            }
+            if (cmp < 0) {
+                low = mid + 1;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        found = false;
+        return low - 1;
+    }
+    function upperBound(haystack, needle, index) {
+        for (let i = index + 1; i < haystack.length; index = i++) {
+            if (haystack[i][COLUMN$1] !== needle)
+                break;
+        }
+        return index;
+    }
+    function lowerBound(haystack, needle, index) {
+        for (let i = index - 1; i >= 0; index = i--) {
+            if (haystack[i][COLUMN$1] !== needle)
+                break;
+        }
+        return index;
+    }
+    function memoizedState() {
+        return {
+            lastKey: -1,
+            lastNeedle: -1,
+            lastIndex: -1,
+        };
+    }
+    /**
+     * This overly complicated beast is just to record the last tested line/column and the resulting
+     * index, allowing us to skip a few tests if mappings are monotonically increasing.
+     */
+    function memoizedBinarySearch(haystack, needle, state, key) {
+        const { lastKey, lastNeedle, lastIndex } = state;
+        let low = 0;
+        let high = haystack.length - 1;
+        if (key === lastKey) {
+            if (needle === lastNeedle) {
+                found = lastIndex !== -1 && haystack[lastIndex][COLUMN$1] === needle;
+                return lastIndex;
+            }
+            if (needle >= lastNeedle) {
+                // lastIndex may be -1 if the previous needle was not found.
+                low = lastIndex === -1 ? 0 : lastIndex;
+            }
+            else {
+                high = lastIndex;
+            }
+        }
+        state.lastKey = key;
+        state.lastNeedle = needle;
+        return (state.lastIndex = binarySearch(haystack, needle, low, high));
+    }
+
+    // Rebuilds the original source files, with mappings that are ordered by source line/column instead
+    // of generated line/column.
+    function buildBySources(decoded, memos) {
+        const sources = memos.map(buildNullArray);
+        for (let i = 0; i < decoded.length; i++) {
+            const line = decoded[i];
+            for (let j = 0; j < line.length; j++) {
+                const seg = line[j];
+                if (seg.length === 1)
+                    continue;
+                const sourceIndex = seg[SOURCES_INDEX$1];
+                const sourceLine = seg[SOURCE_LINE$1];
+                const sourceColumn = seg[SOURCE_COLUMN$1];
+                const originalSource = sources[sourceIndex];
+                const originalLine = (originalSource[sourceLine] || (originalSource[sourceLine] = []));
+                const memo = memos[sourceIndex];
+                // The binary search either found a match, or it found the left-index just before where the
+                // segment should go. Either way, we want to insert after that. And there may be multiple
+                // generated segments associated with an original location, so there may need to move several
+                // indexes before we find where we need to insert.
+                let index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
+                memo.lastIndex = ++index;
+                insert$1(originalLine, index, [sourceColumn, i, seg[COLUMN$1]]);
+            }
+        }
+        return sources;
+    }
+    function insert$1(array, index, value) {
+        for (let i = array.length; i > index; i--) {
+            array[i] = array[i - 1];
+        }
+        array[index] = value;
+    }
+    // Null arrays allow us to use ordered index keys without actually allocating contiguous memory like
+    // a real array. We use a null-prototype object to avoid prototype pollution and deoptimizations.
+    // Numeric properties on objects are magically sorted in ascending order by the engine regardless of
+    // the insertion order. So, by setting any numeric keys, even out of order, we'll get ascending
+    // order when iterating with for-in.
+    function buildNullArray() {
+        return { __proto__: null };
+    }
+
+    const AnyMap = function (map, mapUrl) {
+        const parsed = parse(map);
+        if (!('sections' in parsed)) {
+            return new TraceMap(parsed, mapUrl);
+        }
+        const mappings = [];
+        const sources = [];
+        const sourcesContent = [];
+        const names = [];
+        const ignoreList = [];
+        recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, ignoreList, 0, 0, Infinity, Infinity);
+        const joined = {
+            version: 3,
+            file: parsed.file,
+            names,
+            sources,
+            sourcesContent,
+            mappings,
+            ignoreList,
+        };
+        return presortedDecodedMap(joined);
+    };
+    function parse(map) {
+        return typeof map === 'string' ? JSON.parse(map) : map;
+    }
+    function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+        const { sections } = input;
+        for (let i = 0; i < sections.length; i++) {
+            const { map, offset } = sections[i];
+            let sl = stopLine;
+            let sc = stopColumn;
+            if (i + 1 < sections.length) {
+                const nextOffset = sections[i + 1].offset;
+                sl = Math.min(stopLine, lineOffset + nextOffset.line);
+                if (sl === stopLine) {
+                    sc = Math.min(stopColumn, columnOffset + nextOffset.column);
+                }
+                else if (sl < stopLine) {
+                    sc = columnOffset + nextOffset.column;
+                }
+            }
+            addSection(map, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
+        }
+    }
+    function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+        const parsed = parse(input);
+        if ('sections' in parsed)
+            return recurse(...arguments);
+        const map = new TraceMap(parsed, mapUrl);
+        const sourcesOffset = sources.length;
+        const namesOffset = names.length;
+        const decoded = decodedMappings(map);
+        const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
+        append(sources, resolvedSources);
+        append(names, map.names);
+        if (contents)
+            append(sourcesContent, contents);
+        else
+            for (let i = 0; i < resolvedSources.length; i++)
+                sourcesContent.push(null);
+        if (ignores)
+            for (let i = 0; i < ignores.length; i++)
+                ignoreList.push(ignores[i] + sourcesOffset);
+        for (let i = 0; i < decoded.length; i++) {
+            const lineI = lineOffset + i;
+            // We can only add so many lines before we step into the range that the next section's map
+            // controls. When we get to the last line, then we'll start checking the segments to see if
+            // they've crossed into the column range. But it may not have any columns that overstep, so we
+            // still need to check that we don't overstep lines, too.
+            if (lineI > stopLine)
+                return;
+            // The out line may already exist in mappings (if we're continuing the line started by a
+            // previous section). Or, we may have jumped ahead several lines to start this section.
+            const out = getLine$1(mappings, lineI);
+            // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the
+            // map can be multiple lines), it doesn't.
+            const cOffset = i === 0 ? columnOffset : 0;
+            const line = decoded[i];
+            for (let j = 0; j < line.length; j++) {
+                const seg = line[j];
+                const column = cOffset + seg[COLUMN$1];
+                // If this segment steps into the column range that the next section's map controls, we need
+                // to stop early.
+                if (lineI === stopLine && column >= stopColumn)
+                    return;
+                if (seg.length === 1) {
+                    out.push([column]);
+                    continue;
+                }
+                const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX$1];
+                const sourceLine = seg[SOURCE_LINE$1];
+                const sourceColumn = seg[SOURCE_COLUMN$1];
+                out.push(seg.length === 4
+                    ? [column, sourcesIndex, sourceLine, sourceColumn]
+                    : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX$1]]);
+            }
+        }
+    }
+    function append(arr, other) {
+        for (let i = 0; i < other.length; i++)
+            arr.push(other[i]);
+    }
+    function getLine$1(arr, index) {
+        for (let i = arr.length; i <= index; i++)
+            arr[i] = [];
+        return arr[index];
+    }
+
+    const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
+    const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
+    const LEAST_UPPER_BOUND = -1;
+    const GREATEST_LOWER_BOUND = 1;
+    class TraceMap {
+        constructor(map, mapUrl) {
+            const isString = typeof map === 'string';
+            if (!isString && map._decodedMemo)
+                return map;
+            const parsed = (isString ? JSON.parse(map) : map);
+            const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+            this.version = version;
+            this.file = file;
+            this.names = names || [];
+            this.sourceRoot = sourceRoot;
+            this.sources = sources;
+            this.sourcesContent = sourcesContent;
+            this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
+            const from = resolve(sourceRoot || '', stripFilename(mapUrl));
+            this.resolvedSources = sources.map((s) => resolve(s || '', from));
+            const { mappings } = parsed;
+            if (typeof mappings === 'string') {
+                this._encoded = mappings;
+                this._decoded = undefined;
+            }
+            else {
+                this._encoded = undefined;
+                this._decoded = maybeSort(mappings, isString);
+            }
+            this._decodedMemo = memoizedState();
+            this._bySources = undefined;
+            this._bySourceMemos = undefined;
+        }
+    }
+    /**
+     * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+     * with public access modifiers.
+     */
+    function cast$2(map) {
+        return map;
+    }
+    /**
+     * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
+     */
+    function encodedMappings(map) {
+        var _a;
+        var _b;
+        return ((_a = (_b = cast$2(map))._encoded) !== null && _a !== void 0 ? _a : (_b._encoded = encode(cast$2(map)._decoded)));
+    }
+    /**
+     * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
+     */
+    function decodedMappings(map) {
+        var _a;
+        return ((_a = cast$2(map))._decoded || (_a._decoded = decode(cast$2(map)._encoded)));
+    }
+    /**
+     * A higher-level API to find the source/line/column associated with a generated line/column
+     * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
+     * `source-map` library.
+     */
+    function originalPositionFor(map, needle) {
+        let { line, column, bias } = needle;
+        line--;
+        if (line < 0)
+            throw new Error(LINE_GTR_ZERO);
+        if (column < 0)
+            throw new Error(COL_GTR_EQ_ZERO);
+        const decoded = decodedMappings(map);
+        // It's common for parent source maps to have pointers to lines that have no
+        // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+        if (line >= decoded.length)
+            return OMapping(null, null, null, null);
+        const segments = decoded[line];
+        const index = traceSegmentInternal(segments, cast$2(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+        if (index === -1)
+            return OMapping(null, null, null, null);
+        const segment = segments[index];
+        if (segment.length === 1)
+            return OMapping(null, null, null, null);
+        const { names, resolvedSources } = map;
+        return OMapping(resolvedSources[segment[SOURCES_INDEX$1]], segment[SOURCE_LINE$1] + 1, segment[SOURCE_COLUMN$1], segment.length === 5 ? names[segment[NAMES_INDEX$1]] : null);
+    }
+    /**
+     * Finds the generated line/column position of the provided source/line/column source position.
+     */
+    function generatedPositionFor(map, needle) {
+        const { source, line, column, bias } = needle;
+        return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
+    }
+    /**
+     * Finds all generated line/column positions of the provided source/line/column source position.
+     */
+    function allGeneratedPositionsFor(map, needle) {
+        const { source, line, column, bias } = needle;
+        // SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit.
+        return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
+    }
+    /**
+     * Iterates each mapping in generated position order.
+     */
+    function eachMapping(map, cb) {
+        const decoded = decodedMappings(map);
+        const { names, resolvedSources } = map;
+        for (let i = 0; i < decoded.length; i++) {
+            const line = decoded[i];
+            for (let j = 0; j < line.length; j++) {
+                const seg = line[j];
+                const generatedLine = i + 1;
+                const generatedColumn = seg[0];
+                let source = null;
+                let originalLine = null;
+                let originalColumn = null;
+                let name = null;
+                if (seg.length !== 1) {
+                    source = resolvedSources[seg[1]];
+                    originalLine = seg[2] + 1;
+                    originalColumn = seg[3];
+                }
+                if (seg.length === 5)
+                    name = names[seg[4]];
+                cb({
+                    generatedLine,
+                    generatedColumn,
+                    source,
+                    originalLine,
+                    originalColumn,
+                    name,
+                });
+            }
+        }
+    }
+    function sourceIndex(map, source) {
+        const { sources, resolvedSources } = map;
+        let index = sources.indexOf(source);
+        if (index === -1)
+            index = resolvedSources.indexOf(source);
+        return index;
+    }
+    /**
+     * Retrieves the source content for a particular source, if its found. Returns null if not.
+     */
+    function sourceContentFor(map, source) {
+        const { sourcesContent } = map;
+        if (sourcesContent == null)
+            return null;
+        const index = sourceIndex(map, source);
+        return index === -1 ? null : sourcesContent[index];
+    }
+    /**
+     * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
+     * maps.
+     */
+    function presortedDecodedMap(map, mapUrl) {
+        const tracer = new TraceMap(clone(map, []), mapUrl);
+        cast$2(tracer)._decoded = map.mappings;
+        return tracer;
+    }
+    function clone(map, mappings) {
+        return {
+            version: map.version,
+            file: map.file,
+            names: map.names,
+            sourceRoot: map.sourceRoot,
+            sources: map.sources,
+            sourcesContent: map.sourcesContent,
+            mappings,
+            ignoreList: map.ignoreList || map.x_google_ignoreList,
+        };
+    }
+    function OMapping(source, line, column, name) {
+        return { source, line, column, name };
+    }
+    function GMapping(line, column) {
+        return { line, column };
+    }
+    function traceSegmentInternal(segments, memo, line, column, bias) {
+        let index = memoizedBinarySearch(segments, column, memo, line);
+        if (found) {
+            index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+        }
+        else if (bias === LEAST_UPPER_BOUND)
+            index++;
+        if (index === -1 || index === segments.length)
+            return -1;
+        return index;
+    }
+    function sliceGeneratedPositions(segments, memo, line, column, bias) {
+        let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
+        // We ignored the bias when tracing the segment so that we're guarnateed to find the first (in
+        // insertion order) segment that matched. Even if we did respect the bias when tracing, we would
+        // still need to call `lowerBound()` to find the first segment, which is slower than just looking
+        // for the GREATEST_LOWER_BOUND to begin with. The only difference that matters for us is when the
+        // binary search didn't match, in which case GREATEST_LOWER_BOUND just needs to increment to
+        // match LEAST_UPPER_BOUND.
+        if (!found && bias === LEAST_UPPER_BOUND)
+            min++;
+        if (min === -1 || min === segments.length)
+            return [];
+        // We may have found the segment that started at an earlier column. If this is the case, then we
+        // need to slice all generated segments that match _that_ column, because all such segments span
+        // to our desired column.
+        const matchedColumn = found ? column : segments[min][COLUMN$1];
+        // The binary search is not guaranteed to find the lower bound when a match wasn't found.
+        if (!found)
+            min = lowerBound(segments, matchedColumn, min);
+        const max = upperBound(segments, matchedColumn, min);
+        const result = [];
+        for (; min <= max; min++) {
+            const segment = segments[min];
+            result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
+        }
+        return result;
+    }
+    function generatedPosition(map, source, line, column, bias, all) {
+        var _a;
+        line--;
+        if (line < 0)
+            throw new Error(LINE_GTR_ZERO);
+        if (column < 0)
+            throw new Error(COL_GTR_EQ_ZERO);
+        const { sources, resolvedSources } = map;
+        let sourceIndex = sources.indexOf(source);
+        if (sourceIndex === -1)
+            sourceIndex = resolvedSources.indexOf(source);
+        if (sourceIndex === -1)
+            return all ? [] : GMapping(null, null);
+        const generated = ((_a = cast$2(map))._bySources || (_a._bySources = buildBySources(decodedMappings(map), (cast$2(map)._bySourceMemos = sources.map(memoizedState)))));
+        const segments = generated[sourceIndex][line];
+        if (segments == null)
+            return all ? [] : GMapping(null, null);
+        const memo = cast$2(map)._bySourceMemos[sourceIndex];
+        if (all)
+            return sliceGeneratedPositions(segments, memo, line, column, bias);
+        const index = traceSegmentInternal(segments, memo, line, column, bias);
+        if (index === -1)
+            return GMapping(null, null);
+        const segment = segments[index];
+        return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
+    }
+
+    /**
+     * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
+     * index of the `key` in the backing array.
+     *
+     * This is designed to allow synchronizing a second array with the contents of the backing array,
+     * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
+     * and there are never duplicates.
+     */
+    class SetArray {
+        constructor() {
+            this._indexes = { __proto__: null };
+            this.array = [];
+        }
+    }
+    /**
+     * Typescript doesn't allow friend access to private fields, so this just casts the set into a type
+     * with public access modifiers.
+     */
+    function cast$1(set) {
+        return set;
+    }
+    /**
+     * Gets the index associated with `key` in the backing array, if it is already present.
+     */
+    function get(setarr, key) {
+        return cast$1(setarr)._indexes[key];
+    }
+    /**
+     * Puts `key` into the backing array, if it is not already present. Returns
+     * the index of the `key` in the backing array.
+     */
+    function put(setarr, key) {
+        // The key may or may not be present. If it is present, it's a number.
+        const index = get(setarr, key);
+        if (index !== undefined)
+            return index;
+        const { array, _indexes: indexes } = cast$1(setarr);
+        const length = array.push(key);
+        return (indexes[key] = length - 1);
+    }
+
+    const COLUMN = 0;
+    const SOURCES_INDEX = 1;
+    const SOURCE_LINE = 2;
+    const SOURCE_COLUMN = 3;
+    const NAMES_INDEX = 4;
+
+    const NO_NAME = -1;
+    /**
+     * Provides the state to generate a sourcemap.
+     */
+    class GenMapping {
+        constructor({ file, sourceRoot } = {}) {
+            this._names = new SetArray();
+            this._sources = new SetArray();
+            this._sourcesContent = [];
+            this._mappings = [];
+            this.file = file;
+            this.sourceRoot = sourceRoot;
+            this._ignoreList = new SetArray();
+        }
+    }
+    /**
+     * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+     * with public access modifiers.
+     */
+    function cast(map) {
+        return map;
+    }
+    /**
+     * Same as `addMapping`, but will only add the mapping if it generates useful information in the
+     * resulting map. This only works correctly if mappings are added **in order**, meaning you should
+     * not add a mapping with a lower generated line/column than one that came before.
+     */
+    const maybeAddMapping = (map, mapping) => {
+        return addMappingInternal(true, map, mapping);
+    };
+    /**
+     * Adds/removes the content of the source file to the source map.
+     */
+    function setSourceContent(map, source, content) {
+        const { _sources: sources, _sourcesContent: sourcesContent } = cast(map);
+        const index = put(sources, source);
+        sourcesContent[index] = content;
+    }
+    /**
+     * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+     * a sourcemap, or to JSON.stringify.
+     */
+    function toDecodedMap(map) {
+        const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, _ignoreList: ignoreList, } = cast(map);
+        removeEmptyFinalLines(mappings);
+        return {
+            version: 3,
+            file: map.file || undefined,
+            names: names.array,
+            sourceRoot: map.sourceRoot || undefined,
+            sources: sources.array,
+            sourcesContent,
+            mappings,
+            ignoreList: ignoreList.array,
+        };
+    }
+    /**
+     * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+     * a sourcemap, or to JSON.stringify.
+     */
+    function toEncodedMap(map) {
+        const decoded = toDecodedMap(map);
+        return Object.assign(Object.assign({}, decoded), { mappings: encode(decoded.mappings) });
+    }
+    /**
+     * Constructs a new GenMapping, using the already present mappings of the input.
+     */
+    function fromMap(input) {
+        const map = new TraceMap(input);
+        const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot });
+        putAll(cast(gen)._names, map.names);
+        putAll(cast(gen)._sources, map.sources);
+        cast(gen)._sourcesContent = map.sourcesContent || map.sources.map(() => null);
+        cast(gen)._mappings = decodedMappings(map);
+        if (map.ignoreList)
+            putAll(cast(gen)._ignoreList, map.ignoreList);
+        return gen;
+    }
+    // This split declaration is only so that terser can elminiate the static initialization block.
+    function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+        const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = cast(map);
+        const line = getLine(mappings, genLine);
+        const index = getColumnIndex(line, genColumn);
+        if (!source) {
+            if (skipable && skipSourceless(line, index))
+                return;
+            return insert(line, index, [genColumn]);
+        }
+        const sourcesIndex = put(sources, source);
+        const namesIndex = name ? put(names, name) : NO_NAME;
+        if (sourcesIndex === sourcesContent.length)
+            sourcesContent[sourcesIndex] = content !== null && content !== void 0 ? content : null;
+        if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
+            return;
+        }
+        return insert(line, index, name
+            ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
+            : [genColumn, sourcesIndex, sourceLine, sourceColumn]);
+    }
+    function getLine(mappings, index) {
+        for (let i = mappings.length; i <= index; i++) {
+            mappings[i] = [];
+        }
+        return mappings[index];
+    }
+    function getColumnIndex(line, genColumn) {
+        let index = line.length;
+        for (let i = index - 1; i >= 0; index = i--) {
+            const current = line[i];
+            if (genColumn >= current[COLUMN])
+                break;
+        }
+        return index;
+    }
+    function insert(array, index, value) {
+        for (let i = array.length; i > index; i--) {
+            array[i] = array[i - 1];
+        }
+        array[index] = value;
+    }
+    function removeEmptyFinalLines(mappings) {
+        const { length } = mappings;
+        let len = length;
+        for (let i = len - 1; i >= 0; len = i, i--) {
+            if (mappings[i].length > 0)
+                break;
+        }
+        if (len < length)
+            mappings.length = len;
+    }
+    function putAll(setarr, array) {
+        for (let i = 0; i < array.length; i++)
+            put(setarr, array[i]);
+    }
+    function skipSourceless(line, index) {
+        // The start of a line is already sourceless, so adding a sourceless segment to the beginning
+        // doesn't generate any useful information.
+        if (index === 0)
+            return true;
+        const prev = line[index - 1];
+        // If the previous segment is also sourceless, then adding another sourceless segment doesn't
+        // genrate any new information. Else, this segment will end the source/named segment and point to
+        // a sourceless position, which is useful.
+        return prev.length === 1;
+    }
+    function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
+        // A source/named segment at the start of a line gives position at that genColumn
+        if (index === 0)
+            return false;
+        const prev = line[index - 1];
+        // If the previous segment is sourceless, then we're transitioning to a source.
+        if (prev.length === 1)
+            return false;
+        // If the previous segment maps to the exact same source position, then this segment doesn't
+        // provide any new position information.
+        return (sourcesIndex === prev[SOURCES_INDEX] &&
+            sourceLine === prev[SOURCE_LINE] &&
+            sourceColumn === prev[SOURCE_COLUMN] &&
+            namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME));
+    }
+    function addMappingInternal(skipable, map, mapping) {
+        const { generated, source, original, name, content } = mapping;
+        if (!source) {
+            return addSegmentInternal(skipable, map, generated.line - 1, generated.column, null, null, null, null, null);
+        }
+        return addSegmentInternal(skipable, map, generated.line - 1, generated.column, source, original.line - 1, original.column, name, content);
+    }
+
+    class SourceMapConsumer {
+        constructor(map, mapUrl) {
+            const trace = (this._map = new AnyMap(map, mapUrl));
+            this.file = trace.file;
+            this.names = trace.names;
+            this.sourceRoot = trace.sourceRoot;
+            this.sources = trace.resolvedSources;
+            this.sourcesContent = trace.sourcesContent;
+            this.version = trace.version;
+        }
+        static fromSourceMap(map, mapUrl) {
+            // This is more performant if we receive
+            // a @jridgewell/source-map SourceMapGenerator
+            if (map.toDecodedMap) {
+                return new SourceMapConsumer(map.toDecodedMap(), mapUrl);
+            }
+            // This is a fallback for `source-map` and `source-map-js`
+            return new SourceMapConsumer(map.toJSON(), mapUrl);
+        }
+        get mappings() {
+            return encodedMappings(this._map);
+        }
+        originalPositionFor(needle) {
+            return originalPositionFor(this._map, needle);
+        }
+        generatedPositionFor(originalPosition) {
+            return generatedPositionFor(this._map, originalPosition);
+        }
+        allGeneratedPositionsFor(originalPosition) {
+            return allGeneratedPositionsFor(this._map, originalPosition);
+        }
+        hasContentsOfAllSources() {
+            if (!this.sourcesContent || this.sourcesContent.length !== this.sources.length) {
+                return false;
+            }
+            for (const content of this.sourcesContent) {
+                if (content == null) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        sourceContentFor(source, nullOnMissing) {
+            const sourceContent = sourceContentFor(this._map, source);
+            if (sourceContent != null) {
+                return sourceContent;
+            }
+            if (nullOnMissing) {
+                return null;
+            }
+            throw new Error(`"${source}" is not in the SourceMap.`);
+        }
+        eachMapping(callback, context /*, order?: number*/) {
+            // order is ignored as @jridgewell/trace-map doesn't implement it
+            eachMapping(this._map, context ? callback.bind(context) : callback);
+        }
+        destroy() {
+            // noop.
+        }
+    }
+    class SourceMapGenerator {
+        constructor(opts) {
+            // TODO :: should this be duck-typed ?
+            this._map = opts instanceof GenMapping ? opts : new GenMapping(opts);
+        }
+        static fromSourceMap(consumer) {
+            return new SourceMapGenerator(fromMap(consumer));
+        }
+        addMapping(mapping) {
+            maybeAddMapping(this._map, mapping);
+        }
+        setSourceContent(source, content) {
+            setSourceContent(this._map, source, content);
+        }
+        toJSON() {
+            return toEncodedMap(this._map);
+        }
+        toString() {
+            return JSON.stringify(this.toJSON());
+        }
+        toDecodedMap() {
+            return toDecodedMap(this._map);
+        }
+    }
+
+    exports.SourceMapConsumer = SourceMapConsumer;
+    exports.SourceMapGenerator = SourceMapGenerator;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=source-map.umd.js.map

node_modules/.pnpm/@jridgewell+source-map@0.3.6/node_modules/@jridgewell/source-map/dist/types/source-map.d.ts

@@ -0,0 +1,35 @@
+import { AnyMap, originalPositionFor, generatedPositionFor, eachMapping } from '@jridgewell/trace-mapping';
+import { GenMapping, maybeAddMapping, toDecodedMap, toEncodedMap, setSourceContent } from '@jridgewell/gen-mapping';
+import type { TraceMap, SourceMapInput, SectionedSourceMapInput, DecodedSourceMap } from '@jridgewell/trace-mapping';
+export type { TraceMap, SourceMapInput, SectionedSourceMapInput, DecodedSourceMap };
+import type { Mapping, EncodedSourceMap } from '@jridgewell/gen-mapping';
+export type { Mapping, EncodedSourceMap };
+export declare class SourceMapConsumer {
+    private _map;
+    file: TraceMap['file'];
+    names: TraceMap['names'];
+    sourceRoot: TraceMap['sourceRoot'];
+    sources: TraceMap['sources'];
+    sourcesContent: TraceMap['sourcesContent'];
+    version: TraceMap['version'];
+    constructor(map: ConstructorParameters<typeof AnyMap>[0], mapUrl: Parameters<typeof AnyMap>[1]);
+    static fromSourceMap(map: SourceMapGenerator, mapUrl: Parameters<typeof AnyMap>[1]): SourceMapConsumer;
+    get mappings(): string;
+    originalPositionFor(needle: Parameters<typeof originalPositionFor>[1]): ReturnType<typeof originalPositionFor>;
+    generatedPositionFor(originalPosition: Parameters<typeof generatedPositionFor>[1]): ReturnType<typeof generatedPositionFor>;
+    allGeneratedPositionsFor(originalPosition: Parameters<typeof generatedPositionFor>[1]): ReturnType<typeof generatedPositionFor>[];
+    hasContentsOfAllSources(): boolean;
+    sourceContentFor(source: string, nullOnMissing?: boolean): string | null;
+    eachMapping(callback: Parameters<typeof eachMapping>[1], context?: any): void;
+    destroy(): void;
+}
+export declare class SourceMapGenerator {
+    private _map;
+    constructor(opts: ConstructorParameters<typeof GenMapping>[0] | GenMapping);
+    static fromSourceMap(consumer: SourceMapConsumer): SourceMapGenerator;
+    addMapping(mapping: Parameters<typeof maybeAddMapping>[1]): ReturnType<typeof maybeAddMapping>;
+    setSourceContent(source: Parameters<typeof setSourceContent>[1], content: Parameters<typeof setSourceContent>[2]): ReturnType<typeof setSourceContent>;
+    toJSON(): ReturnType<typeof toEncodedMap>;
+    toString(): string;
+    toDecodedMap(): ReturnType<typeof toDecodedMap>;
+}

node_modules/.pnpm/@jridgewell+source-map@0.3.6/node_modules/@jridgewell/source-map/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@jridgewell/source-map",
+  "version": "0.3.6",
+  "description": "Packages @jridgewell/trace-mapping and @jridgewell/gen-mapping into the familiar source-map API",
+  "keywords": [
+    "sourcemap",
+    "source",
+    "map"
+  ],
+  "author": "Justin Ridgewell <justin@ridgewell.name>",
+  "license": "MIT",
+  "repository": "https://github.com/jridgewell/source-map",
+  "main": "dist/source-map.cjs",
+  "module": "dist/source-map.mjs",
+  "types": "dist/types/source-map.d.ts",
+  "exports": {
+    ".": [
+      {
+        "types": "./dist/types/source-map.d.ts",
+        "browser": "./dist/source-map.umd.js",
+        "require": "./dist/source-map.cjs",
+        "import": "./dist/source-map.mjs"
+      },
+      "./dist/source-map.cjs"
+    ],
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prebuild": "rm -rf dist",
+    "build": "run-s -n build:*",
+    "build:rollup": "rollup -c rollup.config.js",
+    "build:ts": "tsc --project tsconfig.build.json",
+    "lint": "run-s -n lint:*",
+    "lint:prettier": "npm run test:lint:prettier -- --write",
+    "lint:ts": "npm run test:lint:ts -- --fix",
+    "test": "run-s -n test:lint test:only",
+    "test:debug": "ts-mocha --inspect-brk",
+    "test:lint": "run-s -n test:lint:*",
+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
+    "test:only": "ts-mocha",
+    "test:coverage": "c8 --reporter text --reporter html ts-mocha",
+    "test:watch": "ts-mocha --watch",
+    "prepublishOnly": "npm run preversion",
+    "preversion": "run-s test build"
+  },
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "13.2.1",
+    "@rollup/plugin-typescript": "8.3.0",
+    "@types/mocha": "9.1.1",
+    "@types/node": "17.0.30",
+    "@typescript-eslint/eslint-plugin": "5.10.0",
+    "@typescript-eslint/parser": "5.10.0",
+    "c8": "7.11.0",
+    "eslint": "8.7.0",
+    "eslint-config-prettier": "8.3.0",
+    "mocha": "10.0.0",
+    "npm-run-all": "4.1.5",
+    "prettier": "2.5.1",
+    "rollup": "2.66.0",
+    "ts-mocha": "10.0.0",
+    "typescript": "4.5.5"
+  },
+  "dependencies": {
+    "@jridgewell/gen-mapping": "^0.3.5",
+    "@jridgewell/trace-mapping": "^0.3.25"
+  }
+}

node_modules/.pnpm/@jridgewell+source-map@0.3.6/node_modules/@jridgewell/trace-mapping

@@ -0,0 +1 @@
+../../../@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping

node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2015 Rich Harris
+
+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/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/README.md

@@ -0,0 +1,264 @@
+# @jridgewell/sourcemap-codec
+
+Encode/decode the `mappings` property of a [sourcemap](https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit).
+
+
+## Why?
+
+Sourcemaps are difficult to generate and manipulate, because the `mappings` property – the part that actually links the generated code back to the original source – is encoded using an obscure method called [Variable-length quantity](https://en.wikipedia.org/wiki/Variable-length_quantity). On top of that, each segment in the mapping contains offsets rather than absolute indices, which means that you can't look at a segment in isolation – you have to understand the whole sourcemap.
+
+This package makes the process slightly easier.
+
+
+## Installation
+
+```bash
+npm install @jridgewell/sourcemap-codec
+```
+
+
+## Usage
+
+```js
+import { encode, decode } from '@jridgewell/sourcemap-codec';
+
+var decoded = decode( ';EAEEA,EAAE,EAAC,CAAE;ECQY,UACC' );
+
+assert.deepEqual( decoded, [
+	// the first line (of the generated code) has no mappings,
+	// as shown by the starting semi-colon (which separates lines)
+	[],
+
+	// the second line contains four (comma-separated) segments
+	[
+		// segments are encoded as you'd expect:
+		// [ generatedCodeColumn, sourceIndex, sourceCodeLine, sourceCodeColumn, nameIndex ]
+
+		// i.e. the first segment begins at column 2, and maps back to the second column
+		// of the second line (both zero-based) of the 0th source, and uses the 0th
+		// name in the `map.names` array
+		[ 2, 0, 2, 2, 0 ],
+
+		// the remaining segments are 4-length rather than 5-length,
+		// because they don't map a name
+		[ 4, 0, 2, 4 ],
+		[ 6, 0, 2, 5 ],
+		[ 7, 0, 2, 7 ]
+	],
+
+	// the final line contains two segments
+	[
+		[ 2, 1, 10, 19 ],
+		[ 12, 1, 11, 20 ]
+	]
+]);
+
+var encoded = encode( decoded );
+assert.equal( encoded, ';EAEEA,EAAE,EAAC,CAAE;ECQY,UACC' );
+```
+
+## Benchmarks
+
+```
+node v20.10.0
+
+amp.js.map - 45120 segments
+
+Decode Memory Usage:
+local code                             5815135 bytes
+@jridgewell/sourcemap-codec 1.4.15     5868160 bytes
+sourcemap-codec                        5492584 bytes
+source-map-0.6.1                      13569984 bytes
+source-map-0.8.0                       6390584 bytes
+chrome dev tools                       8011136 bytes
+Smallest memory usage is sourcemap-codec
+
+Decode speed:
+decode: local code x 492 ops/sec ±1.22% (90 runs sampled)
+decode: @jridgewell/sourcemap-codec 1.4.15 x 499 ops/sec ±1.16% (89 runs sampled)
+decode: sourcemap-codec x 376 ops/sec ±1.66% (89 runs sampled)
+decode: source-map-0.6.1 x 34.99 ops/sec ±0.94% (48 runs sampled)
+decode: source-map-0.8.0 x 351 ops/sec ±0.07% (95 runs sampled)
+chrome dev tools x 165 ops/sec ±0.91% (86 runs sampled)
+Fastest is decode: @jridgewell/sourcemap-codec 1.4.15
+
+Encode Memory Usage:
+local code                              444248 bytes
+@jridgewell/sourcemap-codec 1.4.15      623024 bytes
+sourcemap-codec                        8696280 bytes
+source-map-0.6.1                       8745176 bytes
+source-map-0.8.0                       8736624 bytes
+Smallest memory usage is local code
+
+Encode speed:
+encode: local code x 796 ops/sec ±0.11% (97 runs sampled)
+encode: @jridgewell/sourcemap-codec 1.4.15 x 795 ops/sec ±0.25% (98 runs sampled)
+encode: sourcemap-codec x 231 ops/sec ±0.83% (86 runs sampled)
+encode: source-map-0.6.1 x 166 ops/sec ±0.57% (86 runs sampled)
+encode: source-map-0.8.0 x 203 ops/sec ±0.45% (88 runs sampled)
+Fastest is encode: local code,encode: @jridgewell/sourcemap-codec 1.4.15
+
+
+***
+
+
+babel.min.js.map - 347793 segments
+
+Decode Memory Usage:
+local code                            35424960 bytes
+@jridgewell/sourcemap-codec 1.4.15    35424696 bytes
+sourcemap-codec                       36033464 bytes
+source-map-0.6.1                      62253704 bytes
+source-map-0.8.0                      43843920 bytes
+chrome dev tools                      45111400 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec 1.4.15
+
+Decode speed:
+decode: local code x 38.18 ops/sec ±5.44% (52 runs sampled)
+decode: @jridgewell/sourcemap-codec 1.4.15 x 38.36 ops/sec ±5.02% (52 runs sampled)
+decode: sourcemap-codec x 34.05 ops/sec ±4.45% (47 runs sampled)
+decode: source-map-0.6.1 x 4.31 ops/sec ±2.76% (15 runs sampled)
+decode: source-map-0.8.0 x 55.60 ops/sec ±0.13% (73 runs sampled)
+chrome dev tools x 16.94 ops/sec ±3.78% (46 runs sampled)
+Fastest is decode: source-map-0.8.0
+
+Encode Memory Usage:
+local code                             2606016 bytes
+@jridgewell/sourcemap-codec 1.4.15     2626440 bytes
+sourcemap-codec                       21152576 bytes
+source-map-0.6.1                      25023928 bytes
+source-map-0.8.0                      25256448 bytes
+Smallest memory usage is local code
+
+Encode speed:
+encode: local code x 127 ops/sec ±0.18% (83 runs sampled)
+encode: @jridgewell/sourcemap-codec 1.4.15 x 128 ops/sec ±0.26% (83 runs sampled)
+encode: sourcemap-codec x 29.31 ops/sec ±2.55% (53 runs sampled)
+encode: source-map-0.6.1 x 18.85 ops/sec ±3.19% (36 runs sampled)
+encode: source-map-0.8.0 x 19.34 ops/sec ±1.97% (36 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec 1.4.15
+
+
+***
+
+
+preact.js.map - 1992 segments
+
+Decode Memory Usage:
+local code                              261696 bytes
+@jridgewell/sourcemap-codec 1.4.15      244296 bytes
+sourcemap-codec                         302816 bytes
+source-map-0.6.1                        939176 bytes
+source-map-0.8.0                           336 bytes
+chrome dev tools                        587368 bytes
+Smallest memory usage is source-map-0.8.0
+
+Decode speed:
+decode: local code x 17,782 ops/sec ±0.32% (97 runs sampled)
+decode: @jridgewell/sourcemap-codec 1.4.15 x 17,863 ops/sec ±0.40% (100 runs sampled)
+decode: sourcemap-codec x 12,453 ops/sec ±0.27% (101 runs sampled)
+decode: source-map-0.6.1 x 1,288 ops/sec ±1.05% (96 runs sampled)
+decode: source-map-0.8.0 x 9,289 ops/sec ±0.27% (101 runs sampled)
+chrome dev tools x 4,769 ops/sec ±0.18% (100 runs sampled)
+Fastest is decode: @jridgewell/sourcemap-codec 1.4.15
+
+Encode Memory Usage:
+local code                              262944 bytes
+@jridgewell/sourcemap-codec 1.4.15       25544 bytes
+sourcemap-codec                         323048 bytes
+source-map-0.6.1                        507808 bytes
+source-map-0.8.0                        507480 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec 1.4.15
+
+Encode speed:
+encode: local code x 24,207 ops/sec ±0.79% (95 runs sampled)
+encode: @jridgewell/sourcemap-codec 1.4.15 x 24,288 ops/sec ±0.48% (96 runs sampled)
+encode: sourcemap-codec x 6,761 ops/sec ±0.21% (100 runs sampled)
+encode: source-map-0.6.1 x 5,374 ops/sec ±0.17% (99 runs sampled)
+encode: source-map-0.8.0 x 5,633 ops/sec ±0.32% (99 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec 1.4.15,encode: local code
+
+
+***
+
+
+react.js.map - 5726 segments
+
+Decode Memory Usage:
+local code                              678816 bytes
+@jridgewell/sourcemap-codec 1.4.15      678816 bytes
+sourcemap-codec                         816400 bytes
+source-map-0.6.1                       2288864 bytes
+source-map-0.8.0                        721360 bytes
+chrome dev tools                       1012512 bytes
+Smallest memory usage is local code
+
+Decode speed:
+decode: local code x 6,178 ops/sec ±0.19% (98 runs sampled)
+decode: @jridgewell/sourcemap-codec 1.4.15 x 6,261 ops/sec ±0.22% (100 runs sampled)
+decode: sourcemap-codec x 4,472 ops/sec ±0.90% (99 runs sampled)
+decode: source-map-0.6.1 x 449 ops/sec ±0.31% (95 runs sampled)
+decode: source-map-0.8.0 x 3,219 ops/sec ±0.13% (100 runs sampled)
+chrome dev tools x 1,743 ops/sec ±0.20% (99 runs sampled)
+Fastest is decode: @jridgewell/sourcemap-codec 1.4.15
+
+Encode Memory Usage:
+local code                              140960 bytes
+@jridgewell/sourcemap-codec 1.4.15      159808 bytes
+sourcemap-codec                         969304 bytes
+source-map-0.6.1                        930520 bytes
+source-map-0.8.0                        930248 bytes
+Smallest memory usage is local code
+
+Encode speed:
+encode: local code x 8,013 ops/sec ±0.19% (100 runs sampled)
+encode: @jridgewell/sourcemap-codec 1.4.15 x 7,989 ops/sec ±0.20% (101 runs sampled)
+encode: sourcemap-codec x 2,472 ops/sec ±0.21% (99 runs sampled)
+encode: source-map-0.6.1 x 2,200 ops/sec ±0.17% (99 runs sampled)
+encode: source-map-0.8.0 x 2,220 ops/sec ±0.37% (99 runs sampled)
+Fastest is encode: local code
+
+
+***
+
+
+vscode.map - 2141001 segments
+
+Decode Memory Usage:
+local code                           198955264 bytes
+@jridgewell/sourcemap-codec 1.4.15   199175352 bytes
+sourcemap-codec                      199102688 bytes
+source-map-0.6.1                     386323432 bytes
+source-map-0.8.0                     244116432 bytes
+chrome dev tools                     293734280 bytes
+Smallest memory usage is local code
+
+Decode speed:
+decode: local code x 3.90 ops/sec ±22.21% (15 runs sampled)
+decode: @jridgewell/sourcemap-codec 1.4.15 x 3.95 ops/sec ±23.53% (15 runs sampled)
+decode: sourcemap-codec x 3.82 ops/sec ±17.94% (14 runs sampled)
+decode: source-map-0.6.1 x 0.61 ops/sec ±7.81% (6 runs sampled)
+decode: source-map-0.8.0 x 9.54 ops/sec ±0.28% (28 runs sampled)
+chrome dev tools x 2.18 ops/sec ±10.58% (10 runs sampled)
+Fastest is decode: source-map-0.8.0
+
+Encode Memory Usage:
+local code                            13509880 bytes
+@jridgewell/sourcemap-codec 1.4.15    13537648 bytes
+sourcemap-codec                       32540104 bytes
+source-map-0.6.1                     127531040 bytes
+source-map-0.8.0                     127535312 bytes
+Smallest memory usage is local code
+
+Encode speed:
+encode: local code x 20.10 ops/sec ±0.19% (38 runs sampled)
+encode: @jridgewell/sourcemap-codec 1.4.15 x 20.26 ops/sec ±0.32% (38 runs sampled)
+encode: sourcemap-codec x 5.44 ops/sec ±1.64% (18 runs sampled)
+encode: source-map-0.6.1 x 2.30 ops/sec ±4.79% (10 runs sampled)
+encode: source-map-0.8.0 x 2.46 ops/sec ±6.53% (10 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec 1.4.15
+```
+
+# License
+
+MIT

node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs

@@ -0,0 +1,424 @@
+const comma = ','.charCodeAt(0);
+const semicolon = ';'.charCodeAt(0);
+const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const intToChar = new Uint8Array(64); // 64 possible chars.
+const charToInt = new Uint8Array(128); // z is 122 in ASCII
+for (let i = 0; i < chars.length; i++) {
+    const c = chars.charCodeAt(i);
+    intToChar[i] = c;
+    charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = reader.next();
+        integer = charToInt[c];
+        value |= (integer & 31) << shift;
+        shift += 5;
+    } while (integer & 32);
+    const shouldNegate = value & 1;
+    value >>>= 1;
+    if (shouldNegate) {
+        value = -0x80000000 | -value;
+    }
+    return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+    do {
+        let clamped = delta & 0b011111;
+        delta >>>= 5;
+        if (delta > 0)
+            clamped |= 0b100000;
+        builder.write(intToChar[clamped]);
+    } while (delta > 0);
+    return num;
+}
+function hasMoreVlq(reader, max) {
+    if (reader.pos >= max)
+        return false;
+    return reader.peek() !== comma;
+}
+
+const bufLength = 1024 * 16;
+// Provide a fallback for older environments.
+const td = typeof TextDecoder !== 'undefined'
+    ? /* #__PURE__ */ new TextDecoder()
+    : typeof Buffer !== 'undefined'
+        ? {
+            decode(buf) {
+                const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+                return out.toString();
+            },
+        }
+        : {
+            decode(buf) {
+                let out = '';
+                for (let i = 0; i < buf.length; i++) {
+                    out += String.fromCharCode(buf[i]);
+                }
+                return out;
+            },
+        };
+class StringWriter {
+    constructor() {
+        this.pos = 0;
+        this.out = '';
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+}
+class StringReader {
+    constructor(buffer) {
+        this.pos = 0;
+        this.buffer = buffer;
+    }
+    next() {
+        return this.buffer.charCodeAt(this.pos++);
+    }
+    peek() {
+        return this.buffer.charCodeAt(this.pos);
+    }
+    indexOf(char) {
+        const { buffer, pos } = this;
+        const idx = buffer.indexOf(char, pos);
+        return idx === -1 ? buffer.length : idx;
+    }
+}
+
+const EMPTY = [];
+function decodeOriginalScopes(input) {
+    const { length } = input;
+    const reader = new StringReader(input);
+    const scopes = [];
+    const stack = [];
+    let line = 0;
+    for (; reader.pos < length; reader.pos++) {
+        line = decodeInteger(reader, line);
+        const column = decodeInteger(reader, 0);
+        if (!hasMoreVlq(reader, length)) {
+            const last = stack.pop();
+            last[2] = line;
+            last[3] = column;
+            continue;
+        }
+        const kind = decodeInteger(reader, 0);
+        const fields = decodeInteger(reader, 0);
+        const hasName = fields & 0b0001;
+        const scope = (hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind]);
+        let vars = EMPTY;
+        if (hasMoreVlq(reader, length)) {
+            vars = [];
+            do {
+                const varsIndex = decodeInteger(reader, 0);
+                vars.push(varsIndex);
+            } while (hasMoreVlq(reader, length));
+        }
+        scope.vars = vars;
+        scopes.push(scope);
+        stack.push(scope);
+    }
+    return scopes;
+}
+function encodeOriginalScopes(scopes) {
+    const writer = new StringWriter();
+    for (let i = 0; i < scopes.length;) {
+        i = _encodeOriginalScopes(scopes, i, writer, [0]);
+    }
+    return writer.flush();
+}
+function _encodeOriginalScopes(scopes, index, writer, state) {
+    const scope = scopes[index];
+    const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
+    if (index > 0)
+        writer.write(comma);
+    state[0] = encodeInteger(writer, startLine, state[0]);
+    encodeInteger(writer, startColumn, 0);
+    encodeInteger(writer, kind, 0);
+    const fields = scope.length === 6 ? 0b0001 : 0;
+    encodeInteger(writer, fields, 0);
+    if (scope.length === 6)
+        encodeInteger(writer, scope[5], 0);
+    for (const v of vars) {
+        encodeInteger(writer, v, 0);
+    }
+    for (index++; index < scopes.length;) {
+        const next = scopes[index];
+        const { 0: l, 1: c } = next;
+        if (l > endLine || (l === endLine && c >= endColumn)) {
+            break;
+        }
+        index = _encodeOriginalScopes(scopes, index, writer, state);
+    }
+    writer.write(comma);
+    state[0] = encodeInteger(writer, endLine, state[0]);
+    encodeInteger(writer, endColumn, 0);
+    return index;
+}
+function decodeGeneratedRanges(input) {
+    const { length } = input;
+    const reader = new StringReader(input);
+    const ranges = [];
+    const stack = [];
+    let genLine = 0;
+    let definitionSourcesIndex = 0;
+    let definitionScopeIndex = 0;
+    let callsiteSourcesIndex = 0;
+    let callsiteLine = 0;
+    let callsiteColumn = 0;
+    let bindingLine = 0;
+    let bindingColumn = 0;
+    do {
+        const semi = reader.indexOf(';');
+        let genColumn = 0;
+        for (; reader.pos < semi; reader.pos++) {
+            genColumn = decodeInteger(reader, genColumn);
+            if (!hasMoreVlq(reader, semi)) {
+                const last = stack.pop();
+                last[2] = genLine;
+                last[3] = genColumn;
+                continue;
+            }
+            const fields = decodeInteger(reader, 0);
+            const hasDefinition = fields & 0b0001;
+            const hasCallsite = fields & 0b0010;
+            const hasScope = fields & 0b0100;
+            let callsite = null;
+            let bindings = EMPTY;
+            let range;
+            if (hasDefinition) {
+                const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);
+                definitionScopeIndex = decodeInteger(reader, definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0);
+                definitionSourcesIndex = defSourcesIndex;
+                range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];
+            }
+            else {
+                range = [genLine, genColumn, 0, 0];
+            }
+            range.isScope = !!hasScope;
+            if (hasCallsite) {
+                const prevCsi = callsiteSourcesIndex;
+                const prevLine = callsiteLine;
+                callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);
+                const sameSource = prevCsi === callsiteSourcesIndex;
+                callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);
+                callsiteColumn = decodeInteger(reader, sameSource && prevLine === callsiteLine ? callsiteColumn : 0);
+                callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
+            }
+            range.callsite = callsite;
+            if (hasMoreVlq(reader, semi)) {
+                bindings = [];
+                do {
+                    bindingLine = genLine;
+                    bindingColumn = genColumn;
+                    const expressionsCount = decodeInteger(reader, 0);
+                    let expressionRanges;
+                    if (expressionsCount < -1) {
+                        expressionRanges = [[decodeInteger(reader, 0)]];
+                        for (let i = -1; i > expressionsCount; i--) {
+                            const prevBl = bindingLine;
+                            bindingLine = decodeInteger(reader, bindingLine);
+                            bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);
+                            const expression = decodeInteger(reader, 0);
+                            expressionRanges.push([expression, bindingLine, bindingColumn]);
+                        }
+                    }
+                    else {
+                        expressionRanges = [[expressionsCount]];
+                    }
+                    bindings.push(expressionRanges);
+                } while (hasMoreVlq(reader, semi));
+            }
+            range.bindings = bindings;
+            ranges.push(range);
+            stack.push(range);
+        }
+        genLine++;
+        reader.pos = semi + 1;
+    } while (reader.pos < length);
+    return ranges;
+}
+function encodeGeneratedRanges(ranges) {
+    if (ranges.length === 0)
+        return '';
+    const writer = new StringWriter();
+    for (let i = 0; i < ranges.length;) {
+        i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);
+    }
+    return writer.flush();
+}
+function _encodeGeneratedRanges(ranges, index, writer, state) {
+    const range = ranges[index];
+    const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, isScope, callsite, bindings, } = range;
+    if (state[0] < startLine) {
+        catchupLine(writer, state[0], startLine);
+        state[0] = startLine;
+        state[1] = 0;
+    }
+    else if (index > 0) {
+        writer.write(comma);
+    }
+    state[1] = encodeInteger(writer, range[1], state[1]);
+    const fields = (range.length === 6 ? 0b0001 : 0) | (callsite ? 0b0010 : 0) | (isScope ? 0b0100 : 0);
+    encodeInteger(writer, fields, 0);
+    if (range.length === 6) {
+        const { 4: sourcesIndex, 5: scopesIndex } = range;
+        if (sourcesIndex !== state[2]) {
+            state[3] = 0;
+        }
+        state[2] = encodeInteger(writer, sourcesIndex, state[2]);
+        state[3] = encodeInteger(writer, scopesIndex, state[3]);
+    }
+    if (callsite) {
+        const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;
+        if (sourcesIndex !== state[4]) {
+            state[5] = 0;
+            state[6] = 0;
+        }
+        else if (callLine !== state[5]) {
+            state[6] = 0;
+        }
+        state[4] = encodeInteger(writer, sourcesIndex, state[4]);
+        state[5] = encodeInteger(writer, callLine, state[5]);
+        state[6] = encodeInteger(writer, callColumn, state[6]);
+    }
+    if (bindings) {
+        for (const binding of bindings) {
+            if (binding.length > 1)
+                encodeInteger(writer, -binding.length, 0);
+            const expression = binding[0][0];
+            encodeInteger(writer, expression, 0);
+            let bindingStartLine = startLine;
+            let bindingStartColumn = startColumn;
+            for (let i = 1; i < binding.length; i++) {
+                const expRange = binding[i];
+                bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine);
+                bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn);
+                encodeInteger(writer, expRange[0], 0);
+            }
+        }
+    }
+    for (index++; index < ranges.length;) {
+        const next = ranges[index];
+        const { 0: l, 1: c } = next;
+        if (l > endLine || (l === endLine && c >= endColumn)) {
+            break;
+        }
+        index = _encodeGeneratedRanges(ranges, index, writer, state);
+    }
+    if (state[0] < endLine) {
+        catchupLine(writer, state[0], endLine);
+        state[0] = endLine;
+        state[1] = 0;
+    }
+    else {
+        writer.write(comma);
+    }
+    state[1] = encodeInteger(writer, endColumn, state[1]);
+    return index;
+}
+function catchupLine(writer, lastLine, line) {
+    do {
+        writer.write(semicolon);
+    } while (++lastLine < line);
+}
+
+function decode(mappings) {
+    const { length } = mappings;
+    const reader = new StringReader(mappings);
+    const decoded = [];
+    let genColumn = 0;
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    do {
+        const semi = reader.indexOf(';');
+        const line = [];
+        let sorted = true;
+        let lastCol = 0;
+        genColumn = 0;
+        while (reader.pos < semi) {
+            let seg;
+            genColumn = decodeInteger(reader, genColumn);
+            if (genColumn < lastCol)
+                sorted = false;
+            lastCol = genColumn;
+            if (hasMoreVlq(reader, semi)) {
+                sourcesIndex = decodeInteger(reader, sourcesIndex);
+                sourceLine = decodeInteger(reader, sourceLine);
+                sourceColumn = decodeInteger(reader, sourceColumn);
+                if (hasMoreVlq(reader, semi)) {
+                    namesIndex = decodeInteger(reader, namesIndex);
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+                }
+                else {
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+                }
+            }
+            else {
+                seg = [genColumn];
+            }
+            line.push(seg);
+            reader.pos++;
+        }
+        if (!sorted)
+            sort(line);
+        decoded.push(line);
+        reader.pos = semi + 1;
+    } while (reader.pos <= length);
+    return decoded;
+}
+function sort(line) {
+    line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+    return a[0] - b[0];
+}
+function encode(decoded) {
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    for (let i = 0; i < decoded.length; i++) {
+        const line = decoded[i];
+        if (i > 0)
+            writer.write(semicolon);
+        if (line.length === 0)
+            continue;
+        let genColumn = 0;
+        for (let j = 0; j < line.length; j++) {
+            const segment = line[j];
+            if (j > 0)
+                writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
+            if (segment.length === 1)
+                continue;
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+            if (segment.length === 4)
+                continue;
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
+        }
+    }
+    return writer.flush();
+}
+
+export { decode, decodeGeneratedRanges, decodeOriginalScopes, encode, encodeGeneratedRanges, encodeOriginalScopes };
+//# sourceMappingURL=sourcemap-codec.mjs.map

node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js

@@ -0,0 +1,439 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.sourcemapCodec = {}));
+})(this, (function (exports) { 'use strict';
+
+    const comma = ','.charCodeAt(0);
+    const semicolon = ';'.charCodeAt(0);
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    const intToChar = new Uint8Array(64); // 64 possible chars.
+    const charToInt = new Uint8Array(128); // z is 122 in ASCII
+    for (let i = 0; i < chars.length; i++) {
+        const c = chars.charCodeAt(i);
+        intToChar[i] = c;
+        charToInt[c] = i;
+    }
+    function decodeInteger(reader, relative) {
+        let value = 0;
+        let shift = 0;
+        let integer = 0;
+        do {
+            const c = reader.next();
+            integer = charToInt[c];
+            value |= (integer & 31) << shift;
+            shift += 5;
+        } while (integer & 32);
+        const shouldNegate = value & 1;
+        value >>>= 1;
+        if (shouldNegate) {
+            value = -0x80000000 | -value;
+        }
+        return relative + value;
+    }
+    function encodeInteger(builder, num, relative) {
+        let delta = num - relative;
+        delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+        do {
+            let clamped = delta & 0b011111;
+            delta >>>= 5;
+            if (delta > 0)
+                clamped |= 0b100000;
+            builder.write(intToChar[clamped]);
+        } while (delta > 0);
+        return num;
+    }
+    function hasMoreVlq(reader, max) {
+        if (reader.pos >= max)
+            return false;
+        return reader.peek() !== comma;
+    }
+
+    const bufLength = 1024 * 16;
+    // Provide a fallback for older environments.
+    const td = typeof TextDecoder !== 'undefined'
+        ? /* #__PURE__ */ new TextDecoder()
+        : typeof Buffer !== 'undefined'
+            ? {
+                decode(buf) {
+                    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+                    return out.toString();
+                },
+            }
+            : {
+                decode(buf) {
+                    let out = '';
+                    for (let i = 0; i < buf.length; i++) {
+                        out += String.fromCharCode(buf[i]);
+                    }
+                    return out;
+                },
+            };
+    class StringWriter {
+        constructor() {
+            this.pos = 0;
+            this.out = '';
+            this.buffer = new Uint8Array(bufLength);
+        }
+        write(v) {
+            const { buffer } = this;
+            buffer[this.pos++] = v;
+            if (this.pos === bufLength) {
+                this.out += td.decode(buffer);
+                this.pos = 0;
+            }
+        }
+        flush() {
+            const { buffer, out, pos } = this;
+            return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+        }
+    }
+    class StringReader {
+        constructor(buffer) {
+            this.pos = 0;
+            this.buffer = buffer;
+        }
+        next() {
+            return this.buffer.charCodeAt(this.pos++);
+        }
+        peek() {
+            return this.buffer.charCodeAt(this.pos);
+        }
+        indexOf(char) {
+            const { buffer, pos } = this;
+            const idx = buffer.indexOf(char, pos);
+            return idx === -1 ? buffer.length : idx;
+        }
+    }
+
+    const EMPTY = [];
+    function decodeOriginalScopes(input) {
+        const { length } = input;
+        const reader = new StringReader(input);
+        const scopes = [];
+        const stack = [];
+        let line = 0;
+        for (; reader.pos < length; reader.pos++) {
+            line = decodeInteger(reader, line);
+            const column = decodeInteger(reader, 0);
+            if (!hasMoreVlq(reader, length)) {
+                const last = stack.pop();
+                last[2] = line;
+                last[3] = column;
+                continue;
+            }
+            const kind = decodeInteger(reader, 0);
+            const fields = decodeInteger(reader, 0);
+            const hasName = fields & 0b0001;
+            const scope = (hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind]);
+            let vars = EMPTY;
+            if (hasMoreVlq(reader, length)) {
+                vars = [];
+                do {
+                    const varsIndex = decodeInteger(reader, 0);
+                    vars.push(varsIndex);
+                } while (hasMoreVlq(reader, length));
+            }
+            scope.vars = vars;
+            scopes.push(scope);
+            stack.push(scope);
+        }
+        return scopes;
+    }
+    function encodeOriginalScopes(scopes) {
+        const writer = new StringWriter();
+        for (let i = 0; i < scopes.length;) {
+            i = _encodeOriginalScopes(scopes, i, writer, [0]);
+        }
+        return writer.flush();
+    }
+    function _encodeOriginalScopes(scopes, index, writer, state) {
+        const scope = scopes[index];
+        const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
+        if (index > 0)
+            writer.write(comma);
+        state[0] = encodeInteger(writer, startLine, state[0]);
+        encodeInteger(writer, startColumn, 0);
+        encodeInteger(writer, kind, 0);
+        const fields = scope.length === 6 ? 0b0001 : 0;
+        encodeInteger(writer, fields, 0);
+        if (scope.length === 6)
+            encodeInteger(writer, scope[5], 0);
+        for (const v of vars) {
+            encodeInteger(writer, v, 0);
+        }
+        for (index++; index < scopes.length;) {
+            const next = scopes[index];
+            const { 0: l, 1: c } = next;
+            if (l > endLine || (l === endLine && c >= endColumn)) {
+                break;
+            }
+            index = _encodeOriginalScopes(scopes, index, writer, state);
+        }
+        writer.write(comma);
+        state[0] = encodeInteger(writer, endLine, state[0]);
+        encodeInteger(writer, endColumn, 0);
+        return index;
+    }
+    function decodeGeneratedRanges(input) {
+        const { length } = input;
+        const reader = new StringReader(input);
+        const ranges = [];
+        const stack = [];
+        let genLine = 0;
+        let definitionSourcesIndex = 0;
+        let definitionScopeIndex = 0;
+        let callsiteSourcesIndex = 0;
+        let callsiteLine = 0;
+        let callsiteColumn = 0;
+        let bindingLine = 0;
+        let bindingColumn = 0;
+        do {
+            const semi = reader.indexOf(';');
+            let genColumn = 0;
+            for (; reader.pos < semi; reader.pos++) {
+                genColumn = decodeInteger(reader, genColumn);
+                if (!hasMoreVlq(reader, semi)) {
+                    const last = stack.pop();
+                    last[2] = genLine;
+                    last[3] = genColumn;
+                    continue;
+                }
+                const fields = decodeInteger(reader, 0);
+                const hasDefinition = fields & 0b0001;
+                const hasCallsite = fields & 0b0010;
+                const hasScope = fields & 0b0100;
+                let callsite = null;
+                let bindings = EMPTY;
+                let range;
+                if (hasDefinition) {
+                    const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);
+                    definitionScopeIndex = decodeInteger(reader, definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0);
+                    definitionSourcesIndex = defSourcesIndex;
+                    range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];
+                }
+                else {
+                    range = [genLine, genColumn, 0, 0];
+                }
+                range.isScope = !!hasScope;
+                if (hasCallsite) {
+                    const prevCsi = callsiteSourcesIndex;
+                    const prevLine = callsiteLine;
+                    callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);
+                    const sameSource = prevCsi === callsiteSourcesIndex;
+                    callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);
+                    callsiteColumn = decodeInteger(reader, sameSource && prevLine === callsiteLine ? callsiteColumn : 0);
+                    callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
+                }
+                range.callsite = callsite;
+                if (hasMoreVlq(reader, semi)) {
+                    bindings = [];
+                    do {
+                        bindingLine = genLine;
+                        bindingColumn = genColumn;
+                        const expressionsCount = decodeInteger(reader, 0);
+                        let expressionRanges;
+                        if (expressionsCount < -1) {
+                            expressionRanges = [[decodeInteger(reader, 0)]];
+                            for (let i = -1; i > expressionsCount; i--) {
+                                const prevBl = bindingLine;
+                                bindingLine = decodeInteger(reader, bindingLine);
+                                bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);
+                                const expression = decodeInteger(reader, 0);
+                                expressionRanges.push([expression, bindingLine, bindingColumn]);
+                            }
+                        }
+                        else {
+                            expressionRanges = [[expressionsCount]];
+                        }
+                        bindings.push(expressionRanges);
+                    } while (hasMoreVlq(reader, semi));
+                }
+                range.bindings = bindings;
+                ranges.push(range);
+                stack.push(range);
+            }
+            genLine++;
+            reader.pos = semi + 1;
+        } while (reader.pos < length);
+        return ranges;
+    }
+    function encodeGeneratedRanges(ranges) {
+        if (ranges.length === 0)
+            return '';
+        const writer = new StringWriter();
+        for (let i = 0; i < ranges.length;) {
+            i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);
+        }
+        return writer.flush();
+    }
+    function _encodeGeneratedRanges(ranges, index, writer, state) {
+        const range = ranges[index];
+        const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, isScope, callsite, bindings, } = range;
+        if (state[0] < startLine) {
+            catchupLine(writer, state[0], startLine);
+            state[0] = startLine;
+            state[1] = 0;
+        }
+        else if (index > 0) {
+            writer.write(comma);
+        }
+        state[1] = encodeInteger(writer, range[1], state[1]);
+        const fields = (range.length === 6 ? 0b0001 : 0) | (callsite ? 0b0010 : 0) | (isScope ? 0b0100 : 0);
+        encodeInteger(writer, fields, 0);
+        if (range.length === 6) {
+            const { 4: sourcesIndex, 5: scopesIndex } = range;
+            if (sourcesIndex !== state[2]) {
+                state[3] = 0;
+            }
+            state[2] = encodeInteger(writer, sourcesIndex, state[2]);
+            state[3] = encodeInteger(writer, scopesIndex, state[3]);
+        }
+        if (callsite) {
+            const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;
+            if (sourcesIndex !== state[4]) {
+                state[5] = 0;
+                state[6] = 0;
+            }
+            else if (callLine !== state[5]) {
+                state[6] = 0;
+            }
+            state[4] = encodeInteger(writer, sourcesIndex, state[4]);
+            state[5] = encodeInteger(writer, callLine, state[5]);
+            state[6] = encodeInteger(writer, callColumn, state[6]);
+        }
+        if (bindings) {
+            for (const binding of bindings) {
+                if (binding.length > 1)
+                    encodeInteger(writer, -binding.length, 0);
+                const expression = binding[0][0];
+                encodeInteger(writer, expression, 0);
+                let bindingStartLine = startLine;
+                let bindingStartColumn = startColumn;
+                for (let i = 1; i < binding.length; i++) {
+                    const expRange = binding[i];
+                    bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine);
+                    bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn);
+                    encodeInteger(writer, expRange[0], 0);
+                }
+            }
+        }
+        for (index++; index < ranges.length;) {
+            const next = ranges[index];
+            const { 0: l, 1: c } = next;
+            if (l > endLine || (l === endLine && c >= endColumn)) {
+                break;
+            }
+            index = _encodeGeneratedRanges(ranges, index, writer, state);
+        }
+        if (state[0] < endLine) {
+            catchupLine(writer, state[0], endLine);
+            state[0] = endLine;
+            state[1] = 0;
+        }
+        else {
+            writer.write(comma);
+        }
+        state[1] = encodeInteger(writer, endColumn, state[1]);
+        return index;
+    }
+    function catchupLine(writer, lastLine, line) {
+        do {
+            writer.write(semicolon);
+        } while (++lastLine < line);
+    }
+
+    function decode(mappings) {
+        const { length } = mappings;
+        const reader = new StringReader(mappings);
+        const decoded = [];
+        let genColumn = 0;
+        let sourcesIndex = 0;
+        let sourceLine = 0;
+        let sourceColumn = 0;
+        let namesIndex = 0;
+        do {
+            const semi = reader.indexOf(';');
+            const line = [];
+            let sorted = true;
+            let lastCol = 0;
+            genColumn = 0;
+            while (reader.pos < semi) {
+                let seg;
+                genColumn = decodeInteger(reader, genColumn);
+                if (genColumn < lastCol)
+                    sorted = false;
+                lastCol = genColumn;
+                if (hasMoreVlq(reader, semi)) {
+                    sourcesIndex = decodeInteger(reader, sourcesIndex);
+                    sourceLine = decodeInteger(reader, sourceLine);
+                    sourceColumn = decodeInteger(reader, sourceColumn);
+                    if (hasMoreVlq(reader, semi)) {
+                        namesIndex = decodeInteger(reader, namesIndex);
+                        seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+                    }
+                    else {
+                        seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+                    }
+                }
+                else {
+                    seg = [genColumn];
+                }
+                line.push(seg);
+                reader.pos++;
+            }
+            if (!sorted)
+                sort(line);
+            decoded.push(line);
+            reader.pos = semi + 1;
+        } while (reader.pos <= length);
+        return decoded;
+    }
+    function sort(line) {
+        line.sort(sortComparator);
+    }
+    function sortComparator(a, b) {
+        return a[0] - b[0];
+    }
+    function encode(decoded) {
+        const writer = new StringWriter();
+        let sourcesIndex = 0;
+        let sourceLine = 0;
+        let sourceColumn = 0;
+        let namesIndex = 0;
+        for (let i = 0; i < decoded.length; i++) {
+            const line = decoded[i];
+            if (i > 0)
+                writer.write(semicolon);
+            if (line.length === 0)
+                continue;
+            let genColumn = 0;
+            for (let j = 0; j < line.length; j++) {
+                const segment = line[j];
+                if (j > 0)
+                    writer.write(comma);
+                genColumn = encodeInteger(writer, segment[0], genColumn);
+                if (segment.length === 1)
+                    continue;
+                sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+                sourceLine = encodeInteger(writer, segment[2], sourceLine);
+                sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+                if (segment.length === 4)
+                    continue;
+                namesIndex = encodeInteger(writer, segment[4], namesIndex);
+            }
+        }
+        return writer.flush();
+    }
+
+    exports.decode = decode;
+    exports.decodeGeneratedRanges = decodeGeneratedRanges;
+    exports.decodeOriginalScopes = decodeOriginalScopes;
+    exports.encode = encode;
+    exports.encodeGeneratedRanges = encodeGeneratedRanges;
+    exports.encodeOriginalScopes = encodeOriginalScopes;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=sourcemap-codec.umd.js.map

node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/types/scopes.d.ts

@@ -0,0 +1,49 @@
+declare type Line = number;
+declare type Column = number;
+declare type Kind = number;
+declare type Name = number;
+declare type Var = number;
+declare type SourcesIndex = number;
+declare type ScopesIndex = number;
+declare type Mix<A, B, O> = (A & O) | (B & O);
+export declare type OriginalScope = Mix<[
+    Line,
+    Column,
+    Line,
+    Column,
+    Kind
+], [
+    Line,
+    Column,
+    Line,
+    Column,
+    Kind,
+    Name
+], {
+    vars: Var[];
+}>;
+export declare type GeneratedRange = Mix<[
+    Line,
+    Column,
+    Line,
+    Column
+], [
+    Line,
+    Column,
+    Line,
+    Column,
+    SourcesIndex,
+    ScopesIndex
+], {
+    callsite: CallSite | null;
+    bindings: Binding[];
+    isScope: boolean;
+}>;
+export declare type CallSite = [SourcesIndex, Line, Column];
+declare type Binding = BindingExpressionRange[];
+export declare type BindingExpressionRange = [Name] | [Name, Line, Column];
+export declare function decodeOriginalScopes(input: string): OriginalScope[];
+export declare function encodeOriginalScopes(scopes: OriginalScope[]): string;
+export declare function decodeGeneratedRanges(input: string): GeneratedRange[];
+export declare function encodeGeneratedRanges(ranges: GeneratedRange[]): string;
+export {};

node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/types/sourcemap-codec.d.ts

@@ -0,0 +1,8 @@
+export { decodeOriginalScopes, encodeOriginalScopes, decodeGeneratedRanges, encodeGeneratedRanges, } from './scopes';
+export type { OriginalScope, GeneratedRange, CallSite, BindingExpressionRange } from './scopes';
+export declare type SourceMapSegment = [number] | [number, number, number, number] | [number, number, number, number, number];
+export declare type SourceMapLine = SourceMapSegment[];
+export declare type SourceMapMappings = SourceMapLine[];
+export declare function decode(mappings: string): SourceMapMappings;
+export declare function encode(decoded: SourceMapMappings): string;
+export declare function encode(decoded: Readonly<SourceMapMappings>): string;

node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/types/strings.d.ts

@@ -0,0 +1,15 @@
+export declare class StringWriter {
+    pos: number;
+    private out;
+    private buffer;
+    write(v: number): void;
+    flush(): string;
+}
+export declare class StringReader {
+    pos: number;
+    private buffer;
+    constructor(buffer: string);
+    next(): number;
+    peek(): number;
+    indexOf(char: string): number;
+}

node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/types/vlq.d.ts

@@ -0,0 +1,6 @@
+import type { StringReader, StringWriter } from './strings';
+export declare const comma: number;
+export declare const semicolon: number;
+export declare function decodeInteger(reader: StringReader, relative: number): number;
+export declare function encodeInteger(builder: StringWriter, num: number, relative: number): number;
+export declare function hasMoreVlq(reader: StringReader, max: number): boolean;

node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@jridgewell/sourcemap-codec",
+  "version": "1.5.0",
+  "description": "Encode/decode sourcemap mappings",
+  "keywords": [
+    "sourcemap",
+    "vlq"
+  ],
+  "main": "dist/sourcemap-codec.umd.js",
+  "module": "dist/sourcemap-codec.mjs",
+  "types": "dist/types/sourcemap-codec.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": [
+      {
+        "types": "./dist/types/sourcemap-codec.d.ts",
+        "browser": "./dist/sourcemap-codec.umd.js",
+        "require": "./dist/sourcemap-codec.umd.js",
+        "import": "./dist/sourcemap-codec.mjs"
+      },
+      "./dist/sourcemap-codec.umd.js"
+    ],
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "benchmark": "run-s build:rollup benchmark:*",
+    "benchmark:install": "cd benchmark && npm install",
+    "benchmark:only": "node --expose-gc benchmark/index.js",
+    "build": "run-s -n build:*",
+    "build:rollup": "rollup -c rollup.config.js",
+    "build:ts": "tsc --project tsconfig.build.json",
+    "lint": "run-s -n lint:*",
+    "lint:prettier": "npm run test:lint:prettier -- --write",
+    "lint:ts": "npm run test:lint:ts -- --fix",
+    "prebuild": "rm -rf dist",
+    "prepublishOnly": "npm run preversion",
+    "preversion": "run-s test build",
+    "test": "run-s -n test:lint test:only",
+    "test:debug": "mocha --inspect-brk",
+    "test:lint": "run-s -n test:lint:*",
+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
+    "test:only": "mocha",
+    "test:coverage": "c8 mocha",
+    "test:watch": "mocha --watch"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jridgewell/sourcemap-codec.git"
+  },
+  "author": "Rich Harris",
+  "license": "MIT",
+  "devDependencies": {
+    "@rollup/plugin-typescript": "8.3.0",
+    "@types/mocha": "10.0.6",
+    "@types/node": "17.0.15",
+    "@typescript-eslint/eslint-plugin": "5.10.0",
+    "@typescript-eslint/parser": "5.10.0",
+    "benchmark": "2.1.4",
+    "c8": "7.11.2",
+    "eslint": "8.7.0",
+    "eslint-config-prettier": "8.3.0",
+    "mocha": "9.2.0",
+    "npm-run-all": "4.1.5",
+    "prettier": "2.5.1",
+    "rollup": "2.64.0",
+    "source-map": "0.6.1",
+    "source-map-js": "1.0.2",
+    "sourcemap-codec": "1.4.8",
+    "tsx": "4.7.1",
+    "typescript": "4.5.4"
+  }
+}

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/resolve-uri

@@ -0,0 +1 @@
+../../../@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/sourcemap-codec

@@ -0,0 +1 @@
+../../../@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2022 Justin Ridgewell <justin@ridgewell.name>
+
+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/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/README.md

@@ -0,0 +1,257 @@
+# @jridgewell/trace-mapping
+
+> Trace the original position through a source map
+
+`trace-mapping` allows you to take the line and column of an output file and trace it to the
+original location in the source file through a source map.
+
+You may already be familiar with the [`source-map`][source-map] package's `SourceMapConsumer`. This
+provides the same `originalPositionFor` and `generatedPositionFor` API, without requiring WASM.
+
+## Installation
+
+```sh
+npm install @jridgewell/trace-mapping
+```
+
+## Usage
+
+```typescript
+import {
+  TraceMap,
+  originalPositionFor,
+  generatedPositionFor,
+  sourceContentFor,
+  isIgnored,
+} from '@jridgewell/trace-mapping';
+
+const tracer = new TraceMap({
+  version: 3,
+  sources: ['input.js'],
+  sourcesContent: ['content of input.js'],
+  names: ['foo'],
+  mappings: 'KAyCIA',
+  ignoreList: [],
+});
+
+// Lines start at line 1, columns at column 0.
+const traced = originalPositionFor(tracer, { line: 1, column: 5 });
+assert.deepEqual(traced, {
+  source: 'input.js',
+  line: 42,
+  column: 4,
+  name: 'foo',
+});
+
+const content = sourceContentFor(tracer, traced.source);
+assert.strictEqual(content, 'content for input.js');
+
+const generated = generatedPositionFor(tracer, {
+  source: 'input.js',
+  line: 42,
+  column: 4,
+});
+assert.deepEqual(generated, {
+  line: 1,
+  column: 5,
+});
+
+const ignored = isIgnored(tracer, 'input.js');
+assert.equal(ignored, false);
+```
+
+We also provide a lower level API to get the actual segment that matches our line and column. Unlike
+`originalPositionFor`, `traceSegment` uses a 0-base for `line`:
+
+```typescript
+import { traceSegment } from '@jridgewell/trace-mapping';
+
+// line is 0-base.
+const traced = traceSegment(tracer, /* line */ 0, /* column */ 5);
+
+// Segments are [outputColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
+// Again, line is 0-base and so is sourceLine
+assert.deepEqual(traced, [5, 0, 41, 4, 0]);
+```
+
+### SectionedSourceMaps
+
+The sourcemap spec defines a special `sections` field that's designed to handle concatenation of
+output code with associated sourcemaps. This type of sourcemap is rarely used (no major build tool
+produces it), but if you are hand coding a concatenation you may need it. We provide an `AnyMap`
+helper that can receive either a regular sourcemap or a `SectionedSourceMap` and returns a
+`TraceMap` instance:
+
+```typescript
+import { AnyMap } from '@jridgewell/trace-mapping';
+const fooOutput = 'foo';
+const barOutput = 'bar';
+const output = [fooOutput, barOutput].join('\n');
+
+const sectioned = new AnyMap({
+  version: 3,
+  sections: [
+    {
+      // 0-base line and column
+      offset: { line: 0, column: 0 },
+      // fooOutput's sourcemap
+      map: {
+        version: 3,
+        sources: ['foo.js'],
+        names: ['foo'],
+        mappings: 'AAAAA',
+      },
+    },
+    {
+      // barOutput's sourcemap will not affect the first line, only the second
+      offset: { line: 1, column: 0 },
+      map: {
+        version: 3,
+        sources: ['bar.js'],
+        names: ['bar'],
+        mappings: 'AAAAA',
+      },
+    },
+  ],
+});
+
+const traced = originalPositionFor(sectioned, {
+  line: 2,
+  column: 0,
+});
+
+assert.deepEqual(traced, {
+  source: 'bar.js',
+  line: 1,
+  column: 0,
+  name: 'bar',
+});
+```
+
+## Benchmarks
+
+```
+node v18.0.0
+
+amp.js.map - 45120 segments
+
+Memory Usage:
+trace-mapping decoded         562400 bytes
+trace-mapping encoded        5706544 bytes
+source-map-js               10717664 bytes
+source-map-0.6.1            17446384 bytes
+source-map-0.8.0             9701757 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping:    decoded JSON input x 180 ops/sec ±0.34% (85 runs sampled)
+trace-mapping:    encoded JSON input x 364 ops/sec ±1.77% (89 runs sampled)
+trace-mapping:    decoded Object input x 3,116 ops/sec ±0.50% (96 runs sampled)
+trace-mapping:    encoded Object input x 410 ops/sec ±2.62% (85 runs sampled)
+source-map-js:    encoded Object input x 84.23 ops/sec ±0.91% (73 runs sampled)
+source-map-0.6.1: encoded Object input x 37.21 ops/sec ±2.08% (51 runs sampled)
+Fastest is trace-mapping:    decoded Object input
+
+Trace speed:
+trace-mapping:    decoded originalPositionFor x 3,952,212 ops/sec ±0.17% (98 runs sampled)
+trace-mapping:    encoded originalPositionFor x 3,487,468 ops/sec ±1.58% (90 runs sampled)
+source-map-js:    encoded originalPositionFor x 827,730 ops/sec ±0.78% (97 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 748,991 ops/sec ±0.53% (94 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 2,532,894 ops/sec ±0.57% (95 runs sampled)
+Fastest is trace-mapping:    decoded originalPositionFor
+
+
+***
+
+
+babel.min.js.map - 347793 segments
+
+Memory Usage:
+trace-mapping decoded          89832 bytes
+trace-mapping encoded       35474640 bytes
+source-map-js               51257176 bytes
+source-map-0.6.1            63515664 bytes
+source-map-0.8.0            42933752 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping:    decoded JSON input x 15.41 ops/sec ±8.65% (34 runs sampled)
+trace-mapping:    encoded JSON input x 28.20 ops/sec ±12.87% (42 runs sampled)
+trace-mapping:    decoded Object input x 964 ops/sec ±0.36% (99 runs sampled)
+trace-mapping:    encoded Object input x 31.77 ops/sec ±13.79% (45 runs sampled)
+source-map-js:    encoded Object input x 6.45 ops/sec ±5.16% (21 runs sampled)
+source-map-0.6.1: encoded Object input x 4.07 ops/sec ±5.24% (15 runs sampled)
+Fastest is trace-mapping:    decoded Object input
+
+Trace speed:
+trace-mapping:    decoded originalPositionFor x 7,183,038 ops/sec ±0.58% (95 runs sampled)
+trace-mapping:    encoded originalPositionFor x 5,192,185 ops/sec ±0.41% (100 runs sampled)
+source-map-js:    encoded originalPositionFor x 4,259,489 ops/sec ±0.79% (94 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 3,742,629 ops/sec ±0.71% (95 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 6,270,211 ops/sec ±0.64% (94 runs sampled)
+Fastest is trace-mapping:    decoded originalPositionFor
+
+
+***
+
+
+preact.js.map - 1992 segments
+
+Memory Usage:
+trace-mapping decoded          37128 bytes
+trace-mapping encoded         247280 bytes
+source-map-js                1143536 bytes
+source-map-0.6.1             1290992 bytes
+source-map-0.8.0               96544 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping:    decoded JSON input x 3,483 ops/sec ±0.30% (98 runs sampled)
+trace-mapping:    encoded JSON input x 6,092 ops/sec ±0.18% (97 runs sampled)
+trace-mapping:    decoded Object input x 249,076 ops/sec ±0.24% (98 runs sampled)
+trace-mapping:    encoded Object input x 14,555 ops/sec ±0.48% (100 runs sampled)
+source-map-js:    encoded Object input x 2,447 ops/sec ±0.36% (99 runs sampled)
+source-map-0.6.1: encoded Object input x 1,201 ops/sec ±0.57% (96 runs sampled)
+Fastest is trace-mapping:    decoded Object input
+
+Trace speed:
+trace-mapping:    decoded originalPositionFor x 7,620,192 ops/sec ±0.09% (99 runs sampled)
+trace-mapping:    encoded originalPositionFor x 6,872,554 ops/sec ±0.30% (97 runs sampled)
+source-map-js:    encoded originalPositionFor x 2,489,570 ops/sec ±0.35% (94 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 1,698,633 ops/sec ±0.28% (98 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 4,015,644 ops/sec ±0.22% (98 runs sampled)
+Fastest is trace-mapping:    decoded originalPositionFor
+
+
+***
+
+
+react.js.map - 5726 segments
+
+Memory Usage:
+trace-mapping decoded          16176 bytes
+trace-mapping encoded         681552 bytes
+source-map-js                2418352 bytes
+source-map-0.6.1             2443672 bytes
+source-map-0.8.0              111768 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping:    decoded JSON input x 1,720 ops/sec ±0.34% (98 runs sampled)
+trace-mapping:    encoded JSON input x 4,406 ops/sec ±0.35% (100 runs sampled)
+trace-mapping:    decoded Object input x 92,122 ops/sec ±0.10% (99 runs sampled)
+trace-mapping:    encoded Object input x 5,385 ops/sec ±0.37% (99 runs sampled)
+source-map-js:    encoded Object input x 794 ops/sec ±0.40% (98 runs sampled)
+source-map-0.6.1: encoded Object input x 416 ops/sec ±0.54% (91 runs sampled)
+Fastest is trace-mapping:    decoded Object input
+
+Trace speed:
+trace-mapping:    decoded originalPositionFor x 32,759,519 ops/sec ±0.33% (100 runs sampled)
+trace-mapping:    encoded originalPositionFor x 31,116,306 ops/sec ±0.33% (97 runs sampled)
+source-map-js:    encoded originalPositionFor x 17,458,435 ops/sec ±0.44% (97 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 12,687,097 ops/sec ±0.43% (95 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 23,538,275 ops/sec ±0.38% (95 runs sampled)
+Fastest is trace-mapping:    decoded originalPositionFor
+```
+
+[source-map]: https://www.npmjs.com/package/source-map

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs

@@ -0,0 +1,580 @@
+import { encode, decode } from '@jridgewell/sourcemap-codec';
+import resolveUri from '@jridgewell/resolve-uri';
+
+function resolve(input, base) {
+    // The base is always treated as a directory, if it's not empty.
+    // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
+    // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
+    if (base && !base.endsWith('/'))
+        base += '/';
+    return resolveUri(input, base);
+}
+
+/**
+ * Removes everything after the last "/", but leaves the slash.
+ */
+function stripFilename(path) {
+    if (!path)
+        return '';
+    const index = path.lastIndexOf('/');
+    return path.slice(0, index + 1);
+}
+
+const COLUMN = 0;
+const SOURCES_INDEX = 1;
+const SOURCE_LINE = 2;
+const SOURCE_COLUMN = 3;
+const NAMES_INDEX = 4;
+const REV_GENERATED_LINE = 1;
+const REV_GENERATED_COLUMN = 2;
+
+function maybeSort(mappings, owned) {
+    const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+    if (unsortedIndex === mappings.length)
+        return mappings;
+    // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
+    // not, we do not want to modify the consumer's input array.
+    if (!owned)
+        mappings = mappings.slice();
+    for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+        mappings[i] = sortSegments(mappings[i], owned);
+    }
+    return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+    for (let i = start; i < mappings.length; i++) {
+        if (!isSorted(mappings[i]))
+            return i;
+    }
+    return mappings.length;
+}
+function isSorted(line) {
+    for (let j = 1; j < line.length; j++) {
+        if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+            return false;
+        }
+    }
+    return true;
+}
+function sortSegments(line, owned) {
+    if (!owned)
+        line = line.slice();
+    return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+    return a[COLUMN] - b[COLUMN];
+}
+
+let found = false;
+/**
+ * A binary search implementation that returns the index if a match is found.
+ * If no match is found, then the left-index (the index associated with the item that comes just
+ * before the desired index) is returned. To maintain proper sort order, a splice would happen at
+ * the next index:
+ *
+ * ```js
+ * const array = [1, 3];
+ * const needle = 2;
+ * const index = binarySearch(array, needle, (item, needle) => item - needle);
+ *
+ * assert.equal(index, 0);
+ * array.splice(index + 1, 0, needle);
+ * assert.deepEqual(array, [1, 2, 3]);
+ * ```
+ */
+function binarySearch(haystack, needle, low, high) {
+    while (low <= high) {
+        const mid = low + ((high - low) >> 1);
+        const cmp = haystack[mid][COLUMN] - needle;
+        if (cmp === 0) {
+            found = true;
+            return mid;
+        }
+        if (cmp < 0) {
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    found = false;
+    return low - 1;
+}
+function upperBound(haystack, needle, index) {
+    for (let i = index + 1; i < haystack.length; index = i++) {
+        if (haystack[i][COLUMN] !== needle)
+            break;
+    }
+    return index;
+}
+function lowerBound(haystack, needle, index) {
+    for (let i = index - 1; i >= 0; index = i--) {
+        if (haystack[i][COLUMN] !== needle)
+            break;
+    }
+    return index;
+}
+function memoizedState() {
+    return {
+        lastKey: -1,
+        lastNeedle: -1,
+        lastIndex: -1,
+    };
+}
+/**
+ * This overly complicated beast is just to record the last tested line/column and the resulting
+ * index, allowing us to skip a few tests if mappings are monotonically increasing.
+ */
+function memoizedBinarySearch(haystack, needle, state, key) {
+    const { lastKey, lastNeedle, lastIndex } = state;
+    let low = 0;
+    let high = haystack.length - 1;
+    if (key === lastKey) {
+        if (needle === lastNeedle) {
+            found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+            return lastIndex;
+        }
+        if (needle >= lastNeedle) {
+            // lastIndex may be -1 if the previous needle was not found.
+            low = lastIndex === -1 ? 0 : lastIndex;
+        }
+        else {
+            high = lastIndex;
+        }
+    }
+    state.lastKey = key;
+    state.lastNeedle = needle;
+    return (state.lastIndex = binarySearch(haystack, needle, low, high));
+}
+
+// Rebuilds the original source files, with mappings that are ordered by source line/column instead
+// of generated line/column.
+function buildBySources(decoded, memos) {
+    const sources = memos.map(buildNullArray);
+    for (let i = 0; i < decoded.length; i++) {
+        const line = decoded[i];
+        for (let j = 0; j < line.length; j++) {
+            const seg = line[j];
+            if (seg.length === 1)
+                continue;
+            const sourceIndex = seg[SOURCES_INDEX];
+            const sourceLine = seg[SOURCE_LINE];
+            const sourceColumn = seg[SOURCE_COLUMN];
+            const originalSource = sources[sourceIndex];
+            const originalLine = (originalSource[sourceLine] || (originalSource[sourceLine] = []));
+            const memo = memos[sourceIndex];
+            // The binary search either found a match, or it found the left-index just before where the
+            // segment should go. Either way, we want to insert after that. And there may be multiple
+            // generated segments associated with an original location, so there may need to move several
+            // indexes before we find where we need to insert.
+            let index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
+            memo.lastIndex = ++index;
+            insert(originalLine, index, [sourceColumn, i, seg[COLUMN]]);
+        }
+    }
+    return sources;
+}
+function insert(array, index, value) {
+    for (let i = array.length; i > index; i--) {
+        array[i] = array[i - 1];
+    }
+    array[index] = value;
+}
+// Null arrays allow us to use ordered index keys without actually allocating contiguous memory like
+// a real array. We use a null-prototype object to avoid prototype pollution and deoptimizations.
+// Numeric properties on objects are magically sorted in ascending order by the engine regardless of
+// the insertion order. So, by setting any numeric keys, even out of order, we'll get ascending
+// order when iterating with for-in.
+function buildNullArray() {
+    return { __proto__: null };
+}
+
+const AnyMap = function (map, mapUrl) {
+    const parsed = parse(map);
+    if (!('sections' in parsed)) {
+        return new TraceMap(parsed, mapUrl);
+    }
+    const mappings = [];
+    const sources = [];
+    const sourcesContent = [];
+    const names = [];
+    const ignoreList = [];
+    recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, ignoreList, 0, 0, Infinity, Infinity);
+    const joined = {
+        version: 3,
+        file: parsed.file,
+        names,
+        sources,
+        sourcesContent,
+        mappings,
+        ignoreList,
+    };
+    return presortedDecodedMap(joined);
+};
+function parse(map) {
+    return typeof map === 'string' ? JSON.parse(map) : map;
+}
+function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+    const { sections } = input;
+    for (let i = 0; i < sections.length; i++) {
+        const { map, offset } = sections[i];
+        let sl = stopLine;
+        let sc = stopColumn;
+        if (i + 1 < sections.length) {
+            const nextOffset = sections[i + 1].offset;
+            sl = Math.min(stopLine, lineOffset + nextOffset.line);
+            if (sl === stopLine) {
+                sc = Math.min(stopColumn, columnOffset + nextOffset.column);
+            }
+            else if (sl < stopLine) {
+                sc = columnOffset + nextOffset.column;
+            }
+        }
+        addSection(map, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
+    }
+}
+function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+    const parsed = parse(input);
+    if ('sections' in parsed)
+        return recurse(...arguments);
+    const map = new TraceMap(parsed, mapUrl);
+    const sourcesOffset = sources.length;
+    const namesOffset = names.length;
+    const decoded = decodedMappings(map);
+    const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
+    append(sources, resolvedSources);
+    append(names, map.names);
+    if (contents)
+        append(sourcesContent, contents);
+    else
+        for (let i = 0; i < resolvedSources.length; i++)
+            sourcesContent.push(null);
+    if (ignores)
+        for (let i = 0; i < ignores.length; i++)
+            ignoreList.push(ignores[i] + sourcesOffset);
+    for (let i = 0; i < decoded.length; i++) {
+        const lineI = lineOffset + i;
+        // We can only add so many lines before we step into the range that the next section's map
+        // controls. When we get to the last line, then we'll start checking the segments to see if
+        // they've crossed into the column range. But it may not have any columns that overstep, so we
+        // still need to check that we don't overstep lines, too.
+        if (lineI > stopLine)
+            return;
+        // The out line may already exist in mappings (if we're continuing the line started by a
+        // previous section). Or, we may have jumped ahead several lines to start this section.
+        const out = getLine(mappings, lineI);
+        // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the
+        // map can be multiple lines), it doesn't.
+        const cOffset = i === 0 ? columnOffset : 0;
+        const line = decoded[i];
+        for (let j = 0; j < line.length; j++) {
+            const seg = line[j];
+            const column = cOffset + seg[COLUMN];
+            // If this segment steps into the column range that the next section's map controls, we need
+            // to stop early.
+            if (lineI === stopLine && column >= stopColumn)
+                return;
+            if (seg.length === 1) {
+                out.push([column]);
+                continue;
+            }
+            const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
+            const sourceLine = seg[SOURCE_LINE];
+            const sourceColumn = seg[SOURCE_COLUMN];
+            out.push(seg.length === 4
+                ? [column, sourcesIndex, sourceLine, sourceColumn]
+                : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]);
+        }
+    }
+}
+function append(arr, other) {
+    for (let i = 0; i < other.length; i++)
+        arr.push(other[i]);
+}
+function getLine(arr, index) {
+    for (let i = arr.length; i <= index; i++)
+        arr[i] = [];
+    return arr[index];
+}
+
+const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
+const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
+const LEAST_UPPER_BOUND = -1;
+const GREATEST_LOWER_BOUND = 1;
+class TraceMap {
+    constructor(map, mapUrl) {
+        const isString = typeof map === 'string';
+        if (!isString && map._decodedMemo)
+            return map;
+        const parsed = (isString ? JSON.parse(map) : map);
+        const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+        this.version = version;
+        this.file = file;
+        this.names = names || [];
+        this.sourceRoot = sourceRoot;
+        this.sources = sources;
+        this.sourcesContent = sourcesContent;
+        this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
+        const from = resolve(sourceRoot || '', stripFilename(mapUrl));
+        this.resolvedSources = sources.map((s) => resolve(s || '', from));
+        const { mappings } = parsed;
+        if (typeof mappings === 'string') {
+            this._encoded = mappings;
+            this._decoded = undefined;
+        }
+        else {
+            this._encoded = undefined;
+            this._decoded = maybeSort(mappings, isString);
+        }
+        this._decodedMemo = memoizedState();
+        this._bySources = undefined;
+        this._bySourceMemos = undefined;
+    }
+}
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+ * with public access modifiers.
+ */
+function cast(map) {
+    return map;
+}
+/**
+ * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
+ */
+function encodedMappings(map) {
+    var _a;
+    var _b;
+    return ((_a = (_b = cast(map))._encoded) !== null && _a !== void 0 ? _a : (_b._encoded = encode(cast(map)._decoded)));
+}
+/**
+ * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
+ */
+function decodedMappings(map) {
+    var _a;
+    return ((_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded)));
+}
+/**
+ * A low-level API to find the segment associated with a generated line/column (think, from a
+ * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
+ */
+function traceSegment(map, line, column) {
+    const decoded = decodedMappings(map);
+    // It's common for parent source maps to have pointers to lines that have no
+    // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+    if (line >= decoded.length)
+        return null;
+    const segments = decoded[line];
+    const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, GREATEST_LOWER_BOUND);
+    return index === -1 ? null : segments[index];
+}
+/**
+ * A higher-level API to find the source/line/column associated with a generated line/column
+ * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
+ * `source-map` library.
+ */
+function originalPositionFor(map, needle) {
+    let { line, column, bias } = needle;
+    line--;
+    if (line < 0)
+        throw new Error(LINE_GTR_ZERO);
+    if (column < 0)
+        throw new Error(COL_GTR_EQ_ZERO);
+    const decoded = decodedMappings(map);
+    // It's common for parent source maps to have pointers to lines that have no
+    // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+    if (line >= decoded.length)
+        return OMapping(null, null, null, null);
+    const segments = decoded[line];
+    const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+    if (index === -1)
+        return OMapping(null, null, null, null);
+    const segment = segments[index];
+    if (segment.length === 1)
+        return OMapping(null, null, null, null);
+    const { names, resolvedSources } = map;
+    return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+/**
+ * Finds the generated line/column position of the provided source/line/column source position.
+ */
+function generatedPositionFor(map, needle) {
+    const { source, line, column, bias } = needle;
+    return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
+}
+/**
+ * Finds all generated line/column positions of the provided source/line/column source position.
+ */
+function allGeneratedPositionsFor(map, needle) {
+    const { source, line, column, bias } = needle;
+    // SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit.
+    return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
+}
+/**
+ * Iterates each mapping in generated position order.
+ */
+function eachMapping(map, cb) {
+    const decoded = decodedMappings(map);
+    const { names, resolvedSources } = map;
+    for (let i = 0; i < decoded.length; i++) {
+        const line = decoded[i];
+        for (let j = 0; j < line.length; j++) {
+            const seg = line[j];
+            const generatedLine = i + 1;
+            const generatedColumn = seg[0];
+            let source = null;
+            let originalLine = null;
+            let originalColumn = null;
+            let name = null;
+            if (seg.length !== 1) {
+                source = resolvedSources[seg[1]];
+                originalLine = seg[2] + 1;
+                originalColumn = seg[3];
+            }
+            if (seg.length === 5)
+                name = names[seg[4]];
+            cb({
+                generatedLine,
+                generatedColumn,
+                source,
+                originalLine,
+                originalColumn,
+                name,
+            });
+        }
+    }
+}
+function sourceIndex(map, source) {
+    const { sources, resolvedSources } = map;
+    let index = sources.indexOf(source);
+    if (index === -1)
+        index = resolvedSources.indexOf(source);
+    return index;
+}
+/**
+ * Retrieves the source content for a particular source, if its found. Returns null if not.
+ */
+function sourceContentFor(map, source) {
+    const { sourcesContent } = map;
+    if (sourcesContent == null)
+        return null;
+    const index = sourceIndex(map, source);
+    return index === -1 ? null : sourcesContent[index];
+}
+/**
+ * Determines if the source is marked to ignore by the source map.
+ */
+function isIgnored(map, source) {
+    const { ignoreList } = map;
+    if (ignoreList == null)
+        return false;
+    const index = sourceIndex(map, source);
+    return index === -1 ? false : ignoreList.includes(index);
+}
+/**
+ * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
+ * maps.
+ */
+function presortedDecodedMap(map, mapUrl) {
+    const tracer = new TraceMap(clone(map, []), mapUrl);
+    cast(tracer)._decoded = map.mappings;
+    return tracer;
+}
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+function decodedMap(map) {
+    return clone(map, decodedMappings(map));
+}
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+function encodedMap(map) {
+    return clone(map, encodedMappings(map));
+}
+function clone(map, mappings) {
+    return {
+        version: map.version,
+        file: map.file,
+        names: map.names,
+        sourceRoot: map.sourceRoot,
+        sources: map.sources,
+        sourcesContent: map.sourcesContent,
+        mappings,
+        ignoreList: map.ignoreList || map.x_google_ignoreList,
+    };
+}
+function OMapping(source, line, column, name) {
+    return { source, line, column, name };
+}
+function GMapping(line, column) {
+    return { line, column };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+    let index = memoizedBinarySearch(segments, column, memo, line);
+    if (found) {
+        index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+    }
+    else if (bias === LEAST_UPPER_BOUND)
+        index++;
+    if (index === -1 || index === segments.length)
+        return -1;
+    return index;
+}
+function sliceGeneratedPositions(segments, memo, line, column, bias) {
+    let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
+    // We ignored the bias when tracing the segment so that we're guarnateed to find the first (in
+    // insertion order) segment that matched. Even if we did respect the bias when tracing, we would
+    // still need to call `lowerBound()` to find the first segment, which is slower than just looking
+    // for the GREATEST_LOWER_BOUND to begin with. The only difference that matters for us is when the
+    // binary search didn't match, in which case GREATEST_LOWER_BOUND just needs to increment to
+    // match LEAST_UPPER_BOUND.
+    if (!found && bias === LEAST_UPPER_BOUND)
+        min++;
+    if (min === -1 || min === segments.length)
+        return [];
+    // We may have found the segment that started at an earlier column. If this is the case, then we
+    // need to slice all generated segments that match _that_ column, because all such segments span
+    // to our desired column.
+    const matchedColumn = found ? column : segments[min][COLUMN];
+    // The binary search is not guaranteed to find the lower bound when a match wasn't found.
+    if (!found)
+        min = lowerBound(segments, matchedColumn, min);
+    const max = upperBound(segments, matchedColumn, min);
+    const result = [];
+    for (; min <= max; min++) {
+        const segment = segments[min];
+        result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
+    }
+    return result;
+}
+function generatedPosition(map, source, line, column, bias, all) {
+    var _a;
+    line--;
+    if (line < 0)
+        throw new Error(LINE_GTR_ZERO);
+    if (column < 0)
+        throw new Error(COL_GTR_EQ_ZERO);
+    const { sources, resolvedSources } = map;
+    let sourceIndex = sources.indexOf(source);
+    if (sourceIndex === -1)
+        sourceIndex = resolvedSources.indexOf(source);
+    if (sourceIndex === -1)
+        return all ? [] : GMapping(null, null);
+    const generated = ((_a = cast(map))._bySources || (_a._bySources = buildBySources(decodedMappings(map), (cast(map)._bySourceMemos = sources.map(memoizedState)))));
+    const segments = generated[sourceIndex][line];
+    if (segments == null)
+        return all ? [] : GMapping(null, null);
+    const memo = cast(map)._bySourceMemos[sourceIndex];
+    if (all)
+        return sliceGeneratedPositions(segments, memo, line, column, bias);
+    const index = traceSegmentInternal(segments, memo, line, column, bias);
+    if (index === -1)
+        return GMapping(null, null);
+    const segment = segments[index];
+    return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
+}
+
+export { AnyMap, GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap, allGeneratedPositionsFor, decodedMap, decodedMappings, eachMapping, encodedMap, encodedMappings, generatedPositionFor, isIgnored, originalPositionFor, presortedDecodedMap, sourceContentFor, traceSegment };
+//# sourceMappingURL=trace-mapping.mjs.map

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js

@@ -0,0 +1,600 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@jridgewell/sourcemap-codec'), require('@jridgewell/resolve-uri')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@jridgewell/sourcemap-codec', '@jridgewell/resolve-uri'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.traceMapping = {}, global.sourcemapCodec, global.resolveURI));
+})(this, (function (exports, sourcemapCodec, resolveUri) { 'use strict';
+
+    function resolve(input, base) {
+        // The base is always treated as a directory, if it's not empty.
+        // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
+        // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
+        if (base && !base.endsWith('/'))
+            base += '/';
+        return resolveUri(input, base);
+    }
+
+    /**
+     * Removes everything after the last "/", but leaves the slash.
+     */
+    function stripFilename(path) {
+        if (!path)
+            return '';
+        const index = path.lastIndexOf('/');
+        return path.slice(0, index + 1);
+    }
+
+    const COLUMN = 0;
+    const SOURCES_INDEX = 1;
+    const SOURCE_LINE = 2;
+    const SOURCE_COLUMN = 3;
+    const NAMES_INDEX = 4;
+    const REV_GENERATED_LINE = 1;
+    const REV_GENERATED_COLUMN = 2;
+
+    function maybeSort(mappings, owned) {
+        const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+        if (unsortedIndex === mappings.length)
+            return mappings;
+        // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
+        // not, we do not want to modify the consumer's input array.
+        if (!owned)
+            mappings = mappings.slice();
+        for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+            mappings[i] = sortSegments(mappings[i], owned);
+        }
+        return mappings;
+    }
+    function nextUnsortedSegmentLine(mappings, start) {
+        for (let i = start; i < mappings.length; i++) {
+            if (!isSorted(mappings[i]))
+                return i;
+        }
+        return mappings.length;
+    }
+    function isSorted(line) {
+        for (let j = 1; j < line.length; j++) {
+            if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function sortSegments(line, owned) {
+        if (!owned)
+            line = line.slice();
+        return line.sort(sortComparator);
+    }
+    function sortComparator(a, b) {
+        return a[COLUMN] - b[COLUMN];
+    }
+
+    let found = false;
+    /**
+     * A binary search implementation that returns the index if a match is found.
+     * If no match is found, then the left-index (the index associated with the item that comes just
+     * before the desired index) is returned. To maintain proper sort order, a splice would happen at
+     * the next index:
+     *
+     * ```js
+     * const array = [1, 3];
+     * const needle = 2;
+     * const index = binarySearch(array, needle, (item, needle) => item - needle);
+     *
+     * assert.equal(index, 0);
+     * array.splice(index + 1, 0, needle);
+     * assert.deepEqual(array, [1, 2, 3]);
+     * ```
+     */
+    function binarySearch(haystack, needle, low, high) {
+        while (low <= high) {
+            const mid = low + ((high - low) >> 1);
+            const cmp = haystack[mid][COLUMN] - needle;
+            if (cmp === 0) {
+                found = true;
+                return mid;
+            }
+            if (cmp < 0) {
+                low = mid + 1;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        found = false;
+        return low - 1;
+    }
+    function upperBound(haystack, needle, index) {
+        for (let i = index + 1; i < haystack.length; index = i++) {
+            if (haystack[i][COLUMN] !== needle)
+                break;
+        }
+        return index;
+    }
+    function lowerBound(haystack, needle, index) {
+        for (let i = index - 1; i >= 0; index = i--) {
+            if (haystack[i][COLUMN] !== needle)
+                break;
+        }
+        return index;
+    }
+    function memoizedState() {
+        return {
+            lastKey: -1,
+            lastNeedle: -1,
+            lastIndex: -1,
+        };
+    }
+    /**
+     * This overly complicated beast is just to record the last tested line/column and the resulting
+     * index, allowing us to skip a few tests if mappings are monotonically increasing.
+     */
+    function memoizedBinarySearch(haystack, needle, state, key) {
+        const { lastKey, lastNeedle, lastIndex } = state;
+        let low = 0;
+        let high = haystack.length - 1;
+        if (key === lastKey) {
+            if (needle === lastNeedle) {
+                found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+                return lastIndex;
+            }
+            if (needle >= lastNeedle) {
+                // lastIndex may be -1 if the previous needle was not found.
+                low = lastIndex === -1 ? 0 : lastIndex;
+            }
+            else {
+                high = lastIndex;
+            }
+        }
+        state.lastKey = key;
+        state.lastNeedle = needle;
+        return (state.lastIndex = binarySearch(haystack, needle, low, high));
+    }
+
+    // Rebuilds the original source files, with mappings that are ordered by source line/column instead
+    // of generated line/column.
+    function buildBySources(decoded, memos) {
+        const sources = memos.map(buildNullArray);
+        for (let i = 0; i < decoded.length; i++) {
+            const line = decoded[i];
+            for (let j = 0; j < line.length; j++) {
+                const seg = line[j];
+                if (seg.length === 1)
+                    continue;
+                const sourceIndex = seg[SOURCES_INDEX];
+                const sourceLine = seg[SOURCE_LINE];
+                const sourceColumn = seg[SOURCE_COLUMN];
+                const originalSource = sources[sourceIndex];
+                const originalLine = (originalSource[sourceLine] || (originalSource[sourceLine] = []));
+                const memo = memos[sourceIndex];
+                // The binary search either found a match, or it found the left-index just before where the
+                // segment should go. Either way, we want to insert after that. And there may be multiple
+                // generated segments associated with an original location, so there may need to move several
+                // indexes before we find where we need to insert.
+                let index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
+                memo.lastIndex = ++index;
+                insert(originalLine, index, [sourceColumn, i, seg[COLUMN]]);
+            }
+        }
+        return sources;
+    }
+    function insert(array, index, value) {
+        for (let i = array.length; i > index; i--) {
+            array[i] = array[i - 1];
+        }
+        array[index] = value;
+    }
+    // Null arrays allow us to use ordered index keys without actually allocating contiguous memory like
+    // a real array. We use a null-prototype object to avoid prototype pollution and deoptimizations.
+    // Numeric properties on objects are magically sorted in ascending order by the engine regardless of
+    // the insertion order. So, by setting any numeric keys, even out of order, we'll get ascending
+    // order when iterating with for-in.
+    function buildNullArray() {
+        return { __proto__: null };
+    }
+
+    const AnyMap = function (map, mapUrl) {
+        const parsed = parse(map);
+        if (!('sections' in parsed)) {
+            return new TraceMap(parsed, mapUrl);
+        }
+        const mappings = [];
+        const sources = [];
+        const sourcesContent = [];
+        const names = [];
+        const ignoreList = [];
+        recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, ignoreList, 0, 0, Infinity, Infinity);
+        const joined = {
+            version: 3,
+            file: parsed.file,
+            names,
+            sources,
+            sourcesContent,
+            mappings,
+            ignoreList,
+        };
+        return presortedDecodedMap(joined);
+    };
+    function parse(map) {
+        return typeof map === 'string' ? JSON.parse(map) : map;
+    }
+    function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+        const { sections } = input;
+        for (let i = 0; i < sections.length; i++) {
+            const { map, offset } = sections[i];
+            let sl = stopLine;
+            let sc = stopColumn;
+            if (i + 1 < sections.length) {
+                const nextOffset = sections[i + 1].offset;
+                sl = Math.min(stopLine, lineOffset + nextOffset.line);
+                if (sl === stopLine) {
+                    sc = Math.min(stopColumn, columnOffset + nextOffset.column);
+                }
+                else if (sl < stopLine) {
+                    sc = columnOffset + nextOffset.column;
+                }
+            }
+            addSection(map, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
+        }
+    }
+    function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+        const parsed = parse(input);
+        if ('sections' in parsed)
+            return recurse(...arguments);
+        const map = new TraceMap(parsed, mapUrl);
+        const sourcesOffset = sources.length;
+        const namesOffset = names.length;
+        const decoded = decodedMappings(map);
+        const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
+        append(sources, resolvedSources);
+        append(names, map.names);
+        if (contents)
+            append(sourcesContent, contents);
+        else
+            for (let i = 0; i < resolvedSources.length; i++)
+                sourcesContent.push(null);
+        if (ignores)
+            for (let i = 0; i < ignores.length; i++)
+                ignoreList.push(ignores[i] + sourcesOffset);
+        for (let i = 0; i < decoded.length; i++) {
+            const lineI = lineOffset + i;
+            // We can only add so many lines before we step into the range that the next section's map
+            // controls. When we get to the last line, then we'll start checking the segments to see if
+            // they've crossed into the column range. But it may not have any columns that overstep, so we
+            // still need to check that we don't overstep lines, too.
+            if (lineI > stopLine)
+                return;
+            // The out line may already exist in mappings (if we're continuing the line started by a
+            // previous section). Or, we may have jumped ahead several lines to start this section.
+            const out = getLine(mappings, lineI);
+            // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the
+            // map can be multiple lines), it doesn't.
+            const cOffset = i === 0 ? columnOffset : 0;
+            const line = decoded[i];
+            for (let j = 0; j < line.length; j++) {
+                const seg = line[j];
+                const column = cOffset + seg[COLUMN];
+                // If this segment steps into the column range that the next section's map controls, we need
+                // to stop early.
+                if (lineI === stopLine && column >= stopColumn)
+                    return;
+                if (seg.length === 1) {
+                    out.push([column]);
+                    continue;
+                }
+                const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
+                const sourceLine = seg[SOURCE_LINE];
+                const sourceColumn = seg[SOURCE_COLUMN];
+                out.push(seg.length === 4
+                    ? [column, sourcesIndex, sourceLine, sourceColumn]
+                    : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]);
+            }
+        }
+    }
+    function append(arr, other) {
+        for (let i = 0; i < other.length; i++)
+            arr.push(other[i]);
+    }
+    function getLine(arr, index) {
+        for (let i = arr.length; i <= index; i++)
+            arr[i] = [];
+        return arr[index];
+    }
+
+    const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
+    const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
+    const LEAST_UPPER_BOUND = -1;
+    const GREATEST_LOWER_BOUND = 1;
+    class TraceMap {
+        constructor(map, mapUrl) {
+            const isString = typeof map === 'string';
+            if (!isString && map._decodedMemo)
+                return map;
+            const parsed = (isString ? JSON.parse(map) : map);
+            const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+            this.version = version;
+            this.file = file;
+            this.names = names || [];
+            this.sourceRoot = sourceRoot;
+            this.sources = sources;
+            this.sourcesContent = sourcesContent;
+            this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
+            const from = resolve(sourceRoot || '', stripFilename(mapUrl));
+            this.resolvedSources = sources.map((s) => resolve(s || '', from));
+            const { mappings } = parsed;
+            if (typeof mappings === 'string') {
+                this._encoded = mappings;
+                this._decoded = undefined;
+            }
+            else {
+                this._encoded = undefined;
+                this._decoded = maybeSort(mappings, isString);
+            }
+            this._decodedMemo = memoizedState();
+            this._bySources = undefined;
+            this._bySourceMemos = undefined;
+        }
+    }
+    /**
+     * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+     * with public access modifiers.
+     */
+    function cast(map) {
+        return map;
+    }
+    /**
+     * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
+     */
+    function encodedMappings(map) {
+        var _a;
+        var _b;
+        return ((_a = (_b = cast(map))._encoded) !== null && _a !== void 0 ? _a : (_b._encoded = sourcemapCodec.encode(cast(map)._decoded)));
+    }
+    /**
+     * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
+     */
+    function decodedMappings(map) {
+        var _a;
+        return ((_a = cast(map))._decoded || (_a._decoded = sourcemapCodec.decode(cast(map)._encoded)));
+    }
+    /**
+     * A low-level API to find the segment associated with a generated line/column (think, from a
+     * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
+     */
+    function traceSegment(map, line, column) {
+        const decoded = decodedMappings(map);
+        // It's common for parent source maps to have pointers to lines that have no
+        // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+        if (line >= decoded.length)
+            return null;
+        const segments = decoded[line];
+        const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, GREATEST_LOWER_BOUND);
+        return index === -1 ? null : segments[index];
+    }
+    /**
+     * A higher-level API to find the source/line/column associated with a generated line/column
+     * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
+     * `source-map` library.
+     */
+    function originalPositionFor(map, needle) {
+        let { line, column, bias } = needle;
+        line--;
+        if (line < 0)
+            throw new Error(LINE_GTR_ZERO);
+        if (column < 0)
+            throw new Error(COL_GTR_EQ_ZERO);
+        const decoded = decodedMappings(map);
+        // It's common for parent source maps to have pointers to lines that have no
+        // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+        if (line >= decoded.length)
+            return OMapping(null, null, null, null);
+        const segments = decoded[line];
+        const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+        if (index === -1)
+            return OMapping(null, null, null, null);
+        const segment = segments[index];
+        if (segment.length === 1)
+            return OMapping(null, null, null, null);
+        const { names, resolvedSources } = map;
+        return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+    }
+    /**
+     * Finds the generated line/column position of the provided source/line/column source position.
+     */
+    function generatedPositionFor(map, needle) {
+        const { source, line, column, bias } = needle;
+        return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
+    }
+    /**
+     * Finds all generated line/column positions of the provided source/line/column source position.
+     */
+    function allGeneratedPositionsFor(map, needle) {
+        const { source, line, column, bias } = needle;
+        // SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit.
+        return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
+    }
+    /**
+     * Iterates each mapping in generated position order.
+     */
+    function eachMapping(map, cb) {
+        const decoded = decodedMappings(map);
+        const { names, resolvedSources } = map;
+        for (let i = 0; i < decoded.length; i++) {
+            const line = decoded[i];
+            for (let j = 0; j < line.length; j++) {
+                const seg = line[j];
+                const generatedLine = i + 1;
+                const generatedColumn = seg[0];
+                let source = null;
+                let originalLine = null;
+                let originalColumn = null;
+                let name = null;
+                if (seg.length !== 1) {
+                    source = resolvedSources[seg[1]];
+                    originalLine = seg[2] + 1;
+                    originalColumn = seg[3];
+                }
+                if (seg.length === 5)
+                    name = names[seg[4]];
+                cb({
+                    generatedLine,
+                    generatedColumn,
+                    source,
+                    originalLine,
+                    originalColumn,
+                    name,
+                });
+            }
+        }
+    }
+    function sourceIndex(map, source) {
+        const { sources, resolvedSources } = map;
+        let index = sources.indexOf(source);
+        if (index === -1)
+            index = resolvedSources.indexOf(source);
+        return index;
+    }
+    /**
+     * Retrieves the source content for a particular source, if its found. Returns null if not.
+     */
+    function sourceContentFor(map, source) {
+        const { sourcesContent } = map;
+        if (sourcesContent == null)
+            return null;
+        const index = sourceIndex(map, source);
+        return index === -1 ? null : sourcesContent[index];
+    }
+    /**
+     * Determines if the source is marked to ignore by the source map.
+     */
+    function isIgnored(map, source) {
+        const { ignoreList } = map;
+        if (ignoreList == null)
+            return false;
+        const index = sourceIndex(map, source);
+        return index === -1 ? false : ignoreList.includes(index);
+    }
+    /**
+     * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
+     * maps.
+     */
+    function presortedDecodedMap(map, mapUrl) {
+        const tracer = new TraceMap(clone(map, []), mapUrl);
+        cast(tracer)._decoded = map.mappings;
+        return tracer;
+    }
+    /**
+     * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+     * a sourcemap, or to JSON.stringify.
+     */
+    function decodedMap(map) {
+        return clone(map, decodedMappings(map));
+    }
+    /**
+     * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+     * a sourcemap, or to JSON.stringify.
+     */
+    function encodedMap(map) {
+        return clone(map, encodedMappings(map));
+    }
+    function clone(map, mappings) {
+        return {
+            version: map.version,
+            file: map.file,
+            names: map.names,
+            sourceRoot: map.sourceRoot,
+            sources: map.sources,
+            sourcesContent: map.sourcesContent,
+            mappings,
+            ignoreList: map.ignoreList || map.x_google_ignoreList,
+        };
+    }
+    function OMapping(source, line, column, name) {
+        return { source, line, column, name };
+    }
+    function GMapping(line, column) {
+        return { line, column };
+    }
+    function traceSegmentInternal(segments, memo, line, column, bias) {
+        let index = memoizedBinarySearch(segments, column, memo, line);
+        if (found) {
+            index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+        }
+        else if (bias === LEAST_UPPER_BOUND)
+            index++;
+        if (index === -1 || index === segments.length)
+            return -1;
+        return index;
+    }
+    function sliceGeneratedPositions(segments, memo, line, column, bias) {
+        let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
+        // We ignored the bias when tracing the segment so that we're guarnateed to find the first (in
+        // insertion order) segment that matched. Even if we did respect the bias when tracing, we would
+        // still need to call `lowerBound()` to find the first segment, which is slower than just looking
+        // for the GREATEST_LOWER_BOUND to begin with. The only difference that matters for us is when the
+        // binary search didn't match, in which case GREATEST_LOWER_BOUND just needs to increment to
+        // match LEAST_UPPER_BOUND.
+        if (!found && bias === LEAST_UPPER_BOUND)
+            min++;
+        if (min === -1 || min === segments.length)
+            return [];
+        // We may have found the segment that started at an earlier column. If this is the case, then we
+        // need to slice all generated segments that match _that_ column, because all such segments span
+        // to our desired column.
+        const matchedColumn = found ? column : segments[min][COLUMN];
+        // The binary search is not guaranteed to find the lower bound when a match wasn't found.
+        if (!found)
+            min = lowerBound(segments, matchedColumn, min);
+        const max = upperBound(segments, matchedColumn, min);
+        const result = [];
+        for (; min <= max; min++) {
+            const segment = segments[min];
+            result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
+        }
+        return result;
+    }
+    function generatedPosition(map, source, line, column, bias, all) {
+        var _a;
+        line--;
+        if (line < 0)
+            throw new Error(LINE_GTR_ZERO);
+        if (column < 0)
+            throw new Error(COL_GTR_EQ_ZERO);
+        const { sources, resolvedSources } = map;
+        let sourceIndex = sources.indexOf(source);
+        if (sourceIndex === -1)
+            sourceIndex = resolvedSources.indexOf(source);
+        if (sourceIndex === -1)
+            return all ? [] : GMapping(null, null);
+        const generated = ((_a = cast(map))._bySources || (_a._bySources = buildBySources(decodedMappings(map), (cast(map)._bySourceMemos = sources.map(memoizedState)))));
+        const segments = generated[sourceIndex][line];
+        if (segments == null)
+            return all ? [] : GMapping(null, null);
+        const memo = cast(map)._bySourceMemos[sourceIndex];
+        if (all)
+            return sliceGeneratedPositions(segments, memo, line, column, bias);
+        const index = traceSegmentInternal(segments, memo, line, column, bias);
+        if (index === -1)
+            return GMapping(null, null);
+        const segment = segments[index];
+        return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
+    }
+
+    exports.AnyMap = AnyMap;
+    exports.GREATEST_LOWER_BOUND = GREATEST_LOWER_BOUND;
+    exports.LEAST_UPPER_BOUND = LEAST_UPPER_BOUND;
+    exports.TraceMap = TraceMap;
+    exports.allGeneratedPositionsFor = allGeneratedPositionsFor;
+    exports.decodedMap = decodedMap;
+    exports.decodedMappings = decodedMappings;
+    exports.eachMapping = eachMapping;
+    exports.encodedMap = encodedMap;
+    exports.encodedMappings = encodedMappings;
+    exports.generatedPositionFor = generatedPositionFor;
+    exports.isIgnored = isIgnored;
+    exports.originalPositionFor = originalPositionFor;
+    exports.presortedDecodedMap = presortedDecodedMap;
+    exports.sourceContentFor = sourceContentFor;
+    exports.traceSegment = traceSegment;
+
+}));
+//# sourceMappingURL=trace-mapping.umd.js.map

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/types/any-map.d.ts

@@ -0,0 +1,8 @@
+import { TraceMap } from './trace-mapping';
+import type { SectionedSourceMapInput } from './types';
+type AnyMap = {
+    new (map: SectionedSourceMapInput, mapUrl?: string | null): TraceMap;
+    (map: SectionedSourceMapInput, mapUrl?: string | null): TraceMap;
+};
+export declare const AnyMap: AnyMap;
+export {};

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/types/binary-search.d.ts

@@ -0,0 +1,32 @@
+import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment';
+export type MemoState = {
+    lastKey: number;
+    lastNeedle: number;
+    lastIndex: number;
+};
+export declare let found: boolean;
+/**
+ * A binary search implementation that returns the index if a match is found.
+ * If no match is found, then the left-index (the index associated with the item that comes just
+ * before the desired index) is returned. To maintain proper sort order, a splice would happen at
+ * the next index:
+ *
+ * ```js
+ * const array = [1, 3];
+ * const needle = 2;
+ * const index = binarySearch(array, needle, (item, needle) => item - needle);
+ *
+ * assert.equal(index, 0);
+ * array.splice(index + 1, 0, needle);
+ * assert.deepEqual(array, [1, 2, 3]);
+ * ```
+ */
+export declare function binarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, low: number, high: number): number;
+export declare function upperBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number;
+export declare function lowerBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number;
+export declare function memoizedState(): MemoState;
+/**
+ * This overly complicated beast is just to record the last tested line/column and the resulting
+ * index, allowing us to skip a few tests if mappings are monotonically increasing.
+ */
+export declare function memoizedBinarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, state: MemoState, key: number): number;

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/types/by-source.d.ts

@@ -0,0 +1,7 @@
+import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment';
+import type { MemoState } from './binary-search';
+export type Source = {
+    __proto__: null;
+    [line: number]: Exclude<ReverseSegment, [number]>[];
+};
+export default function buildBySources(decoded: readonly SourceMapSegment[][], memos: MemoState[]): Source[];

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/types/resolve.d.ts

@@ -0,0 +1 @@
+export default function resolve(input: string, base: string | undefined): string;

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/types/sort.d.ts

@@ -0,0 +1,2 @@
+import type { SourceMapSegment } from './sourcemap-segment';
+export default function maybeSort(mappings: SourceMapSegment[][], owned: boolean): SourceMapSegment[][];

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/types/sourcemap-segment.d.ts

@@ -0,0 +1,16 @@
+type GeneratedColumn = number;
+type SourcesIndex = number;
+type SourceLine = number;
+type SourceColumn = number;
+type NamesIndex = number;
+type GeneratedLine = number;
+export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+export type ReverseSegment = [SourceColumn, GeneratedLine, GeneratedColumn];
+export declare const COLUMN = 0;
+export declare const SOURCES_INDEX = 1;
+export declare const SOURCE_LINE = 2;
+export declare const SOURCE_COLUMN = 3;
+export declare const NAMES_INDEX = 4;
+export declare const REV_GENERATED_LINE = 1;
+export declare const REV_GENERATED_COLUMN = 2;
+export {};

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/types/strip-filename.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Removes everything after the last "/", but leaves the slash.
+ */
+export default function stripFilename(path: string | undefined | null): string;

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/types/trace-mapping.d.ts

@@ -0,0 +1,79 @@
+import type { SourceMapSegment } from './sourcemap-segment';
+import type { SourceMapV3, DecodedSourceMap, EncodedSourceMap, InvalidOriginalMapping, OriginalMapping, InvalidGeneratedMapping, GeneratedMapping, SourceMapInput, Needle, SourceNeedle, SourceMap, EachMapping } from './types';
+export type { SourceMapSegment } from './sourcemap-segment';
+export type { SourceMap, DecodedSourceMap, EncodedSourceMap, Section, SectionedSourceMap, SourceMapV3, Bias, EachMapping, GeneratedMapping, InvalidGeneratedMapping, InvalidOriginalMapping, Needle, OriginalMapping, OriginalMapping as Mapping, SectionedSourceMapInput, SourceMapInput, SourceNeedle, XInput, EncodedSourceMapXInput, DecodedSourceMapXInput, SectionedSourceMapXInput, SectionXInput, } from './types';
+export declare const LEAST_UPPER_BOUND = -1;
+export declare const GREATEST_LOWER_BOUND = 1;
+export { AnyMap } from './any-map';
+export declare class TraceMap implements SourceMap {
+    version: SourceMapV3['version'];
+    file: SourceMapV3['file'];
+    names: SourceMapV3['names'];
+    sourceRoot: SourceMapV3['sourceRoot'];
+    sources: SourceMapV3['sources'];
+    sourcesContent: SourceMapV3['sourcesContent'];
+    ignoreList: SourceMapV3['ignoreList'];
+    resolvedSources: string[];
+    private _encoded;
+    private _decoded;
+    private _decodedMemo;
+    private _bySources;
+    private _bySourceMemos;
+    constructor(map: SourceMapInput, mapUrl?: string | null);
+}
+/**
+ * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
+ */
+export declare function encodedMappings(map: TraceMap): EncodedSourceMap['mappings'];
+/**
+ * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
+ */
+export declare function decodedMappings(map: TraceMap): Readonly<DecodedSourceMap['mappings']>;
+/**
+ * A low-level API to find the segment associated with a generated line/column (think, from a
+ * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
+ */
+export declare function traceSegment(map: TraceMap, line: number, column: number): Readonly<SourceMapSegment> | null;
+/**
+ * A higher-level API to find the source/line/column associated with a generated line/column
+ * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
+ * `source-map` library.
+ */
+export declare function originalPositionFor(map: TraceMap, needle: Needle): OriginalMapping | InvalidOriginalMapping;
+/**
+ * Finds the generated line/column position of the provided source/line/column source position.
+ */
+export declare function generatedPositionFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping | InvalidGeneratedMapping;
+/**
+ * Finds all generated line/column positions of the provided source/line/column source position.
+ */
+export declare function allGeneratedPositionsFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping[];
+/**
+ * Iterates each mapping in generated position order.
+ */
+export declare function eachMapping(map: TraceMap, cb: (mapping: EachMapping) => void): void;
+/**
+ * Retrieves the source content for a particular source, if its found. Returns null if not.
+ */
+export declare function sourceContentFor(map: TraceMap, source: string): string | null;
+/**
+ * Determines if the source is marked to ignore by the source map.
+ */
+export declare function isIgnored(map: TraceMap, source: string): boolean;
+/**
+ * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
+ * maps.
+ */
+export declare function presortedDecodedMap(map: DecodedSourceMap, mapUrl?: string): TraceMap;
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function decodedMap(map: TraceMap): Omit<DecodedSourceMap, 'mappings'> & {
+    mappings: readonly SourceMapSegment[][];
+};
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function encodedMap(map: TraceMap): EncodedSourceMap;

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/types/types.d.ts

@@ -0,0 +1,99 @@
+import type { SourceMapSegment } from './sourcemap-segment';
+import type { GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap } from './trace-mapping';
+export interface SourceMapV3 {
+    file?: string | null;
+    names: string[];
+    sourceRoot?: string;
+    sources: (string | null)[];
+    sourcesContent?: (string | null)[];
+    version: 3;
+    ignoreList?: number[];
+}
+export interface EncodedSourceMap extends SourceMapV3 {
+    mappings: string;
+}
+export interface DecodedSourceMap extends SourceMapV3 {
+    mappings: SourceMapSegment[][];
+}
+export interface Section {
+    offset: {
+        line: number;
+        column: number;
+    };
+    map: EncodedSourceMap | DecodedSourceMap | SectionedSourceMap;
+}
+export interface SectionedSourceMap {
+    file?: string | null;
+    sections: Section[];
+    version: 3;
+}
+export type OriginalMapping = {
+    source: string | null;
+    line: number;
+    column: number;
+    name: string | null;
+};
+export type InvalidOriginalMapping = {
+    source: null;
+    line: null;
+    column: null;
+    name: null;
+};
+export type GeneratedMapping = {
+    line: number;
+    column: number;
+};
+export type InvalidGeneratedMapping = {
+    line: null;
+    column: null;
+};
+export type Bias = typeof GREATEST_LOWER_BOUND | typeof LEAST_UPPER_BOUND;
+export type XInput = {
+    x_google_ignoreList?: SourceMapV3['ignoreList'];
+};
+export type EncodedSourceMapXInput = EncodedSourceMap & XInput;
+export type DecodedSourceMapXInput = DecodedSourceMap & XInput;
+export type SectionedSourceMapXInput = Omit<SectionedSourceMap, 'sections'> & {
+    sections: SectionXInput[];
+};
+export type SectionXInput = Omit<Section, 'map'> & {
+    map: SectionedSourceMapInput;
+};
+export type SourceMapInput = string | EncodedSourceMapXInput | DecodedSourceMapXInput | TraceMap;
+export type SectionedSourceMapInput = SourceMapInput | SectionedSourceMapXInput;
+export type Needle = {
+    line: number;
+    column: number;
+    bias?: Bias;
+};
+export type SourceNeedle = {
+    source: string;
+    line: number;
+    column: number;
+    bias?: Bias;
+};
+export type EachMapping = {
+    generatedLine: number;
+    generatedColumn: number;
+    source: null;
+    originalLine: null;
+    originalColumn: null;
+    name: null;
+} | {
+    generatedLine: number;
+    generatedColumn: number;
+    source: string | null;
+    originalLine: number;
+    originalColumn: number;
+    name: string | null;
+};
+export declare abstract class SourceMap {
+    version: SourceMapV3['version'];
+    file: SourceMapV3['file'];
+    names: SourceMapV3['names'];
+    sourceRoot: SourceMapV3['sourceRoot'];
+    sources: SourceMapV3['sources'];
+    sourcesContent: SourceMapV3['sourcesContent'];
+    resolvedSources: SourceMapV3['sources'];
+    ignoreList: SourceMapV3['ignoreList'];
+}

node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@jridgewell/trace-mapping",
+  "version": "0.3.25",
+  "description": "Trace the original position through a source map",
+  "keywords": [
+    "source",
+    "map"
+  ],
+  "main": "dist/trace-mapping.umd.js",
+  "module": "dist/trace-mapping.mjs",
+  "types": "dist/types/trace-mapping.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": [
+      {
+        "types": "./dist/types/trace-mapping.d.ts",
+        "browser": "./dist/trace-mapping.umd.js",
+        "require": "./dist/trace-mapping.umd.js",
+        "import": "./dist/trace-mapping.mjs"
+      },
+      "./dist/trace-mapping.umd.js"
+    ],
+    "./package.json": "./package.json"
+  },
+  "author": "Justin Ridgewell <justin@ridgewell.name>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jridgewell/trace-mapping.git"
+  },
+  "license": "MIT",
+  "scripts": {
+    "benchmark": "run-s build:rollup benchmark:*",
+    "benchmark:install": "cd benchmark && npm install",
+    "benchmark:only": "node --expose-gc benchmark/index.mjs",
+    "build": "run-s -n build:*",
+    "build:rollup": "rollup -c rollup.config.mjs",
+    "build:ts": "tsc --project tsconfig.build.json",
+    "lint": "run-s -n lint:*",
+    "lint:prettier": "npm run test:lint:prettier -- --write",
+    "lint:ts": "npm run test:lint:ts -- --fix",
+    "prebuild": "rm -rf dist",
+    "prepublishOnly": "npm run preversion",
+    "preversion": "run-s test build",
+    "test": "run-s -n test:lint test:only",
+    "test:debug": "mocha --inspect-brk",
+    "test:lint": "run-s -n test:lint:*",
+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts' '**/*.md'",
+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
+    "test:only": "c8 mocha",
+    "test:watch": "mocha --watch"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "11.1.6",
+    "@types/mocha": "10.0.6",
+    "@types/node": "20.11.20",
+    "@typescript-eslint/eslint-plugin": "6.18.1",
+    "@typescript-eslint/parser": "6.18.1",
+    "benchmark": "2.1.4",
+    "c8": "9.0.0",
+    "esbuild": "0.19.11",
+    "eslint": "8.56.0",
+    "eslint-config-prettier": "9.1.0",
+    "eslint-plugin-no-only-tests": "3.1.0",
+    "mocha": "10.3.0",
+    "npm-run-all": "4.1.5",
+    "prettier": "3.1.1",
+    "rollup": "4.9.4",
+    "tsx": "4.7.0",
+    "typescript": "5.3.3"
+  },
+  "dependencies": {
+    "@jridgewell/resolve-uri": "^3.1.0",
+    "@jridgewell/sourcemap-codec": "^1.4.14"
+  }
+}

node_modules/.pnpm/@types+eslint-scope@3.7.7/node_modules/@types/eslint

@@ -0,0 +1 @@
+../../../@types+eslint@9.6.1/node_modules/@types/eslint

node_modules/.pnpm/@types+eslint-scope@3.7.7/node_modules/@types/eslint-scope/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/.pnpm/@types+eslint-scope@3.7.7/node_modules/@types/eslint-scope/README.md

@@ -0,0 +1,90 @@
+# Installation
+> `npm install --save @types/eslint-scope`
+
+# Summary
+This package contains type definitions for eslint-scope (https://github.com/eslint/eslint-scope).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint-scope.
+## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint-scope/index.d.ts)
+````ts
+import * as eslint from "eslint";
+import * as estree from "estree";
+
+export const version: string;
+
+export class ScopeManager implements eslint.Scope.ScopeManager {
+    scopes: Scope[];
+    globalScope: Scope;
+    acquire(node: {}, inner?: boolean): Scope | null;
+    getDeclaredVariables(node: {}): Variable[];
+}
+
+export class Scope implements eslint.Scope.Scope {
+    type:
+        | "block"
+        | "catch"
+        | "class"
+        | "for"
+        | "function"
+        | "function-expression-name"
+        | "global"
+        | "module"
+        | "switch"
+        | "with"
+        | "TDZ";
+    isStrict: boolean;
+    upper: Scope | null;
+    childScopes: Scope[];
+    variableScope: Scope;
+    block: estree.Node;
+    variables: Variable[];
+    set: Map<string, Variable>;
+    references: Reference[];
+    through: Reference[];
+    functionExpressionScope: boolean;
+}
+
+export class Variable implements eslint.Scope.Variable {
+    name: string;
+    scope: Scope;
+    identifiers: estree.Identifier[];
+    references: Reference[];
+    defs: eslint.Scope.Definition[];
+}
+
+export class Reference implements eslint.Scope.Reference {
+    identifier: estree.Identifier;
+    from: Scope;
+    resolved: Variable | null;
+    writeExpr: estree.Node | null;
+    init: boolean;
+
+    isWrite(): boolean;
+    isRead(): boolean;
+    isWriteOnly(): boolean;
+    isReadOnly(): boolean;
+    isReadWrite(): boolean;
+}
+
+export interface AnalysisOptions {
+    optimistic?: boolean;
+    directive?: boolean;
+    ignoreEval?: boolean;
+    nodejsScope?: boolean;
+    impliedStrict?: boolean;
+    fallback?: string | ((node: {}) => string[]);
+    sourceType?: "script" | "module";
+    ecmaVersion?: number;
+}
+
+export function analyze(ast: {}, options?: AnalysisOptions): ScopeManager;
+
+````
+
+### Additional Details
+ * Last updated: Mon, 06 Nov 2023 22:41:05 GMT
+ * Dependencies: [@types/eslint](https://npmjs.com/package/@types/eslint), [@types/estree](https://npmjs.com/package/@types/estree)
+
+# Credits
+These definitions were written by [Toru Nagashima](https://github.com/mysticatea).

node_modules/.pnpm/@types+eslint-scope@3.7.7/node_modules/@types/eslint-scope/index.d.ts

@@ -0,0 +1,71 @@
+import * as eslint from "eslint";
+import * as estree from "estree";
+
+export const version: string;
+
+export class ScopeManager implements eslint.Scope.ScopeManager {
+    scopes: Scope[];
+    globalScope: Scope;
+    acquire(node: {}, inner?: boolean): Scope | null;
+    getDeclaredVariables(node: {}): Variable[];
+}
+
+export class Scope implements eslint.Scope.Scope {
+    type:
+        | "block"
+        | "catch"
+        | "class"
+        | "for"
+        | "function"
+        | "function-expression-name"
+        | "global"
+        | "module"
+        | "switch"
+        | "with"
+        | "TDZ";
+    isStrict: boolean;
+    upper: Scope | null;
+    childScopes: Scope[];
+    variableScope: Scope;
+    block: estree.Node;
+    variables: Variable[];
+    set: Map<string, Variable>;
+    references: Reference[];
+    through: Reference[];
+    functionExpressionScope: boolean;
+}
+
+export class Variable implements eslint.Scope.Variable {
+    name: string;
+    scope: Scope;
+    identifiers: estree.Identifier[];
+    references: Reference[];
+    defs: eslint.Scope.Definition[];
+}
+
+export class Reference implements eslint.Scope.Reference {
+    identifier: estree.Identifier;
+    from: Scope;
+    resolved: Variable | null;
+    writeExpr: estree.Node | null;
+    init: boolean;
+
+    isWrite(): boolean;
+    isRead(): boolean;
+    isWriteOnly(): boolean;
+    isReadOnly(): boolean;
+    isReadWrite(): boolean;
+}
+
+export interface AnalysisOptions {
+    optimistic?: boolean;
+    directive?: boolean;
+    ignoreEval?: boolean;
+    nodejsScope?: boolean;
+    impliedStrict?: boolean;
+    fallback?: string | ((node: {}) => string[]);
+    sourceType?: "script" | "module";
+    ecmaVersion?: number;
+}
+
+export function analyze(ast: {}, options?: AnalysisOptions): ScopeManager;

node_modules/.pnpm/@types+eslint-scope@3.7.7/node_modules/@types/eslint-scope/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "@types/eslint-scope",
+    "version": "3.7.7",
+    "description": "TypeScript definitions for eslint-scope",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint-scope",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Toru Nagashima",
+            "githubUsername": "mysticatea",
+            "url": "https://github.com/mysticatea"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/eslint-scope"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/eslint": "*",
+        "@types/estree": "*"
+    },
+    "typesPublisherContentHash": "49eee35b78c19e2c83bc96ce190c7a88329006f876dd7f1fb378c1e8034fc8f2",
+    "typeScriptVersion": "4.5"
+}

node_modules/.pnpm/@types+eslint-scope@3.7.7/node_modules/@types/estree

@@ -0,0 +1 @@
+../../../@types+estree@1.0.6/node_modules/@types/estree

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/eslint`
+
+# Summary
+This package contains type definitions for eslint (https://eslint.org).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint.
+
+### Additional Details
+ * Last updated: Mon, 26 Aug 2024 07:08:02 GMT
+ * Dependencies: [@types/estree](https://npmjs.com/package/@types/estree), [@types/json-schema](https://npmjs.com/package/@types/json-schema)
+
+# Credits
+These definitions were written by [Pierre-Marie Dartus](https://github.com/pmdartus), [Jed Fox](https://github.com/j-f1), [Saad Quadri](https://github.com/saadq), [Jason Kwok](https://github.com/JasonHK), [Brad Zacher](https://github.com/bradzacher), [JounQin](https://github.com/JounQin), and [Bryan Mishkin](https://github.com/bmish).

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/index.d.ts

@@ -0,0 +1,1596 @@
+import * as ESTree from "estree";
+import { JSONSchema4 } from "json-schema";
+import { LegacyESLint } from "./use-at-your-own-risk";
+
+export namespace AST {
+    type TokenType =
+        | "Boolean"
+        | "Null"
+        | "Identifier"
+        | "Keyword"
+        | "Punctuator"
+        | "JSXIdentifier"
+        | "JSXText"
+        | "Numeric"
+        | "String"
+        | "RegularExpression";
+
+    interface Token {
+        type: TokenType;
+        value: string;
+        range: Range;
+        loc: SourceLocation;
+    }
+
+    interface SourceLocation {
+        start: ESTree.Position;
+        end: ESTree.Position;
+    }
+
+    type Range = [number, number];
+
+    interface Program extends ESTree.Program {
+        comments: ESTree.Comment[];
+        tokens: Token[];
+        loc: SourceLocation;
+        range: Range;
+    }
+}
+
+export namespace Scope {
+    interface ScopeManager {
+        scopes: Scope[];
+        globalScope: Scope | null;
+
+        acquire(node: ESTree.Node, inner?: boolean): Scope | null;
+
+        getDeclaredVariables(node: ESTree.Node): Variable[];
+    }
+
+    interface Scope {
+        type:
+            | "block"
+            | "catch"
+            | "class"
+            | "for"
+            | "function"
+            | "function-expression-name"
+            | "global"
+            | "module"
+            | "switch"
+            | "with"
+            | "TDZ";
+        isStrict: boolean;
+        upper: Scope | null;
+        childScopes: Scope[];
+        variableScope: Scope;
+        block: ESTree.Node;
+        variables: Variable[];
+        set: Map<string, Variable>;
+        references: Reference[];
+        through: Reference[];
+        functionExpressionScope: boolean;
+    }
+
+    interface Variable {
+        name: string;
+        scope: Scope;
+        identifiers: ESTree.Identifier[];
+        references: Reference[];
+        defs: Definition[];
+    }
+
+    interface Reference {
+        identifier: ESTree.Identifier;
+        from: Scope;
+        resolved: Variable | null;
+        writeExpr: ESTree.Node | null;
+        init: boolean;
+
+        isWrite(): boolean;
+
+        isRead(): boolean;
+
+        isWriteOnly(): boolean;
+
+        isReadOnly(): boolean;
+
+        isReadWrite(): boolean;
+    }
+
+    type DefinitionType =
+        | { type: "CatchClause"; node: ESTree.CatchClause; parent: null }
+        | { type: "ClassName"; node: ESTree.ClassDeclaration | ESTree.ClassExpression; parent: null }
+        | { type: "FunctionName"; node: ESTree.FunctionDeclaration | ESTree.FunctionExpression; parent: null }
+        | { type: "ImplicitGlobalVariable"; node: ESTree.Program; parent: null }
+        | {
+            type: "ImportBinding";
+            node: ESTree.ImportSpecifier | ESTree.ImportDefaultSpecifier | ESTree.ImportNamespaceSpecifier;
+            parent: ESTree.ImportDeclaration;
+        }
+        | {
+            type: "Parameter";
+            node: ESTree.FunctionDeclaration | ESTree.FunctionExpression | ESTree.ArrowFunctionExpression;
+            parent: null;
+        }
+        | { type: "TDZ"; node: any; parent: null }
+        | { type: "Variable"; node: ESTree.VariableDeclarator; parent: ESTree.VariableDeclaration };
+
+    type Definition = DefinitionType & { name: ESTree.Identifier };
+}
+
+// #region SourceCode
+
+export class SourceCode {
+    text: string;
+    ast: AST.Program;
+    lines: string[];
+    hasBOM: boolean;
+    parserServices: SourceCode.ParserServices;
+    scopeManager: Scope.ScopeManager;
+    visitorKeys: SourceCode.VisitorKeys;
+
+    constructor(text: string, ast: AST.Program);
+    constructor(config: SourceCode.Config);
+
+    static splitLines(text: string): string[];
+
+    getText(node?: ESTree.Node, beforeCount?: number, afterCount?: number): string;
+
+    getLines(): string[];
+
+    getAllComments(): ESTree.Comment[];
+
+    getAncestors(node: ESTree.Node): ESTree.Node[];
+
+    getDeclaredVariables(node: ESTree.Node): Scope.Variable[];
+
+    getJSDocComment(node: ESTree.Node): ESTree.Comment | null;
+
+    getNodeByRangeIndex(index: number): ESTree.Node | null;
+
+    isSpaceBetweenTokens(first: AST.Token, second: AST.Token): boolean;
+
+    getLocFromIndex(index: number): ESTree.Position;
+
+    getIndexFromLoc(location: ESTree.Position): number;
+
+    // Inherited methods from TokenStore
+    // ---------------------------------
+
+    getTokenByRangeStart(offset: number, options?: { includeComments: false }): AST.Token | null;
+    getTokenByRangeStart(offset: number, options: { includeComments: boolean }): AST.Token | ESTree.Comment | null;
+
+    getFirstToken: SourceCode.UnaryNodeCursorWithSkipOptions;
+
+    getFirstTokens: SourceCode.UnaryNodeCursorWithCountOptions;
+
+    getLastToken: SourceCode.UnaryNodeCursorWithSkipOptions;
+
+    getLastTokens: SourceCode.UnaryNodeCursorWithCountOptions;
+
+    getTokenBefore: SourceCode.UnaryCursorWithSkipOptions;
+
+    getTokensBefore: SourceCode.UnaryCursorWithCountOptions;
+
+    getTokenAfter: SourceCode.UnaryCursorWithSkipOptions;
+
+    getTokensAfter: SourceCode.UnaryCursorWithCountOptions;
+
+    getFirstTokenBetween: SourceCode.BinaryCursorWithSkipOptions;
+
+    getFirstTokensBetween: SourceCode.BinaryCursorWithCountOptions;
+
+    getLastTokenBetween: SourceCode.BinaryCursorWithSkipOptions;
+
+    getLastTokensBetween: SourceCode.BinaryCursorWithCountOptions;
+
+    getTokensBetween: SourceCode.BinaryCursorWithCountOptions;
+
+    getTokens:
+        & ((node: ESTree.Node, beforeCount?: number, afterCount?: number) => AST.Token[])
+        & SourceCode.UnaryNodeCursorWithCountOptions;
+
+    commentsExistBetween(
+        left: ESTree.Node | AST.Token | ESTree.Comment,
+        right: ESTree.Node | AST.Token | ESTree.Comment,
+    ): boolean;
+
+    getCommentsBefore(nodeOrToken: ESTree.Node | AST.Token): ESTree.Comment[];
+
+    getCommentsAfter(nodeOrToken: ESTree.Node | AST.Token): ESTree.Comment[];
+
+    getCommentsInside(node: ESTree.Node): ESTree.Comment[];
+
+    getScope(node: ESTree.Node): Scope.Scope;
+
+    isSpaceBetween(
+        first: ESTree.Node | AST.Token,
+        second: ESTree.Node | AST.Token,
+    ): boolean;
+
+    markVariableAsUsed(name: string, refNode?: ESTree.Node): boolean;
+}
+
+export namespace SourceCode {
+    interface Config {
+        text: string;
+        ast: AST.Program;
+        parserServices?: ParserServices | undefined;
+        scopeManager?: Scope.ScopeManager | undefined;
+        visitorKeys?: VisitorKeys | undefined;
+    }
+
+    type ParserServices = any;
+
+    interface VisitorKeys {
+        [nodeType: string]: string[];
+    }
+
+    interface UnaryNodeCursorWithSkipOptions {
+        <T extends AST.Token>(
+            node: ESTree.Node,
+            options:
+                | ((token: AST.Token) => token is T)
+                | {
+                    filter: (token: AST.Token) => token is T;
+                    includeComments?: false | undefined;
+                    skip?: number | undefined;
+                },
+        ): T | null;
+        <T extends AST.Token | ESTree.Comment>(
+            node: ESTree.Node,
+            options: {
+                filter: (tokenOrComment: AST.Token | ESTree.Comment) => tokenOrComment is T;
+                includeComments: boolean;
+                skip?: number | undefined;
+            },
+        ): T | null;
+        (
+            node: ESTree.Node,
+            options?:
+                | {
+                    filter?: ((token: AST.Token) => boolean) | undefined;
+                    includeComments?: false | undefined;
+                    skip?: number | undefined;
+                }
+                | ((token: AST.Token) => boolean)
+                | number,
+        ): AST.Token | null;
+        (
+            node: ESTree.Node,
+            options: {
+                filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
+                includeComments: boolean;
+                skip?: number | undefined;
+            },
+        ): AST.Token | ESTree.Comment | null;
+    }
+
+    interface UnaryNodeCursorWithCountOptions {
+        <T extends AST.Token>(
+            node: ESTree.Node,
+            options:
+                | ((token: AST.Token) => token is T)
+                | {
+                    filter: (token: AST.Token) => token is T;
+                    includeComments?: false | undefined;
+                    count?: number | undefined;
+                },
+        ): T[];
+        <T extends AST.Token | ESTree.Comment>(
+            node: ESTree.Node,
+            options: {
+                filter: (tokenOrComment: AST.Token | ESTree.Comment) => tokenOrComment is T;
+                includeComments: boolean;
+                count?: number | undefined;
+            },
+        ): T[];
+        (
+            node: ESTree.Node,
+            options?:
+                | {
+                    filter?: ((token: AST.Token) => boolean) | undefined;
+                    includeComments?: false | undefined;
+                    count?: number | undefined;
+                }
+                | ((token: AST.Token) => boolean)
+                | number,
+        ): AST.Token[];
+        (
+            node: ESTree.Node,
+            options: {
+                filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
+                includeComments: boolean;
+                count?: number | undefined;
+            },
+        ): Array<AST.Token | ESTree.Comment>;
+    }
+
+    interface UnaryCursorWithSkipOptions {
+        <T extends AST.Token>(
+            node: ESTree.Node | AST.Token | ESTree.Comment,
+            options:
+                | ((token: AST.Token) => token is T)
+                | {
+                    filter: (token: AST.Token) => token is T;
+                    includeComments?: false | undefined;
+                    skip?: number | undefined;
+                },
+        ): T | null;
+        <T extends AST.Token | ESTree.Comment>(
+            node: ESTree.Node | AST.Token | ESTree.Comment,
+            options: {
+                filter: (tokenOrComment: AST.Token | ESTree.Comment) => tokenOrComment is T;
+                includeComments: boolean;
+                skip?: number | undefined;
+            },
+        ): T | null;
+        (
+            node: ESTree.Node | AST.Token | ESTree.Comment,
+            options?:
+                | {
+                    filter?: ((token: AST.Token) => boolean) | undefined;
+                    includeComments?: false | undefined;
+                    skip?: number | undefined;
+                }
+                | ((token: AST.Token) => boolean)
+                | number,
+        ): AST.Token | null;
+        (
+            node: ESTree.Node | AST.Token | ESTree.Comment,
+            options: {
+                filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
+                includeComments: boolean;
+                skip?: number | undefined;
+            },
+        ): AST.Token | ESTree.Comment | null;
+    }
+
+    interface UnaryCursorWithCountOptions {
+        <T extends AST.Token>(
+            node: ESTree.Node | AST.Token | ESTree.Comment,
+            options:
+                | ((token: AST.Token) => token is T)
+                | {
+                    filter: (token: AST.Token) => token is T;
+                    includeComments?: false | undefined;
+                    count?: number | undefined;
+                },
+        ): T[];
+        <T extends AST.Token | ESTree.Comment>(
+            node: ESTree.Node | AST.Token | ESTree.Comment,
+            options: {
+                filter: (tokenOrComment: AST.Token | ESTree.Comment) => tokenOrComment is T;
+                includeComments: boolean;
+                count?: number | undefined;
+            },
+        ): T[];
+        (
+            node: ESTree.Node | AST.Token | ESTree.Comment,
+            options?:
+                | {
+                    filter?: ((token: AST.Token) => boolean) | undefined;
+                    includeComments?: false | undefined;
+                    count?: number | undefined;
+                }
+                | ((token: AST.Token) => boolean)
+                | number,
+        ): AST.Token[];
+        (
+            node: ESTree.Node | AST.Token | ESTree.Comment,
+            options: {
+                filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
+                includeComments: boolean;
+                count?: number | undefined;
+            },
+        ): Array<AST.Token | ESTree.Comment>;
+    }
+
+    interface BinaryCursorWithSkipOptions {
+        <T extends AST.Token>(
+            left: ESTree.Node | AST.Token | ESTree.Comment,
+            right: ESTree.Node | AST.Token | ESTree.Comment,
+            options:
+                | ((token: AST.Token) => token is T)
+                | {
+                    filter: (token: AST.Token) => token is T;
+                    includeComments?: false | undefined;
+                    skip?: number | undefined;
+                },
+        ): T | null;
+        <T extends AST.Token | ESTree.Comment>(
+            left: ESTree.Node | AST.Token | ESTree.Comment,
+            right: ESTree.Node | AST.Token | ESTree.Comment,
+            options: {
+                filter: (tokenOrComment: AST.Token | ESTree.Comment) => tokenOrComment is T;
+                includeComments: boolean;
+                skip?: number | undefined;
+            },
+        ): T | null;
+        (
+            left: ESTree.Node | AST.Token | ESTree.Comment,
+            right: ESTree.Node | AST.Token | ESTree.Comment,
+            options?:
+                | {
+                    filter?: ((token: AST.Token) => boolean) | undefined;
+                    includeComments?: false | undefined;
+                    skip?: number | undefined;
+                }
+                | ((token: AST.Token) => boolean)
+                | number,
+        ): AST.Token | null;
+        (
+            left: ESTree.Node | AST.Token | ESTree.Comment,
+            right: ESTree.Node | AST.Token | ESTree.Comment,
+            options: {
+                filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
+                includeComments: boolean;
+                skip?: number | undefined;
+            },
+        ): AST.Token | ESTree.Comment | null;
+    }
+
+    interface BinaryCursorWithCountOptions {
+        <T extends AST.Token>(
+            left: ESTree.Node | AST.Token | ESTree.Comment,
+            right: ESTree.Node | AST.Token | ESTree.Comment,
+            options:
+                | ((token: AST.Token) => token is T)
+                | {
+                    filter: (token: AST.Token) => token is T;
+                    includeComments?: false | undefined;
+                    count?: number | undefined;
+                },
+        ): T[];
+        <T extends AST.Token | ESTree.Comment>(
+            left: ESTree.Node | AST.Token | ESTree.Comment,
+            right: ESTree.Node | AST.Token | ESTree.Comment,
+            options: {
+                filter: (tokenOrComment: AST.Token | ESTree.Comment) => tokenOrComment is T;
+                includeComments: boolean;
+                count?: number | undefined;
+            },
+        ): T[];
+        (
+            left: ESTree.Node | AST.Token | ESTree.Comment,
+            right: ESTree.Node | AST.Token | ESTree.Comment,
+            options?:
+                | {
+                    filter?: ((token: AST.Token) => boolean) | undefined;
+                    includeComments?: false | undefined;
+                    count?: number | undefined;
+                }
+                | ((token: AST.Token) => boolean)
+                | number,
+        ): AST.Token[];
+        (
+            left: ESTree.Node | AST.Token | ESTree.Comment,
+            right: ESTree.Node | AST.Token | ESTree.Comment,
+            options: {
+                filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
+                includeComments: boolean;
+                count?: number | undefined;
+            },
+        ): Array<AST.Token | ESTree.Comment>;
+    }
+}
+
+// #endregion
+
+export namespace Rule {
+    interface RuleModule {
+        create(context: RuleContext): RuleListener;
+        meta?: RuleMetaData | undefined;
+    }
+
+    type NodeTypes = ESTree.Node["type"];
+    interface NodeListener {
+        ArrayExpression?: ((node: ESTree.ArrayExpression & NodeParentExtension) => void) | undefined;
+        "ArrayExpression:exit"?: ((node: ESTree.ArrayExpression & NodeParentExtension) => void) | undefined;
+        ArrayPattern?: ((node: ESTree.ArrayPattern & NodeParentExtension) => void) | undefined;
+        "ArrayPattern:exit"?: ((node: ESTree.ArrayPattern & NodeParentExtension) => void) | undefined;
+        ArrowFunctionExpression?: ((node: ESTree.ArrowFunctionExpression & NodeParentExtension) => void) | undefined;
+        "ArrowFunctionExpression:exit"?:
+            | ((node: ESTree.ArrowFunctionExpression & NodeParentExtension) => void)
+            | undefined;
+        AssignmentExpression?: ((node: ESTree.AssignmentExpression & NodeParentExtension) => void) | undefined;
+        "AssignmentExpression:exit"?: ((node: ESTree.AssignmentExpression & NodeParentExtension) => void) | undefined;
+        AssignmentPattern?: ((node: ESTree.AssignmentPattern & NodeParentExtension) => void) | undefined;
+        "AssignmentPattern:exit"?: ((node: ESTree.AssignmentPattern & NodeParentExtension) => void) | undefined;
+        AwaitExpression?: ((node: ESTree.AwaitExpression & NodeParentExtension) => void) | undefined;
+        "AwaitExpression:exit"?: ((node: ESTree.AwaitExpression & NodeParentExtension) => void) | undefined;
+        BinaryExpression?: ((node: ESTree.BinaryExpression & NodeParentExtension) => void) | undefined;
+        "BinaryExpression:exit"?: ((node: ESTree.BinaryExpression & NodeParentExtension) => void) | undefined;
+        BlockStatement?: ((node: ESTree.BlockStatement & NodeParentExtension) => void) | undefined;
+        "BlockStatement:exit"?: ((node: ESTree.BlockStatement & NodeParentExtension) => void) | undefined;
+        BreakStatement?: ((node: ESTree.BreakStatement & NodeParentExtension) => void) | undefined;
+        "BreakStatement:exit"?: ((node: ESTree.BreakStatement & NodeParentExtension) => void) | undefined;
+        CallExpression?: ((node: ESTree.CallExpression & NodeParentExtension) => void) | undefined;
+        "CallExpression:exit"?: ((node: ESTree.CallExpression & NodeParentExtension) => void) | undefined;
+        CatchClause?: ((node: ESTree.CatchClause & NodeParentExtension) => void) | undefined;
+        "CatchClause:exit"?: ((node: ESTree.CatchClause & NodeParentExtension) => void) | undefined;
+        ChainExpression?: ((node: ESTree.ChainExpression & NodeParentExtension) => void) | undefined;
+        "ChainExpression:exit"?: ((node: ESTree.ChainExpression & NodeParentExtension) => void) | undefined;
+        ClassBody?: ((node: ESTree.ClassBody & NodeParentExtension) => void) | undefined;
+        "ClassBody:exit"?: ((node: ESTree.ClassBody & NodeParentExtension) => void) | undefined;
+        ClassDeclaration?: ((node: ESTree.ClassDeclaration & NodeParentExtension) => void) | undefined;
+        "ClassDeclaration:exit"?: ((node: ESTree.ClassDeclaration & NodeParentExtension) => void) | undefined;
+        ClassExpression?: ((node: ESTree.ClassExpression & NodeParentExtension) => void) | undefined;
+        "ClassExpression:exit"?: ((node: ESTree.ClassExpression & NodeParentExtension) => void) | undefined;
+        ConditionalExpression?: ((node: ESTree.ConditionalExpression & NodeParentExtension) => void) | undefined;
+        "ConditionalExpression:exit"?: ((node: ESTree.ConditionalExpression & NodeParentExtension) => void) | undefined;
+        ContinueStatement?: ((node: ESTree.ContinueStatement & NodeParentExtension) => void) | undefined;
+        "ContinueStatement:exit"?: ((node: ESTree.ContinueStatement & NodeParentExtension) => void) | undefined;
+        DebuggerStatement?: ((node: ESTree.DebuggerStatement & NodeParentExtension) => void) | undefined;
+        "DebuggerStatement:exit"?: ((node: ESTree.DebuggerStatement & NodeParentExtension) => void) | undefined;
+        DoWhileStatement?: ((node: ESTree.DoWhileStatement & NodeParentExtension) => void) | undefined;
+        "DoWhileStatement:exit"?: ((node: ESTree.DoWhileStatement & NodeParentExtension) => void) | undefined;
+        EmptyStatement?: ((node: ESTree.EmptyStatement & NodeParentExtension) => void) | undefined;
+        "EmptyStatement:exit"?: ((node: ESTree.EmptyStatement & NodeParentExtension) => void) | undefined;
+        ExportAllDeclaration?: ((node: ESTree.ExportAllDeclaration & NodeParentExtension) => void) | undefined;
+        "ExportAllDeclaration:exit"?: ((node: ESTree.ExportAllDeclaration & NodeParentExtension) => void) | undefined;
+        ExportDefaultDeclaration?: ((node: ESTree.ExportDefaultDeclaration & NodeParentExtension) => void) | undefined;
+        "ExportDefaultDeclaration:exit"?:
+            | ((node: ESTree.ExportDefaultDeclaration & NodeParentExtension) => void)
+            | undefined;
+        ExportNamedDeclaration?: ((node: ESTree.ExportNamedDeclaration & NodeParentExtension) => void) | undefined;
+        "ExportNamedDeclaration:exit"?:
+            | ((node: ESTree.ExportNamedDeclaration & NodeParentExtension) => void)
+            | undefined;
+        ExportSpecifier?: ((node: ESTree.ExportSpecifier & NodeParentExtension) => void) | undefined;
+        "ExportSpecifier:exit"?: ((node: ESTree.ExportSpecifier & NodeParentExtension) => void) | undefined;
+        ExpressionStatement?: ((node: ESTree.ExpressionStatement & NodeParentExtension) => void) | undefined;
+        "ExpressionStatement:exit"?: ((node: ESTree.ExpressionStatement & NodeParentExtension) => void) | undefined;
+        ForInStatement?: ((node: ESTree.ForInStatement & NodeParentExtension) => void) | undefined;
+        "ForInStatement:exit"?: ((node: ESTree.ForInStatement & NodeParentExtension) => void) | undefined;
+        ForOfStatement?: ((node: ESTree.ForOfStatement & NodeParentExtension) => void) | undefined;
+        "ForOfStatement:exit"?: ((node: ESTree.ForOfStatement & NodeParentExtension) => void) | undefined;
+        ForStatement?: ((node: ESTree.ForStatement & NodeParentExtension) => void) | undefined;
+        "ForStatement:exit"?: ((node: ESTree.ForStatement & NodeParentExtension) => void) | undefined;
+        FunctionDeclaration?: ((node: ESTree.FunctionDeclaration & NodeParentExtension) => void) | undefined;
+        "FunctionDeclaration:exit"?: ((node: ESTree.FunctionDeclaration & NodeParentExtension) => void) | undefined;
+        FunctionExpression?: ((node: ESTree.FunctionExpression & NodeParentExtension) => void) | undefined;
+        "FunctionExpression:exit"?: ((node: ESTree.FunctionExpression & NodeParentExtension) => void) | undefined;
+        Identifier?: ((node: ESTree.Identifier & NodeParentExtension) => void) | undefined;
+        "Identifier:exit"?: ((node: ESTree.Identifier & NodeParentExtension) => void) | undefined;
+        IfStatement?: ((node: ESTree.IfStatement & NodeParentExtension) => void) | undefined;
+        "IfStatement:exit"?: ((node: ESTree.IfStatement & NodeParentExtension) => void) | undefined;
+        ImportDeclaration?: ((node: ESTree.ImportDeclaration & NodeParentExtension) => void) | undefined;
+        "ImportDeclaration:exit"?: ((node: ESTree.ImportDeclaration & NodeParentExtension) => void) | undefined;
+        ImportDefaultSpecifier?: ((node: ESTree.ImportDefaultSpecifier & NodeParentExtension) => void) | undefined;
+        "ImportDefaultSpecifier:exit"?:
+            | ((node: ESTree.ImportDefaultSpecifier & NodeParentExtension) => void)
+            | undefined;
+        ImportExpression?: ((node: ESTree.ImportExpression & NodeParentExtension) => void) | undefined;
+        "ImportExpression:exit"?: ((node: ESTree.ImportExpression & NodeParentExtension) => void) | undefined;
+        ImportNamespaceSpecifier?: ((node: ESTree.ImportNamespaceSpecifier & NodeParentExtension) => void) | undefined;
+        "ImportNamespaceSpecifier:exit"?:
+            | ((node: ESTree.ImportNamespaceSpecifier & NodeParentExtension) => void)
+            | undefined;
+        ImportSpecifier?: ((node: ESTree.ImportSpecifier & NodeParentExtension) => void) | undefined;
+        "ImportSpecifier:exit"?: ((node: ESTree.ImportSpecifier & NodeParentExtension) => void) | undefined;
+        LabeledStatement?: ((node: ESTree.LabeledStatement & NodeParentExtension) => void) | undefined;
+        "LabeledStatement:exit"?: ((node: ESTree.LabeledStatement & NodeParentExtension) => void) | undefined;
+        Literal?: ((node: ESTree.Literal & NodeParentExtension) => void) | undefined;
+        "Literal:exit"?: ((node: ESTree.Literal & NodeParentExtension) => void) | undefined;
+        LogicalExpression?: ((node: ESTree.LogicalExpression & NodeParentExtension) => void) | undefined;
+        "LogicalExpression:exit"?: ((node: ESTree.LogicalExpression & NodeParentExtension) => void) | undefined;
+        MemberExpression?: ((node: ESTree.MemberExpression & NodeParentExtension) => void) | undefined;
+        "MemberExpression:exit"?: ((node: ESTree.MemberExpression & NodeParentExtension) => void) | undefined;
+        MetaProperty?: ((node: ESTree.MetaProperty & NodeParentExtension) => void) | undefined;
+        "MetaProperty:exit"?: ((node: ESTree.MetaProperty & NodeParentExtension) => void) | undefined;
+        MethodDefinition?: ((node: ESTree.MethodDefinition & NodeParentExtension) => void) | undefined;
+        "MethodDefinition:exit"?: ((node: ESTree.MethodDefinition & NodeParentExtension) => void) | undefined;
+        NewExpression?: ((node: ESTree.NewExpression & NodeParentExtension) => void) | undefined;
+        "NewExpression:exit"?: ((node: ESTree.NewExpression & NodeParentExtension) => void) | undefined;
+        ObjectExpression?: ((node: ESTree.ObjectExpression & NodeParentExtension) => void) | undefined;
+        "ObjectExpression:exit"?: ((node: ESTree.ObjectExpression & NodeParentExtension) => void) | undefined;
+        ObjectPattern?: ((node: ESTree.ObjectPattern & NodeParentExtension) => void) | undefined;
+        "ObjectPattern:exit"?: ((node: ESTree.ObjectPattern & NodeParentExtension) => void) | undefined;
+        PrivateIdentifier?: ((node: ESTree.PrivateIdentifier & NodeParentExtension) => void) | undefined;
+        "PrivateIdentifier:exit"?: ((node: ESTree.PrivateIdentifier & NodeParentExtension) => void) | undefined;
+        Program?: ((node: ESTree.Program) => void) | undefined;
+        "Program:exit"?: ((node: ESTree.Program) => void) | undefined;
+        Property?: ((node: ESTree.Property & NodeParentExtension) => void) | undefined;
+        "Property:exit"?: ((node: ESTree.Property & NodeParentExtension) => void) | undefined;
+        PropertyDefinition?: ((node: ESTree.PropertyDefinition & NodeParentExtension) => void) | undefined;
+        "PropertyDefinition:exit"?: ((node: ESTree.PropertyDefinition & NodeParentExtension) => void) | undefined;
+        RestElement?: ((node: ESTree.RestElement & NodeParentExtension) => void) | undefined;
+        "RestElement:exit"?: ((node: ESTree.RestElement & NodeParentExtension) => void) | undefined;
+        ReturnStatement?: ((node: ESTree.ReturnStatement & NodeParentExtension) => void) | undefined;
+        "ReturnStatement:exit"?: ((node: ESTree.ReturnStatement & NodeParentExtension) => void) | undefined;
+        SequenceExpression?: ((node: ESTree.SequenceExpression & NodeParentExtension) => void) | undefined;
+        "SequenceExpression:exit"?: ((node: ESTree.SequenceExpression & NodeParentExtension) => void) | undefined;
+        SpreadElement?: ((node: ESTree.SpreadElement & NodeParentExtension) => void) | undefined;
+        "SpreadElement:exit"?: ((node: ESTree.SpreadElement & NodeParentExtension) => void) | undefined;
+        StaticBlock?: ((node: ESTree.StaticBlock & NodeParentExtension) => void) | undefined;
+        "StaticBlock:exit"?: ((node: ESTree.StaticBlock & NodeParentExtension) => void) | undefined;
+        Super?: ((node: ESTree.Super & NodeParentExtension) => void) | undefined;
+        "Super:exit"?: ((node: ESTree.Super & NodeParentExtension) => void) | undefined;
+        SwitchCase?: ((node: ESTree.SwitchCase & NodeParentExtension) => void) | undefined;
+        "SwitchCase:exit"?: ((node: ESTree.SwitchCase & NodeParentExtension) => void) | undefined;
+        SwitchStatement?: ((node: ESTree.SwitchStatement & NodeParentExtension) => void) | undefined;
+        "SwitchStatement:exit"?: ((node: ESTree.SwitchStatement & NodeParentExtension) => void) | undefined;
+        TaggedTemplateExpression?: ((node: ESTree.TaggedTemplateExpression & NodeParentExtension) => void) | undefined;
+        "TaggedTemplateExpression:exit"?:
+            | ((node: ESTree.TaggedTemplateExpression & NodeParentExtension) => void)
+            | undefined;
+        TemplateElement?: ((node: ESTree.TemplateElement & NodeParentExtension) => void) | undefined;
+        "TemplateElement:exit"?: ((node: ESTree.TemplateElement & NodeParentExtension) => void) | undefined;
+        TemplateLiteral?: ((node: ESTree.TemplateLiteral & NodeParentExtension) => void) | undefined;
+        "TemplateLiteral:exit"?: ((node: ESTree.TemplateLiteral & NodeParentExtension) => void) | undefined;
+        ThisExpression?: ((node: ESTree.ThisExpression & NodeParentExtension) => void) | undefined;
+        "ThisExpression:exit"?: ((node: ESTree.ThisExpression & NodeParentExtension) => void) | undefined;
+        ThrowStatement?: ((node: ESTree.ThrowStatement & NodeParentExtension) => void) | undefined;
+        "ThrowStatement:exit"?: ((node: ESTree.ThrowStatement & NodeParentExtension) => void) | undefined;
+        TryStatement?: ((node: ESTree.TryStatement & NodeParentExtension) => void) | undefined;
+        "TryStatement:exit"?: ((node: ESTree.TryStatement & NodeParentExtension) => void) | undefined;
+        UnaryExpression?: ((node: ESTree.UnaryExpression & NodeParentExtension) => void) | undefined;
+        "UnaryExpression:exit"?: ((node: ESTree.UnaryExpression & NodeParentExtension) => void) | undefined;
+        UpdateExpression?: ((node: ESTree.UpdateExpression & NodeParentExtension) => void) | undefined;
+        "UpdateExpression:exit"?: ((node: ESTree.UpdateExpression & NodeParentExtension) => void) | undefined;
+        VariableDeclaration?: ((node: ESTree.VariableDeclaration & NodeParentExtension) => void) | undefined;
+        "VariableDeclaration:exit"?: ((node: ESTree.VariableDeclaration & NodeParentExtension) => void) | undefined;
+        VariableDeclarator?: ((node: ESTree.VariableDeclarator & NodeParentExtension) => void) | undefined;
+        "VariableDeclarator:exit"?: ((node: ESTree.VariableDeclarator & NodeParentExtension) => void) | undefined;
+        WhileStatement?: ((node: ESTree.WhileStatement & NodeParentExtension) => void) | undefined;
+        "WhileStatement:exit"?: ((node: ESTree.WhileStatement & NodeParentExtension) => void) | undefined;
+        WithStatement?: ((node: ESTree.WithStatement & NodeParentExtension) => void) | undefined;
+        "WithStatement:exit"?: ((node: ESTree.WithStatement & NodeParentExtension) => void) | undefined;
+        YieldExpression?: ((node: ESTree.YieldExpression & NodeParentExtension) => void) | undefined;
+        "YieldExpression:exit"?: ((node: ESTree.YieldExpression & NodeParentExtension) => void) | undefined;
+    }
+
+    interface NodeParentExtension {
+        parent: Node;
+    }
+    type Node = ESTree.Node & NodeParentExtension;
+
+    interface RuleListener extends NodeListener {
+        onCodePathStart?(codePath: CodePath, node: Node): void;
+
+        onCodePathEnd?(codePath: CodePath, node: Node): void;
+
+        onCodePathSegmentStart?(segment: CodePathSegment, node: Node): void;
+
+        onCodePathSegmentEnd?(segment: CodePathSegment, node: Node): void;
+
+        onCodePathSegmentLoop?(fromSegment: CodePathSegment, toSegment: CodePathSegment, node: Node): void;
+
+        [key: string]:
+            | ((codePath: CodePath, node: Node) => void)
+            | ((segment: CodePathSegment, node: Node) => void)
+            | ((fromSegment: CodePathSegment, toSegment: CodePathSegment, node: Node) => void)
+            | ((node: Node) => void)
+            | NodeListener[keyof NodeListener]
+            | undefined;
+    }
+
+    type CodePathOrigin = "program" | "function" | "class-field-initializer" | "class-static-block";
+
+    interface CodePath {
+        id: string;
+        origin: CodePathOrigin;
+        initialSegment: CodePathSegment;
+        finalSegments: CodePathSegment[];
+        returnedSegments: CodePathSegment[];
+        thrownSegments: CodePathSegment[];
+        upper: CodePath | null;
+        childCodePaths: CodePath[];
+    }
+
+    interface CodePathSegment {
+        id: string;
+        nextSegments: CodePathSegment[];
+        prevSegments: CodePathSegment[];
+        reachable: boolean;
+    }
+
+    interface RuleMetaData {
+        /** Properties often used for documentation generation and tooling. */
+        docs?: {
+            /** Provides a short description of the rule. Commonly used when generating lists of rules. */
+            description?: string | undefined;
+            /** Historically used by some plugins that divide rules into categories in their documentation. */
+            category?: string | undefined;
+            /** Historically used by some plugins to indicate a rule belongs in their `recommended` configuration. */
+            recommended?: boolean | undefined;
+            /** Specifies the URL at which the full documentation can be accessed. Code editors often use this to provide a helpful link on highlighted rule violations. */
+            url?: string | undefined;
+        } | undefined;
+        /** Violation and suggestion messages. */
+        messages?: { [messageId: string]: string } | undefined;
+        /**
+         * Specifies if the `--fix` option on the command line automatically fixes problems reported by the rule.
+         * Mandatory for fixable rules.
+         */
+        fixable?: "code" | "whitespace" | undefined;
+        /**
+         * Specifies the [options](https://eslint.org/docs/latest/extend/custom-rules#options-schemas)
+         * so ESLint can prevent invalid [rule configurations](https://eslint.org/docs/latest/use/configure/rules#configuring-rules).
+         * Mandatory for rules with options.
+         */
+        schema?: JSONSchema4 | JSONSchema4[] | false | undefined;
+
+        /** Indicates whether the rule has been deprecated. Omit if not deprecated. */
+        deprecated?: boolean | undefined;
+        /** The name of the rule(s) this rule was replaced by, if it was deprecated. */
+        replacedBy?: readonly string[];
+
+        /**
+         * Indicates the type of rule:
+         * - `"problem"` means the rule is identifying code that either will cause an error or may cause a confusing behavior. Developers should consider this a high priority to resolve.
+         * - `"suggestion"` means the rule is identifying something that could be done in a better way but no errors will occur if the code isn’t changed.
+         * - `"layout"` means the rule cares primarily about whitespace, semicolons, commas, and parentheses,
+         *   all the parts of the program that determine how the code looks rather than how it executes.
+         *   These rules work on parts of the code that aren’t specified in the AST.
+         */
+        type?: "problem" | "suggestion" | "layout" | undefined;
+        /**
+         * Specifies whether the rule can return suggestions (defaults to `false` if omitted).
+         * Mandatory for rules that provide suggestions.
+         */
+        hasSuggestions?: boolean | undefined;
+    }
+
+    interface RuleContext {
+        id: string;
+        options: any[];
+        settings: { [name: string]: any };
+        parserPath: string | undefined;
+        languageOptions: Linter.LanguageOptions;
+        parserOptions: Linter.ParserOptions;
+        cwd: string;
+        filename: string;
+        physicalFilename: string;
+        sourceCode: SourceCode;
+
+        getAncestors(): ESTree.Node[];
+
+        getDeclaredVariables(node: ESTree.Node): Scope.Variable[];
+
+        /** @deprecated Use property `filename` directly instead */
+        getFilename(): string;
+
+        /** @deprecated Use property `physicalFilename` directly instead */
+        getPhysicalFilename(): string;
+
+        /** @deprecated Use property `cwd` directly instead */
+        getCwd(): string;
+
+        getScope(): Scope.Scope;
+
+        /** @deprecated Use property `sourceCode` directly instead */
+        getSourceCode(): SourceCode;
+
+        markVariableAsUsed(name: string): boolean;
+
+        report(descriptor: ReportDescriptor): void;
+    }
+
+    type ReportFixer = (fixer: RuleFixer) => null | Fix | IterableIterator<Fix> | Fix[];
+
+    interface ReportDescriptorOptionsBase {
+        data?: { [key: string]: string };
+
+        fix?: null | ReportFixer;
+    }
+
+    interface SuggestionReportOptions {
+        data?: { [key: string]: string };
+
+        fix: ReportFixer;
+    }
+
+    type SuggestionDescriptorMessage = { desc: string } | { messageId: string };
+    type SuggestionReportDescriptor = SuggestionDescriptorMessage & SuggestionReportOptions;
+
+    interface ReportDescriptorOptions extends ReportDescriptorOptionsBase {
+        suggest?: SuggestionReportDescriptor[] | null | undefined;
+    }
+
+    type ReportDescriptor = ReportDescriptorMessage & ReportDescriptorLocation & ReportDescriptorOptions;
+    type ReportDescriptorMessage = { message: string } | { messageId: string };
+    type ReportDescriptorLocation =
+        | { node: ESTree.Node }
+        | { loc: AST.SourceLocation | { line: number; column: number } };
+
+    interface RuleFixer {
+        insertTextAfter(nodeOrToken: ESTree.Node | AST.Token, text: string): Fix;
+
+        insertTextAfterRange(range: AST.Range, text: string): Fix;
+
+        insertTextBefore(nodeOrToken: ESTree.Node | AST.Token, text: string): Fix;
+
+        insertTextBeforeRange(range: AST.Range, text: string): Fix;
+
+        remove(nodeOrToken: ESTree.Node | AST.Token): Fix;
+
+        removeRange(range: AST.Range): Fix;
+
+        replaceText(nodeOrToken: ESTree.Node | AST.Token, text: string): Fix;
+
+        replaceTextRange(range: AST.Range, text: string): Fix;
+    }
+
+    interface Fix {
+        range: AST.Range;
+        text: string;
+    }
+}
+
+// #region Linter
+
+export class Linter {
+    static readonly version: string;
+
+    version: string;
+
+    constructor(options?: { cwd?: string | undefined; configType?: "flat" | "eslintrc" });
+
+    verify(
+        code: SourceCode | string,
+        config: Linter.LegacyConfig | Linter.Config | Linter.Config[],
+        filename?: string,
+    ): Linter.LintMessage[];
+    verify(
+        code: SourceCode | string,
+        config: Linter.LegacyConfig | Linter.Config | Linter.Config[],
+        options: Linter.LintOptions,
+    ): Linter.LintMessage[];
+
+    verifyAndFix(
+        code: string,
+        config: Linter.LegacyConfig | Linter.Config | Linter.Config[],
+        filename?: string,
+    ): Linter.FixReport;
+    verifyAndFix(
+        code: string,
+        config: Linter.LegacyConfig | Linter.Config | Linter.Config[],
+        options: Linter.FixOptions,
+    ): Linter.FixReport;
+
+    getSourceCode(): SourceCode;
+
+    defineRule(name: string, rule: Rule.RuleModule): void;
+
+    defineRules(rules: { [name: string]: Rule.RuleModule }): void;
+
+    getRules(): Map<string, Rule.RuleModule>;
+
+    defineParser(name: string, parser: Linter.Parser): void;
+
+    getTimes(): Linter.Stats["times"];
+
+    getFixPassCount(): Linter.Stats["fixPasses"];
+}
+
+export namespace Linter {
+    /**
+     * The numeric severity level for a rule.
+     *
+     * - `0` means off.
+     * - `1` means warn.
+     * - `2` means error.
+     *
+     * @see [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)
+     */
+    type Severity = 0 | 1 | 2;
+
+    /**
+     * The human readable severity level for a rule.
+     *
+     * @see [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)
+     */
+    type StringSeverity = "off" | "warn" | "error";
+
+    /**
+     * The numeric or human readable severity level for a rule.
+     *
+     * @see [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)
+     */
+    type RuleSeverity = Severity | StringSeverity;
+
+    /**
+     * An array containing the rule severity level, followed by the rule options.
+     *
+     * @see [Rules](https://eslint.org/docs/latest/use/configure/rules)
+     */
+    type RuleSeverityAndOptions<Options extends any[] = any[]> = [RuleSeverity, ...Partial<Options>];
+
+    /**
+     * The severity level for the rule or an array containing the rule severity level, followed by the rule options.
+     *
+     * @see [Rules](https://eslint.org/docs/latest/use/configure/rules)
+     */
+    type RuleEntry<Options extends any[] = any[]> = RuleSeverity | RuleSeverityAndOptions<Options>;
+
+    /**
+     * The rules config object is a key/value map of rule names and their severity and options.
+     */
+    interface RulesRecord {
+        [rule: string]: RuleEntry;
+    }
+
+    /**
+     * A configuration object that may have a `rules` block.
+     */
+    interface HasRules<Rules extends RulesRecord = RulesRecord> {
+        rules?: Partial<Rules> | undefined;
+    }
+
+    /**
+     * The ECMAScript version of the code being linted.
+     */
+    type EcmaVersion =
+        | 3
+        | 5
+        | 6
+        | 7
+        | 8
+        | 9
+        | 10
+        | 11
+        | 12
+        | 13
+        | 14
+        | 15
+        | 16
+        | 2015
+        | 2016
+        | 2017
+        | 2018
+        | 2019
+        | 2020
+        | 2021
+        | 2022
+        | 2023
+        | 2024
+        | 2025
+        | "latest";
+
+    /**
+     * The type of JavaScript source code.
+     */
+    type SourceType = "script" | "module" | "commonjs";
+
+    /**
+     * ESLint legacy configuration.
+     *
+     * @see [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/)
+     */
+    interface BaseConfig<Rules extends RulesRecord = RulesRecord, OverrideRules extends RulesRecord = Rules>
+        extends HasRules<Rules>
+    {
+        $schema?: string | undefined;
+
+        /**
+         * An environment provides predefined global variables.
+         *
+         * @see [Environments](https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-environments)
+         */
+        env?: { [name: string]: boolean } | undefined;
+
+        /**
+         * Extending configuration files.
+         *
+         * @see [Extends](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated#extending-configuration-files)
+         */
+        extends?: string | string[] | undefined;
+
+        /**
+         * Specifying globals.
+         *
+         * @see [Globals](https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-globals)
+         */
+        globals?: Linter.Globals | undefined;
+
+        /**
+         * Disable processing of inline comments.
+         *
+         * @see [Disabling Inline Comments](https://eslint.org/docs/latest/use/configure/rules-deprecated#disabling-inline-comments)
+         */
+        noInlineConfig?: boolean | undefined;
+
+        /**
+         * Overrides can be used to use a differing configuration for matching sub-directories and files.
+         *
+         * @see [How do overrides work](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated#how-do-overrides-work)
+         */
+        overrides?: Array<ConfigOverride<OverrideRules>> | undefined;
+
+        /**
+         * Parser.
+         *
+         * @see [Working with Custom Parsers](https://eslint.org/docs/latest/extend/custom-parsers)
+         * @see [Specifying Parser](https://eslint.org/docs/latest/use/configure/parser-deprecated)
+         */
+        parser?: string | undefined;
+
+        /**
+         * Parser options.
+         *
+         * @see [Working with Custom Parsers](https://eslint.org/docs/latest/extend/custom-parsers)
+         * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-parser-options)
+         */
+        parserOptions?: ParserOptions | undefined;
+
+        /**
+         * Which third-party plugins define additional rules, environments, configs, etc. for ESLint to use.
+         *
+         * @see [Configuring Plugins](https://eslint.org/docs/latest/use/configure/plugins-deprecated#configure-plugins)
+         */
+        plugins?: string[] | undefined;
+
+        /**
+         * Specifying processor.
+         *
+         * @see [processor](https://eslint.org/docs/latest/use/configure/plugins-deprecated#specify-a-processor)
+         */
+        processor?: string | undefined;
+
+        /**
+         * Report unused eslint-disable comments as warning.
+         *
+         * @see [Report unused eslint-disable comments](https://eslint.org/docs/latest/use/configure/rules-deprecated#report-unused-eslint-disable-comments)
+         */
+        reportUnusedDisableDirectives?: boolean | undefined;
+
+        /**
+         * Settings.
+         *
+         * @see [Settings](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated#adding-shared-settings)
+         */
+        settings?: { [name: string]: any } | undefined;
+    }
+
+    /**
+     * The overwrites that apply more differing configuration to specific files or directories.
+     */
+    interface ConfigOverride<Rules extends RulesRecord = RulesRecord> extends BaseConfig<Rules> {
+        /**
+         * The glob patterns for excluded files.
+         */
+        excludedFiles?: string | string[] | undefined;
+
+        /**
+         * The glob patterns for target files.
+         */
+        files: string | string[];
+    }
+
+    /**
+     * ESLint legacy configuration.
+     *
+     * @see [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/)
+     */
+    // https://github.com/eslint/eslint/blob/v8.57.0/conf/config-schema.js
+    interface LegacyConfig<Rules extends RulesRecord = RulesRecord, OverrideRules extends RulesRecord = Rules>
+        extends BaseConfig<Rules, OverrideRules>
+    {
+        /**
+         * Tell ESLint to ignore specific files and directories.
+         *
+         * @see [Ignore Patterns](https://eslint.org/docs/latest/use/configure/ignore-deprecated#ignorepatterns-in-config-files)
+         */
+        ignorePatterns?: string | string[] | undefined;
+
+        /**
+         * @see [Using Configuration Files](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated#using-configuration-files)
+         */
+        root?: boolean | undefined;
+    }
+
+    /**
+     * Parser options.
+     *
+     * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-parser-options)
+     */
+    interface ParserOptions {
+        /**
+         * Accepts any valid ECMAScript version number or `'latest'`:
+         *
+         * - A version: es3, es5, es6, es7, es8, es9, es10, es11, es12, es13, es14, ..., or
+         * - A year: es2015, es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, ..., or
+         * - `'latest'`
+         *
+         * When it's a version or a year, the value must be a number - so do not include the `es` prefix.
+         *
+         * Specifies the version of ECMAScript syntax you want to use. This is used by the parser to determine how to perform scope analysis, and it affects the default
+         *
+         * @default 5
+         */
+        ecmaVersion?: EcmaVersion | undefined;
+
+        /**
+         * The type of JavaScript source code. Possible values are "script" for
+         * traditional script files, "module" for ECMAScript modules (ESM), and
+         * "commonjs" for CommonJS files.
+         *
+         * @default 'script'
+         *
+         * @see https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-parser-options
+         */
+        sourceType?: SourceType | undefined;
+
+        /**
+         * An object indicating which additional language features you'd like to use.
+         *
+         * @see https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-parser-options
+         */
+        ecmaFeatures?: {
+            globalReturn?: boolean | undefined;
+            impliedStrict?: boolean | undefined;
+            jsx?: boolean | undefined;
+            experimentalObjectRestSpread?: boolean | undefined;
+            [key: string]: any;
+        } | undefined;
+        [key: string]: any;
+    }
+
+    interface LintOptions {
+        filename?: string | undefined;
+        preprocess?: ((code: string) => string[]) | undefined;
+        postprocess?: ((problemLists: LintMessage[][]) => LintMessage[]) | undefined;
+        filterCodeBlock?: boolean | undefined;
+        disableFixes?: boolean | undefined;
+        allowInlineConfig?: boolean | undefined;
+        reportUnusedDisableDirectives?: boolean | undefined;
+    }
+
+    interface LintSuggestion {
+        desc: string;
+        fix: Rule.Fix;
+        messageId?: string | undefined;
+    }
+
+    interface LintMessage {
+        column: number;
+        line: number;
+        endColumn?: number | undefined;
+        endLine?: number | undefined;
+        ruleId: string | null;
+        message: string;
+        messageId?: string | undefined;
+        nodeType?: string | undefined;
+        fatal?: true | undefined;
+        severity: Exclude<Severity, 0>;
+        fix?: Rule.Fix | undefined;
+        suggestions?: LintSuggestion[] | undefined;
+    }
+
+    interface LintSuppression {
+        kind: string;
+        justification: string;
+    }
+
+    interface SuppressedLintMessage extends LintMessage {
+        suppressions: LintSuppression[];
+    }
+
+    interface FixOptions extends LintOptions {
+        fix?: boolean | undefined;
+    }
+
+    interface FixReport {
+        fixed: boolean;
+        output: string;
+        messages: LintMessage[];
+    }
+
+    // Temporarily loosen type for just flat config files (see #68232)
+    type NonESTreeParser =
+        & Omit<ESTreeParser, "parseForESLint">
+        & ({
+            parse(text: string, options?: any): unknown;
+        } | {
+            parseForESLint(text: string, options?: any): Omit<ESLintParseResult, "ast" | "scopeManager"> & {
+                ast: unknown;
+                scopeManager?: unknown;
+            };
+        });
+
+    type ESTreeParser =
+        & ESLint.ObjectMetaProperties
+        & (
+            | { parse(text: string, options?: any): AST.Program }
+            | { parseForESLint(text: string, options?: any): ESLintParseResult }
+        );
+
+    type Parser = NonESTreeParser | ESTreeParser;
+
+    interface ESLintParseResult {
+        ast: AST.Program;
+        parserServices?: SourceCode.ParserServices | undefined;
+        scopeManager?: Scope.ScopeManager | undefined;
+        visitorKeys?: SourceCode.VisitorKeys | undefined;
+    }
+
+    interface ProcessorFile {
+        text: string;
+        filename: string;
+    }
+
+    // https://eslint.org/docs/latest/extend/plugins#processors-in-plugins
+    interface Processor<T extends string | ProcessorFile = string | ProcessorFile> extends ESLint.ObjectMetaProperties {
+        supportsAutofix?: boolean | undefined;
+        preprocess?(text: string, filename: string): T[];
+        postprocess?(messages: LintMessage[][], filename: string): LintMessage[];
+    }
+
+    interface Config<Rules extends RulesRecord = RulesRecord> {
+        /**
+         * An string to identify the configuration object. Used in error messages and
+         * inspection tools.
+         */
+        name?: string;
+
+        /**
+         * An array of glob patterns indicating the files that the configuration
+         * object should apply to. If not specified, the configuration object applies
+         * to all files
+         */
+        files?: Array<string | string[]>;
+
+        /**
+         * An array of glob patterns indicating the files that the configuration
+         * object should not apply to. If not specified, the configuration object
+         * applies to all files matched by files
+         */
+        ignores?: string[];
+
+        /**
+         * An object containing settings related to how JavaScript is configured for
+         * linting.
+         */
+        languageOptions?: LanguageOptions;
+
+        /**
+         * An object containing settings related to the linting process
+         */
+        linterOptions?: LinterOptions;
+
+        /**
+         * Either an object containing preprocess() and postprocess() methods or a
+         * string indicating the name of a processor inside of a plugin
+         * (i.e., "pluginName/processorName").
+         */
+        processor?: string | Processor;
+
+        /**
+         * An object containing a name-value mapping of plugin names to plugin objects.
+         * When files is specified, these plugins are only available to the matching files.
+         */
+        plugins?: Record<string, ESLint.Plugin>;
+
+        /**
+         * An object containing the configured rules. When files or ignores are specified,
+         * these rule configurations are only available to the matching files.
+         */
+        rules?: Partial<Rules>;
+
+        /**
+         * An object containing name-value pairs of information that should be
+         * available to all rules.
+         */
+        settings?: Record<string, unknown>;
+    }
+
+    /** @deprecated  Use `Config` instead of `FlatConfig` */
+    type FlatConfig = Config;
+
+    type GlobalConf = boolean | "off" | "readable" | "readonly" | "writable" | "writeable";
+
+    interface Globals {
+        [name: string]: GlobalConf;
+    }
+
+    interface LanguageOptions {
+        /**
+         * The version of ECMAScript to support. May be any year (i.e., 2022) or
+         * version (i.e., 5). Set to "latest" for the most recent supported version.
+         * @default "latest"
+         */
+        ecmaVersion?: EcmaVersion | undefined;
+
+        /**
+         * The type of JavaScript source code. Possible values are "script" for
+         * traditional script files, "module" for ECMAScript modules (ESM), and
+         * "commonjs" for CommonJS files. (default: "module" for .js and .mjs
+         * files; "commonjs" for .cjs files)
+         */
+        sourceType?: SourceType | undefined;
+
+        /**
+         * An object specifying additional objects that should be added to the
+         * global scope during linting.
+         */
+        globals?: Globals | undefined;
+
+        /**
+         * An object containing a parse() or parseForESLint() method.
+         * If not configured, the default ESLint parser (Espree) will be used.
+         */
+        parser?: Parser | undefined;
+
+        /**
+         * An object specifying additional options that are passed directly to the
+         * parser() method on the parser. The available options are parser-dependent
+         */
+        parserOptions?: Linter.ParserOptions | undefined;
+    }
+
+    interface LinterOptions {
+        /**
+         * A boolean value indicating if inline configuration is allowed.
+         */
+        noInlineConfig?: boolean;
+
+        /**
+         * A severity value indicating if and how unused disable directives should be
+         * tracked and reported.
+         */
+        reportUnusedDisableDirectives?: Severity | StringSeverity | boolean;
+    }
+
+    interface Stats {
+        /**
+         * The number of times ESLint has applied at least one fix after linting.
+         */
+        fixPasses: number;
+
+        /**
+         * The times spent on (parsing, fixing, linting) a file, where the linting refers to the timing information for each rule.
+         */
+        times: { passes: TimePass[] };
+    }
+
+    interface TimePass {
+        parse: { total: number };
+        rules?: Record<string, { total: number }>;
+        fix: { total: number };
+        total: number;
+    }
+}
+
+// #endregion
+
+// #region ESLint
+
+export class ESLint {
+    static configType: "flat";
+
+    static readonly version: string;
+
+    static outputFixes(results: ESLint.LintResult[]): Promise<void>;
+
+    static getErrorResults(results: ESLint.LintResult[]): ESLint.LintResult[];
+
+    constructor(options?: ESLint.Options);
+
+    lintFiles(patterns: string | string[]): Promise<ESLint.LintResult[]>;
+
+    lintText(
+        code: string,
+        options?: { filePath?: string | undefined; warnIgnored?: boolean | undefined },
+    ): Promise<ESLint.LintResult[]>;
+
+    getRulesMetaForResults(results: ESLint.LintResult[]): ESLint.LintResultData["rulesMeta"];
+
+    hasFlag(flag: string): boolean;
+
+    calculateConfigForFile(filePath: string): Promise<any>;
+
+    findConfigFile(): Promise<string | undefined>;
+
+    isPathIgnored(filePath: string): Promise<boolean>;
+
+    loadFormatter(nameOrPath?: string): Promise<ESLint.Formatter>;
+}
+
+export namespace ESLint {
+    type ConfigData<Rules extends Linter.RulesRecord = Linter.RulesRecord> = Omit<
+        Linter.LegacyConfig<Rules>,
+        "$schema"
+    >;
+
+    interface Environment {
+        globals?: Linter.Globals | undefined;
+        parserOptions?: Linter.ParserOptions | undefined;
+    }
+
+    interface ObjectMetaProperties {
+        /** @deprecated Use `meta.name` instead. */
+        name?: string | undefined;
+
+        /** @deprecated Use `meta.version` instead. */
+        version?: string | undefined;
+
+        meta?: {
+            name?: string | undefined;
+            version?: string | undefined;
+        };
+    }
+
+    interface Plugin extends ObjectMetaProperties {
+        configs?: Record<string, Linter.LegacyConfig | Linter.Config | Linter.Config[]> | undefined;
+        environments?: Record<string, Environment> | undefined;
+        processors?: Record<string, Linter.Processor> | undefined;
+        rules?: Record<string, Rule.RuleModule> | undefined;
+    }
+
+    type FixType = "directive" | "problem" | "suggestion" | "layout";
+
+    type CacheStrategy = "content" | "metadata";
+
+    interface Options {
+        // File enumeration
+        cwd?: string | undefined;
+        errorOnUnmatchedPattern?: boolean | undefined;
+        globInputPaths?: boolean | undefined;
+        ignore?: boolean | undefined;
+        ignorePatterns?: string[] | null | undefined;
+        passOnNoPatterns?: boolean | undefined;
+        warnIgnored?: boolean | undefined;
+
+        // Linting
+        allowInlineConfig?: boolean | undefined;
+        baseConfig?: Linter.Config | Linter.Config[] | null | undefined;
+        overrideConfig?: Linter.Config | Linter.Config[] | null | undefined;
+        overrideConfigFile?: string | boolean | undefined;
+        plugins?: Record<string, Plugin> | null | undefined;
+        ruleFilter?: ((arg: { ruleId: string; severity: Exclude<Linter.Severity, 0> }) => boolean) | undefined;
+        stats?: boolean | undefined;
+
+        // Autofix
+        fix?: boolean | ((message: Linter.LintMessage) => boolean) | undefined;
+        fixTypes?: FixType[] | undefined;
+
+        // Cache-related
+        cache?: boolean | undefined;
+        cacheLocation?: string | undefined;
+        cacheStrategy?: CacheStrategy | undefined;
+
+        // Other Options
+        flags?: string[] | undefined;
+    }
+
+    interface LegacyOptions {
+        // File enumeration
+        cwd?: string | undefined;
+        errorOnUnmatchedPattern?: boolean | undefined;
+        extensions?: string[] | undefined;
+        globInputPaths?: boolean | undefined;
+        ignore?: boolean | undefined;
+        ignorePath?: string | undefined;
+
+        // Linting
+        allowInlineConfig?: boolean | undefined;
+        baseConfig?: Linter.LegacyConfig | undefined;
+        overrideConfig?: Linter.LegacyConfig | undefined;
+        overrideConfigFile?: string | undefined;
+        plugins?: Record<string, Plugin> | undefined;
+        reportUnusedDisableDirectives?: Linter.StringSeverity | undefined;
+        resolvePluginsRelativeTo?: string | undefined;
+        rulePaths?: string[] | undefined;
+        useEslintrc?: boolean | undefined;
+
+        // Autofix
+        fix?: boolean | ((message: Linter.LintMessage) => boolean) | undefined;
+        fixTypes?: FixType[] | undefined;
+
+        // Cache-related
+        cache?: boolean | undefined;
+        cacheLocation?: string | undefined;
+        cacheStrategy?: CacheStrategy | undefined;
+
+        // Other Options
+        flags?: string[] | undefined;
+    }
+
+    interface LintResult {
+        filePath: string;
+        messages: Linter.LintMessage[];
+        suppressedMessages: Linter.SuppressedLintMessage[];
+        errorCount: number;
+        fatalErrorCount: number;
+        warningCount: number;
+        fixableErrorCount: number;
+        fixableWarningCount: number;
+        output?: string | undefined;
+        source?: string | undefined;
+        stats?: Linter.Stats | undefined;
+        usedDeprecatedRules: DeprecatedRuleUse[];
+    }
+
+    interface LintResultData {
+        cwd: string;
+        rulesMeta: {
+            [ruleId: string]: Rule.RuleMetaData;
+        };
+    }
+
+    interface DeprecatedRuleUse {
+        ruleId: string;
+        replacedBy: string[];
+    }
+
+    interface Formatter {
+        format(results: LintResult[], data: LintResultData): string | Promise<string>;
+    }
+
+    // Docs reference the types by those name
+    type EditInfo = Rule.Fix;
+    type LoadedFormatter = Formatter;
+    type ResultsMeta = LintResultData;
+}
+
+// #endregion
+
+export function loadESLint(options: { useFlatConfig: true }): Promise<typeof ESLint>;
+export function loadESLint(options: { useFlatConfig: false }): Promise<typeof LegacyESLint>;
+export function loadESLint(
+    options?: { useFlatConfig?: boolean | undefined },
+): Promise<typeof ESLint | typeof LegacyESLint>;
+
+// #region RuleTester
+
+export class RuleTester {
+    static describe: ((...args: any) => any) | null;
+    static it: ((...args: any) => any) | null;
+    static itOnly: ((...args: any) => any) | null;
+
+    constructor(config?: Linter.Config);
+
+    run(
+        name: string,
+        rule: Rule.RuleModule,
+        tests: {
+            valid: Array<string | RuleTester.ValidTestCase>;
+            invalid: RuleTester.InvalidTestCase[];
+        },
+    ): void;
+
+    static only(
+        item: string | RuleTester.ValidTestCase | RuleTester.InvalidTestCase,
+    ): RuleTester.ValidTestCase | RuleTester.InvalidTestCase;
+}
+
+export namespace RuleTester {
+    interface ValidTestCase {
+        name?: string;
+        code: string;
+        options?: any;
+        filename?: string | undefined;
+        only?: boolean;
+        languageOptions?: Linter.LanguageOptions | undefined;
+        settings?: { [name: string]: any } | undefined;
+    }
+
+    interface SuggestionOutput {
+        messageId?: string;
+        desc?: string;
+        data?: Record<string, unknown> | undefined;
+        output: string;
+    }
+
+    interface InvalidTestCase extends ValidTestCase {
+        errors: number | Array<TestCaseError | string>;
+        output?: string | null | undefined;
+    }
+
+    interface TestCaseError {
+        message?: string | RegExp;
+        messageId?: string;
+        type?: string | undefined;
+        data?: any;
+        line?: number | undefined;
+        column?: number | undefined;
+        endLine?: number | undefined;
+        endColumn?: number | undefined;
+        suggestions?: SuggestionOutput[] | undefined;
+    }
+}
+
+// #endregion

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/package.json

@@ -0,0 +1,70 @@
+{
+    "name": "@types/eslint",
+    "version": "9.6.1",
+    "description": "TypeScript definitions for eslint",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Pierre-Marie Dartus",
+            "githubUsername": "pmdartus",
+            "url": "https://github.com/pmdartus"
+        },
+        {
+            "name": "Jed Fox",
+            "githubUsername": "j-f1",
+            "url": "https://github.com/j-f1"
+        },
+        {
+            "name": "Saad Quadri",
+            "githubUsername": "saadq",
+            "url": "https://github.com/saadq"
+        },
+        {
+            "name": "Jason Kwok",
+            "githubUsername": "JasonHK",
+            "url": "https://github.com/JasonHK"
+        },
+        {
+            "name": "Brad Zacher",
+            "githubUsername": "bradzacher",
+            "url": "https://github.com/bradzacher"
+        },
+        {
+            "name": "JounQin",
+            "githubUsername": "JounQin",
+            "url": "https://github.com/JounQin"
+        },
+        {
+            "name": "Bryan Mishkin",
+            "githubUsername": "bmish",
+            "url": "https://github.com/bmish"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./index.d.ts"
+        },
+        "./use-at-your-own-risk": {
+            "types": "./use-at-your-own-risk.d.ts"
+        },
+        "./rules": {
+            "types": "./rules/index.d.ts"
+        },
+        "./package.json": "./package.json"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/eslint"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/estree": "*",
+        "@types/json-schema": "*"
+    },
+    "typesPublisherContentHash": "bc2620143f844d291da2d199e7b8e2605e3277f1941a508dc72ac92843b149b6",
+    "typeScriptVersion": "4.8"
+}

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/rules/best-practices.d.ts

@@ -0,0 +1,1048 @@
+import { Linter } from "../index";
+
+export interface BestPractices extends Linter.RulesRecord {
+    /**
+     * Rule to enforce getter and setter pairs in objects.
+     *
+     * @since 0.22.0
+     * @see https://eslint.org/docs/rules/accessor-pairs
+     */
+    "accessor-pairs": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                setWithoutGet: boolean;
+                /**
+                 * @default false
+                 */
+                getWithoutSet: boolean;
+                /**
+                 * @default true
+                 */
+                enforceForClassMembers: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce `return` statements in callbacks of array methods.
+     *
+     * @since 2.0.0-alpha-1
+     * @see https://eslint.org/docs/rules/array-callback-return
+     */
+    "array-callback-return": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowImplicit: boolean;
+                /**
+                 * @default false
+                 */
+                checkForEach: boolean;
+                /**
+                 * @default false
+                 */
+                allowVoid: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce the use of variables within the scope they are defined.
+     *
+     * @since 0.1.0
+     * @see https://eslint.org/docs/rules/block-scoped-var
+     */
+    "block-scoped-var": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to enforce that class methods utilize `this`.
+     *
+     * @since 3.4.0
+     * @see https://eslint.org/docs/rules/class-methods-use-this
+     */
+    "class-methods-use-this": Linter.RuleEntry<
+        [
+            Partial<{
+                exceptMethods: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce a maximum cyclomatic complexity allowed in a program.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/complexity
+     */
+    complexity: Linter.RuleEntry<
+        [
+            | Partial<{
+                /**
+                 * @default 20
+                 */
+                max: number;
+                /**
+                 * @deprecated
+                 * @default 20
+                 */
+                maximum: number;
+            }>
+            | number,
+        ]
+    >;
+
+    /**
+     * Rule to require `return` statements to either always or never specify values.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/consistent-return
+     */
+    "consistent-return": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                treatUndefinedAsUnspecified: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent brace style for all control statements.
+     *
+     * @since 0.0.2
+     * @see https://eslint.org/docs/rules/curly
+     */
+    curly: Linter.RuleEntry<["all" | "multi" | "multi-line" | "multi-or-nest" | "consistent"]>;
+
+    /**
+     * Rule to require `default` cases in `switch` statements.
+     *
+     * @since 0.6.0
+     * @see https://eslint.org/docs/rules/default-case
+     */
+    "default-case": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default '^no default$'
+                 */
+                commentPattern: string;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce default clauses in switch statements to be last
+     *
+     * @since 7.0.0
+     * @see https://eslint.org/docs/latest/rules/default-case-last
+     */
+    "default-case-last": Linter.RuleEntry<[]>;
+
+    /**
+     * Enforce default parameters to be last
+     *
+     * @since 6.4.0
+     * @see https://eslint.org/docs/latest/rules/default-param-last
+     */
+    "default-param-last": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to enforce consistent newlines before and after dots.
+     *
+     * @since 0.21.0
+     * @see https://eslint.org/docs/rules/dot-location
+     */
+    "dot-location": Linter.RuleEntry<["object" | "property"]>;
+
+    /**
+     * Rule to enforce dot notation whenever possible.
+     *
+     * @since 0.0.7
+     * @see https://eslint.org/docs/rules/dot-notation
+     */
+    "dot-notation": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                allowKeywords: boolean;
+                allowPattern: string;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require the use of `===` and `!==`.
+     *
+     * @since 0.0.2
+     * @see https://eslint.org/docs/rules/eqeqeq
+     */
+    eqeqeq:
+        | Linter.RuleEntry<
+            [
+                "always",
+                Partial<{
+                    /**
+                     * @default 'always'
+                     */
+                    null: "always" | "never" | "ignore";
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<["smart" | "allow-null"]>;
+
+    /**
+     * Require grouped accessor pairs in object literals and classes.
+     *
+     * @since 6.7.0
+     * @see https://eslint.org/docs/latest/rules/grouped-accessor-pairs
+     */
+    "grouped-accessor-pairs": Linter.RuleEntry<["anyOrder" | "getBeforeSet" | "setBeforeGet"]>;
+
+    /**
+     * Rule to require `for-in` loops to include an `if` statement.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/guard-for-in
+     */
+    "guard-for-in": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to enforce a maximum number of classes per file.
+     *
+     * @since 5.0.0-alpha.3
+     * @see https://eslint.org/docs/rules/max-classes-per-file
+     */
+    "max-classes-per-file": Linter.RuleEntry<[number]>;
+
+    /**
+     * Rule to disallow the use of `alert`, `confirm`, and `prompt`.
+     *
+     * @since 0.0.5
+     * @see https://eslint.org/docs/rules/no-alert
+     */
+    "no-alert": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of `arguments.caller` or `arguments.callee`.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/no-caller
+     */
+    "no-caller": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow lexical declarations in case clauses.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 1.9.0
+     * @see https://eslint.org/docs/rules/no-case-declarations
+     */
+    "no-case-declarations": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow division operators explicitly at the beginning of regular expressions.
+     *
+     * @since 0.1.0
+     * @see https://eslint.org/docs/rules/no-div-regex
+     */
+    "no-div-regex": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `else` blocks after `return` statements in `if` statements.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-else-return
+     */
+    "no-else-return": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                allowElseIf: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow empty functions.
+     *
+     * @since 2.0.0
+     * @see https://eslint.org/docs/rules/no-empty-function
+     */
+    "no-empty-function": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default []
+                 */
+                allow: Array<
+                    | "functions"
+                    | "arrowFunctions"
+                    | "generatorFunctions"
+                    | "methods"
+                    | "generatorMethods"
+                    | "getters"
+                    | "setters"
+                    | "constructors"
+                >;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow empty destructuring patterns.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 1.7.0
+     * @see https://eslint.org/docs/rules/no-empty-pattern
+     */
+    "no-empty-pattern": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `null` comparisons without type-checking operators.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-eq-null
+     */
+    "no-eq-null": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of `eval()`.
+     *
+     * @since 0.0.2
+     * @see https://eslint.org/docs/rules/no-eval
+     */
+    "no-eval": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowIndirect: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow extending native types.
+     *
+     * @since 0.1.4
+     * @see https://eslint.org/docs/rules/no-extend-native
+     */
+    "no-extend-native": Linter.RuleEntry<
+        [
+            Partial<{
+                exceptions: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow unnecessary calls to `.bind()`.
+     *
+     * @since 0.8.0
+     * @see https://eslint.org/docs/rules/no-extra-bind
+     */
+    "no-extra-bind": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary labels.
+     *
+     * @since 2.0.0-rc.0
+     * @see https://eslint.org/docs/rules/no-extra-label
+     */
+    "no-extra-label": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow fallthrough of `case` statements.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.7
+     * @see https://eslint.org/docs/rules/no-fallthrough
+     */
+    "no-fallthrough": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default 'falls?\s?through'
+                 */
+                commentPattern: string;
+                /**
+                 * @default false
+                 */
+                allowEmptyCase: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow leading or trailing decimal points in numeric literals.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/no-floating-decimal
+     */
+    "no-floating-decimal": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow assignments to native objects or read-only global variables.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 3.3.0
+     * @see https://eslint.org/docs/rules/no-global-assign
+     */
+    "no-global-assign": Linter.RuleEntry<
+        [
+            Partial<{
+                exceptions: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow shorthand type conversions.
+     *
+     * @since 1.0.0-rc-2
+     * @see https://eslint.org/docs/rules/no-implicit-coercion
+     */
+    "no-implicit-coercion": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                boolean: boolean;
+                /**
+                 * @default true
+                 */
+                number: boolean;
+                /**
+                 * @default true
+                 */
+                string: boolean;
+                /**
+                 * @default false
+                 */
+                disallowTemplateShorthand: boolean;
+                /**
+                 * @default []
+                 */
+                allow: Array<"~" | "!!" | "+" | "*">;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow variable and `function` declarations in the global scope.
+     *
+     * @since 2.0.0-alpha-1
+     * @see https://eslint.org/docs/rules/no-implicit-globals
+     */
+    "no-implicit-globals": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of `eval()`-like methods.
+     *
+     * @since 0.0.7
+     * @see https://eslint.org/docs/rules/no-implied-eval
+     */
+    "no-implied-eval": Linter.RuleEntry<[]>;
+
+    /**
+     * Disallow assigning to imported bindings.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 6.4.0
+     * @see https://eslint.org/docs/latest/rules/no-import-assign
+     */
+    "no-import-assign": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `this` keywords outside of classes or class-like objects.
+     *
+     * @since 1.0.0-rc-2
+     * @see https://eslint.org/docs/rules/no-invalid-this
+     */
+    "no-invalid-this": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                capIsConstructor: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow the use of the `__iterator__` property.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-iterator
+     */
+    "no-iterator": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow labeled statements.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-labels
+     */
+    "no-labels": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowLoop: boolean;
+                /**
+                 * @default false
+                 */
+                allowSwitch: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow unnecessary nested blocks.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-lone-blocks
+     */
+    "no-lone-blocks": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow function declarations that contain unsafe references inside loop statements.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-loop-func
+     */
+    "no-loop-func": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow magic numbers.
+     *
+     * @since 1.7.0
+     * @see https://eslint.org/docs/rules/no-magic-numbers
+     */
+    "no-magic-numbers": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default []
+                 */
+                ignore: number[];
+                /**
+                 * @default false
+                 */
+                ignoreArrayIndexes: boolean;
+                /**
+                 * @default false
+                 */
+                enforceConst: boolean;
+                /**
+                 * @default false
+                 */
+                detectObjects: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow multiple spaces.
+     *
+     * @since 0.9.0
+     * @see https://eslint.org/docs/rules/no-multi-spaces
+     */
+    "no-multi-spaces": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                ignoreEOLComments: boolean;
+                /**
+                 * @default { Property: true }
+                 */
+                exceptions: Record<string, boolean>;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow multiline strings.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-multi-str
+     */
+    "no-multi-str": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `new` operators outside of assignments or comparisons.
+     *
+     * @since 0.0.7
+     * @see https://eslint.org/docs/rules/no-new
+     */
+    "no-new": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `new` operators with the `Function` object.
+     *
+     * @since 0.0.7
+     * @see https://eslint.org/docs/rules/no-new-func
+     */
+    "no-new-func": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `new` operators with the `String`, `Number`, and `Boolean` objects.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/no-new-wrappers
+     */
+    "no-new-wrappers": Linter.RuleEntry<[]>;
+
+    /**
+     * Disallow `\\8` and `\\9` escape sequences in string literals.
+     *
+     * @since 7.14.0
+     * @see https://eslint.org/docs/rules/no-nonoctal-decimal-escape
+     */
+    "no-nonoctal-decimal-escape": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow octal literals.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/no-octal
+     */
+    "no-octal": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow octal escape sequences in string literals.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-octal-escape
+     */
+    "no-octal-escape": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow reassigning `function` parameters.
+     *
+     * @since 0.18.0
+     * @see https://eslint.org/docs/rules/no-param-reassign
+     */
+    "no-param-reassign": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                props: boolean;
+                /**
+                 * @default []
+                 */
+                ignorePropertyModificationsFor: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow the use of the `__proto__` property.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-proto
+     */
+    "no-proto": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow variable redeclaration.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-redeclare
+     */
+    "no-redeclare": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                builtinGlobals: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow certain properties on certain objects.
+     *
+     * @since 3.5.0
+     * @see https://eslint.org/docs/rules/no-restricted-properties
+     */
+    "no-restricted-properties": Linter.RuleEntry<
+        [
+            ...Array<
+                | {
+                    object: string;
+                    property?: string | undefined;
+                    message?: string | undefined;
+                }
+                | {
+                    property: string;
+                    message?: string | undefined;
+                }
+            >,
+        ]
+    >;
+
+    /**
+     * Rule to disallow assignment operators in `return` statements.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-return-assign
+     */
+    "no-return-assign": Linter.RuleEntry<["except-parens" | "always"]>;
+
+    /**
+     * Rule to disallow unnecessary `return await`.
+     *
+     * @since 3.10.0
+     * @see https://eslint.org/docs/rules/no-return-await
+     */
+    "no-return-await": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `javascript:` urls.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-script-url
+     */
+    "no-script-url": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow assignments where both sides are exactly the same.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 2.0.0-rc.0
+     * @see https://eslint.org/docs/rules/no-self-assign
+     */
+    "no-self-assign": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow comparisons where both sides are exactly the same.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-self-compare
+     */
+    "no-self-compare": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow comma operators.
+     *
+     * @since 0.5.1
+     * @see https://eslint.org/docs/rules/no-sequences
+     */
+    "no-sequences": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow throwing literals as exceptions.
+     *
+     * @since 0.15.0
+     * @see https://eslint.org/docs/rules/no-throw-literal
+     */
+    "no-throw-literal": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unmodified loop conditions.
+     *
+     * @since 2.0.0-alpha-2
+     * @see https://eslint.org/docs/rules/no-unmodified-loop-condition
+     */
+    "no-unmodified-loop-condition": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unused expressions.
+     *
+     * @since 0.1.0
+     * @see https://eslint.org/docs/rules/no-unused-expressions
+     */
+    "no-unused-expressions": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowShortCircuit: boolean;
+                /**
+                 * @default false
+                 */
+                allowTernary: boolean;
+                /**
+                 * @default false
+                 */
+                allowTaggedTemplates: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow unused labels.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 2.0.0-rc.0
+     * @see https://eslint.org/docs/rules/no-unused-labels
+     */
+    "no-unused-labels": Linter.RuleEntry<[]>;
+
+    /**
+     * Disallow useless backreferences in regular expressions
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 7.0.0-alpha.0
+     * @see https://eslint.org/docs/latest/rules/no-useless-backreference
+     */
+    "no-useless-backreference": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary calls to `.call()` and `.apply()`.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/no-useless-call
+     */
+    "no-useless-call": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary `catch` clauses.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 5.11.0
+     * @see https://eslint.org/docs/rules/no-useless-catch
+     */
+    "no-useless-catch": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary concatenation of literals or template literals.
+     *
+     * @since 1.3.0
+     * @see https://eslint.org/docs/rules/no-useless-concat
+     */
+    "no-useless-concat": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary escape characters.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 2.5.0
+     * @see https://eslint.org/docs/rules/no-useless-escape
+     */
+    "no-useless-escape": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow redundant return statements.
+     *
+     * @since 3.9.0
+     * @see https://eslint.org/docs/rules/no-useless-return
+     */
+    "no-useless-return": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `void` operators.
+     *
+     * @since 0.8.0
+     * @see https://eslint.org/docs/rules/no-void
+     */
+    "no-void": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowAsStatement: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow specified warning terms in comments.
+     *
+     * @since 0.4.4
+     * @see https://eslint.org/docs/rules/no-warning-comments
+     */
+    "no-warning-comments": Linter.RuleEntry<
+        [
+            {
+                /**
+                 * @default ["todo", "fixme", "xxx"]
+                 */
+                terms: string[];
+                /**
+                 * @default 'start'
+                 */
+                location: "start" | "anywhere";
+            },
+        ]
+    >;
+
+    /**
+     * Rule to disallow `with` statements.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.2
+     * @see https://eslint.org/docs/rules/no-with
+     */
+    "no-with": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to enforce using named capture group in regular expression.
+     *
+     * @since 5.15.0
+     * @see https://eslint.org/docs/rules/prefer-named-capture-group
+     */
+    "prefer-named-capture-group": Linter.RuleEntry<[]>;
+
+    /**
+     * Disallow use of `Object.prototype.hasOwnProperty.call()` and prefer use of `Object.hasOwn()`.
+     *
+     * @since 3.5.0
+     * @see https://eslint.org/docs/rules/prefer-object-has-own
+     */
+    "prefer-object-has-own": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require using Error objects as Promise rejection reasons.
+     *
+     * @since 3.14.0
+     * @see https://eslint.org/docs/rules/prefer-promise-reject-errors
+     */
+    "prefer-promise-reject-errors": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowEmptyReject: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Disallow use of the `RegExp` constructor in favor of regular expression literals.
+     *
+     * @since 6.4.0
+     * @see https://eslint.org/docs/latest/rules/prefer-regex-literals
+     */
+    "prefer-regex-literals": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                disallowRedundantWrapping: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce the consistent use of the radix argument when using `parseInt()`.
+     *
+     * @since 0.0.7
+     * @see https://eslint.org/docs/rules/radix
+     */
+    radix: Linter.RuleEntry<["always" | "as-needed"]>;
+
+    /**
+     * Rule to disallow async functions which have no `await` expression.
+     *
+     * @since 3.11.0
+     * @see https://eslint.org/docs/rules/require-await
+     */
+    "require-await": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to enforce the use of `u` flag on RegExp.
+     *
+     * @since 5.3.0
+     * @see https://eslint.org/docs/rules/require-unicode-regexp
+     */
+    "require-unicode-regexp": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require `var` declarations be placed at the top of their containing scope.
+     *
+     * @since 0.8.0
+     * @see https://eslint.org/docs/rules/vars-on-top
+     */
+    "vars-on-top": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require parentheses around immediate `function` invocations.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/wrap-iife
+     */
+    "wrap-iife": Linter.RuleEntry<
+        [
+            "outside" | "inside" | "any",
+            Partial<{
+                /**
+                 * @default false
+                 */
+                functionPrototypeMethods: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require or disallow “Yoda” conditions.
+     *
+     * @since 0.7.1
+     * @see https://eslint.org/docs/rules/yoda
+     */
+    yoda:
+        | Linter.RuleEntry<
+            [
+                "never",
+                Partial<{
+                    exceptRange: boolean;
+                    onlyEquality: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<["always"]>;
+}

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/rules/deprecated.d.ts

@@ -0,0 +1,267 @@
+import { Linter } from "../index";
+
+export interface Deprecated extends Linter.RulesRecord {
+    /**
+     * Rule to enforce consistent indentation.
+     *
+     * @since 4.0.0-alpha.0
+     * @deprecated since 4.0.0, use [`indent`](https://eslint.org/docs/rules/indent) instead.
+     * @see https://eslint.org/docs/rules/indent-legacy
+     */
+    "indent-legacy": Linter.RuleEntry<
+        [
+            number | "tab",
+            Partial<{
+                /**
+                 * @default 0
+                 */
+                SwitchCase: number;
+                /**
+                 * @default 1
+                 */
+                VariableDeclarator:
+                    | Partial<{
+                        /**
+                         * @default 1
+                         */
+                        var: number | "first";
+                        /**
+                         * @default 1
+                         */
+                        let: number | "first";
+                        /**
+                         * @default 1
+                         */
+                        const: number | "first";
+                    }>
+                    | number
+                    | "first";
+                /**
+                 * @default 1
+                 */
+                outerIIFEBody: number;
+                /**
+                 * @default 1
+                 */
+                MemberExpression: number | "off";
+                /**
+                 * @default { parameters: 1, body: 1 }
+                 */
+                FunctionDeclaration: Partial<{
+                    /**
+                     * @default 1
+                     */
+                    parameters: number | "first" | "off";
+                    /**
+                     * @default 1
+                     */
+                    body: number;
+                }>;
+                /**
+                 * @default { parameters: 1, body: 1 }
+                 */
+                FunctionExpression: Partial<{
+                    /**
+                     * @default 1
+                     */
+                    parameters: number | "first" | "off";
+                    /**
+                     * @default 1
+                     */
+                    body: number;
+                }>;
+                /**
+                 * @default { arguments: 1 }
+                 */
+                CallExpression: Partial<{
+                    /**
+                     * @default 1
+                     */
+                    arguments: number | "first" | "off";
+                }>;
+                /**
+                 * @default 1
+                 */
+                ArrayExpression: number | "first" | "off";
+                /**
+                 * @default 1
+                 */
+                ObjectExpression: number | "first" | "off";
+                /**
+                 * @default 1
+                 */
+                ImportDeclaration: number | "first" | "off";
+                /**
+                 * @default false
+                 */
+                flatTernaryExpressions: boolean;
+                ignoredNodes: string[];
+                /**
+                 * @default false
+                 */
+                ignoreComments: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require or disallow newlines around directives.
+     *
+     * @since 3.5.0
+     * @deprecated since 4.0.0, use [`padding-line-between-statements`](https://eslint.org/docs/rules/padding-line-between-statements) instead.
+     * @see https://eslint.org/docs/rules/lines-around-directive
+     */
+    "lines-around-directive": Linter.RuleEntry<["always" | "never"]>;
+
+    /**
+     * Rule to require or disallow an empty line after variable declarations.
+     *
+     * @since 0.18.0
+     * @deprecated since 4.0.0, use [`padding-line-between-statements`](https://eslint.org/docs/rules/padding-line-between-statements) instead.
+     * @see https://eslint.org/docs/rules/newline-after-var
+     */
+    "newline-after-var": Linter.RuleEntry<["always" | "never"]>;
+
+    /**
+     * Rule to require an empty line before `return` statements.
+     *
+     * @since 2.3.0
+     * @deprecated since 4.0.0, use [`padding-line-between-statements`](https://eslint.org/docs/rules/padding-line-between-statements) instead.
+     * @see https://eslint.org/docs/rules/newline-before-return
+     */
+    "newline-before-return": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow shadowing of variables inside of `catch`.
+     *
+     * @since 0.0.9
+     * @deprecated since 5.1.0, use [`no-shadow`](https://eslint.org/docs/rules/no-shadow) instead.
+     * @see https://eslint.org/docs/rules/no-catch-shadow
+     */
+    "no-catch-shadow": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow reassignment of native objects.
+     *
+     * @since 0.0.9
+     * @deprecated since 3.3.0, use [`no-global-assign`](https://eslint.org/docs/rules/no-global-assign) instead.
+     * @see https://eslint.org/docs/rules/no-native-reassign
+     */
+    "no-native-reassign": Linter.RuleEntry<
+        [
+            Partial<{
+                exceptions: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow negating the left operand in `in` expressions.
+     *
+     * @since 0.1.2
+     * @deprecated since 3.3.0, use [`no-unsafe-negation`](https://eslint.org/docs/rules/no-unsafe-negation) instead.
+     * @see https://eslint.org/docs/rules/no-negated-in-lhs
+     */
+    "no-negated-in-lhs": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow spacing between function identifiers and their applications.
+     *
+     * @since 0.1.2
+     * @deprecated since 3.3.0, use [`func-call-spacing`](https://eslint.org/docs/rules/func-call-spacing) instead.
+     * @see https://eslint.org/docs/rules/no-spaced-func
+     */
+    "no-spaced-func": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to suggest using `Reflect` methods where applicable.
+     *
+     * @since 1.0.0-rc-2
+     * @deprecated since 3.9.0
+     * @see https://eslint.org/docs/rules/prefer-reflect
+     */
+    "prefer-reflect": Linter.RuleEntry<
+        [
+            Partial<{
+                exceptions: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require JSDoc comments.
+     *
+     * @since 1.4.0
+     * @deprecated since 5.10.0
+     * @see https://eslint.org/docs/rules/require-jsdoc
+     */
+    "require-jsdoc": Linter.RuleEntry<
+        [
+            Partial<{
+                require: Partial<{
+                    /**
+                     * @default true
+                     */
+                    FunctionDeclaration: boolean;
+                    /**
+                     * @default false
+                     */
+                    MethodDefinition: boolean;
+                    /**
+                     * @default false
+                     */
+                    ClassDeclaration: boolean;
+                    /**
+                     * @default false
+                     */
+                    ArrowFunctionExpression: boolean;
+                    /**
+                     * @default false
+                     */
+                    FunctionExpression: boolean;
+                }>;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce valid JSDoc comments.
+     *
+     * @since 0.4.0
+     * @deprecated since 5.10.0
+     * @see https://eslint.org/docs/rules/valid-jsdoc
+     */
+    "valid-jsdoc": Linter.RuleEntry<
+        [
+            Partial<{
+                prefer: Record<string, string>;
+                preferType: Record<string, string>;
+                /**
+                 * @default true
+                 */
+                requireReturn: boolean;
+                /**
+                 * @default true
+                 */
+                requireReturnType: boolean;
+                /**
+                 * @remarks
+                 * Also accept for regular expression pattern
+                 */
+                matchDescription: string;
+                /**
+                 * @default true
+                 */
+                requireParamDescription: boolean;
+                /**
+                 * @default true
+                 */
+                requireReturnDescription: boolean;
+                /**
+                 * @default true
+                 */
+                requireParamType: boolean;
+            }>,
+        ]
+    >;
+}

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/rules/ecmascript-6.d.ts

@@ -0,0 +1,534 @@
+import { Linter } from "../index";
+
+export interface ECMAScript6 extends Linter.RulesRecord {
+    /**
+     * Rule to require braces around arrow function bodies.
+     *
+     * @since 1.8.0
+     * @see https://eslint.org/docs/rules/arrow-body-style
+     */
+    "arrow-body-style":
+        | Linter.RuleEntry<
+            [
+                "as-needed",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    requireReturnForObjectLiteral: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<["always" | "never"]>;
+
+    /**
+     * Rule to require parentheses around arrow function arguments.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/arrow-parens
+     */
+    "arrow-parens":
+        | Linter.RuleEntry<["always"]>
+        | Linter.RuleEntry<
+            [
+                "as-needed",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    requireForBlockBody: boolean;
+                }>,
+            ]
+        >;
+
+    /**
+     * Rule to enforce consistent spacing before and after the arrow in arrow functions.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/arrow-spacing
+     */
+    "arrow-spacing": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require `super()` calls in constructors.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.24.0
+     * @see https://eslint.org/docs/rules/constructor-super
+     */
+    "constructor-super": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to enforce consistent spacing around `*` operators in generator functions.
+     *
+     * @since 0.17.0
+     * @see https://eslint.org/docs/rules/generator-star-spacing
+     */
+    "generator-star-spacing": Linter.RuleEntry<
+        [
+            | Partial<{
+                before: boolean;
+                after: boolean;
+                named:
+                    | Partial<{
+                        before: boolean;
+                        after: boolean;
+                    }>
+                    | "before"
+                    | "after"
+                    | "both"
+                    | "neither";
+                anonymous:
+                    | Partial<{
+                        before: boolean;
+                        after: boolean;
+                    }>
+                    | "before"
+                    | "after"
+                    | "both"
+                    | "neither";
+                method:
+                    | Partial<{
+                        before: boolean;
+                        after: boolean;
+                    }>
+                    | "before"
+                    | "after"
+                    | "both"
+                    | "neither";
+            }>
+            | "before"
+            | "after"
+            | "both"
+            | "neither",
+        ]
+    >;
+
+    /**
+     * Require or disallow logical assignment operator shorthand.
+     *
+     * @since 8.24.0
+     * @see https://eslint.org/docs/rules/logical-assignment-operators
+     */
+    "logical-assignment-operators":
+        | Linter.RuleEntry<
+            [
+                "always",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    enforceForIfStatements: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<["never"]>;
+
+    /**
+     * Rule to disallow reassigning class members.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/no-class-assign
+     */
+    "no-class-assign": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow arrow functions where they could be confused with comparisons.
+     *
+     * @since 2.0.0-alpha-2
+     * @see https://eslint.org/docs/rules/no-confusing-arrow
+     */
+    "no-confusing-arrow": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                allowParens: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow reassigning `const` variables.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/no-const-assign
+     */
+    "no-const-assign": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow duplicate class members.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 1.2.0
+     * @see https://eslint.org/docs/rules/no-dupe-class-members
+     */
+    "no-dupe-class-members": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow duplicate module imports.
+     *
+     * @since 2.5.0
+     * @see https://eslint.org/docs/rules/no-duplicate-imports
+     */
+    "no-duplicate-imports": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                includeExports: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow `new` operators with the `Symbol` object.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 2.0.0-beta.1
+     * @see https://eslint.org/docs/rules/no-new-symbol
+     */
+    "no-new-symbol": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow specified modules when loaded by `import`.
+     *
+     * @since 2.0.0-alpha-1
+     * @see https://eslint.org/docs/rules/no-restricted-imports
+     */
+    "no-restricted-imports": Linter.RuleEntry<
+        [
+            ...Array<
+                | string
+                | {
+                    name: string;
+                    importNames?: string[] | undefined;
+                    message?: string | undefined;
+                }
+                | Partial<{
+                    paths: Array<
+                        | string
+                        | {
+                            name: string;
+                            importNames?: string[] | undefined;
+                            message?: string | undefined;
+                        }
+                    >;
+                    patterns: string[];
+                }>
+            >,
+        ]
+    >;
+
+    /**
+     * Rule to disallow `this`/`super` before calling `super()` in constructors.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.24.0
+     * @see https://eslint.org/docs/rules/no-this-before-super
+     */
+    "no-this-before-super": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary computed property keys in object literals.
+     *
+     * @since 2.9.0
+     * @see https://eslint.org/docs/rules/no-useless-computed-key
+     */
+    "no-useless-computed-key": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary constructors.
+     *
+     * @since 2.0.0-beta.1
+     * @see https://eslint.org/docs/rules/no-useless-constructor
+     */
+    "no-useless-constructor": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow renaming import, export, and destructured assignments to the same name.
+     *
+     * @since 2.11.0
+     * @see https://eslint.org/docs/rules/no-useless-rename
+     */
+    "no-useless-rename": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                ignoreImport: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreExport: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreDestructuring: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require `let` or `const` instead of `var`.
+     *
+     * @since 0.12.0
+     * @see https://eslint.org/docs/rules/no-var
+     */
+    "no-var": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require or disallow method and property shorthand syntax for object literals.
+     *
+     * @since 0.20.0
+     * @see https://eslint.org/docs/rules/object-shorthand
+     */
+    "object-shorthand":
+        | Linter.RuleEntry<
+            [
+                "always" | "methods",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    avoidQuotes: boolean;
+                    /**
+                     * @default false
+                     */
+                    ignoreConstructors: boolean;
+                    /**
+                     * @default false
+                     */
+                    avoidExplicitReturnArrows: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<
+            [
+                "properties",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    avoidQuotes: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<["never" | "consistent" | "consistent-as-needed"]>;
+
+    /**
+     * Rule to require using arrow functions for callbacks.
+     *
+     * @since 1.2.0
+     * @see https://eslint.org/docs/rules/prefer-arrow-callback
+     */
+    "prefer-arrow-callback": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowNamedFunctions: boolean;
+                /**
+                 * @default true
+                 */
+                allowUnboundThis: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require `const` declarations for variables that are never reassigned after declared.
+     *
+     * @since 0.23.0
+     * @see https://eslint.org/docs/rules/prefer-const
+     */
+    "prefer-const": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default 'any'
+                 */
+                destructuring: "any" | "all";
+                /**
+                 * @default false
+                 */
+                ignoreReadBeforeAssign: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require destructuring from arrays and/or objects.
+     *
+     * @since 3.13.0
+     * @see https://eslint.org/docs/rules/prefer-destructuring
+     */
+    "prefer-destructuring": Linter.RuleEntry<
+        [
+            Partial<
+                | {
+                    VariableDeclarator: Partial<{
+                        array: boolean;
+                        object: boolean;
+                    }>;
+                    AssignmentExpression: Partial<{
+                        array: boolean;
+                        object: boolean;
+                    }>;
+                }
+                | {
+                    array: boolean;
+                    object: boolean;
+                }
+            >,
+            Partial<{
+                enforceForRenamedProperties: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Disallow the use of `Math.pow` in favor of the `**` operator.
+     *
+     * @since 6.7.0
+     * @see https://eslint.org/docs/latest/rules/prefer-exponentiation-operator
+     */
+    "prefer-exponentiation-operator": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals.
+     *
+     * @since 3.5.0
+     * @see https://eslint.org/docs/rules/prefer-numeric-literals
+     */
+    "prefer-numeric-literals": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require rest parameters instead of `arguments`.
+     *
+     * @since 2.0.0-alpha-1
+     * @see https://eslint.org/docs/rules/prefer-rest-params
+     */
+    "prefer-rest-params": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require spread operators instead of `.apply()`.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/prefer-spread
+     */
+    "prefer-spread": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require template literals instead of string concatenation.
+     *
+     * @since 1.2.0
+     * @see https://eslint.org/docs/rules/prefer-template
+     */
+    "prefer-template": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require generator functions to contain `yield`.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/require-yield
+     */
+    "require-yield": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to enforce spacing between rest and spread operators and their expressions.
+     *
+     * @since 2.12.0
+     * @see https://eslint.org/docs/rules/rest-spread-spacing
+     */
+    "rest-spread-spacing": Linter.RuleEntry<["never" | "always"]>;
+
+    /**
+     * Rule to enforce sorted import declarations within modules.
+     *
+     * @since 2.0.0-beta.1
+     * @see https://eslint.org/docs/rules/sort-imports
+     */
+    "sort-imports": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                ignoreCase: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreDeclarationSort: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreMemberSort: boolean;
+                /**
+                 * @default ['none', 'all', 'multiple', 'single']
+                 */
+                memberSyntaxSortOrder: Array<"none" | "all" | "multiple" | "single">;
+                /**
+                 * @default false
+                 */
+                allowSeparatedGroups: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require symbol descriptions.
+     *
+     * @since 3.4.0
+     * @see https://eslint.org/docs/rules/symbol-description
+     */
+    "symbol-description": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require or disallow spacing around embedded expressions of template strings.
+     *
+     * @since 2.0.0-rc.0
+     * @see https://eslint.org/docs/rules/template-curly-spacing
+     */
+    "template-curly-spacing": Linter.RuleEntry<["never" | "always"]>;
+
+    /**
+     * Rule to require or disallow spacing around the `*` in `yield*` expressions.
+     *
+     * @since 2.0.0-alpha-1
+     * @see https://eslint.org/docs/rules/yield-star-spacing
+     */
+    "yield-star-spacing": Linter.RuleEntry<
+        [
+            | Partial<{
+                before: boolean;
+                after: boolean;
+            }>
+            | "before"
+            | "after"
+            | "both"
+            | "neither",
+        ]
+    >;
+}

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/rules/index.d.ts

@@ -0,0 +1,23 @@
+import { Linter } from "../index";
+
+import { BestPractices } from "./best-practices";
+import { Deprecated } from "./deprecated";
+import { ECMAScript6 } from "./ecmascript-6";
+import { NodeJSAndCommonJS } from "./node-commonjs";
+import { PossibleErrors } from "./possible-errors";
+import { StrictMode } from "./strict-mode";
+import { StylisticIssues } from "./stylistic-issues";
+import { Variables } from "./variables";
+
+export interface ESLintRules
+    extends
+        Linter.RulesRecord,
+        PossibleErrors,
+        BestPractices,
+        StrictMode,
+        Variables,
+        NodeJSAndCommonJS,
+        StylisticIssues,
+        ECMAScript6,
+        Deprecated
+{}

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/rules/node-commonjs.d.ts

@@ -0,0 +1,133 @@
+import { Linter } from "../index";
+
+export interface NodeJSAndCommonJS extends Linter.RulesRecord {
+    /**
+     * Rule to require `return` statements after callbacks.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/callback-return
+     */
+    "callback-return": Linter.RuleEntry<[string[]]>;
+
+    /**
+     * Rule to require `require()` calls to be placed at top-level module scope.
+     *
+     * @since 1.4.0
+     * @see https://eslint.org/docs/rules/global-require
+     */
+    "global-require": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require error handling in callbacks.
+     *
+     * @since 0.4.5
+     * @see https://eslint.org/docs/rules/handle-callback-err
+     */
+    "handle-callback-err": Linter.RuleEntry<[string]>;
+
+    /**
+     * Rule to disallow use of the `Buffer()` constructor.
+     *
+     * @since 4.0.0-alpha.0
+     * @see https://eslint.org/docs/rules/no-buffer-constructor
+     */
+    "no-buffer-constructor": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `require` calls to be mixed with regular variable declarations.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-mixed-requires
+     */
+    "no-mixed-requires": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                grouping: boolean;
+                /**
+                 * @default false
+                 */
+                allowCall: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow `new` operators with calls to `require`.
+     *
+     * @since 0.6.0
+     * @see https://eslint.org/docs/rules/no-new-require
+     */
+    "no-new-require": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow string concatenation when using `__dirname` and `__filename`.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-path-concat
+     */
+    "no-path-concat": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of `process.env`.
+     *
+     * @since 0.9.0
+     * @see https://eslint.org/docs/rules/no-process-env
+     */
+    "no-process-env": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of `process.exit()`.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-process-exit
+     */
+    "no-process-exit": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow specified modules when loaded by `require`.
+     *
+     * @since 0.6.0
+     * @see https://eslint.org/docs/rules/no-restricted-modules
+     */
+    "no-restricted-modules": Linter.RuleEntry<
+        [
+            ...Array<
+                | string
+                | {
+                    name: string;
+                    message?: string | undefined;
+                }
+                | Partial<{
+                    paths: Array<
+                        | string
+                        | {
+                            name: string;
+                            message?: string | undefined;
+                        }
+                    >;
+                    patterns: string[];
+                }>
+            >,
+        ]
+    >;
+
+    /**
+     * Rule to disallow synchronous methods.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-sync
+     */
+    "no-sync": Linter.RuleEntry<
+        [
+            {
+                /**
+                 * @default false
+                 */
+                allowAtRootLevel: boolean;
+            },
+        ]
+    >;
+}

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/rules/possible-errors.d.ts

@@ -0,0 +1,571 @@
+import { Linter } from "../index";
+
+export interface PossibleErrors extends Linter.RulesRecord {
+    /**
+     * Rule to enforce `for` loop update clause moving the counter in the right direction.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 4.0.0-beta.0
+     * @see https://eslint.org/docs/rules/for-direction
+     */
+    "for-direction": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to enforce `return` statements in getters.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 4.2.0
+     * @see https://eslint.org/docs/rules/getter-return
+     */
+    "getter-return": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowImplicit: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow using an async function as a `Promise` executor.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 5.3.0
+     * @see https://eslint.org/docs/rules/no-async-promise-executor
+     */
+    "no-async-promise-executor": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `await` inside of loops.
+     *
+     * @since 3.12.0
+     * @see https://eslint.org/docs/rules/no-await-in-loop
+     */
+    "no-await-in-loop": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow comparing against `-0`.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 3.17.0
+     * @see https://eslint.org/docs/rules/no-compare-neg-zero
+     */
+    "no-compare-neg-zero": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow assignment operators in conditional statements.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-cond-assign
+     */
+    "no-cond-assign": Linter.RuleEntry<["except-parens" | "always"]>;
+
+    /**
+     * Rule to disallow the use of `console`.
+     *
+     * @since 0.0.2
+     * @see https://eslint.org/docs/rules/no-console
+     */
+    "no-console": Linter.RuleEntry<
+        [
+            Partial<{
+                allow: Array<keyof Console>;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow constant expressions in conditions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.4.1
+     * @see https://eslint.org/docs/rules/no-constant-condition
+     */
+    "no-constant-condition": Linter.RuleEntry<
+        [
+            {
+                /**
+                 * @default true
+                 */
+                checkLoops: boolean;
+            },
+        ]
+    >;
+
+    /**
+     * Rule to disallow control characters in regular expressions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.1.0
+     * @see https://eslint.org/docs/rules/no-control-regex
+     */
+    "no-control-regex": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of `debugger`.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.2
+     * @see https://eslint.org/docs/rules/no-debugger
+     */
+    "no-debugger": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow duplicate arguments in `function` definitions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.16.0
+     * @see https://eslint.org/docs/rules/no-dupe-args
+     */
+    "no-dupe-args": Linter.RuleEntry<[]>;
+
+    /**
+     * Disallow duplicate conditions in if-else-if chains.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 6.7.0
+     * @see https://eslint.org/docs/rules/no-dupe-else-if
+     */
+    "no-dupe-else-if": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow duplicate keys in object literals.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-dupe-keys
+     */
+    "no-dupe-keys": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow a duplicate case label.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.17.0
+     * @see https://eslint.org/docs/rules/no-duplicate-case
+     */
+    "no-duplicate-case": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow empty block statements.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.2
+     * @see https://eslint.org/docs/rules/no-empty
+     */
+    "no-empty": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowEmptyCatch: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow empty character classes in regular expressions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.22.0
+     * @see https://eslint.org/docs/rules/no-empty-character-class
+     */
+    "no-empty-character-class": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow reassigning exceptions in `catch` clauses.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-ex-assign
+     */
+    "no-ex-assign": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary boolean casts.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-extra-boolean-cast
+     */
+    "no-extra-boolean-cast": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary parentheses.
+     *
+     * @since 0.1.4
+     * @see https://eslint.org/docs/rules/no-extra-parens
+     */
+    "no-extra-parens":
+        | Linter.RuleEntry<
+            [
+                "all",
+                Partial<{
+                    /**
+                     * @default true,
+                     */
+                    conditionalAssign: boolean;
+                    /**
+                     * @default true
+                     */
+                    returnAssign: boolean;
+                    /**
+                     * @default true
+                     */
+                    nestedBinaryExpressions: boolean;
+                    /**
+                     * @default 'none'
+                     */
+                    ignoreJSX: "none" | "all" | "multi-line" | "single-line";
+                    /**
+                     * @default true
+                     */
+                    enforceForArrowConditionals: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<["functions"]>;
+
+    /**
+     * Rule to disallow unnecessary semicolons.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-extra-semi
+     */
+    "no-extra-semi": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow reassigning `function` declarations.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-func-assign
+     */
+    "no-func-assign": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow variable or `function` declarations in nested blocks.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.6.0
+     * @see https://eslint.org/docs/rules/no-inner-declarations
+     */
+    "no-inner-declarations": Linter.RuleEntry<["functions" | "both"]>;
+
+    /**
+     * Rule to disallow invalid regular expression strings in `RegExp` constructors.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.1.4
+     * @see https://eslint.org/docs/rules/no-invalid-regexp
+     */
+    "no-invalid-regexp": Linter.RuleEntry<
+        [
+            Partial<{
+                allowConstructorFlags: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow irregular whitespace.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.9.0
+     * @see https://eslint.org/docs/rules/no-irregular-whitespace
+     */
+    "no-irregular-whitespace": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                skipStrings: boolean;
+                /**
+                 * @default false
+                 */
+                skipComments: boolean;
+                /**
+                 * @default false
+                 */
+                skipRegExps: boolean;
+                /**
+                 * @default false
+                 */
+                skipTemplates: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Disallow literal numbers that lose precision.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 7.1.0
+     * @see https://eslint.org/docs/latest/rules/no-loss-of-precision
+     */
+    "no-loss-of-precision": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow characters which are made with multiple code points in character class syntax.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 5.3.0
+     * @see https://eslint.org/docs/rules/no-misleading-character-class
+     */
+    "no-misleading-character-class": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow calling global object properties as functions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-obj-calls
+     */
+    "no-obj-calls": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow returning values from Promise executor functions.
+     *
+     * @since 7.3.0
+     * @see https://eslint.org/docs/rules/no-promise-executor-return
+     */
+    "no-promise-executor-return": Linter.RuleEntry<[
+        {
+            /**
+             * @default false
+             */
+            allowVoid?: boolean;
+        },
+    ]>;
+
+    /**
+     * Rule to disallow use of `Object.prototypes` builtins directly.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 2.11.0
+     * @see https://eslint.org/docs/rules/no-prototype-builtins
+     */
+    "no-prototype-builtins": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow multiple spaces in regular expressions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-regex-spaces
+     */
+    "no-regex-spaces": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow sparse arrays.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-sparse-arrays
+     */
+    "no-sparse-arrays": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow template literal placeholder syntax in regular strings.
+     *
+     * @since 3.3.0
+     * @see https://eslint.org/docs/rules/no-template-curly-in-string
+     */
+    "no-template-curly-in-string": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow confusing multiline expressions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.24.0
+     * @see https://eslint.org/docs/rules/no-unexpected-multiline
+     */
+    "no-unexpected-multiline": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unreachable code after `return`, `throw`, `continue`, and `break` statements.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/no-unreachable
+     */
+    "no-unreachable": Linter.RuleEntry<[]>;
+
+    /**
+     * Disallow loops with a body that allows only one iteration.
+     *
+     * @since 7.3.0
+     * @see https://eslint.org/docs/latest/rules/no-unreachable-loop
+     */
+    "no-unreachable-loop": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default []
+                 */
+                ignore: "WhileStatement" | "DoWhileStatement" | "ForStatement" | "ForInStatement" | "ForOfStatement";
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow control flow statements in `finally` blocks.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 2.9.0
+     * @see https://eslint.org/docs/rules/no-unsafe-finally
+     */
+    "no-unsafe-finally": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow negating the left operand of relational operators.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 3.3.0
+     * @see https://eslint.org/docs/rules/no-unsafe-negation
+     */
+    "no-unsafe-negation": Linter.RuleEntry<[]>;
+
+    /**
+     * Disallow use of optional chaining in contexts where the `undefined` value is not allowed.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 7.15.0
+     * @see https://eslint.org/docs/rules/no-unsafe-optional-chaining
+     */
+    "no-unsafe-optional-chaining": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                disallowArithmeticOperators: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow assignments that can lead to race conditions due to usage of `await` or `yield`.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 5.3.0
+     * @see https://eslint.org/docs/rules/require-atomic-updates
+     */
+    "require-atomic-updates": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require calls to `isNaN()` when checking for `NaN`.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/use-isnan
+     */
+    "use-isnan": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                enforceForSwitchCase: boolean;
+                /**
+                 * @default true
+                 */
+                enforceForIndexOf: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce comparing `typeof` expressions against valid strings.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.5.0
+     * @see https://eslint.org/docs/rules/valid-typeof
+     */
+    "valid-typeof": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                requireStringLiterals: boolean;
+            }>,
+        ]
+    >;
+}

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/rules/strict-mode.d.ts

@@ -0,0 +1,11 @@
+import { Linter } from "../index";
+
+export interface StrictMode extends Linter.RulesRecord {
+    /**
+     * Rule to require or disallow strict mode directives.
+     *
+     * @since 0.1.0
+     * @see https://eslint.org/docs/rules/strict
+     */
+    strict: Linter.RuleEntry<["safe" | "global" | "function" | "never"]>;
+}

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/rules/stylistic-issues.d.ts

@@ -0,0 +1,1905 @@
+import { Linter } from "../index";
+
+export interface StylisticIssues extends Linter.RulesRecord {
+    /**
+     * Rule to enforce linebreaks after opening and before closing array brackets.
+     *
+     * @since 4.0.0-alpha.1
+     * @see https://eslint.org/docs/rules/array-bracket-newline
+     */
+    "array-bracket-newline": Linter.RuleEntry<
+        [
+            | "always"
+            | "never"
+            | "consistent"
+            | Partial<{
+                /**
+                 * @default true
+                 */
+                multiline: boolean;
+                /**
+                 * @default null
+                 */
+                minItems: number | null;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent spacing inside array brackets.
+     *
+     * @since 0.24.0
+     * @see https://eslint.org/docs/rules/array-bracket-spacing
+     */
+    "array-bracket-spacing":
+        | Linter.RuleEntry<
+            [
+                "never",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    singleValue: boolean;
+                    /**
+                     * @default false
+                     */
+                    objectsInArrays: boolean;
+                    /**
+                     * @default false
+                     */
+                    arraysInArrays: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<
+            [
+                "always",
+                Partial<{
+                    /**
+                     * @default true
+                     */
+                    singleValue: boolean;
+                    /**
+                     * @default true
+                     */
+                    objectsInArrays: boolean;
+                    /**
+                     * @default true
+                     */
+                    arraysInArrays: boolean;
+                }>,
+            ]
+        >;
+
+    /**
+     * Rule to enforce line breaks after each array element.
+     *
+     * @since 4.0.0-rc.0
+     * @see https://eslint.org/docs/rules/array-element-newline
+     */
+    "array-element-newline": Linter.RuleEntry<
+        [
+            | "always"
+            | "never"
+            | "consistent"
+            | Partial<{
+                /**
+                 * @default true
+                 */
+                multiline: boolean;
+                /**
+                 * @default null
+                 */
+                minItems: number | null;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow or enforce spaces inside of blocks after opening block and before closing block.
+     *
+     * @since 1.2.0
+     * @see https://eslint.org/docs/rules/block-spacing
+     */
+    "block-spacing": Linter.RuleEntry<["always" | "never"]>;
+
+    /**
+     * Rule to enforce consistent brace style for blocks.
+     *
+     * @since 0.0.7
+     * @see https://eslint.org/docs/rules/brace-style
+     */
+    "brace-style": Linter.RuleEntry<
+        [
+            "1tbs" | "stroustrup" | "allman",
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowSingleLine: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce camelcase naming convention.
+     *
+     * @since 0.0.2
+     * @see https://eslint.org/docs/rules/camelcase
+     */
+    camelcase: Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default 'always'
+                 */
+                properties: "always" | "never";
+                /**
+                 * @default false
+                 */
+                ignoreDestructuring: boolean;
+                /**
+                 * @remarks
+                 * Also accept for regular expression patterns
+                 */
+                allow: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce or disallow capitalization of the first letter of a comment.
+     *
+     * @since 3.11.0
+     * @see https://eslint.org/docs/rules/capitalized-comments
+     */
+    "capitalized-comments": Linter.RuleEntry<
+        [
+            "always" | "never",
+            Partial<{
+                ignorePattern: string;
+                /**
+                 * @default false
+                 */
+                ignoreInlineComments: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreConsecutiveComments: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require or disallow trailing commas.
+     *
+     * @since 0.16.0
+     * @see https://eslint.org/docs/rules/comma-dangle
+     */
+    "comma-dangle": Linter.RuleEntry<
+        [
+            | "never"
+            | "always"
+            | "always-multiline"
+            | "only-multiline"
+            | Partial<{
+                /**
+                 * @default 'never'
+                 */
+                arrays: "never" | "always" | "always-multiline" | "only-multiline";
+                /**
+                 * @default 'never'
+                 */
+                objects: "never" | "always" | "always-multiline" | "only-multiline";
+                /**
+                 * @default 'never'
+                 */
+                imports: "never" | "always" | "always-multiline" | "only-multiline";
+                /**
+                 * @default 'never'
+                 */
+                exports: "never" | "always" | "always-multiline" | "only-multiline";
+                /**
+                 * @default 'never'
+                 */
+                functions: "never" | "always" | "always-multiline" | "only-multiline";
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent spacing before and after commas.
+     *
+     * @since 0.9.0
+     * @see https://eslint.org/docs/rules/comma-spacing
+     */
+    "comma-spacing": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                before: boolean;
+                /**
+                 * @default true
+                 */
+                after: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent comma style.
+     *
+     * @since 0.9.0
+     * @see https://eslint.org/docs/rules/comma-style
+     */
+    "comma-style": Linter.RuleEntry<
+        [
+            "last" | "first",
+            Partial<{
+                exceptions: Record<string, boolean>;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent spacing inside computed property brackets.
+     *
+     * @since 0.23.0
+     * @see https://eslint.org/docs/rules/computed-property-spacing
+     */
+    "computed-property-spacing": Linter.RuleEntry<["never" | "always"]>;
+
+    /**
+     * Rule to enforce consistent naming when capturing the current execution context.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/consistent-this
+     */
+    "consistent-this": Linter.RuleEntry<[...string[]]>;
+
+    /**
+     * Rule to require or disallow newline at the end of files.
+     *
+     * @since 0.7.1
+     * @see https://eslint.org/docs/rules/eol-last
+     */
+    "eol-last": Linter.RuleEntry<
+        [
+            "always" | "never", // | 'unix' | 'windows'
+        ]
+    >;
+
+    /**
+     * Rule to require or disallow spacing between function identifiers and their invocations.
+     *
+     * @since 3.3.0
+     * @see https://eslint.org/docs/rules/func-call-spacing
+     */
+    "func-call-spacing": Linter.RuleEntry<["never" | "always"]>;
+
+    /**
+     * Rule to require function names to match the name of the variable or property to which they are assigned.
+     *
+     * @since 3.8.0
+     * @see https://eslint.org/docs/rules/func-name-matching
+     */
+    "func-name-matching":
+        | Linter.RuleEntry<
+            [
+                "always" | "never",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    considerPropertyDescriptor: boolean;
+                    /**
+                     * @default false
+                     */
+                    includeCommonJSModuleExports: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<
+            [
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    considerPropertyDescriptor: boolean;
+                    /**
+                     * @default false
+                     */
+                    includeCommonJSModuleExports: boolean;
+                }>,
+            ]
+        >;
+
+    /**
+     * Rule to require or disallow named `function` expressions.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/func-names
+     */
+    "func-names": Linter.RuleEntry<
+        [
+            "always" | "as-needed" | "never",
+            Partial<{
+                generators: "always" | "as-needed" | "never";
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce the consistent use of either `function` declarations or expressions.
+     *
+     * @since 0.2.0
+     * @see https://eslint.org/docs/rules/func-style
+     */
+    "func-style": Linter.RuleEntry<
+        [
+            "expression" | "declaration",
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowArrowFunctions: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent line breaks inside function parentheses.
+     *
+     * @since 4.6.0
+     * @see https://eslint.org/docs/rules/function-paren-newline
+     */
+    "function-paren-newline": Linter.RuleEntry<
+        [
+            | "always"
+            | "never"
+            | "multiline"
+            | "multiline-arguments"
+            | "consistent"
+            | Partial<{
+                minItems: number;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow specified identifiers.
+     *
+     * @since 2.0.0-beta.2
+     * @see https://eslint.org/docs/rules/id-blacklist
+     */
+    "id-blacklist": Linter.RuleEntry<[...string[]]>;
+
+    /**
+     * Rule to enforce minimum and maximum identifier lengths.
+     *
+     * @since 1.0.0
+     * @see https://eslint.org/docs/rules/id-length
+     */
+    "id-length": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default 2
+                 */
+                min: number;
+                /**
+                 * @default Infinity
+                 */
+                max: number;
+                /**
+                 * @default 'always'
+                 */
+                properties: "always" | "never";
+                exceptions: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require identifiers to match a specified regular expression.
+     *
+     * @since 1.0.0
+     * @see https://eslint.org/docs/rules/id-match
+     */
+    "id-match": Linter.RuleEntry<
+        [
+            string,
+            Partial<{
+                /**
+                 * @default false
+                 */
+                properties: boolean;
+                /**
+                 * @default false
+                 */
+                onlyDeclarations: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreDestructuring: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce the location of arrow function bodies.
+     *
+     * @since 4.12.0
+     * @see https://eslint.org/docs/rules/implicit-arrow-linebreak
+     */
+    "implicit-arrow-linebreak": Linter.RuleEntry<["beside" | "below"]>;
+
+    /**
+     * Rule to enforce consistent indentation.
+     *
+     * @since 0.14.0
+     * @see https://eslint.org/docs/rules/indent
+     */
+    indent: Linter.RuleEntry<
+        [
+            number | "tab",
+            Partial<{
+                /**
+                 * @default 0
+                 */
+                SwitchCase: number;
+                /**
+                 * @default 1
+                 */
+                VariableDeclarator:
+                    | Partial<{
+                        /**
+                         * @default 1
+                         */
+                        var: number | "first";
+                        /**
+                         * @default 1
+                         */
+                        let: number | "first";
+                        /**
+                         * @default 1
+                         */
+                        const: number | "first";
+                    }>
+                    | number
+                    | "first";
+                /**
+                 * @default 1
+                 */
+                outerIIFEBody: number;
+                /**
+                 * @default 1
+                 */
+                MemberExpression: number | "off";
+                /**
+                 * @default { parameters: 1, body: 1 }
+                 */
+                FunctionDeclaration: Partial<{
+                    /**
+                     * @default 1
+                     */
+                    parameters: number | "first" | "off";
+                    /**
+                     * @default 1
+                     */
+                    body: number;
+                }>;
+                /**
+                 * @default { parameters: 1, body: 1 }
+                 */
+                FunctionExpression: Partial<{
+                    /**
+                     * @default 1
+                     */
+                    parameters: number | "first" | "off";
+                    /**
+                     * @default 1
+                     */
+                    body: number;
+                }>;
+                /**
+                 * @default { arguments: 1 }
+                 */
+                CallExpression: Partial<{
+                    /**
+                     * @default 1
+                     */
+                    arguments: number | "first" | "off";
+                }>;
+                /**
+                 * @default 1
+                 */
+                ArrayExpression: number | "first" | "off";
+                /**
+                 * @default 1
+                 */
+                ObjectExpression: number | "first" | "off";
+                /**
+                 * @default 1
+                 */
+                ImportDeclaration: number | "first" | "off";
+                /**
+                 * @default false
+                 */
+                flatTernaryExpressions: boolean;
+                ignoredNodes: string[];
+                /**
+                 * @default false
+                 */
+                ignoreComments: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce the consistent use of either double or single quotes in JSX attributes.
+     *
+     * @since 1.4.0
+     * @see https://eslint.org/docs/rules/jsx-quotes
+     */
+    "jsx-quotes": Linter.RuleEntry<["prefer-double" | "prefer-single"]>;
+
+    /**
+     * Rule to enforce consistent spacing between keys and values in object literal properties.
+     *
+     * @since 0.9.0
+     * @see https://eslint.org/docs/rules/key-spacing
+     */
+    "key-spacing": Linter.RuleEntry<
+        [
+            | Partial<
+                | {
+                    /**
+                     * @default false
+                     */
+                    beforeColon: boolean;
+                    /**
+                     * @default true
+                     */
+                    afterColon: boolean;
+                    /**
+                     * @default 'strict'
+                     */
+                    mode: "strict" | "minimum";
+                    align:
+                        | Partial<{
+                            /**
+                             * @default false
+                             */
+                            beforeColon: boolean;
+                            /**
+                             * @default true
+                             */
+                            afterColon: boolean;
+                            /**
+                             * @default 'colon'
+                             */
+                            on: "value" | "colon";
+                            /**
+                             * @default 'strict'
+                             */
+                            mode: "strict" | "minimum";
+                        }>
+                        | "value"
+                        | "colon";
+                }
+                | {
+                    singleLine?:
+                        | Partial<{
+                            /**
+                             * @default false
+                             */
+                            beforeColon: boolean;
+                            /**
+                             * @default true
+                             */
+                            afterColon: boolean;
+                            /**
+                             * @default 'strict'
+                             */
+                            mode: "strict" | "minimum";
+                        }>
+                        | undefined;
+                    multiLine?:
+                        | Partial<{
+                            /**
+                             * @default false
+                             */
+                            beforeColon: boolean;
+                            /**
+                             * @default true
+                             */
+                            afterColon: boolean;
+                            /**
+                             * @default 'strict'
+                             */
+                            mode: "strict" | "minimum";
+                            align:
+                                | Partial<{
+                                    /**
+                                     * @default false
+                                     */
+                                    beforeColon: boolean;
+                                    /**
+                                     * @default true
+                                     */
+                                    afterColon: boolean;
+                                    /**
+                                     * @default 'colon'
+                                     */
+                                    on: "value" | "colon";
+                                    /**
+                                     * @default 'strict'
+                                     */
+                                    mode: "strict" | "minimum";
+                                }>
+                                | "value"
+                                | "colon";
+                        }>
+                        | undefined;
+                }
+            >
+            | {
+                align: Partial<{
+                    /**
+                     * @default false
+                     */
+                    beforeColon: boolean;
+                    /**
+                     * @default true
+                     */
+                    afterColon: boolean;
+                    /**
+                     * @default 'colon'
+                     */
+                    on: "value" | "colon";
+                    /**
+                     * @default 'strict'
+                     */
+                    mode: "strict" | "minimum";
+                }>;
+                singleLine?:
+                    | Partial<{
+                        /**
+                         * @default false
+                         */
+                        beforeColon: boolean;
+                        /**
+                         * @default true
+                         */
+                        afterColon: boolean;
+                        /**
+                         * @default 'strict'
+                         */
+                        mode: "strict" | "minimum";
+                    }>
+                    | undefined;
+                multiLine?:
+                    | Partial<{
+                        /**
+                         * @default false
+                         */
+                        beforeColon: boolean;
+                        /**
+                         * @default true
+                         */
+                        afterColon: boolean;
+                        /**
+                         * @default 'strict'
+                         */
+                        mode: "strict" | "minimum";
+                    }>
+                    | undefined;
+            },
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent spacing before and after keywords.
+     *
+     * @since 2.0.0-beta.1
+     * @see https://eslint.org/docs/rules/keyword-spacing
+     */
+    "keyword-spacing": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                before: boolean;
+                /**
+                 * @default true
+                 */
+                after: boolean;
+                overrides: Record<
+                    string,
+                    Partial<{
+                        before: boolean;
+                        after: boolean;
+                    }>
+                >;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce position of line comments.
+     *
+     * @since 3.5.0
+     * @see https://eslint.org/docs/rules/line-comment-position
+     */
+    "line-comment-position": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default 'above'
+                 */
+                position: "above" | "beside";
+                ignorePattern: string;
+                /**
+                 * @default true
+                 */
+                applyDefaultIgnorePatterns: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent linebreak style.
+     *
+     * @since 0.21.0
+     * @see https://eslint.org/docs/rules/linebreak-style
+     */
+    "linebreak-style": Linter.RuleEntry<["unix" | "windows"]>;
+
+    /**
+     * Rule to require empty lines around comments.
+     *
+     * @since 0.22.0
+     * @see https://eslint.org/docs/rules/lines-around-comment
+     */
+    "lines-around-comment": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                beforeBlockComment: boolean;
+                /**
+                 * @default false
+                 */
+                afterBlockComment: boolean;
+                /**
+                 * @default false
+                 */
+                beforeLineComment: boolean;
+                /**
+                 * @default false
+                 */
+                afterLineComment: boolean;
+                /**
+                 * @default false
+                 */
+                allowBlockStart: boolean;
+                /**
+                 * @default false
+                 */
+                allowBlockEnd: boolean;
+                /**
+                 * @default false
+                 */
+                allowObjectStart: boolean;
+                /**
+                 * @default false
+                 */
+                allowObjectEnd: boolean;
+                /**
+                 * @default false
+                 */
+                allowArrayStart: boolean;
+                /**
+                 * @default false
+                 */
+                allowArrayEnd: boolean;
+                /**
+                 * @default false
+                 */
+                allowClassStart: boolean;
+                /**
+                 * @default false
+                 */
+                allowClassEnd: boolean;
+                ignorePattern: string;
+                /**
+                 * @default true
+                 */
+                applyDefaultIgnorePatterns: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require or disallow an empty line between class members.
+     *
+     * @since 4.9.0
+     * @see https://eslint.org/docs/rules/lines-between-class-members
+     */
+    "lines-between-class-members": Linter.RuleEntry<
+        [
+            "always" | "never",
+            Partial<{
+                /**
+                 * @default false
+                 */
+                exceptAfterSingleLine: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce a maximum depth that blocks can be nested.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/max-depth
+     */
+    "max-depth": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default 4
+                 */
+                max: number;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce a maximum line length.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/max-len
+     */
+    "max-len": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default 80
+                 */
+                code: number;
+                /**
+                 * @default 4
+                 */
+                tabWidth: number;
+                comments: number;
+                ignorePattern: string;
+                /**
+                 * @default false
+                 */
+                ignoreComments: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreTrailingComments: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreUrls: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreStrings: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreTemplateLiterals: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreRegExpLiterals: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce a maximum number of lines per file.
+     *
+     * @since 2.12.0
+     * @see https://eslint.org/docs/rules/max-lines
+     */
+    "max-lines": Linter.RuleEntry<
+        [
+            | Partial<{
+                /**
+                 * @default 300
+                 */
+                max: number;
+                /**
+                 * @default false
+                 */
+                skipBlankLines: boolean;
+                /**
+                 * @default false
+                 */
+                skipComments: boolean;
+            }>
+            | number,
+        ]
+    >;
+
+    /**
+     * Rule to enforce a maximum number of line of code in a function.
+     *
+     * @since 5.0.0
+     * @see https://eslint.org/docs/rules/max-lines-per-function
+     */
+    "max-lines-per-function": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default 50
+                 */
+                max: number;
+                /**
+                 * @default false
+                 */
+                skipBlankLines: boolean;
+                /**
+                 * @default false
+                 */
+                skipComments: boolean;
+                /**
+                 * @default false
+                 */
+                IIFEs: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce a maximum depth that callbacks can be nested.
+     *
+     * @since 0.2.0
+     * @see https://eslint.org/docs/rules/max-nested-callbacks
+     */
+    "max-nested-callbacks": Linter.RuleEntry<
+        [
+            | Partial<{
+                /**
+                 * @default 10
+                 */
+                max: number;
+            }>
+            | number,
+        ]
+    >;
+
+    /**
+     * Rule to enforce a maximum number of parameters in function definitions.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/max-params
+     */
+    "max-params": Linter.RuleEntry<
+        [
+            | Partial<{
+                /**
+                 * @default 3
+                 */
+                max: number;
+            }>
+            | number,
+        ]
+    >;
+
+    /**
+     * Rule to enforce a maximum number of statements allowed in function blocks.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/max-statements
+     */
+    "max-statements": Linter.RuleEntry<
+        [
+            | Partial<{
+                /**
+                 * @default 10
+                 */
+                max: number;
+                /**
+                 * @default false
+                 */
+                ignoreTopLevelFunctions: boolean;
+            }>
+            | number,
+        ]
+    >;
+
+    /**
+     * Rule to enforce a maximum number of statements allowed per line.
+     *
+     * @since 2.5.0
+     * @see https://eslint.org/docs/rules/max-statements-per-line
+     */
+    "max-statements-per-line": Linter.RuleEntry<
+        [
+            | Partial<{
+                /**
+                 * @default 1
+                 */
+                max: number;
+            }>
+            | number,
+        ]
+    >;
+
+    /**
+     * Rule to enforce a particular style for multiline comments.
+     *
+     * @since 4.10.0
+     * @see https://eslint.org/docs/rules/multiline-comment-style
+     */
+    "multiline-comment-style": Linter.RuleEntry<["starred-block" | "bare-block" | "separate-lines"]>;
+
+    /**
+     * Rule to enforce newlines between operands of ternary expressions.
+     *
+     * @since 3.1.0
+     * @see https://eslint.org/docs/rules/multiline-ternary
+     */
+    "multiline-ternary": Linter.RuleEntry<["always" | "always-multiline" | "never"]>;
+
+    /**
+     * Rule to require constructor names to begin with a capital letter.
+     *
+     * @since 0.0.3-0
+     * @see https://eslint.org/docs/rules/new-cap
+     */
+    "new-cap": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                newIsCap: boolean;
+                /**
+                 * @default true
+                 */
+                capIsNew: boolean;
+                newIsCapExceptions: string[];
+                newIsCapExceptionPattern: string;
+                capIsNewExceptions: string[];
+                capIsNewExceptionPattern: string;
+                /**
+                 * @default true
+                 */
+                properties: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce or disallow parentheses when invoking a constructor with no arguments.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/new-parens
+     */
+    "new-parens": Linter.RuleEntry<["always" | "never"]>;
+
+    /**
+     * Rule to require a newline after each call in a method chain.
+     *
+     * @since 2.0.0-rc.0
+     * @see https://eslint.org/docs/rules/newline-per-chained-call
+     */
+    "newline-per-chained-call": Linter.RuleEntry<
+        [
+            {
+                /**
+                 * @default 2
+                 */
+                ignoreChainWithDepth: number;
+            },
+        ]
+    >;
+
+    /**
+     * Rule to disallow `Array` constructors.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-array-constructor
+     */
+    "no-array-constructor": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow bitwise operators.
+     *
+     * @since 0.0.2
+     * @see https://eslint.org/docs/rules/no-bitwise
+     */
+    "no-bitwise": Linter.RuleEntry<
+        [
+            Partial<{
+                allow: string[];
+                /**
+                 * @default false
+                 */
+                int32Hint: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow `continue` statements.
+     *
+     * @since 0.19.0
+     * @see https://eslint.org/docs/rules/no-continue
+     */
+    "no-continue": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow inline comments after code.
+     *
+     * @since 0.10.0
+     * @see https://eslint.org/docs/rules/no-inline-comments
+     */
+    "no-inline-comments": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `if` statements as the only statement in `else` blocks.
+     *
+     * @since 0.6.0
+     * @see https://eslint.org/docs/rules/no-lonely-if
+     */
+    "no-lonely-if": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow mixed binary operators.
+     *
+     * @since 2.12.0
+     * @see https://eslint.org/docs/rules/no-mixed-operators
+     */
+    "no-mixed-operators": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default
+                 * [
+                 *     ["+", "-", "*", "/", "%", "**"],
+                 *     ["&", "|", "^", "~", "<<", ">>", ">>>"],
+                 *     ["==", "!=", "===", "!==", ">", ">=", "<", "<="],
+                 *     ["&&", "||"],
+                 *     ["in", "instanceof"]
+                 * ]
+                 */
+                groups: string[][];
+                /**
+                 * @default true
+                 */
+                allowSamePrecedence: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow mixed spaces and tabs for indentation.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.7.1
+     * @see https://eslint.org/docs/rules/no-mixed-spaces-and-tabs
+     */
+    "no-mixed-spaces-and-tabs": Linter.RuleEntry<["smart-tabs"]>;
+
+    /**
+     * Rule to disallow use of chained assignment expressions.
+     *
+     * @since 3.14.0
+     * @see https://eslint.org/docs/rules/no-multi-assign
+     */
+    "no-multi-assign": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow multiple empty lines.
+     *
+     * @since 0.9.0
+     * @see https://eslint.org/docs/rules/no-multiple-empty-lines
+     */
+    "no-multiple-empty-lines": Linter.RuleEntry<
+        [
+            | Partial<{
+                /**
+                 * @default 2
+                 */
+                max: number;
+                maxEOF: number;
+                maxBOF: number;
+            }>
+            | number,
+        ]
+    >;
+
+    /**
+     * Rule to disallow negated conditions.
+     *
+     * @since 1.6.0
+     * @see https://eslint.org/docs/rules/no-negated-condition
+     */
+    "no-negated-condition": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow nested ternary expressions.
+     *
+     * @since 0.2.0
+     * @see https://eslint.org/docs/rules/no-nested-ternary
+     */
+    "no-nested-ternary": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `Object` constructors.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-new-object
+     */
+    "no-new-object": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the unary operators `++` and `--`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-plusplus
+     */
+    "no-plusplus": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowForLoopAfterthoughts: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow specified syntax.
+     *
+     * @since 1.4.0
+     * @see https://eslint.org/docs/rules/no-restricted-syntax
+     */
+    "no-restricted-syntax": Linter.RuleEntry<
+        [
+            ...Array<
+                | string
+                | {
+                    selector: string;
+                    message?: string | undefined;
+                }
+            >,
+        ]
+    >;
+
+    /**
+     * Rule to disallow all tabs.
+     *
+     * @since 3.2.0
+     * @see https://eslint.org/docs/rules/no-tabs
+     */
+    "no-tabs": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowIndentationTabs: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow ternary operators.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-ternary
+     */
+    "no-ternary": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow trailing whitespace at the end of lines.
+     *
+     * @since 0.7.1
+     * @see https://eslint.org/docs/rules/no-trailing-spaces
+     */
+    "no-trailing-spaces": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                skipBlankLines: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreComments: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow dangling underscores in identifiers.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-underscore-dangle
+     */
+    "no-underscore-dangle": Linter.RuleEntry<
+        [
+            Partial<{
+                allow: string[];
+                /**
+                 * @default false
+                 */
+                allowAfterThis: boolean;
+                /**
+                 * @default false
+                 */
+                allowAfterSuper: boolean;
+                /**
+                 * @default false
+                 */
+                enforceInMethodNames: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow ternary operators when simpler alternatives exist.
+     *
+     * @since 0.21.0
+     * @see https://eslint.org/docs/rules/no-unneeded-ternary
+     */
+    "no-unneeded-ternary": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                defaultAssignment: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow whitespace before properties.
+     *
+     * @since 2.0.0-beta.1
+     * @see https://eslint.org/docs/rules/no-whitespace-before-property
+     */
+    "no-whitespace-before-property": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to enforce the location of single-line statements.
+     *
+     * @since 3.17.0
+     * @see https://eslint.org/docs/rules/nonblock-statement-body-position
+     */
+    "nonblock-statement-body-position": Linter.RuleEntry<
+        [
+            "beside" | "below" | "any",
+            Partial<{
+                overrides: Record<string, "beside" | "below" | "any">;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent line breaks inside braces.
+     *
+     * @since 2.12.0
+     * @see https://eslint.org/docs/rules/object-curly-newline
+     */
+    "object-curly-newline": Linter.RuleEntry<
+        [
+            | "always"
+            | "never"
+            | Partial<{
+                /**
+                 * @default false
+                 */
+                multiline: boolean;
+                minProperties: number;
+                /**
+                 * @default true
+                 */
+                consistent: boolean;
+            }>
+            | Partial<
+                Record<
+                    "ObjectExpression" | "ObjectPattern" | "ImportDeclaration" | "ExportDeclaration",
+                    | "always"
+                    | "never"
+                    | Partial<{
+                        /**
+                         * @default false
+                         */
+                        multiline: boolean;
+                        minProperties: number;
+                        /**
+                         * @default true
+                         */
+                        consistent: boolean;
+                    }>
+                >
+            >,
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent spacing inside braces.
+     *
+     * @since 0.22.0
+     * @see https://eslint.org/docs/rules/object-curly-spacing
+     */
+    "object-curly-spacing":
+        | Linter.RuleEntry<
+            [
+                "never",
+                {
+                    /**
+                     * @default false
+                     */
+                    arraysInObjects: boolean;
+                    /**
+                     * @default false
+                     */
+                    objectsInObjects: boolean;
+                },
+            ]
+        >
+        | Linter.RuleEntry<
+            [
+                "always",
+                {
+                    /**
+                     * @default true
+                     */
+                    arraysInObjects: boolean;
+                    /**
+                     * @default true
+                     */
+                    objectsInObjects: boolean;
+                },
+            ]
+        >;
+
+    /**
+     * Rule to enforce placing object properties on separate lines.
+     *
+     * @since 2.10.0
+     * @see https://eslint.org/docs/rules/object-property-newline
+     */
+    "object-property-newline": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowAllPropertiesOnSameLine: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce variables to be declared either together or separately in functions.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/one-var
+     */
+    "one-var": Linter.RuleEntry<
+        [
+            | "always"
+            | "never"
+            | "consecutive"
+            | Partial<
+                {
+                    /**
+                     * @default false
+                     */
+                    separateRequires: boolean;
+                } & Record<"var" | "let" | "const", "always" | "never" | "consecutive">
+            >
+            | Partial<Record<"initialized" | "uninitialized", "always" | "never" | "consecutive">>,
+        ]
+    >;
+
+    /**
+     * Rule to require or disallow newlines around variable declarations.
+     *
+     * @since 2.0.0-beta.3
+     * @see https://eslint.org/docs/rules/one-var-declaration-per-line
+     */
+    "one-var-declaration-per-line": Linter.RuleEntry<["initializations" | "always"]>;
+
+    /**
+     * Rule to require or disallow assignment operator shorthand where possible.
+     *
+     * @since 0.10.0
+     * @see https://eslint.org/docs/rules/operator-assignment
+     */
+    "operator-assignment": Linter.RuleEntry<["always" | "never"]>;
+
+    /**
+     * Rule to enforce consistent linebreak style for operators.
+     *
+     * @since 0.19.0
+     * @see https://eslint.org/docs/rules/operator-linebreak
+     */
+    "operator-linebreak": Linter.RuleEntry<
+        [
+            "after" | "before" | "none",
+            Partial<{
+                overrides: Record<string, "after" | "before" | "none">;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require or disallow padding within blocks.
+     *
+     * @since 0.9.0
+     * @see https://eslint.org/docs/rules/padded-blocks
+     */
+    "padded-blocks": Linter.RuleEntry<
+        [
+            "always" | "never" | Partial<Record<"blocks" | "classes" | "switches", "always" | "never">>,
+            {
+                /**
+                 * @default false
+                 */
+                allowSingleLineBlocks: boolean;
+            },
+        ]
+    >;
+
+    /**
+     * Rule to require or disallow padding lines between statements.
+     *
+     * @since 4.0.0-beta.0
+     * @see https://eslint.org/docs/rules/padding-line-between-statements
+     */
+    "padding-line-between-statements": Linter.RuleEntry<
+        [
+            ...Array<
+                {
+                    blankLine: "any" | "never" | "always";
+                } & Record<"prev" | "next", string | string[]>
+            >,
+        ]
+    >;
+
+    /**
+     * Rule to disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead.
+     *
+     * @since 5.0.0-alpha.3
+     * @see https://eslint.org/docs/rules/prefer-object-spread
+     */
+    "prefer-object-spread": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require quotes around object literal property names.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/quote-props
+     */
+    "quote-props":
+        | Linter.RuleEntry<["always" | "consistent"]>
+        | Linter.RuleEntry<
+            [
+                "as-needed",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    keywords: boolean;
+                    /**
+                     * @default true
+                     */
+                    unnecessary: boolean;
+                    /**
+                     * @default false
+                     */
+                    numbers: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<
+            [
+                "consistent-as-needed",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    keywords: boolean;
+                }>,
+            ]
+        >;
+
+    /**
+     * Rule to enforce the consistent use of either backticks, double, or single quotes.
+     *
+     * @since 0.0.7
+     * @see https://eslint.org/docs/rules/quotes
+     */
+    quotes: Linter.RuleEntry<
+        [
+            "double" | "single" | "backtick",
+            Partial<{
+                /**
+                 * @default false
+                 */
+                avoidEscape: boolean;
+                /**
+                 * @default false
+                 */
+                allowTemplateLiterals: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require or disallow semicolons instead of ASI.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/semi
+     */
+    semi:
+        | Linter.RuleEntry<
+            [
+                "always",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    omitLastInOneLineBlock: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<
+            [
+                "never",
+                Partial<{
+                    /**
+                     * @default 'any'
+                     */
+                    beforeStatementContinuationChars: "any" | "always" | "never";
+                }>,
+            ]
+        >;
+
+    /**
+     * Rule to enforce consistent spacing before and after semicolons.
+     *
+     * @since 0.16.0
+     * @see https://eslint.org/docs/rules/semi-spacing
+     */
+    "semi-spacing": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                before: boolean;
+                /**
+                 * @default true
+                 */
+                after: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce location of semicolons.
+     *
+     * @since 4.0.0-beta.0
+     * @see https://eslint.org/docs/rules/semi-style
+     */
+    "semi-style": Linter.RuleEntry<["last" | "first"]>;
+
+    /**
+     * Rule to require object keys to be sorted.
+     *
+     * @since 3.3.0
+     * @see https://eslint.org/docs/rules/sort-keys
+     */
+    "sort-keys": Linter.RuleEntry<
+        [
+            "asc" | "desc",
+            Partial<{
+                /**
+                 * @default true
+                 */
+                caseSensitive: boolean;
+                /**
+                 * @default 2
+                 */
+                minKeys: number;
+                /**
+                 * @default false
+                 */
+                natural: boolean;
+                /**
+                 * @default false
+                 */
+                allowLineSeparatedGroups: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require variables within the same declaration block to be sorted.
+     *
+     * @since 0.2.0
+     * @see https://eslint.org/docs/rules/sort-vars
+     */
+    "sort-vars": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                ignoreCase: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent spacing before blocks.
+     *
+     * @since 0.9.0
+     * @see https://eslint.org/docs/rules/space-before-blocks
+     */
+    "space-before-blocks": Linter.RuleEntry<
+        ["always" | "never" | Partial<Record<"functions" | "keywords" | "classes", "always" | "never" | "off">>]
+    >;
+
+    /**
+     * Rule to enforce consistent spacing before `function` definition opening parenthesis.
+     *
+     * @since 0.18.0
+     * @see https://eslint.org/docs/rules/space-before-function-paren
+     */
+    "space-before-function-paren": Linter.RuleEntry<
+        ["always" | "never" | Partial<Record<"anonymous" | "named" | "asyncArrow", "always" | "never" | "ignore">>]
+    >;
+
+    /**
+     * Rule to enforce consistent spacing inside parentheses.
+     *
+     * @since 0.8.0
+     * @see https://eslint.org/docs/rules/space-in-parens
+     */
+    "space-in-parens": Linter.RuleEntry<
+        [
+            "never" | "always",
+            Partial<{
+                exceptions: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require spacing around infix operators.
+     *
+     * @since 0.2.0
+     * @see https://eslint.org/docs/rules/space-infix-ops
+     */
+    "space-infix-ops": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                int32Hint: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent spacing before or after unary operators.
+     *
+     * @since 0.10.0
+     * @see https://eslint.org/docs/rules/space-unary-ops
+     */
+    "space-unary-ops": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                words: boolean;
+                /**
+                 * @default false
+                 */
+                nonwords: boolean;
+                overrides: Record<string, boolean>;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce consistent spacing after the `//` or `/*` in a comment.
+     *
+     * @since 0.23.0
+     * @see https://eslint.org/docs/rules/spaced-comment
+     */
+    "spaced-comment": Linter.RuleEntry<
+        [
+            "always" | "never",
+            {
+                exceptions: string[];
+                markers: string[];
+                line: {
+                    exceptions: string[];
+                    markers: string[];
+                };
+                block: {
+                    exceptions: string[];
+                    markers: string[];
+                    /**
+                     * @default false
+                     */
+                    balanced: boolean;
+                };
+            },
+        ]
+    >;
+
+    /**
+     * Rule to enforce spacing around colons of switch statements.
+     *
+     * @since 4.0.0-beta.0
+     * @see https://eslint.org/docs/rules/switch-colon-spacing
+     */
+    "switch-colon-spacing": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                before: boolean;
+                /**
+                 * @default true
+                 */
+                after: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require or disallow spacing between template tags and their literals.
+     *
+     * @since 3.15.0
+     * @see https://eslint.org/docs/rules/template-tag-spacing
+     */
+    "template-tag-spacing": Linter.RuleEntry<["never" | "always"]>;
+
+    /**
+     * Rule to require or disallow Unicode byte order mark (BOM).
+     *
+     * @since 2.11.0
+     * @see https://eslint.org/docs/rules/unicode-bom
+     */
+    "unicode-bom": Linter.RuleEntry<["never" | "always"]>;
+
+    /**
+     * Rule to require parenthesis around regex literals.
+     *
+     * @since 0.1.0
+     * @see https://eslint.org/docs/rules/wrap-regex
+     */
+    "wrap-regex": Linter.RuleEntry<[]>;
+}

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/rules/variables.d.ts

@@ -0,0 +1,194 @@
+import { Linter } from "../index";
+
+export interface Variables extends Linter.RulesRecord {
+    /**
+     * Rule to require or disallow initialization in variable declarations.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/init-declarations
+     */
+    "init-declarations":
+        | Linter.RuleEntry<["always"]>
+        | Linter.RuleEntry<
+            [
+                "never",
+                Partial<{
+                    ignoreForLoopInit: boolean;
+                }>,
+            ]
+        >;
+
+    /**
+     * Rule to disallow deleting variables.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-delete-var
+     */
+    "no-delete-var": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow labels that share a name with a variable.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-label-var
+     */
+    "no-label-var": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow specified global variables.
+     *
+     * @since 2.3.0
+     * @see https://eslint.org/docs/rules/no-restricted-globals
+     */
+    "no-restricted-globals": Linter.RuleEntry<
+        [
+            ...Array<
+                | string
+                | {
+                    name: string;
+                    message?: string | undefined;
+                }
+            >,
+        ]
+    >;
+
+    /**
+     * Rule to disallow variable declarations from shadowing variables declared in the outer scope.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-shadow
+     */
+    "no-shadow": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                builtinGlobals: boolean;
+                /**
+                 * @default 'functions'
+                 */
+                hoist: "functions" | "all" | "never";
+                allow: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow identifiers from shadowing restricted names.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.1.4
+     * @see https://eslint.org/docs/rules/no-shadow-restricted-names
+     */
+    "no-shadow-restricted-names": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of undeclared variables unless mentioned in `global` comments.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-undef
+     */
+    "no-undef": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                typeof: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow initializing variables to `undefined`.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/no-undef-init
+     */
+    "no-undef-init": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of `undefined` as an identifier.
+     *
+     * @since 0.7.1
+     * @see https://eslint.org/docs/rules/no-undefined
+     */
+    "no-undefined": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unused variables.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-unused-vars
+     */
+    "no-unused-vars": Linter.RuleEntry<
+        [
+            | "all"
+            | "local"
+            | Partial<{
+                /**
+                 * @default 'all'
+                 */
+                vars: "all" | "local";
+                varsIgnorePattern: string;
+                /**
+                 * @default 'after-used'
+                 */
+                args: "after-used" | "all" | "none";
+                /**
+                 * @default false
+                 */
+                ignoreRestSiblings: boolean;
+                argsIgnorePattern: string;
+                /**
+                 * @default 'none'
+                 */
+                caughtErrors: "none" | "all";
+                caughtErrorsIgnorePattern: string;
+                destructuredArrayIgnorePattern: string;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow the use of variables before they are defined.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-use-before-define
+     */
+    "no-use-before-define": Linter.RuleEntry<
+        [
+            | Partial<{
+                /**
+                 * @default true
+                 */
+                functions: boolean;
+                /**
+                 * @default true
+                 */
+                classes: boolean;
+                /**
+                 * @default true
+                 */
+                variables: boolean;
+                /**
+                 * @default false
+                 */
+                allowNamedExports: boolean;
+            }>
+            | "nofunc",
+        ]
+    >;
+}

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/eslint/use-at-your-own-risk.d.ts

@@ -0,0 +1,57 @@
+import { ESLint, Rule } from "./index.js";
+
+/** @deprecated */
+export const builtinRules: Map<string, Rule.RuleModule>;
+
+/** @deprecated */
+export class FileEnumerator {
+    constructor(
+        params?: {
+            cwd?: string;
+            configArrayFactory?: any;
+            extensions?: any;
+            globInputPaths?: boolean;
+            errorOnUnmatchedPattern?: boolean;
+            ignore?: boolean;
+        },
+    );
+    isTargetPath(filePath: string, providedConfig?: any): boolean;
+    iterateFiles(
+        patternOrPatterns: string | string[],
+    ): IterableIterator<{ config: any; filePath: string; ignored: boolean }>;
+}
+
+export { /** @deprecated */ ESLint as FlatESLint };
+
+/** @deprecated */
+export class LegacyESLint {
+    static configType: "eslintrc";
+
+    static readonly version: string;
+
+    static outputFixes(results: ESLint.LintResult[]): Promise<void>;
+
+    static getErrorResults(results: ESLint.LintResult[]): ESLint.LintResult[];
+
+    constructor(options?: ESLint.LegacyOptions);
+
+    lintFiles(patterns: string | string[]): Promise<ESLint.LintResult[]>;
+
+    lintText(
+        code: string,
+        options?: { filePath?: string | undefined; warnIgnored?: boolean | undefined },
+    ): Promise<ESLint.LintResult[]>;
+
+    getRulesMetaForResults(results: ESLint.LintResult[]): ESLint.LintResultData["rulesMeta"];
+
+    hasFlag(flag: string): false;
+
+    calculateConfigForFile(filePath: string): Promise<any>;
+
+    isPathIgnored(filePath: string): Promise<boolean>;
+
+    loadFormatter(nameOrPath?: string): Promise<ESLint.Formatter>;
+}
+
+/** @deprecated */
+export function shouldUseFlatConfig(): Promise<boolean>;

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/estree

@@ -0,0 +1 @@
+../../../@types+estree@1.0.6/node_modules/@types/estree

node_modules/.pnpm/@types+eslint@9.6.1/node_modules/@types/json-schema

@@ -0,0 +1 @@
+../../../@types+json-schema@7.0.15/node_modules/@types/json-schema

node_modules/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/json-schema`
+
+# Summary
+This package contains type definitions for json-schema (https://github.com/kriszyp/json-schema).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/json-schema.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 03:09:37 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [Boris Cherny](https://github.com/bcherny), [Lucian Buzzo](https://github.com/lucianbuzzo), [Roland Groza](https://github.com/rolandjitsu), and [Jason Kwok](https://github.com/JasonHK).