add: bundle

js/bundle.js

@@ -0,0 +1,181 @@
+(() => {
+    var __webpack_exports__ = {};
+    parseCodecs = e => {
+        e = e.mimeType;
+        if (!e) return {};
+        e = e.match(/(?<mimetype>[^/]+\/[^;]+)(?:;\s*codecs="?(?<codecs>[^"]+))?/);
+        if (!e) return {};
+        e = e.groups.codecs;
+        if (!e) return {};
+        e = e.trim().replace(/,$/, "").split(",").map(e => e.trim()).filter(Boolean);
+        let t = null, n = null;
+        for (const i of e) {
+            var o = i.split(".")[0];
+            ["avc1", "avc2", "avc3", "avc4", "vp9", "vp8", "hev1", "hev2", "h263", "h264", "mp4v", "hvc1", "av01", "theora"].includes(o) ? t = t || i : ["mp4a", "opus", "vorbis", "mp3", "aac", "ac-3", "ec-3", "eac3", "dtsc", "dtse", "dtsh", "dtsl"].includes(o) ? n = n || i : console.warn("WARNING: Unknown codec " + i)
+        }
+        return t || n ? {vcodec: t, acodec: n} : 2 === e.length ? {vcodec: e[0], acodec: e[1]} : {}
+    }, getStringBetween = (e, t, n, o = 0, i = 0) => {
+        var s = e.indexOf(t), n = n ? e.indexOf(n, s) : e.length;
+        return e.substring(s + t.length + i, n + o)
+    }, getUrlFromSignature = (e, t) => {
+        var t = getDecipherFunction(t), n = {};
+        for (const l of e.split("&")) {
+            var [o, i] = l.split("=");
+            n[decodeURIComponent(o)] = decodeURIComponent(i)
+        }
+        var [s, r, a] = [n.url, n.s, n.sp];
+        return console.log(e, s, r, a), s + `&${a}=` + t(r)
+    }, getDecipherFunction = string => {
+        const js = string.replace("var _yt_player={}", ""), top = getStringBetween(js, 'a=a.split("")', "};", 1, -28),
+            beginningOfFunction = "var " + getStringBetween(top, 'a=a.split("")', "(", 10, 1).split(".")[0] + "=",
+            side = getStringBetween(js, beginningOfFunction, "};", 2, -beginningOfFunction.length);
+        return console.log(side + top), eval(side + top)
+    }, request = async (e, t, i = null, s = {}, n) => (n && (t = t.replace("https://www.youtube.com", "http://127.0.0.1")), console.log("请求url:" + t), console.log("请求data:" + i), console.log("请求method:" + e), console.log("请求headers:" + JSON.stringify(s)), n ? fetch(t, {
+        method: e,
+        headers: s,
+        body: i
+    }).then(e => e.text()) : new Promise((n, o) => {
+        AF.request(t, e, i, s, (e, t) => {
+            t ? (console.log("请求失败: " + t), o(t)) : n(e)
+        })
+    })), detail = async (t, e) => {
+        try {
+            console.log("接受到解析请求: " + t);
+            var n = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.101 Safari/537.36"},
+                o = await request("GET", t, null, n, e),
+                i = "https://www.youtube.com" + JSON.parse(o.match(/set\(({.+?})\);/)[1]).PLAYER_JS_URL,
+                s = (console.log("解析baseUrl: " + i), await request("GET", i, null, n, e)),
+                r = /var ytInitialPlayerResponse\s*=\s*({.*?});/, a = o.match(r);
+            if (!a || !a.length) throw console.log("解释失败: 无法找到json"), new Error("JSON not found.");
+            var l = JSON.parse(a[1]),
+                c = (console.log("ytInitialPlayerResponse: " + JSON.stringify(l)), l.videoDetails), d = [];
+            for (const x of c.thumbnail.thumbnails) d.push({url: x.url, width: x.width + "", height: x.height + ""});
+            var u, h, p, m = [];
+            for (u of [].concat(l.streamingData.formats).concat(l.streamingData.adaptiveFormats)) console.log("format: " + JSON.stringify(u)), u.url || (u.url = getUrlFromSignature(u.signatureCipher, s)), u.url && ({
+                vcodec: h,
+                acodec: p
+            } = parseCodecs(u), h) && p && m.push({
+                width: u.width + "",
+                height: u.height + "",
+                type: u.mimeType,
+                quality: u.quality,
+                itag: u.itag,
+                fps: u.fps + "",
+                bitrate: u.bitrate + "",
+                url: u.url,
+                ext: "mp4",
+                vcodec: h,
+                acodec: p,
+                vbr: "0",
+                abr: "0",
+                container: "mp4_dash"
+            });
+            if (r = /var ytInitialData\s*=\s*({.*?});/, !(a = o.match(r)) || !a.length) throw console.log("解析失败，无法找到 ytInitialData"), new Error("JSON not found.");
+            var g, v = JSON.parse(a[1]), y = (console.log("ytInitialData: " + JSON.stringify(v)), []);
+            for (const T of v.contents.twoColumnWatchNextResults.secondaryResults.secondaryResults.results) T.compactVideoRenderer && (g = T.compactVideoRenderer, console.log("推荐视频: " + JSON.stringify(g)), g.videoId) && y.push({
+                type: "gridVideoRenderer",
+                videoId: g.videoId,
+                title: g.title?.simpleText,
+                thumbnails: g.thumbnail?.thumbnails,
+                channelName: g.longBylineText?.runs?.[0]?.text,
+                publishedTimeText: g.publishedTimeText?.simpleText,
+                viewCountText: g.viewCountText?.simpleText,
+                shortViewCountText: g.shortViewCountText?.simpleText,
+                lengthText: g.lengthText?.simpleText
+            });
+            var w = {
+                code: 200,
+                msg: "",
+                data: {
+                    videoDetails: {
+                        isLiveContent: c.isLiveContent,
+                        title: c.title,
+                        thumbnails: d,
+                        description: c.shortDescription,
+                        lengthSeconds: c.lengthSeconds,
+                        viewCount: c.viewCount,
+                        keywords: c.keywords,
+                        author: c.author,
+                        channelID: c.channelId,
+                        recommendInfo: y,
+                        channelURL: "https://www.youtube.com/channel/" + c.channelId,
+                        videoId: c.videoId
+                    }, streamingData: {formats: m}
+                },
+                id: "MusicDetailViewModel_detail_url"
+            };
+            return console.log("解析结果: " + JSON.stringify(w)), w
+        } catch (e) {
+            t = {code: -1, msg: e.toString()};
+            return console.log("解析失败: " + JSON.stringify(t)), t
+        }
+    }, search = async (e, t, n) => {
+        try {
+            if (console.log("接受到搜索请求: " + e), console.log("next: " + t), t) {
+                var o = JSON.parse(t), i = o.key, s = {
+                        context: {client: {clientName: "WEB", clientVersion: "2.20240506.01.00"}},
+                        continuation: o.continuation
+                    },
+                    r = await request("POST", "https://www.youtube.com/youtubei/v1/search?key=" + i, JSON.stringify(s), {}, n),
+                    r = JSON.parse(r), a = (console.log("搜索结果res: " + JSON.stringify(r)), []);
+                for (const x of r.onResponseReceivedCommands[0].appendContinuationItemsAction.continuationItems[0].itemSectionRenderer.contents) {
+                    var l = x.videoRenderer;
+                    l && l.videoId && a.push({
+                        type: "videoWithContextRenderer",
+                        data: {
+                            videoId: l.videoId,
+                            title: l.title?.runs?.[0]?.text,
+                            thumbnails: l.thumbnail?.thumbnails,
+                            channelName: l.longBylineText?.runs?.[0]?.text,
+                            publishedTimeText: l.publishedTimeText?.simpleText,
+                            viewCountText: l.viewCountText?.simpleText,
+                            shortViewCountText: l.shortViewCountText?.simpleText,
+                            lengthText: l.lengthText?.simpleText
+                        }
+                    })
+                }
+                var c = {
+                    code: 200,
+                    msg: "",
+                    data: {
+                        data: a,
+                        next: JSON.stringify({
+                            key: o.key,
+                            continuation: r.onResponseReceivedCommands[0].appendContinuationItemsAction.continuationItems[1].continuationItemRenderer.continuationEndpoint.continuationCommand.token
+                        })
+                    },
+                    id: "MusicSearchResultViewModel_search_result"
+                };
+                return console.log("搜索结果成功1: " + JSON.stringify(c)), c
+            }
+            var d = `https://www.youtube.com/results?q=${encodeURIComponent(e)}&sp=EgIQAQ%253D%253D`,
+                u = await request("GET", d, null, {}, n), h = /var ytInitialData\s*=\s*({.*?});/, p = u.match(h);
+            if (!p || !p.length) throw console.log("搜索失败：无法找到ytInitialData"), new Error("JSON not found.");
+            var m, g = JSON.parse(p[1]), v = (console.log("ytInitialDataResp: " + JSON.stringify(g)), []);
+            for (const T of g.contents.twoColumnSearchResultsRenderer.primaryContents.sectionListRenderer.contents[0].itemSectionRenderer.contents) T.videoRenderer && (m = T.videoRenderer) && m.videoId && v.push({
+                type: "videoWithContextRenderer",
+                data: {
+                    videoId: m.videoId,
+                    title: m.title?.runs?.[0]?.text,
+                    thumbnails: m.thumbnail?.thumbnails,
+                    channelName: m.longBylineText?.runs?.[0]?.text,
+                    publishedTimeText: m.publishedTimeText?.simpleText,
+                    viewCountText: m.viewCountText?.simpleText,
+                    shortViewCountText: m.shortViewCountText?.simpleText,
+                    lengthText: m.lengthText?.simpleText
+                }
+            });
+            var y = {},
+                w = (0 < u.split("innertubeApiKey").length && (y.key = u.split("innertubeApiKey")[1].trim().split(",")[0].split('"')[2]), y.continuation = g.contents.twoColumnSearchResultsRenderer.primaryContents.sectionListRenderer.contents[1].continuationItemRenderer.continuationEndpoint.continuationCommand.token, {
+                    code: 200,
+                    msg: "",
+                    data: {data: v, next: JSON.stringify(y)},
+                    id: "MusicSearchResultViewModel_search_result"
+                });
+            return console.log("搜索结果成功2: " + JSON.stringify(w)), w
+        } catch (e) {
+            t = {code: -1, msg: e.toString()};
+            return console.log("解析失败: " + JSON.stringify(t)), t
+        }
+    }
+})();

js/node_modules/.bin/atob

@@ -1 +0,0 @@
-../atob/bin/atob.js

js/node_modules/.bin/browserslist

@@ -0,0 +1 @@
+../browserslist/cli.js

js/node_modules/.bin/json5

@@ -1 +0,0 @@
-../json5/lib/cli.js

js/node_modules/.bin/miller-rabin

@@ -1 +0,0 @@
-../miller-rabin/bin/miller-rabin

js/node_modules/.bin/sha.js

@@ -1 +0,0 @@
-../sha.js/bin.js

js/node_modules/.bin/update-browserslist-db

@@ -0,0 +1 @@
+../update-browserslist-db/cli.js

js/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.

js/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

js/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

js/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

js/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[];

js/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 {};

js/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;
+};

js/node_modules/@jridgewell/gen-mapping/package.json

@@ -0,0 +1,112 @@
+{
+  "_from": "@jridgewell/gen-mapping@^0.3.5",
+  "_id": "@jridgewell/gen-mapping@0.3.5",
+  "_inBundle": false,
+  "_integrity": "sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==",
+  "_location": "/@jridgewell/gen-mapping",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@jridgewell/gen-mapping@^0.3.5",
+    "name": "@jridgewell/gen-mapping",
+    "escapedName": "@jridgewell%2fgen-mapping",
+    "scope": "@jridgewell",
+    "rawSpec": "^0.3.5",
+    "saveSpec": null,
+    "fetchSpec": "^0.3.5"
+  },
+  "_requiredBy": [
+    "/@jridgewell/source-map"
+  ],
+  "_resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz",
+  "_shasum": "dcce6aff74bdf6dad1a95802b69b04a2fcb1fb36",
+  "_spec": "@jridgewell/gen-mapping@^0.3.5",
+  "_where": "/Users/ben/Desktop/app/be/be-ytb/js/node_modules/@jridgewell/source-map",
+  "author": {
+    "name": "Justin Ridgewell",
+    "email": "justin@ridgewell.name"
+  },
+  "bugs": {
+    "url": "https://github.com/jridgewell/gen-mapping/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "@jridgewell/set-array": "^1.2.1",
+    "@jridgewell/sourcemap-codec": "^1.4.10",
+    "@jridgewell/trace-mapping": "^0.3.24"
+  },
+  "deprecated": false,
+  "description": "Generate source maps",
+  "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"
+  },
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "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"
+  ],
+  "homepage": "https://github.com/jridgewell/gen-mapping#readme",
+  "keywords": [
+    "source",
+    "map"
+  ],
+  "license": "MIT",
+  "main": "dist/gen-mapping.umd.js",
+  "module": "dist/gen-mapping.mjs",
+  "name": "@jridgewell/gen-mapping",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jridgewell/gen-mapping.git"
+  },
+  "scripts": {
+    "benchmark": "run-s build:rollup benchmark:*",
+    "benchmark:install": "cd benchmark && npm install",
+    "benchmark:only": "node benchmark/index.mjs",
+    "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": "c8 mocha",
+    "test:watch": "mocha --watch"
+  },
+  "types": "dist/types/gen-mapping.d.ts",
+  "version": "0.3.5"
+}

js/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.

js/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               |

js/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

js/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

js/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;

js/node_modules/@jridgewell/resolve-uri/package.json

@@ -0,0 +1,105 @@
+{
+  "_from": "@jridgewell/resolve-uri@^3.1.0",
+  "_id": "@jridgewell/resolve-uri@3.1.2",
+  "_inBundle": false,
+  "_integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+  "_location": "/@jridgewell/resolve-uri",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@jridgewell/resolve-uri@^3.1.0",
+    "name": "@jridgewell/resolve-uri",
+    "escapedName": "@jridgewell%2fresolve-uri",
+    "scope": "@jridgewell",
+    "rawSpec": "^3.1.0",
+    "saveSpec": null,
+    "fetchSpec": "^3.1.0"
+  },
+  "_requiredBy": [
+    "/@jridgewell/trace-mapping"
+  ],
+  "_resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+  "_shasum": "7a0ee601f60f99a20c7c7c5ff0c80388c1189bd6",
+  "_spec": "@jridgewell/resolve-uri@^3.1.0",
+  "_where": "/Users/ben/Desktop/app/be/be-ytb/js/node_modules/@jridgewell/trace-mapping",
+  "author": {
+    "name": "Justin Ridgewell",
+    "email": "justin@ridgewell.name"
+  },
+  "bugs": {
+    "url": "https://github.com/jridgewell/resolve-uri/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Resolve a URI relative to an optional base URI",
+  "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"
+  },
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "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"
+  ],
+  "homepage": "https://github.com/jridgewell/resolve-uri#readme",
+  "keywords": [
+    "resolve",
+    "uri",
+    "url",
+    "path"
+  ],
+  "license": "MIT",
+  "main": "dist/resolve-uri.umd.js",
+  "module": "dist/resolve-uri.mjs",
+  "name": "@jridgewell/resolve-uri",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jridgewell/resolve-uri.git"
+  },
+  "scripts": {
+    "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",
+    "pretest": "run-s build:rollup",
+    "preversion": "run-s test build",
+    "test": "run-s -n test:lint test:only",
+    "test:coverage": "c8 mocha",
+    "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:watch": "mocha --watch"
+  },
+  "types": "dist/types/resolve-uri.d.ts",
+  "version": "3.1.2"
+}

js/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.

js/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' ]);
+```

js/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

js/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

js/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 {};

js/node_modules/@jridgewell/set-array/package.json

@@ -0,0 +1,101 @@
+{
+  "_from": "@jridgewell/set-array@^1.2.1",
+  "_id": "@jridgewell/set-array@1.2.1",
+  "_inBundle": false,
+  "_integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==",
+  "_location": "/@jridgewell/set-array",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@jridgewell/set-array@^1.2.1",
+    "name": "@jridgewell/set-array",
+    "escapedName": "@jridgewell%2fset-array",
+    "scope": "@jridgewell",
+    "rawSpec": "^1.2.1",
+    "saveSpec": null,
+    "fetchSpec": "^1.2.1"
+  },
+  "_requiredBy": [
+    "/@jridgewell/gen-mapping"
+  ],
+  "_resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz",
+  "_shasum": "558fb6472ed16a4c850b889530e6b36438c49280",
+  "_spec": "@jridgewell/set-array@^1.2.1",
+  "_where": "/Users/ben/Desktop/app/be/be-ytb/js/node_modules/@jridgewell/gen-mapping",
+  "author": {
+    "name": "Justin Ridgewell",
+    "email": "justin@ridgewell.name"
+  },
+  "bugs": {
+    "url": "https://github.com/jridgewell/set-array/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Like a Set, but provides the index of the `key` in the backing array",
+  "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"
+  },
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "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"
+  ],
+  "homepage": "https://github.com/jridgewell/set-array#readme",
+  "keywords": [],
+  "license": "MIT",
+  "main": "dist/set-array.umd.js",
+  "module": "dist/set-array.mjs",
+  "name": "@jridgewell/set-array",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jridgewell/set-array.git"
+  },
+  "scripts": {
+    "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:coverage": "c8 mocha",
+    "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:watch": "mocha --watch"
+  },
+  "typings": "dist/types/set-array.d.ts",
+  "version": "1.2.1"
+}

js/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.

js/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/

js/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

js/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

js/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

js/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>;
+}

js/node_modules/@jridgewell/source-map/package.json

@@ -0,0 +1,107 @@
+{
+  "_from": "@jridgewell/source-map@^0.3.3",
+  "_id": "@jridgewell/source-map@0.3.6",
+  "_inBundle": false,
+  "_integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==",
+  "_location": "/@jridgewell/source-map",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@jridgewell/source-map@^0.3.3",
+    "name": "@jridgewell/source-map",
+    "escapedName": "@jridgewell%2fsource-map",
+    "scope": "@jridgewell",
+    "rawSpec": "^0.3.3",
+    "saveSpec": null,
+    "fetchSpec": "^0.3.3"
+  },
+  "_requiredBy": [
+    "/terser"
+  ],
+  "_resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz",
+  "_shasum": "9d71ca886e32502eb9362c9a74a46787c36df81a",
+  "_spec": "@jridgewell/source-map@^0.3.3",
+  "_where": "/Users/ben/Desktop/app/be/be-ytb/js/node_modules/terser",
+  "author": {
+    "name": "Justin Ridgewell",
+    "email": "justin@ridgewell.name"
+  },
+  "bugs": {
+    "url": "https://github.com/jridgewell/source-map/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "@jridgewell/gen-mapping": "^0.3.5",
+    "@jridgewell/trace-mapping": "^0.3.25"
+  },
+  "deprecated": false,
+  "description": "Packages @jridgewell/trace-mapping and @jridgewell/gen-mapping into the familiar source-map API",
+  "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"
+  },
+  "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"
+  ],
+  "homepage": "https://github.com/jridgewell/source-map#readme",
+  "keywords": [
+    "sourcemap",
+    "source",
+    "map"
+  ],
+  "license": "MIT",
+  "main": "dist/source-map.cjs",
+  "module": "dist/source-map.mjs",
+  "name": "@jridgewell/source-map",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jridgewell/source-map.git"
+  },
+  "scripts": {
+    "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:coverage": "c8 --reporter text --reporter html ts-mocha",
+    "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:watch": "ts-mocha --watch"
+  },
+  "types": "dist/types/source-map.d.ts",
+  "version": "0.3.6"
+}

js/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.

js/node_modules/@jridgewell/sourcemap-codec/README.md

@@ -0,0 +1,200 @@
+# @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 v18.0.0
+
+amp.js.map - 45120 segments
+
+Decode Memory Usage:
+@jridgewell/sourcemap-codec       5479160 bytes
+sourcemap-codec                   5659336 bytes
+source-map-0.6.1                 17144440 bytes
+source-map-0.8.0                  6867424 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Decode speed:
+decode: @jridgewell/sourcemap-codec x 502 ops/sec ±1.03% (90 runs sampled)
+decode: sourcemap-codec x 445 ops/sec ±0.97% (92 runs sampled)
+decode: source-map-0.6.1 x 36.01 ops/sec ±1.64% (49 runs sampled)
+decode: source-map-0.8.0 x 367 ops/sec ±0.04% (95 runs sampled)
+Fastest is decode: @jridgewell/sourcemap-codec
+
+Encode Memory Usage:
+@jridgewell/sourcemap-codec       1261620 bytes
+sourcemap-codec                   9119248 bytes
+source-map-0.6.1                  8968560 bytes
+source-map-0.8.0                  8952952 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Encode speed:
+encode: @jridgewell/sourcemap-codec x 738 ops/sec ±0.42% (98 runs sampled)
+encode: sourcemap-codec x 238 ops/sec ±0.73% (88 runs sampled)
+encode: source-map-0.6.1 x 162 ops/sec ±0.43% (84 runs sampled)
+encode: source-map-0.8.0 x 191 ops/sec ±0.34% (90 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec
+
+
+***
+
+
+babel.min.js.map - 347793 segments
+
+Decode Memory Usage:
+@jridgewell/sourcemap-codec      35338184 bytes
+sourcemap-codec                  35922736 bytes
+source-map-0.6.1                 62366360 bytes
+source-map-0.8.0                 44337416 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Decode speed:
+decode: @jridgewell/sourcemap-codec x 40.35 ops/sec ±4.47% (54 runs sampled)
+decode: sourcemap-codec x 36.76 ops/sec ±3.67% (51 runs sampled)
+decode: source-map-0.6.1 x 4.44 ops/sec ±2.15% (16 runs sampled)
+decode: source-map-0.8.0 x 59.35 ops/sec ±0.05% (78 runs sampled)
+Fastest is decode: source-map-0.8.0
+
+Encode Memory Usage:
+@jridgewell/sourcemap-codec       7212604 bytes
+sourcemap-codec                  21421456 bytes
+source-map-0.6.1                 25286888 bytes
+source-map-0.8.0                 25498744 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Encode speed:
+encode: @jridgewell/sourcemap-codec x 112 ops/sec ±0.13% (84 runs sampled)
+encode: sourcemap-codec x 30.23 ops/sec ±2.76% (53 runs sampled)
+encode: source-map-0.6.1 x 19.43 ops/sec ±3.70% (37 runs sampled)
+encode: source-map-0.8.0 x 19.40 ops/sec ±3.26% (37 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec
+
+
+***
+
+
+preact.js.map - 1992 segments
+
+Decode Memory Usage:
+@jridgewell/sourcemap-codec        500272 bytes
+sourcemap-codec                    516864 bytes
+source-map-0.6.1                  1596672 bytes
+source-map-0.8.0                   517272 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Decode speed:
+decode: @jridgewell/sourcemap-codec x 16,137 ops/sec ±0.17% (99 runs sampled)
+decode: sourcemap-codec x 12,139 ops/sec ±0.13% (99 runs sampled)
+decode: source-map-0.6.1 x 1,264 ops/sec ±0.12% (100 runs sampled)
+decode: source-map-0.8.0 x 9,894 ops/sec ±0.08% (101 runs sampled)
+Fastest is decode: @jridgewell/sourcemap-codec
+
+Encode Memory Usage:
+@jridgewell/sourcemap-codec        321026 bytes
+sourcemap-codec                    830832 bytes
+source-map-0.6.1                   586608 bytes
+source-map-0.8.0                   586680 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Encode speed:
+encode: @jridgewell/sourcemap-codec x 19,876 ops/sec ±0.78% (95 runs sampled)
+encode: sourcemap-codec x 6,983 ops/sec ±0.15% (100 runs sampled)
+encode: source-map-0.6.1 x 5,070 ops/sec ±0.12% (102 runs sampled)
+encode: source-map-0.8.0 x 5,641 ops/sec ±0.17% (100 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec
+
+
+***
+
+
+react.js.map - 5726 segments
+
+Decode Memory Usage:
+@jridgewell/sourcemap-codec        734848 bytes
+sourcemap-codec                    954200 bytes
+source-map-0.6.1                  2276432 bytes
+source-map-0.8.0                   955488 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Decode speed:
+decode: @jridgewell/sourcemap-codec x 5,723 ops/sec ±0.12% (98 runs sampled)
+decode: sourcemap-codec x 4,555 ops/sec ±0.09% (101 runs sampled)
+decode: source-map-0.6.1 x 437 ops/sec ±0.11% (93 runs sampled)
+decode: source-map-0.8.0 x 3,441 ops/sec ±0.15% (100 runs sampled)
+Fastest is decode: @jridgewell/sourcemap-codec
+
+Encode Memory Usage:
+@jridgewell/sourcemap-codec        638672 bytes
+sourcemap-codec                   1109840 bytes
+source-map-0.6.1                  1321224 bytes
+source-map-0.8.0                  1324448 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Encode speed:
+encode: @jridgewell/sourcemap-codec x 6,801 ops/sec ±0.48% (98 runs sampled)
+encode: sourcemap-codec x 2,533 ops/sec ±0.13% (101 runs sampled)
+encode: source-map-0.6.1 x 2,248 ops/sec ±0.08% (100 runs sampled)
+encode: source-map-0.8.0 x 2,303 ops/sec ±0.15% (100 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec
+```
+
+# License
+
+MIT

js/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs

@@ -0,0 +1,164 @@
+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);
+}
+function sortComparator(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;
+}
+
+export { decode, encode };
+//# sourceMappingURL=sourcemap-codec.mjs.map

js/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js

@@ -0,0 +1,175 @@
+(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;
+    }
+    // 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);
+    }
+    function sortComparator(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;
+    }
+
+    exports.decode = decode;
+    exports.encode = encode;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=sourcemap-codec.umd.js.map

js/node_modules/@jridgewell/sourcemap-codec/dist/types/sourcemap-codec.d.ts

@@ -0,0 +1,6 @@
+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;

js/node_modules/@jridgewell/sourcemap-codec/package.json

@@ -0,0 +1,107 @@
+{
+  "_from": "@jridgewell/sourcemap-codec@^1.4.14",
+  "_id": "@jridgewell/sourcemap-codec@1.4.15",
+  "_inBundle": false,
+  "_integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==",
+  "_location": "/@jridgewell/sourcemap-codec",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@jridgewell/sourcemap-codec@^1.4.14",
+    "name": "@jridgewell/sourcemap-codec",
+    "escapedName": "@jridgewell%2fsourcemap-codec",
+    "scope": "@jridgewell",
+    "rawSpec": "^1.4.14",
+    "saveSpec": null,
+    "fetchSpec": "^1.4.14"
+  },
+  "_requiredBy": [
+    "/@jridgewell/gen-mapping",
+    "/@jridgewell/trace-mapping"
+  ],
+  "_resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz",
+  "_shasum": "d7c6e6755c78567a951e04ab52ef0fd26de59f32",
+  "_spec": "@jridgewell/sourcemap-codec@^1.4.14",
+  "_where": "/Users/ben/Desktop/app/be/be-ytb/js/node_modules/@jridgewell/trace-mapping",
+  "author": {
+    "name": "Rich Harris"
+  },
+  "bugs": {
+    "url": "https://github.com/jridgewell/sourcemap-codec/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Encode/decode sourcemap mappings",
+  "devDependencies": {
+    "@rollup/plugin-typescript": "8.3.0",
+    "@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",
+    "typescript": "4.5.4"
+  },
+  "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"
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://github.com/jridgewell/sourcemap-codec#readme",
+  "keywords": [
+    "sourcemap",
+    "vlq"
+  ],
+  "license": "MIT",
+  "main": "dist/sourcemap-codec.umd.js",
+  "module": "dist/sourcemap-codec.mjs",
+  "name": "@jridgewell/sourcemap-codec",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jridgewell/sourcemap-codec.git"
+  },
+  "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",
+    "pretest": "run-s build:rollup",
+    "preversion": "run-s test build",
+    "test": "run-s -n test:lint test:only",
+    "test:coverage": "c8 mocha",
+    "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:watch": "mocha --watch"
+  },
+  "types": "dist/types/sourcemap-codec.d.ts",
+  "version": "1.4.15"
+}

js/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.

js/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

js/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

js/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

js/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 {};

js/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;

js/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[];

js/node_modules/@jridgewell/trace-mapping/dist/types/resolve.d.ts

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

js/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[][];

js/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 {};

js/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;

js/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;

js/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'];
+}

js/node_modules/@jridgewell/trace-mapping/package.json

@@ -0,0 +1,112 @@
+{
+  "_from": "@jridgewell/trace-mapping@^0.3.20",
+  "_id": "@jridgewell/trace-mapping@0.3.25",
+  "_inBundle": false,
+  "_integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
+  "_location": "/@jridgewell/trace-mapping",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@jridgewell/trace-mapping@^0.3.20",
+    "name": "@jridgewell/trace-mapping",
+    "escapedName": "@jridgewell%2ftrace-mapping",
+    "scope": "@jridgewell",
+    "rawSpec": "^0.3.20",
+    "saveSpec": null,
+    "fetchSpec": "^0.3.20"
+  },
+  "_requiredBy": [
+    "/@jridgewell/gen-mapping",
+    "/@jridgewell/source-map",
+    "/terser-webpack-plugin"
+  ],
+  "_resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
+  "_shasum": "15f190e98895f3fc23276ee14bc76b675c2e50f0",
+  "_spec": "@jridgewell/trace-mapping@^0.3.20",
+  "_where": "/Users/ben/Desktop/app/be/be-ytb/js/node_modules/terser-webpack-plugin",
+  "author": {
+    "name": "Justin Ridgewell",
+    "email": "justin@ridgewell.name"
+  },
+  "bugs": {
+    "url": "https://github.com/jridgewell/trace-mapping/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "@jridgewell/resolve-uri": "^3.1.0",
+    "@jridgewell/sourcemap-codec": "^1.4.14"
+  },
+  "deprecated": false,
+  "description": "Trace the original position through a source map",
+  "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"
+  },
+  "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"
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://github.com/jridgewell/trace-mapping#readme",
+  "keywords": [
+    "source",
+    "map"
+  ],
+  "license": "MIT",
+  "main": "dist/trace-mapping.umd.js",
+  "module": "dist/trace-mapping.mjs",
+  "name": "@jridgewell/trace-mapping",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jridgewell/trace-mapping.git"
+  },
+  "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"
+  },
+  "types": "dist/types/trace-mapping.d.ts",
+  "version": "0.3.25"
+}

js/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

js/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).

js/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;

js/node_modules/@types/eslint-scope/package.json

@@ -0,0 +1,56 @@
+{
+  "_from": "@types/eslint-scope@^3.7.3",
+  "_id": "@types/eslint-scope@3.7.7",
+  "_inBundle": false,
+  "_integrity": "sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==",
+  "_location": "/@types/eslint-scope",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/eslint-scope@^3.7.3",
+    "name": "@types/eslint-scope",
+    "escapedName": "@types%2feslint-scope",
+    "scope": "@types",
+    "rawSpec": "^3.7.3",
+    "saveSpec": null,
+    "fetchSpec": "^3.7.3"
+  },
+  "_requiredBy": [
+    "/webpack"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.7.tgz",
+  "_shasum": "3108bd5f18b0cdb277c867b3dd449c9ed7079ac5",
+  "_spec": "@types/eslint-scope@^3.7.3",
+  "_where": "/Users/ben/Desktop/app/be/be-ytb/js/node_modules/webpack",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Toru Nagashima",
+      "url": "https://github.com/mysticatea"
+    }
+  ],
+  "dependencies": {
+    "@types/eslint": "*",
+    "@types/estree": "*"
+  },
+  "deprecated": false,
+  "description": "TypeScript definitions for eslint-scope",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint-scope",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/eslint-scope",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/eslint-scope"
+  },
+  "scripts": {},
+  "typeScriptVersion": "4.5",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "49eee35b78c19e2c83bc96ce190c7a88329006f876dd7f1fb378c1e8034fc8f2",
+  "version": "3.7.7"
+}

js/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

js/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: Thu, 18 Apr 2024 18:35:25 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).

js/node_modules/@types/eslint/helpers.d.ts

@@ -0,0 +1,3 @@
+type Prepend<Tuple extends any[], Addend> = ((_: Addend, ..._1: Tuple) => any) extends (..._: infer Result) => any
+    ? Result
+    : never;

js/node_modules/@types/eslint/index.d.ts

@@ -0,0 +1,1505 @@
+/// <reference path="helpers.d.ts" />
+
+import * as ESTree from "estree";
+import { JSONSchema4 } from "json-schema";
+
+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[];
+
+    getComments(node: ESTree.Node): { leading: ESTree.Comment[]; trailing: ESTree.Comment[] };
+
+    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 {
+    /**
+     * TODO: Old style rules are planned to be removed in v9, remove this type then (https://github.com/eslint/rfcs/blob/main/designs/2021-schema-object-rules/README.md)
+     * @deprecated Use `RuleModule` instead.
+     */
+    type OldStyleRule = RuleModule["create"];
+
+    interface RuleModule {
+        create(context: RuleContext): RuleListener;
+        meta?: RuleMetaData | undefined;
+        schema?: RuleMetaData["schema"];
+    }
+
+    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;
+    }
+
+    interface CodePath {
+        id: string;
+        initialSegment: CodePathSegment;
+        finalSegments: CodePathSegment[];
+        returnedSegments: CodePathSegment[];
+        thrownSegments: CodePathSegment[];
+        currentSegments: 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;
+            /**
+             * TODO: remove this field in next major release of @types/eslint.
+             * @deprecated use `meta.hasSuggestions` instead
+             */
+            suggestion?: boolean | 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/developer-guide/working-with-rules#options-schemas)
+         * so ESLint can prevent invalid [rule configurations](https://eslint.org/docs/latest/user-guide/configuring/rules#configuring-rules).
+         * Mandatory for rules with options.
+         */
+        schema?: JSONSchema4 | JSONSchema4[] | 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.FlatConfig["languageOptions"];
+        parserOptions: Linter.ParserOptions;
+        parserServices: SourceCode.ParserServices;
+        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 version: string;
+
+    version: string;
+
+    constructor(options?: { cwd?: string | undefined; configType?: "flat" | "eslintrc" });
+
+    verify(
+        code: SourceCode | string,
+        config: Linter.Config | Linter.FlatConfig[],
+        filename?: string,
+    ): Linter.LintMessage[];
+    verify(
+        code: SourceCode | string,
+        config: Linter.Config | Linter.FlatConfig[],
+        options: Linter.LintOptions,
+    ): Linter.LintMessage[];
+
+    verifyAndFix(code: string, config: Linter.Config | Linter.FlatConfig[], filename?: string): Linter.FixReport;
+    verifyAndFix(
+        code: string,
+        config: Linter.Config | Linter.FlatConfig[],
+        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.ParserModule): void;
+}
+
+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 RuleLevel = Severity | StringSeverity;
+
+    /**
+     * An array containing the rule severity level, followed by the rule options.
+     *
+     * @see [Rules](https://eslint.org/docs/user-guide/configuring/rules)
+     */
+    type RuleLevelAndOptions<Options extends any[] = any[]> = Prepend<Partial<Options>, RuleLevel>;
+
+    /**
+     * 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/user-guide/configuring/rules)
+     */
+    type RuleEntry<Options extends any[] = any[]> = RuleLevel | RuleLevelAndOptions<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;
+    }
+
+    /**
+     * ESLint configuration.
+     *
+     * @see [ESLint Configuration](https://eslint.org/docs/latest/user-guide/configuring/)
+     */
+    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/user-guide/configuring/language-options#specifying-environments)
+         */
+        env?: { [name: string]: boolean } | undefined;
+
+        /**
+         * Extending configuration files.
+         *
+         * @see [Extends](https://eslint.org/docs/latest/user-guide/configuring/configuration-files#extending-configuration-files)
+         */
+        extends?: string | string[] | undefined;
+
+        /**
+         * Specifying globals.
+         *
+         * @see [Globals](https://eslint.org/docs/latest/user-guide/configuring/language-options#specifying-globals)
+         */
+        globals?: { [name: string]: boolean | "off" | "readonly" | "readable" | "writable" | "writeable" } | undefined;
+
+        /**
+         * Disable processing of inline comments.
+         *
+         * @see [Disabling Inline Comments](https://eslint.org/docs/latest/user-guide/configuring/rules#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/user-guide/configuring/configuration-files#how-do-overrides-work)
+         */
+        overrides?: Array<ConfigOverride<OverrideRules>> | undefined;
+
+        /**
+         * Parser.
+         *
+         * @see [Working with Custom Parsers](https://eslint.org/docs/latest/developer-guide/working-with-custom-parsers)
+         * @see [Specifying Parser](https://eslint.org/docs/latest/user-guide/configuring/plugins#configure-a-parser)
+         */
+        parser?: string | undefined;
+
+        /**
+         * Parser options.
+         *
+         * @see [Working with Custom Parsers](https://eslint.org/docs/latest/developer-guide/working-with-custom-parsers)
+         * @see [Specifying Parser Options](https://eslint.org/docs/latest/user-guide/configuring/language-options#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/user-guide/configuring/plugins#configure-plugins)
+         */
+        plugins?: string[] | undefined;
+
+        /**
+         * Specifying processor.
+         *
+         * @see [processor](https://eslint.org/docs/latest/user-guide/configuring/plugins#specify-a-processor)
+         */
+        processor?: string | undefined;
+
+        /**
+         * Report unused `ESLint-disable` comments as warning.
+         *
+         * @see [Report unused `ESLint-disable` comments](https://eslint.org/docs/latest/user-guide/configuring/rules#report-unused-eslint-disable-comments)
+         */
+        reportUnusedDisableDirectives?: boolean | undefined;
+
+        /**
+         * Settings.
+         *
+         * @see [Settings](https://eslint.org/docs/latest/user-guide/configuring/configuration-files#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 configuration.
+     *
+     * @see [ESLint Configuration](https://eslint.org/docs/latest/user-guide/configuring/)
+     */
+    // https://github.com/eslint/eslint/blob/v6.8.0/conf/config-schema.js
+    interface Config<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/user-guide/configuring/ignoring-code)
+         */
+        ignorePatterns?: string | string[] | undefined;
+
+        /**
+         * @see [Using Configuration Files](https://eslint.org/docs/latest/user-guide/configuring/configuration-files#using-configuration-files)
+         */
+        root?: boolean | undefined;
+    }
+
+    /**
+     * Parser options.
+     *
+     * @see [Specifying Parser Options](https://eslint.org/docs/user-guide/configuring/language-options#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 2018
+         *
+         * @see https://typescript-eslint.io/architecture/parser/#ecmaversion
+         */
+        ecmaVersion?:
+            | 3
+            | 5
+            | 6
+            | 7
+            | 8
+            | 9
+            | 10
+            | 11
+            | 12
+            | 13
+            | 14
+            | 15
+            | 2015
+            | 2016
+            | 2017
+            | 2018
+            | 2019
+            | 2020
+            | 2021
+            | 2022
+            | 2023
+            | 2024
+            | "latest"
+            | undefined;
+
+        /**
+         * Set to "script" (default) or "module" if your code is in ECMAScript modules.
+         *
+         * @default 'script'
+         *
+         * @see https://eslint.org/docs/latest/user-guide/configuring/language-options#specifying-parser-options
+         */
+        sourceType?: "script" | "module" | undefined;
+
+        /**
+         * An object indicating which additional language features you'd like to use.
+         *
+         * @see https://eslint.org/docs/latest/user-guide/configuring/language-options#specifying-parser-options
+         * @see https://typescript-eslint.io/architecture/parser#ecmafeatures
+         */
+        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: Severity;
+        fix?: Rule.Fix | undefined;
+        /** @deprecated Use `linter.getSourceCode()` */
+        source?: string | null | 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 FlatConfigParserModule =
+        & Omit<ParserModule, "parseForESLint">
+        & ({
+            parse(text: string, options?: any): unknown;
+        } | {
+            parseForESLint(text: string, options?: any): Omit<ESLintParseResult, "ast" | "scopeManager"> & {
+                ast: unknown;
+                scopeManager?: unknown;
+            };
+        });
+
+    type ParserModule =
+        & ESLint.ObjectMetaProperties
+        & (
+            | { parse(text: string, options?: any): AST.Program }
+            | { parseForESLint(text: string, options?: any): ESLintParseResult }
+        );
+
+    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/developer-guide/working-with-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 FlatConfig<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?: {
+            /**
+             * 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?: ParserOptions["ecmaVersion"];
+
+            /**
+             * 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?: "script" | "module" | "commonjs";
+
+            /**
+             * An object specifying additional objects that should be added to the
+             * global scope during linting.
+             */
+            globals?: ESLint.Environment["globals"];
+
+            /**
+             * An object containing a parse() or parseForESLint() method.
+             * If not configured, the default ESLint parser (Espree) will be used.
+             */
+            parser?: FlatConfigParserModule;
+
+            /**
+             * An object specifying additional options that are passed directly to the
+             * parser() method on the parser. The available options are parser-dependent
+             */
+            parserOptions?: ESLint.Environment["parserOptions"];
+        };
+
+        /**
+         * An object containing settings related to the linting process
+         */
+        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;
+        };
+
+        /**
+         * 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>;
+    }
+}
+
+// #endregion
+
+// #region ESLint
+
+export class ESLint {
+    static 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"];
+
+    calculateConfigForFile(filePath: string): Promise<any>;
+
+    isPathIgnored(filePath: string): Promise<boolean>;
+
+    loadFormatter(nameOrPath?: string): Promise<ESLint.Formatter>;
+}
+
+export namespace ESLint {
+    type ConfigData<Rules extends Linter.RulesRecord = Linter.RulesRecord> = Omit<Linter.Config<Rules>, "$schema">;
+
+    interface Globals {
+        [name: string]: boolean | "writable" | "readonly" | "off";
+    }
+
+    interface Environment {
+        globals?: 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, ConfigData | Linter.FlatConfig | Linter.FlatConfig[]> | undefined;
+        environments?: Record<string, Environment> | undefined;
+        processors?: Record<string, Linter.Processor> | undefined;
+        rules?: Record<string, Rule.OldStyleRule | Rule.RuleModule> | undefined;
+    }
+
+    interface Options {
+        // 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.Config | undefined;
+        overrideConfig?: Linter.Config | 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?: Array<Rule.RuleMetaData["type"]> | undefined;
+
+        // Cache-related
+        cache?: boolean | undefined;
+        cacheLocation?: string | undefined;
+        cacheStrategy?: "content" | "metadata" | 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;
+        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 type by this name
+    type EditInfo = Rule.Fix;
+}
+
+// #endregion
+
+// #region RuleTester
+
+export class RuleTester {
+    constructor(config?: any);
+
+    run(
+        name: string,
+        rule: Rule.RuleModule,
+        tests: {
+            valid?: Array<string | RuleTester.ValidTestCase> | undefined;
+            invalid?: RuleTester.InvalidTestCase[] | undefined;
+        },
+    ): 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;
+        parserOptions?: Linter.ParserOptions | undefined;
+        settings?: { [name: string]: any } | undefined;
+        parser?: string | undefined;
+        globals?: { [name: string]: boolean } | undefined;
+    }
+
+    interface SuggestionOutput {
+        messageId?: string | undefined;
+        desc?: string | undefined;
+        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 | undefined;
+        messageId?: string | undefined;
+        type?: string | undefined;
+        data?: any;
+        line?: number | undefined;
+        column?: number | undefined;
+        endLine?: number | undefined;
+        endColumn?: number | undefined;
+        suggestions?: SuggestionOutput[] | undefined;
+    }
+}
+
+// #endregion

js/node_modules/@types/eslint/package.json

@@ -0,0 +1,92 @@
+{
+  "_from": "@types/eslint@*",
+  "_id": "@types/eslint@8.56.10",
+  "_inBundle": false,
+  "_integrity": "sha512-Shavhk87gCtY2fhXDctcfS3e6FdxWkCx1iUZ9eEUbh7rTqlZT0/IzOkCOVt0fCjcFuZ9FPYfuezTBImfHCDBGQ==",
+  "_location": "/@types/eslint",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/eslint@*",
+    "name": "@types/eslint",
+    "escapedName": "@types%2feslint",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/eslint-scope"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.56.10.tgz",
+  "_shasum": "eb2370a73bf04a901eeba8f22595c7ee0f7eb58d",
+  "_spec": "@types/eslint@*",
+  "_where": "/Users/ben/Desktop/app/be/be-ytb/js/node_modules/@types/eslint-scope",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Pierre-Marie Dartus",
+      "url": "https://github.com/pmdartus"
+    },
+    {
+      "name": "Jed Fox",
+      "url": "https://github.com/j-f1"
+    },
+    {
+      "name": "Saad Quadri",
+      "url": "https://github.com/saadq"
+    },
+    {
+      "name": "Jason Kwok",
+      "url": "https://github.com/JasonHK"
+    },
+    {
+      "name": "Brad Zacher",
+      "url": "https://github.com/bradzacher"
+    },
+    {
+      "name": "JounQin",
+      "url": "https://github.com/JounQin"
+    },
+    {
+      "name": "Bryan Mishkin",
+      "url": "https://github.com/bmish"
+    }
+  ],
+  "dependencies": {
+    "@types/estree": "*",
+    "@types/json-schema": "*"
+  },
+  "deprecated": false,
+  "description": "TypeScript definitions for eslint",
+  "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"
+  },
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/eslint",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/eslint"
+  },
+  "scripts": {},
+  "typeScriptVersion": "4.7",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "522d3c76ab9a1be04075a38852c1f9c8c64f6722d17428f2cbbddc55e0477b81",
+  "version": "8.56.10"
+}

js/node_modules/@types/eslint/rules/best-practices.d.ts

@@ -0,0 +1,1039 @@
+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<[]>;
+
+    /**
+     * 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"]>;
+}

js/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;
+            }>,
+        ]
+    >;
+}

js/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",
+        ]
+    >;
+}

js/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
+{}

js/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;
+            },
+        ]
+    >;
+}

js/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;
+            }>,
+        ]
+    >;
+}

js/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"]>;
+}

js/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<[]>;
+}

js/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",
+        ]
+    >;
+}

js/node_modules/@types/eslint/use-at-your-own-risk.d.ts

@@ -0,0 +1,19 @@
+/** @deprecated */
+export const builtinRules: Map<string, import("./index.js").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 }>;
+}

js/node_modules/@types/estree/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

js/node_modules/@types/estree/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/estree`
+
+# Summary
+This package contains type definitions for estree (https://github.com/estree/estree).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree.
+
+### Additional Details
+ * Last updated: Mon, 06 Nov 2023 22:41:05 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [RReverser](https://github.com/RReverser).

js/node_modules/@types/estree/flow.d.ts

@@ -0,0 +1,167 @@
+declare namespace ESTree {
+    interface FlowTypeAnnotation extends Node {}
+
+    interface FlowBaseTypeAnnotation extends FlowTypeAnnotation {}
+
+    interface FlowLiteralTypeAnnotation extends FlowTypeAnnotation, Literal {}
+
+    interface FlowDeclaration extends Declaration {}
+
+    interface AnyTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface ArrayTypeAnnotation extends FlowTypeAnnotation {
+        elementType: FlowTypeAnnotation;
+    }
+
+    interface BooleanLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+
+    interface BooleanTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface ClassImplements extends Node {
+        id: Identifier;
+        typeParameters?: TypeParameterInstantiation | null;
+    }
+
+    interface ClassProperty {
+        key: Expression;
+        value?: Expression | null;
+        typeAnnotation?: TypeAnnotation | null;
+        computed: boolean;
+        static: boolean;
+    }
+
+    interface DeclareClass extends FlowDeclaration {
+        id: Identifier;
+        typeParameters?: TypeParameterDeclaration | null;
+        body: ObjectTypeAnnotation;
+        extends: InterfaceExtends[];
+    }
+
+    interface DeclareFunction extends FlowDeclaration {
+        id: Identifier;
+    }
+
+    interface DeclareModule extends FlowDeclaration {
+        id: Literal | Identifier;
+        body: BlockStatement;
+    }
+
+    interface DeclareVariable extends FlowDeclaration {
+        id: Identifier;
+    }
+
+    interface FunctionTypeAnnotation extends FlowTypeAnnotation {
+        params: FunctionTypeParam[];
+        returnType: FlowTypeAnnotation;
+        rest?: FunctionTypeParam | null;
+        typeParameters?: TypeParameterDeclaration | null;
+    }
+
+    interface FunctionTypeParam {
+        name: Identifier;
+        typeAnnotation: FlowTypeAnnotation;
+        optional: boolean;
+    }
+
+    interface GenericTypeAnnotation extends FlowTypeAnnotation {
+        id: Identifier | QualifiedTypeIdentifier;
+        typeParameters?: TypeParameterInstantiation | null;
+    }
+
+    interface InterfaceExtends extends Node {
+        id: Identifier | QualifiedTypeIdentifier;
+        typeParameters?: TypeParameterInstantiation | null;
+    }
+
+    interface InterfaceDeclaration extends FlowDeclaration {
+        id: Identifier;
+        typeParameters?: TypeParameterDeclaration | null;
+        extends: InterfaceExtends[];
+        body: ObjectTypeAnnotation;
+    }
+
+    interface IntersectionTypeAnnotation extends FlowTypeAnnotation {
+        types: FlowTypeAnnotation[];
+    }
+
+    interface MixedTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface NullableTypeAnnotation extends FlowTypeAnnotation {
+        typeAnnotation: TypeAnnotation;
+    }
+
+    interface NumberLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+
+    interface NumberTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface StringLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+
+    interface StringTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface TupleTypeAnnotation extends FlowTypeAnnotation {
+        types: FlowTypeAnnotation[];
+    }
+
+    interface TypeofTypeAnnotation extends FlowTypeAnnotation {
+        argument: FlowTypeAnnotation;
+    }
+
+    interface TypeAlias extends FlowDeclaration {
+        id: Identifier;
+        typeParameters?: TypeParameterDeclaration | null;
+        right: FlowTypeAnnotation;
+    }
+
+    interface TypeAnnotation extends Node {
+        typeAnnotation: FlowTypeAnnotation;
+    }
+
+    interface TypeCastExpression extends Expression {
+        expression: Expression;
+        typeAnnotation: TypeAnnotation;
+    }
+
+    interface TypeParameterDeclaration extends Node {
+        params: Identifier[];
+    }
+
+    interface TypeParameterInstantiation extends Node {
+        params: FlowTypeAnnotation[];
+    }
+
+    interface ObjectTypeAnnotation extends FlowTypeAnnotation {
+        properties: ObjectTypeProperty[];
+        indexers: ObjectTypeIndexer[];
+        callProperties: ObjectTypeCallProperty[];
+    }
+
+    interface ObjectTypeCallProperty extends Node {
+        value: FunctionTypeAnnotation;
+        static: boolean;
+    }
+
+    interface ObjectTypeIndexer extends Node {
+        id: Identifier;
+        key: FlowTypeAnnotation;
+        value: FlowTypeAnnotation;
+        static: boolean;
+    }
+
+    interface ObjectTypeProperty extends Node {
+        key: Expression;
+        value: FlowTypeAnnotation;
+        optional: boolean;
+        static: boolean;
+    }
+
+    interface QualifiedTypeIdentifier extends Node {
+        qualification: Identifier | QualifiedTypeIdentifier;
+        id: Identifier;
+    }
+
+    interface UnionTypeAnnotation extends FlowTypeAnnotation {
+        types: FlowTypeAnnotation[];
+    }
+
+    interface VoidTypeAnnotation extends FlowBaseTypeAnnotation {}
+}

js/node_modules/@types/estree/index.d.ts

@@ -0,0 +1,683 @@
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inherited fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+
+export interface BaseNodeWithoutComments {
+    // Every leaf interface that extends BaseNode must specify a type property.
+    // The type property should be a string literal. For example, Identifier
+    // has: `type: "Identifier"`
+    type: string;
+    loc?: SourceLocation | null | undefined;
+    range?: [number, number] | undefined;
+}
+
+export interface BaseNode extends BaseNodeWithoutComments {
+    leadingComments?: Comment[] | undefined;
+    trailingComments?: Comment[] | undefined;
+}
+
+export interface NodeMap {
+    AssignmentProperty: AssignmentProperty;
+    CatchClause: CatchClause;
+    Class: Class;
+    ClassBody: ClassBody;
+    Expression: Expression;
+    Function: Function;
+    Identifier: Identifier;
+    Literal: Literal;
+    MethodDefinition: MethodDefinition;
+    ModuleDeclaration: ModuleDeclaration;
+    ModuleSpecifier: ModuleSpecifier;
+    Pattern: Pattern;
+    PrivateIdentifier: PrivateIdentifier;
+    Program: Program;
+    Property: Property;
+    PropertyDefinition: PropertyDefinition;
+    SpreadElement: SpreadElement;
+    Statement: Statement;
+    Super: Super;
+    SwitchCase: SwitchCase;
+    TemplateElement: TemplateElement;
+    VariableDeclarator: VariableDeclarator;
+}
+
+export type Node = NodeMap[keyof NodeMap];
+
+export interface Comment extends BaseNodeWithoutComments {
+    type: "Line" | "Block";
+    value: string;
+}
+
+export interface SourceLocation {
+    source?: string | null | undefined;
+    start: Position;
+    end: Position;
+}
+
+export interface Position {
+    /** >= 1 */
+    line: number;
+    /** >= 0 */
+    column: number;
+}
+
+export interface Program extends BaseNode {
+    type: "Program";
+    sourceType: "script" | "module";
+    body: Array<Directive | Statement | ModuleDeclaration>;
+    comments?: Comment[] | undefined;
+}
+
+export interface Directive extends BaseNode {
+    type: "ExpressionStatement";
+    expression: Literal;
+    directive: string;
+}
+
+export interface BaseFunction extends BaseNode {
+    params: Pattern[];
+    generator?: boolean | undefined;
+    async?: boolean | undefined;
+    // The body is either BlockStatement or Expression because arrow functions
+    // can have a body that's either. FunctionDeclarations and
+    // FunctionExpressions have only BlockStatement bodies.
+    body: BlockStatement | Expression;
+}
+
+export type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+
+export type Statement =
+    | ExpressionStatement
+    | BlockStatement
+    | StaticBlock
+    | EmptyStatement
+    | DebuggerStatement
+    | WithStatement
+    | ReturnStatement
+    | LabeledStatement
+    | BreakStatement
+    | ContinueStatement
+    | IfStatement
+    | SwitchStatement
+    | ThrowStatement
+    | TryStatement
+    | WhileStatement
+    | DoWhileStatement
+    | ForStatement
+    | ForInStatement
+    | ForOfStatement
+    | Declaration;
+
+export interface BaseStatement extends BaseNode {}
+
+export interface EmptyStatement extends BaseStatement {
+    type: "EmptyStatement";
+}
+
+export interface BlockStatement extends BaseStatement {
+    type: "BlockStatement";
+    body: Statement[];
+    innerComments?: Comment[] | undefined;
+}
+
+export interface StaticBlock extends Omit<BlockStatement, "type"> {
+    type: "StaticBlock";
+}
+
+export interface ExpressionStatement extends BaseStatement {
+    type: "ExpressionStatement";
+    expression: Expression;
+}
+
+export interface IfStatement extends BaseStatement {
+    type: "IfStatement";
+    test: Expression;
+    consequent: Statement;
+    alternate?: Statement | null | undefined;
+}
+
+export interface LabeledStatement extends BaseStatement {
+    type: "LabeledStatement";
+    label: Identifier;
+    body: Statement;
+}
+
+export interface BreakStatement extends BaseStatement {
+    type: "BreakStatement";
+    label?: Identifier | null | undefined;
+}
+
+export interface ContinueStatement extends BaseStatement {
+    type: "ContinueStatement";
+    label?: Identifier | null | undefined;
+}
+
+export interface WithStatement extends BaseStatement {
+    type: "WithStatement";
+    object: Expression;
+    body: Statement;
+}
+
+export interface SwitchStatement extends BaseStatement {
+    type: "SwitchStatement";
+    discriminant: Expression;
+    cases: SwitchCase[];
+}
+
+export interface ReturnStatement extends BaseStatement {
+    type: "ReturnStatement";
+    argument?: Expression | null | undefined;
+}
+
+export interface ThrowStatement extends BaseStatement {
+    type: "ThrowStatement";
+    argument: Expression;
+}
+
+export interface TryStatement extends BaseStatement {
+    type: "TryStatement";
+    block: BlockStatement;
+    handler?: CatchClause | null | undefined;
+    finalizer?: BlockStatement | null | undefined;
+}
+
+export interface WhileStatement extends BaseStatement {
+    type: "WhileStatement";
+    test: Expression;
+    body: Statement;
+}
+
+export interface DoWhileStatement extends BaseStatement {
+    type: "DoWhileStatement";
+    body: Statement;
+    test: Expression;
+}
+
+export interface ForStatement extends BaseStatement {
+    type: "ForStatement";
+    init?: VariableDeclaration | Expression | null | undefined;
+    test?: Expression | null | undefined;
+    update?: Expression | null | undefined;
+    body: Statement;
+}
+
+export interface BaseForXStatement extends BaseStatement {
+    left: VariableDeclaration | Pattern;
+    right: Expression;
+    body: Statement;
+}
+
+export interface ForInStatement extends BaseForXStatement {
+    type: "ForInStatement";
+}
+
+export interface DebuggerStatement extends BaseStatement {
+    type: "DebuggerStatement";
+}
+
+export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+
+export interface BaseDeclaration extends BaseStatement {}
+
+export interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+    type: "FunctionDeclaration";
+    /** It is null when a function declaration is a part of the `export default function` statement */
+    id: Identifier | null;
+    body: BlockStatement;
+}
+
+export interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+    id: Identifier;
+}
+
+export interface VariableDeclaration extends BaseDeclaration {
+    type: "VariableDeclaration";
+    declarations: VariableDeclarator[];
+    kind: "var" | "let" | "const";
+}
+
+export interface VariableDeclarator extends BaseNode {
+    type: "VariableDeclarator";
+    id: Pattern;
+    init?: Expression | null | undefined;
+}
+
+export interface ExpressionMap {
+    ArrayExpression: ArrayExpression;
+    ArrowFunctionExpression: ArrowFunctionExpression;
+    AssignmentExpression: AssignmentExpression;
+    AwaitExpression: AwaitExpression;
+    BinaryExpression: BinaryExpression;
+    CallExpression: CallExpression;
+    ChainExpression: ChainExpression;
+    ClassExpression: ClassExpression;
+    ConditionalExpression: ConditionalExpression;
+    FunctionExpression: FunctionExpression;
+    Identifier: Identifier;
+    ImportExpression: ImportExpression;
+    Literal: Literal;
+    LogicalExpression: LogicalExpression;
+    MemberExpression: MemberExpression;
+    MetaProperty: MetaProperty;
+    NewExpression: NewExpression;
+    ObjectExpression: ObjectExpression;
+    SequenceExpression: SequenceExpression;
+    TaggedTemplateExpression: TaggedTemplateExpression;
+    TemplateLiteral: TemplateLiteral;
+    ThisExpression: ThisExpression;
+    UnaryExpression: UnaryExpression;
+    UpdateExpression: UpdateExpression;
+    YieldExpression: YieldExpression;
+}
+
+export type Expression = ExpressionMap[keyof ExpressionMap];
+
+export interface BaseExpression extends BaseNode {}
+
+export type ChainElement = SimpleCallExpression | MemberExpression;
+
+export interface ChainExpression extends BaseExpression {
+    type: "ChainExpression";
+    expression: ChainElement;
+}
+
+export interface ThisExpression extends BaseExpression {
+    type: "ThisExpression";
+}
+
+export interface ArrayExpression extends BaseExpression {
+    type: "ArrayExpression";
+    elements: Array<Expression | SpreadElement | null>;
+}
+
+export interface ObjectExpression extends BaseExpression {
+    type: "ObjectExpression";
+    properties: Array<Property | SpreadElement>;
+}
+
+export interface PrivateIdentifier extends BaseNode {
+    type: "PrivateIdentifier";
+    name: string;
+}
+
+export interface Property extends BaseNode {
+    type: "Property";
+    key: Expression | PrivateIdentifier;
+    value: Expression | Pattern; // Could be an AssignmentProperty
+    kind: "init" | "get" | "set";
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+}
+
+export interface PropertyDefinition extends BaseNode {
+    type: "PropertyDefinition";
+    key: Expression | PrivateIdentifier;
+    value?: Expression | null | undefined;
+    computed: boolean;
+    static: boolean;
+}
+
+export interface FunctionExpression extends BaseFunction, BaseExpression {
+    id?: Identifier | null | undefined;
+    type: "FunctionExpression";
+    body: BlockStatement;
+}
+
+export interface SequenceExpression extends BaseExpression {
+    type: "SequenceExpression";
+    expressions: Expression[];
+}
+
+export interface UnaryExpression extends BaseExpression {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    prefix: true;
+    argument: Expression;
+}
+
+export interface BinaryExpression extends BaseExpression {
+    type: "BinaryExpression";
+    operator: BinaryOperator;
+    left: Expression;
+    right: Expression;
+}
+
+export interface AssignmentExpression extends BaseExpression {
+    type: "AssignmentExpression";
+    operator: AssignmentOperator;
+    left: Pattern | MemberExpression;
+    right: Expression;
+}
+
+export interface UpdateExpression extends BaseExpression {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    argument: Expression;
+    prefix: boolean;
+}
+
+export interface LogicalExpression extends BaseExpression {
+    type: "LogicalExpression";
+    operator: LogicalOperator;
+    left: Expression;
+    right: Expression;
+}
+
+export interface ConditionalExpression extends BaseExpression {
+    type: "ConditionalExpression";
+    test: Expression;
+    alternate: Expression;
+    consequent: Expression;
+}
+
+export interface BaseCallExpression extends BaseExpression {
+    callee: Expression | Super;
+    arguments: Array<Expression | SpreadElement>;
+}
+export type CallExpression = SimpleCallExpression | NewExpression;
+
+export interface SimpleCallExpression extends BaseCallExpression {
+    type: "CallExpression";
+    optional: boolean;
+}
+
+export interface NewExpression extends BaseCallExpression {
+    type: "NewExpression";
+}
+
+export interface MemberExpression extends BaseExpression, BasePattern {
+    type: "MemberExpression";
+    object: Expression | Super;
+    property: Expression | PrivateIdentifier;
+    computed: boolean;
+    optional: boolean;
+}
+
+export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+
+export interface BasePattern extends BaseNode {}
+
+export interface SwitchCase extends BaseNode {
+    type: "SwitchCase";
+    test?: Expression | null | undefined;
+    consequent: Statement[];
+}
+
+export interface CatchClause extends BaseNode {
+    type: "CatchClause";
+    param: Pattern | null;
+    body: BlockStatement;
+}
+
+export interface Identifier extends BaseNode, BaseExpression, BasePattern {
+    type: "Identifier";
+    name: string;
+}
+
+export type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+
+export interface SimpleLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value: string | boolean | number | null;
+    raw?: string | undefined;
+}
+
+export interface RegExpLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: RegExp | null | undefined;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+    raw?: string | undefined;
+}
+
+export interface BigIntLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: bigint | null | undefined;
+    bigint: string;
+    raw?: string | undefined;
+}
+
+export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+
+export type BinaryOperator =
+    | "=="
+    | "!="
+    | "==="
+    | "!=="
+    | "<"
+    | "<="
+    | ">"
+    | ">="
+    | "<<"
+    | ">>"
+    | ">>>"
+    | "+"
+    | "-"
+    | "*"
+    | "/"
+    | "%"
+    | "**"
+    | "|"
+    | "^"
+    | "&"
+    | "in"
+    | "instanceof";
+
+export type LogicalOperator = "||" | "&&" | "??";
+
+export type AssignmentOperator =
+    | "="
+    | "+="
+    | "-="
+    | "*="
+    | "/="
+    | "%="
+    | "**="
+    | "<<="
+    | ">>="
+    | ">>>="
+    | "|="
+    | "^="
+    | "&="
+    | "||="
+    | "&&="
+    | "??=";
+
+export type UpdateOperator = "++" | "--";
+
+export interface ForOfStatement extends BaseForXStatement {
+    type: "ForOfStatement";
+    await: boolean;
+}
+
+export interface Super extends BaseNode {
+    type: "Super";
+}
+
+export interface SpreadElement extends BaseNode {
+    type: "SpreadElement";
+    argument: Expression;
+}
+
+export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+    type: "ArrowFunctionExpression";
+    expression: boolean;
+    body: BlockStatement | Expression;
+}
+
+export interface YieldExpression extends BaseExpression {
+    type: "YieldExpression";
+    argument?: Expression | null | undefined;
+    delegate: boolean;
+}
+
+export interface TemplateLiteral extends BaseExpression {
+    type: "TemplateLiteral";
+    quasis: TemplateElement[];
+    expressions: Expression[];
+}
+
+export interface TaggedTemplateExpression extends BaseExpression {
+    type: "TaggedTemplateExpression";
+    tag: Expression;
+    quasi: TemplateLiteral;
+}
+
+export interface TemplateElement extends BaseNode {
+    type: "TemplateElement";
+    tail: boolean;
+    value: {
+        /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
+        cooked?: string | null | undefined;
+        raw: string;
+    };
+}
+
+export interface AssignmentProperty extends Property {
+    value: Pattern;
+    kind: "init";
+    method: boolean; // false
+}
+
+export interface ObjectPattern extends BasePattern {
+    type: "ObjectPattern";
+    properties: Array<AssignmentProperty | RestElement>;
+}
+
+export interface ArrayPattern extends BasePattern {
+    type: "ArrayPattern";
+    elements: Array<Pattern | null>;
+}
+
+export interface RestElement extends BasePattern {
+    type: "RestElement";
+    argument: Pattern;
+}
+
+export interface AssignmentPattern extends BasePattern {
+    type: "AssignmentPattern";
+    left: Pattern;
+    right: Expression;
+}
+
+export type Class = ClassDeclaration | ClassExpression;
+export interface BaseClass extends BaseNode {
+    superClass?: Expression | null | undefined;
+    body: ClassBody;
+}
+
+export interface ClassBody extends BaseNode {
+    type: "ClassBody";
+    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+}
+
+export interface MethodDefinition extends BaseNode {
+    type: "MethodDefinition";
+    key: Expression | PrivateIdentifier;
+    value: FunctionExpression;
+    kind: "constructor" | "method" | "get" | "set";
+    computed: boolean;
+    static: boolean;
+}
+
+export interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+    type: "ClassDeclaration";
+    /** It is null when a class declaration is a part of the `export default class` statement */
+    id: Identifier | null;
+}
+
+export interface ClassDeclaration extends MaybeNamedClassDeclaration {
+    id: Identifier;
+}
+
+export interface ClassExpression extends BaseClass, BaseExpression {
+    type: "ClassExpression";
+    id?: Identifier | null | undefined;
+}
+
+export interface MetaProperty extends BaseExpression {
+    type: "MetaProperty";
+    meta: Identifier;
+    property: Identifier;
+}
+
+export type ModuleDeclaration =
+    | ImportDeclaration
+    | ExportNamedDeclaration
+    | ExportDefaultDeclaration
+    | ExportAllDeclaration;
+export interface BaseModuleDeclaration extends BaseNode {}
+
+export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+export interface BaseModuleSpecifier extends BaseNode {
+    local: Identifier;
+}
+
+export interface ImportDeclaration extends BaseModuleDeclaration {
+    type: "ImportDeclaration";
+    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+    source: Literal;
+}
+
+export interface ImportSpecifier extends BaseModuleSpecifier {
+    type: "ImportSpecifier";
+    imported: Identifier;
+}
+
+export interface ImportExpression extends BaseExpression {
+    type: "ImportExpression";
+    source: Expression;
+}
+
+export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+    type: "ImportDefaultSpecifier";
+}
+
+export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+    type: "ImportNamespaceSpecifier";
+}
+
+export interface ExportNamedDeclaration extends BaseModuleDeclaration {
+    type: "ExportNamedDeclaration";
+    declaration?: Declaration | null | undefined;
+    specifiers: ExportSpecifier[];
+    source?: Literal | null | undefined;
+}
+
+export interface ExportSpecifier extends BaseModuleSpecifier {
+    type: "ExportSpecifier";
+    exported: Identifier;
+}
+
+export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+    type: "ExportDefaultDeclaration";
+    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
+}
+
+export interface ExportAllDeclaration extends BaseModuleDeclaration {
+    type: "ExportAllDeclaration";
+    exported: Identifier | null;
+    source: Literal;
+}
+
+export interface AwaitExpression extends BaseExpression {
+    type: "AwaitExpression";
+    argument: Expression;
+}

js/node_modules/@types/estree/package.json

@@ -0,0 +1,56 @@
+{
+  "_from": "@types/estree@^1.0.5",
+  "_id": "@types/estree@1.0.5",
+  "_inBundle": false,
+  "_integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==",
+  "_location": "/@types/estree",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/estree@^1.0.5",
+    "name": "@types/estree",
+    "escapedName": "@types%2festree",
+    "scope": "@types",
+    "rawSpec": "^1.0.5",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.5"
+  },
+  "_requiredBy": [
+    "/@types/eslint",
+    "/@types/eslint-scope",
+    "/webpack"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
+  "_shasum": "a6ce3e556e00fd9895dd872dd172ad0d4bd687f4",
+  "_spec": "@types/estree@^1.0.5",
+  "_where": "/Users/ben/Desktop/app/be/be-ytb/js/node_modules/webpack",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "RReverser",
+      "url": "https://github.com/RReverser"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for estree",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/estree",
+  "nonNpm": true,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/estree"
+  },
+  "scripts": {},
+  "typeScriptVersion": "4.5",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "6f0eeaffe488ce594e73f8df619c677d752a279b51edbc744e4aebb20db4b3a7",
+  "version": "1.0.5"
+}

js/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

js/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).

js/node_modules/@types/json-schema/index.d.ts

@@ -0,0 +1,749 @@
+// ==================================================================================================
+// JSON Schema Draft 04
+// ==================================================================================================
+
+/**
+ * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
+ */
+export type JSONSchema4TypeName =
+    | "string" //
+    | "number"
+    | "integer"
+    | "boolean"
+    | "object"
+    | "array"
+    | "null"
+    | "any";
+
+/**
+ * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5
+ */
+export type JSONSchema4Type =
+    | string //
+    | number
+    | boolean
+    | JSONSchema4Object
+    | JSONSchema4Array
+    | null;
+
+// Workaround for infinite type recursion
+export interface JSONSchema4Object {
+    [key: string]: JSONSchema4Type;
+}
+
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+export interface JSONSchema4Array extends Array<JSONSchema4Type> {}
+
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-04/schema#'
+ * - 'http://json-schema.org/draft-04/hyper-schema#'
+ * - 'http://json-schema.org/draft-03/schema#'
+ * - 'http://json-schema.org/draft-03/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+export type JSONSchema4Version = string;
+
+/**
+ * JSON Schema V4
+ * @see https://tools.ietf.org/html/draft-zyp-json-schema-04
+ */
+export interface JSONSchema4 {
+    id?: string | undefined;
+    $ref?: string | undefined;
+    $schema?: JSONSchema4Version | undefined;
+
+    /**
+     * This attribute is a string that provides a short description of the
+     * instance property.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.21
+     */
+    title?: string | undefined;
+
+    /**
+     * This attribute is a string that provides a full description of the of
+     * purpose the instance property.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.22
+     */
+    description?: string | undefined;
+
+    default?: JSONSchema4Type | undefined;
+    multipleOf?: number | undefined;
+    maximum?: number | undefined;
+    exclusiveMaximum?: boolean | undefined;
+    minimum?: number | undefined;
+    exclusiveMinimum?: boolean | undefined;
+    maxLength?: number | undefined;
+    minLength?: number | undefined;
+    pattern?: string | undefined;
+
+    /**
+     * May only be defined when "items" is defined, and is a tuple of JSONSchemas.
+     *
+     * This provides a definition for additional items in an array instance
+     * when tuple definitions of the items is provided.  This can be false
+     * to indicate additional items in the array are not allowed, or it can
+     * be a schema that defines the schema of the additional items.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.6
+     */
+    additionalItems?: boolean | JSONSchema4 | undefined;
+
+    /**
+     * This attribute defines the allowed items in an instance array, and
+     * MUST be a schema or an array of schemas.  The default value is an
+     * empty schema which allows any value for items in the instance array.
+     *
+     * When this attribute value is a schema and the instance value is an
+     * array, then all the items in the array MUST be valid according to the
+     * schema.
+     *
+     * When this attribute value is an array of schemas and the instance
+     * value is an array, each position in the instance array MUST conform
+     * to the schema in the corresponding position for this array.  This
+     * called tuple typing.  When tuple typing is used, additional items are
+     * allowed, disallowed, or constrained by the "additionalItems"
+     * (Section 5.6) attribute using the same rules as
+     * "additionalProperties" (Section 5.4) for objects.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5
+     */
+    items?: JSONSchema4 | JSONSchema4[] | undefined;
+
+    maxItems?: number | undefined;
+    minItems?: number | undefined;
+    uniqueItems?: boolean | undefined;
+    maxProperties?: number | undefined;
+    minProperties?: number | undefined;
+
+    /**
+     * This attribute indicates if the instance must have a value, and not
+     * be undefined. This is false by default, making the instance
+     * optional.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.7
+     */
+    required?: boolean | string[] | undefined;
+
+    /**
+     * This attribute defines a schema for all properties that are not
+     * explicitly defined in an object type definition. If specified, the
+     * value MUST be a schema or a boolean. If false is provided, no
+     * additional properties are allowed beyond the properties defined in
+     * the schema. The default value is an empty schema which allows any
+     * value for additional properties.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.4
+     */
+    additionalProperties?: boolean | JSONSchema4 | undefined;
+
+    definitions?: {
+        [k: string]: JSONSchema4;
+    } | undefined;
+
+    /**
+     * This attribute is an object with property definitions that define the
+     * valid values of instance object property values. When the instance
+     * value is an object, the property values of the instance object MUST
+     * conform to the property definitions in this object. In this object,
+     * each property definition's value MUST be a schema, and the property's
+     * name MUST be the name of the instance property that it defines.  The
+     * instance property value MUST be valid according to the schema from
+     * the property definition. Properties are considered unordered, the
+     * order of the instance properties MAY be in any order.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.2
+     */
+    properties?: {
+        [k: string]: JSONSchema4;
+    } | undefined;
+
+    /**
+     * This attribute is an object that defines the schema for a set of
+     * property names of an object instance. The name of each property of
+     * this attribute's object is a regular expression pattern in the ECMA
+     * 262/Perl 5 format, while the value is a schema. If the pattern
+     * matches the name of a property on the instance object, the value of
+     * the instance's property MUST be valid against the pattern name's
+     * schema value.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.3
+     */
+    patternProperties?: {
+        [k: string]: JSONSchema4;
+    } | undefined;
+    dependencies?: {
+        [k: string]: JSONSchema4 | string[];
+    } | undefined;
+
+    /**
+     * This provides an enumeration of all possible values that are valid
+     * for the instance property. This MUST be an array, and each item in
+     * the array represents a possible value for the instance value. If
+     * this attribute is defined, the instance value MUST be one of the
+     * values in the array in order for the schema to be valid.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
+     */
+    enum?: JSONSchema4Type[] | undefined;
+
+    /**
+     * A single type, or a union of simple types
+     */
+    type?: JSONSchema4TypeName | JSONSchema4TypeName[] | undefined;
+
+    allOf?: JSONSchema4[] | undefined;
+    anyOf?: JSONSchema4[] | undefined;
+    oneOf?: JSONSchema4[] | undefined;
+    not?: JSONSchema4 | undefined;
+
+    /**
+     * The value of this property MUST be another schema which will provide
+     * a base schema which the current schema will inherit from.  The
+     * inheritance rules are such that any instance that is valid according
+     * to the current schema MUST be valid according to the referenced
+     * schema.  This MAY also be an array, in which case, the instance MUST
+     * be valid for all the schemas in the array.  A schema that extends
+     * another schema MAY define additional attributes, constrain existing
+     * attributes, or add other constraints.
+     *
+     * Conceptually, the behavior of extends can be seen as validating an
+     * instance against all constraints in the extending schema as well as
+     * the extended schema(s).
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.26
+     */
+    extends?: string | string[] | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-5.6
+     */
+    [k: string]: any;
+
+    format?: string | undefined;
+}
+
+// ==================================================================================================
+// JSON Schema Draft 06
+// ==================================================================================================
+
+export type JSONSchema6TypeName =
+    | "string" //
+    | "number"
+    | "integer"
+    | "boolean"
+    | "object"
+    | "array"
+    | "null"
+    | "any";
+
+export type JSONSchema6Type =
+    | string //
+    | number
+    | boolean
+    | JSONSchema6Object
+    | JSONSchema6Array
+    | null;
+
+// Workaround for infinite type recursion
+export interface JSONSchema6Object {
+    [key: string]: JSONSchema6Type;
+}
+
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+export interface JSONSchema6Array extends Array<JSONSchema6Type> {}
+
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-06/schema#'
+ * - 'http://json-schema.org/draft-06/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+export type JSONSchema6Version = string;
+
+/**
+ * JSON Schema V6
+ * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01
+ */
+export type JSONSchema6Definition = JSONSchema6 | boolean;
+export interface JSONSchema6 {
+    $id?: string | undefined;
+    $ref?: string | undefined;
+    $schema?: JSONSchema6Version | undefined;
+
+    /**
+     * Must be strictly greater than 0.
+     * A numeric instance is valid only if division by this keyword's value results in an integer.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.1
+     */
+    multipleOf?: number | undefined;
+
+    /**
+     * Representing an inclusive upper limit for a numeric instance.
+     * This keyword validates only if the instance is less than or exactly equal to "maximum".
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.2
+     */
+    maximum?: number | undefined;
+
+    /**
+     * Representing an exclusive upper limit for a numeric instance.
+     * This keyword validates only if the instance is strictly less than (not equal to) to "exclusiveMaximum".
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.3
+     */
+    exclusiveMaximum?: number | undefined;
+
+    /**
+     * Representing an inclusive lower limit for a numeric instance.
+     * This keyword validates only if the instance is greater than or exactly equal to "minimum".
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.4
+     */
+    minimum?: number | undefined;
+
+    /**
+     * Representing an exclusive lower limit for a numeric instance.
+     * This keyword validates only if the instance is strictly greater than (not equal to) to "exclusiveMinimum".
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.5
+     */
+    exclusiveMinimum?: number | undefined;
+
+    /**
+     * Must be a non-negative integer.
+     * A string instance is valid against this keyword if its length is less than, or equal to, the value of this keyword.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.6
+     */
+    maxLength?: number | undefined;
+
+    /**
+     * Must be a non-negative integer.
+     * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.
+     * Omitting this keyword has the same behavior as a value of 0.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.7
+     */
+    minLength?: number | undefined;
+
+    /**
+     * Should be a valid regular expression, according to the ECMA 262 regular expression dialect.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.8
+     */
+    pattern?: string | undefined;
+
+    /**
+     * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
+     * Omitting this keyword has the same behavior as an empty schema.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.9
+     */
+    items?: JSONSchema6Definition | JSONSchema6Definition[] | undefined;
+
+    /**
+     * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
+     * If "items" is an array of schemas, validation succeeds if every instance element
+     * at a position greater than the size of "items" validates against "additionalItems".
+     * Otherwise, "additionalItems" MUST be ignored, as the "items" schema
+     * (possibly the default value of an empty schema) is applied to all elements.
+     * Omitting this keyword has the same behavior as an empty schema.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.10
+     */
+    additionalItems?: JSONSchema6Definition | undefined;
+
+    /**
+     * Must be a non-negative integer.
+     * An array instance is valid against "maxItems" if its size is less than, or equal to, the value of this keyword.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.11
+     */
+    maxItems?: number | undefined;
+
+    /**
+     * Must be a non-negative integer.
+     * An array instance is valid against "maxItems" if its size is greater than, or equal to, the value of this keyword.
+     * Omitting this keyword has the same behavior as a value of 0.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.12
+     */
+    minItems?: number | undefined;
+
+    /**
+     * If this keyword has boolean value false, the instance validates successfully.
+     * If it has boolean value true, the instance validates successfully if all of its elements are unique.
+     * Omitting this keyword has the same behavior as a value of false.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.13
+     */
+    uniqueItems?: boolean | undefined;
+
+    /**
+     * An array instance is valid against "contains" if at least one of its elements is valid against the given schema.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.14
+     */
+    contains?: JSONSchema6Definition | undefined;
+
+    /**
+     * Must be a non-negative integer.
+     * An object instance is valid against "maxProperties" if its number of properties is less than, or equal to, the value of this keyword.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.15
+     */
+    maxProperties?: number | undefined;
+
+    /**
+     * Must be a non-negative integer.
+     * An object instance is valid against "maxProperties" if its number of properties is greater than,
+     * or equal to, the value of this keyword.
+     * Omitting this keyword has the same behavior as a value of 0.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.16
+     */
+    minProperties?: number | undefined;
+
+    /**
+     * Elements of this array must be unique.
+     * An object instance is valid against this keyword if every item in the array is the name of a property in the instance.
+     * Omitting this keyword has the same behavior as an empty array.
+     *
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.17
+     */
+    required?: string[] | undefined;
+
+    /**
+     * This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself.
+     * Validation succeeds if, for each name that appears in both the instance and as a name within this keyword's value,
+     * the child instance for that name successfully validates against the corresponding schema.
+     * Omitting this keyword has the same behavior as an empty object.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.18
+     */
+    properties?: {
+        [k: string]: JSONSchema6Definition;
+    } | undefined;
+
+    /**
+     * This attribute is an object that defines the schema for a set of property names of an object instance.
+     * The name of each property of this attribute's object is a regular expression pattern in the ECMA 262, while the value is a schema.
+     * If the pattern matches the name of a property on the instance object, the value of the instance's property
+     * MUST be valid against the pattern name's schema value.
+     * Omitting this keyword has the same behavior as an empty object.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.19
+     */
+    patternProperties?: {
+        [k: string]: JSONSchema6Definition;
+    } | undefined;
+
+    /**
+     * This attribute defines a schema for all properties that are not explicitly defined in an object type definition.
+     * If specified, the value MUST be a schema or a boolean.
+     * If false is provided, no additional properties are allowed beyond the properties defined in the schema.
+     * The default value is an empty schema which allows any value for additional properties.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.20
+     */
+    additionalProperties?: JSONSchema6Definition | undefined;
+
+    /**
+     * This keyword specifies rules that are evaluated if the instance is an object and contains a certain property.
+     * Each property specifies a dependency.
+     * If the dependency value is an array, each element in the array must be unique.
+     * Omitting this keyword has the same behavior as an empty object.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.21
+     */
+    dependencies?: {
+        [k: string]: JSONSchema6Definition | string[];
+    } | undefined;
+
+    /**
+     * Takes a schema which validates the names of all properties rather than their values.
+     * Note the property name that the schema is testing will always be a string.
+     * Omitting this keyword has the same behavior as an empty schema.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.22
+     */
+    propertyNames?: JSONSchema6Definition | undefined;
+
+    /**
+     * This provides an enumeration of all possible values that are valid
+     * for the instance property. This MUST be an array, and each item in
+     * the array represents a possible value for the instance value. If
+     * this attribute is defined, the instance value MUST be one of the
+     * values in the array in order for the schema to be valid.
+     *
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.23
+     */
+    enum?: JSONSchema6Type[] | undefined;
+
+    /**
+     * More readable form of a one-element "enum"
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.24
+     */
+    const?: JSONSchema6Type | undefined;
+
+    /**
+     * A single type, or a union of simple types
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.25
+     */
+    type?: JSONSchema6TypeName | JSONSchema6TypeName[] | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.26
+     */
+    allOf?: JSONSchema6Definition[] | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.27
+     */
+    anyOf?: JSONSchema6Definition[] | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.28
+     */
+    oneOf?: JSONSchema6Definition[] | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.29
+     */
+    not?: JSONSchema6Definition | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.1
+     */
+    definitions?: {
+        [k: string]: JSONSchema6Definition;
+    } | undefined;
+
+    /**
+     * This attribute is a string that provides a short description of the instance property.
+     *
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
+     */
+    title?: string | undefined;
+
+    /**
+     * This attribute is a string that provides a full description of the of purpose the instance property.
+     *
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
+     */
+    description?: string | undefined;
+
+    /**
+     * This keyword can be used to supply a default JSON value associated with a particular schema.
+     * It is RECOMMENDED that a default value be valid against the associated schema.
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.3
+     */
+    default?: JSONSchema6Type | undefined;
+
+    /**
+     * Array of examples with no validation effect the value of "default" is usable as an example without repeating it under this keyword
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.4
+     */
+    examples?: JSONSchema6Type[] | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-8
+     */
+    format?: string | undefined;
+}
+
+// ==================================================================================================
+// JSON Schema Draft 07
+// ==================================================================================================
+// https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+// --------------------------------------------------------------------------------------------------
+
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+export type JSONSchema7TypeName =
+    | "string" //
+    | "number"
+    | "integer"
+    | "boolean"
+    | "object"
+    | "array"
+    | "null";
+
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+export type JSONSchema7Type =
+    | string //
+    | number
+    | boolean
+    | JSONSchema7Object
+    | JSONSchema7Array
+    | null;
+
+// Workaround for infinite type recursion
+export interface JSONSchema7Object {
+    [key: string]: JSONSchema7Type;
+}
+
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+export interface JSONSchema7Array extends Array<JSONSchema7Type> {}
+
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-07/schema#'
+ * - 'http://json-schema.org/draft-07/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+export type JSONSchema7Version = string;
+
+/**
+ * JSON Schema v7
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+ */
+export type JSONSchema7Definition = JSONSchema7 | boolean;
+export interface JSONSchema7 {
+    $id?: string | undefined;
+    $ref?: string | undefined;
+    $schema?: JSONSchema7Version | undefined;
+    $comment?: string | undefined;
+
+    /**
+     * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00#section-8.2.4
+     * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#appendix-A
+     */
+    $defs?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1
+     */
+    type?: JSONSchema7TypeName | JSONSchema7TypeName[] | undefined;
+    enum?: JSONSchema7Type[] | undefined;
+    const?: JSONSchema7Type | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2
+     */
+    multipleOf?: number | undefined;
+    maximum?: number | undefined;
+    exclusiveMaximum?: number | undefined;
+    minimum?: number | undefined;
+    exclusiveMinimum?: number | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3
+     */
+    maxLength?: number | undefined;
+    minLength?: number | undefined;
+    pattern?: string | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4
+     */
+    items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
+    additionalItems?: JSONSchema7Definition | undefined;
+    maxItems?: number | undefined;
+    minItems?: number | undefined;
+    uniqueItems?: boolean | undefined;
+    contains?: JSONSchema7Definition | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5
+     */
+    maxProperties?: number | undefined;
+    minProperties?: number | undefined;
+    required?: string[] | undefined;
+    properties?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined;
+    patternProperties?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined;
+    additionalProperties?: JSONSchema7Definition | undefined;
+    dependencies?: {
+        [key: string]: JSONSchema7Definition | string[];
+    } | undefined;
+    propertyNames?: JSONSchema7Definition | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6
+     */
+    if?: JSONSchema7Definition | undefined;
+    then?: JSONSchema7Definition | undefined;
+    else?: JSONSchema7Definition | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7
+     */
+    allOf?: JSONSchema7Definition[] | undefined;
+    anyOf?: JSONSchema7Definition[] | undefined;
+    oneOf?: JSONSchema7Definition[] | undefined;
+    not?: JSONSchema7Definition | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7
+     */
+    format?: string | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-8
+     */
+    contentMediaType?: string | undefined;
+    contentEncoding?: string | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-9
+     */
+    definitions?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
+     */
+    title?: string | undefined;
+    description?: string | undefined;
+    default?: JSONSchema7Type | undefined;
+    readOnly?: boolean | undefined;
+    writeOnly?: boolean | undefined;
+    examples?: JSONSchema7Type | undefined;
+}
+
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+
+export interface ValidationError {
+    property: string;
+    message: string;
+}
+
+/**
+ * To use the validator call JSONSchema.validate with an instance object and an optional schema object.
+ * If a schema is provided, it will be used to validate. If the instance object refers to a schema (self-validating),
+ * that schema will be used to validate and the schema parameter is not necessary (if both exist,
+ * both validations will occur).
+ */
+export function validate(instance: {}, schema: JSONSchema4 | JSONSchema6 | JSONSchema7): ValidationResult;
+
+/**
+ * The checkPropertyChange method will check to see if an value can legally be in property with the given schema
+ * This is slightly different than the validate method in that it will fail if the schema is readonly and it will
+ * not check for self-validation, it is assumed that the passed in value is already internally valid.
+ */
+export function checkPropertyChange(
+    value: any,
+    schema: JSONSchema4 | JSONSchema6 | JSONSchema7,
+    property: string,
+): ValidationResult;
+
+/**
+ * This checks to ensure that the result is valid and will throw an appropriate error message if it is not.
+ */
+export function mustBeValid(result: ValidationResult): void;

js/node_modules/@types/json-schema/package.json

@@ -0,0 +1,67 @@
+{
+  "_from": "@types/json-schema@*",
+  "_id": "@types/json-schema@7.0.15",
+  "_inBundle": false,
+  "_integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+  "_location": "/@types/json-schema",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/json-schema@*",
+    "name": "@types/json-schema",
+    "escapedName": "@types%2fjson-schema",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/eslint",
+    "/terser-webpack-plugin/schema-utils",
+    "/webpack/schema-utils"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+  "_shasum": "596a1747233694d50f6ad8a7869fcb6f56cf5841",
+  "_spec": "@types/json-schema@*",
+  "_where": "/Users/ben/Desktop/app/be/be-ytb/js/node_modules/@types/eslint",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Boris Cherny",
+      "url": "https://github.com/bcherny"
+    },
+    {
+      "name": "Lucian Buzzo",
+      "url": "https://github.com/lucianbuzzo"
+    },
+    {
+      "name": "Roland Groza",
+      "url": "https://github.com/rolandjitsu"
+    },
+    {
+      "name": "Jason Kwok",
+      "url": "https://github.com/JasonHK"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for json-schema",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/json-schema",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/json-schema",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/json-schema"
+  },
+  "scripts": {},
+  "typeScriptVersion": "4.5",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "79984fd70cd25c3f7d72b84368778c763c89728ea0073832d745d4691b705257",
+  "version": "7.0.15"
+}

js/node_modules/@types/node/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

js/node_modules/@types/node/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/node`
+
+# Summary
+This package contains type definitions for node (https://nodejs.org/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
+
+### Additional Details
+ * Last updated: Wed, 08 May 2024 12:09:52 GMT
+ * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
+
+# Credits
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Victor Perin](https://github.com/victorperin), [Yongsheng Zhang](https://github.com/ZYSzys), [NodeJS Contributors](https://github.com/NodeJS), [Linus Unnebäck](https://github.com/LinusU), [wafuwafu13](https://github.com/wafuwafu13), [Matteo Collina](https://github.com/mcollina), and [Dmitry Semigradsky](https://github.com/Semigradsky).

js/node_modules/@types/node/assert.d.ts

@@ -0,0 +1,1040 @@
+/**
+ * The `node:assert` module provides a set of assertion functions for verifying
+ * invariants.
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/assert.js)
+ */
+declare module "assert" {
+    /**
+     * An alias of {@link ok}.
+     * @since v0.5.9
+     * @param value The input that is checked for being truthy.
+     */
+    function assert(value: unknown, message?: string | Error): asserts value;
+    namespace assert {
+        /**
+         * Indicates the failure of an assertion. All errors thrown by the `node:assert` module will be instances of the `AssertionError` class.
+         */
+        class AssertionError extends Error {
+            /**
+             * Set to the `actual` argument for methods such as {@link assert.strictEqual()}.
+             */
+            actual: unknown;
+            /**
+             * Set to the `expected` argument for methods such as {@link assert.strictEqual()}.
+             */
+            expected: unknown;
+            /**
+             * Set to the passed in operator value.
+             */
+            operator: string;
+            /**
+             * Indicates if the message was auto-generated (`true`) or not.
+             */
+            generatedMessage: boolean;
+            /**
+             * Value is always `ERR_ASSERTION` to show that the error is an assertion error.
+             */
+            code: "ERR_ASSERTION";
+            constructor(options?: {
+                /** If provided, the error message is set to this value. */
+                message?: string | undefined;
+                /** The `actual` property on the error instance. */
+                actual?: unknown | undefined;
+                /** The `expected` property on the error instance. */
+                expected?: unknown | undefined;
+                /** The `operator` property on the error instance. */
+                operator?: string | undefined;
+                /** If provided, the generated stack trace omits frames before this function. */
+                // eslint-disable-next-line @typescript-eslint/ban-types
+                stackStartFn?: Function | undefined;
+            });
+        }
+        /**
+         * This feature is deprecated and will be removed in a future version.
+         * Please consider using alternatives such as the `mock` helper function.
+         * @since v14.2.0, v12.19.0
+         * @deprecated Deprecated
+         */
+        class CallTracker {
+            /**
+             * The wrapper function is expected to be called exactly `exact` times. If the
+             * function has not been called exactly `exact` times when `tracker.verify()` is called, then `tracker.verify()` will throw an
+             * error.
+             *
+             * ```js
+             * import assert from 'node:assert';
+             *
+             * // Creates call tracker.
+             * const tracker = new assert.CallTracker();
+             *
+             * function func() {}
+             *
+             * // Returns a function that wraps func() that must be called exact times
+             * // before tracker.verify().
+             * const callsfunc = tracker.calls(func);
+             * ```
+             * @since v14.2.0, v12.19.0
+             * @param [fn='A no-op function']
+             * @param [exact=1]
+             * @return A function that wraps `fn`.
+             */
+            calls(exact?: number): () => void;
+            calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;
+            /**
+             * Example:
+             *
+             * ```js
+             * import assert from 'node:assert';
+             *
+             * const tracker = new assert.CallTracker();
+             *
+             * function func() {}
+             * const callsfunc = tracker.calls(func);
+             * callsfunc(1, 2, 3);
+             *
+             * assert.deepStrictEqual(tracker.getCalls(callsfunc),
+             *                        [{ thisArg: undefined, arguments: [1, 2, 3] }]);
+             * ```
+             * @since v18.8.0, v16.18.0
+             * @return An array with all the calls to a tracked function.
+             */
+            getCalls(fn: Function): CallTrackerCall[];
+            /**
+             * The arrays contains information about the expected and actual number of calls of
+             * the functions that have not been called the expected number of times.
+             *
+             * ```js
+             * import assert from 'node:assert';
+             *
+             * // Creates call tracker.
+             * const tracker = new assert.CallTracker();
+             *
+             * function func() {}
+             *
+             * // Returns a function that wraps func() that must be called exact times
+             * // before tracker.verify().
+             * const callsfunc = tracker.calls(func, 2);
+             *
+             * // Returns an array containing information on callsfunc()
+             * console.log(tracker.report());
+             * // [
+             * //  {
+             * //    message: 'Expected the func function to be executed 2 time(s) but was
+             * //    executed 0 time(s).',
+             * //    actual: 0,
+             * //    expected: 2,
+             * //    operator: 'func',
+             * //    stack: stack trace
+             * //  }
+             * // ]
+             * ```
+             * @since v14.2.0, v12.19.0
+             * @return An array of objects containing information about the wrapper functions returned by {@link tracker.calls()}.
+             */
+            report(): CallTrackerReportInformation[];
+            /**
+             * Reset calls of the call tracker. If a tracked function is passed as an argument, the calls will be reset for it.
+             * If no arguments are passed, all tracked functions will be reset.
+             *
+             * ```js
+             * import assert from 'node:assert';
+             *
+             * const tracker = new assert.CallTracker();
+             *
+             * function func() {}
+             * const callsfunc = tracker.calls(func);
+             *
+             * callsfunc();
+             * // Tracker was called once
+             * assert.strictEqual(tracker.getCalls(callsfunc).length, 1);
+             *
+             * tracker.reset(callsfunc);
+             * assert.strictEqual(tracker.getCalls(callsfunc).length, 0);
+             * ```
+             * @since v18.8.0, v16.18.0
+             * @param fn a tracked function to reset.
+             */
+            reset(fn?: Function): void;
+            /**
+             * Iterates through the list of functions passed to {@link tracker.calls()} and will throw an error for functions that
+             * have not been called the expected number of times.
+             *
+             * ```js
+             * import assert from 'node:assert';
+             *
+             * // Creates call tracker.
+             * const tracker = new assert.CallTracker();
+             *
+             * function func() {}
+             *
+             * // Returns a function that wraps func() that must be called exact times
+             * // before tracker.verify().
+             * const callsfunc = tracker.calls(func, 2);
+             *
+             * callsfunc();
+             *
+             * // Will throw an error since callsfunc() was only called once.
+             * tracker.verify();
+             * ```
+             * @since v14.2.0, v12.19.0
+             */
+            verify(): void;
+        }
+        interface CallTrackerCall {
+            thisArg: object;
+            arguments: unknown[];
+        }
+        interface CallTrackerReportInformation {
+            message: string;
+            /** The actual number of times the function was called. */
+            actual: number;
+            /** The number of times the function was expected to be called. */
+            expected: number;
+            /** The name of the function that is wrapped. */
+            operator: string;
+            /** A stack trace of the function. */
+            stack: object;
+        }
+        type AssertPredicate = RegExp | (new() => object) | ((thrown: unknown) => boolean) | object | Error;
+        /**
+         * Throws an `AssertionError` with the provided error message or a default
+         * error message. If the `message` parameter is an instance of an `Error` then
+         * it will be thrown instead of the `AssertionError`.
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.fail();
+         * // AssertionError [ERR_ASSERTION]: Failed
+         *
+         * assert.fail('boom');
+         * // AssertionError [ERR_ASSERTION]: boom
+         *
+         * assert.fail(new TypeError('need array'));
+         * // TypeError: need array
+         * ```
+         *
+         * Using `assert.fail()` with more than two arguments is possible but deprecated.
+         * See below for further details.
+         * @since v0.1.21
+         * @param [message='Failed']
+         */
+        function fail(message?: string | Error): never;
+        /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
+        function fail(
+            actual: unknown,
+            expected: unknown,
+            message?: string | Error,
+            operator?: string,
+            // eslint-disable-next-line @typescript-eslint/ban-types
+            stackStartFn?: Function,
+        ): never;
+        /**
+         * Tests if `value` is truthy. It is equivalent to `assert.equal(!!value, true, message)`.
+         *
+         * If `value` is not truthy, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is `undefined`, a default
+         * error message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown instead of the `AssertionError`.
+         * If no arguments are passed in at all `message` will be set to the string:`` 'No value argument passed to `assert.ok()`' ``.
+         *
+         * Be aware that in the `repl` the error message will be different to the one
+         * thrown in a file! See below for further details.
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.ok(true);
+         * // OK
+         * assert.ok(1);
+         * // OK
+         *
+         * assert.ok();
+         * // AssertionError: No value argument passed to `assert.ok()`
+         *
+         * assert.ok(false, 'it\'s false');
+         * // AssertionError: it's false
+         *
+         * // In the repl:
+         * assert.ok(typeof 123 === 'string');
+         * // AssertionError: false == true
+         *
+         * // In a file (e.g. test.js):
+         * assert.ok(typeof 123 === 'string');
+         * // AssertionError: The expression evaluated to a falsy value:
+         * //
+         * //   assert.ok(typeof 123 === 'string')
+         *
+         * assert.ok(false);
+         * // AssertionError: The expression evaluated to a falsy value:
+         * //
+         * //   assert.ok(false)
+         *
+         * assert.ok(0);
+         * // AssertionError: The expression evaluated to a falsy value:
+         * //
+         * //   assert.ok(0)
+         * ```
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * // Using `assert()` works the same:
+         * assert(0);
+         * // AssertionError: The expression evaluated to a falsy value:
+         * //
+         * //   assert(0)
+         * ```
+         * @since v0.1.21
+         */
+        function ok(value: unknown, message?: string | Error): asserts value;
+        /**
+         * **Strict assertion mode**
+         *
+         * An alias of {@link strictEqual}.
+         *
+         * **Legacy assertion mode**
+         *
+         * > Stability: 3 - Legacy: Use {@link strictEqual} instead.
+         *
+         * Tests shallow, coercive equality between the `actual` and `expected` parameters
+         * using the [`==` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality). `NaN` is specially handled
+         * and treated as being identical if both sides are `NaN`.
+         *
+         * ```js
+         * import assert from 'node:assert';
+         *
+         * assert.equal(1, 1);
+         * // OK, 1 == 1
+         * assert.equal(1, '1');
+         * // OK, 1 == '1'
+         * assert.equal(NaN, NaN);
+         * // OK
+         *
+         * assert.equal(1, 2);
+         * // AssertionError: 1 == 2
+         * assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
+         * // AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
+         * ```
+         *
+         * If the values are not equal, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is undefined, a default
+         * error message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown instead of the `AssertionError`.
+         * @since v0.1.21
+         */
+        function equal(actual: unknown, expected: unknown, message?: string | Error): void;
+        /**
+         * **Strict assertion mode**
+         *
+         * An alias of {@link notStrictEqual}.
+         *
+         * **Legacy assertion mode**
+         *
+         * > Stability: 3 - Legacy: Use {@link notStrictEqual} instead.
+         *
+         * Tests shallow, coercive inequality with the [`!=` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Inequality). `NaN` is
+         * specially handled and treated as being identical if both sides are `NaN`.
+         *
+         * ```js
+         * import assert from 'node:assert';
+         *
+         * assert.notEqual(1, 2);
+         * // OK
+         *
+         * assert.notEqual(1, 1);
+         * // AssertionError: 1 != 1
+         *
+         * assert.notEqual(1, '1');
+         * // AssertionError: 1 != '1'
+         * ```
+         *
+         * If the values are equal, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is undefined, a default error
+         * message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown instead of the `AssertionError`.
+         * @since v0.1.21
+         */
+        function notEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        /**
+         * **Strict assertion mode**
+         *
+         * An alias of {@link deepStrictEqual}.
+         *
+         * **Legacy assertion mode**
+         *
+         * > Stability: 3 - Legacy: Use {@link deepStrictEqual} instead.
+         *
+         * Tests for deep equality between the `actual` and `expected` parameters. Consider
+         * using {@link deepStrictEqual} instead. {@link deepEqual} can have
+         * surprising results.
+         *
+         * _Deep equality_ means that the enumerable "own" properties of child objects
+         * are also recursively evaluated by the following rules.
+         * @since v0.1.21
+         */
+        function deepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        /**
+         * **Strict assertion mode**
+         *
+         * An alias of {@link notDeepStrictEqual}.
+         *
+         * **Legacy assertion mode**
+         *
+         * > Stability: 3 - Legacy: Use {@link notDeepStrictEqual} instead.
+         *
+         * Tests for any deep inequality. Opposite of {@link deepEqual}.
+         *
+         * ```js
+         * import assert from 'node:assert';
+         *
+         * const obj1 = {
+         *   a: {
+         *     b: 1,
+         *   },
+         * };
+         * const obj2 = {
+         *   a: {
+         *     b: 2,
+         *   },
+         * };
+         * const obj3 = {
+         *   a: {
+         *     b: 1,
+         *   },
+         * };
+         * const obj4 = { __proto__: obj1 };
+         *
+         * assert.notDeepEqual(obj1, obj1);
+         * // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
+         *
+         * assert.notDeepEqual(obj1, obj2);
+         * // OK
+         *
+         * assert.notDeepEqual(obj1, obj3);
+         * // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
+         *
+         * assert.notDeepEqual(obj1, obj4);
+         * // OK
+         * ```
+         *
+         * If the values are deeply equal, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is undefined, a default
+         * error message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown
+         * instead of the `AssertionError`.
+         * @since v0.1.21
+         */
+        function notDeepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        /**
+         * Tests strict equality between the `actual` and `expected` parameters as
+         * determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.strictEqual(1, 2);
+         * // AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
+         * //
+         * // 1 !== 2
+         *
+         * assert.strictEqual(1, 1);
+         * // OK
+         *
+         * assert.strictEqual('Hello foobar', 'Hello World!');
+         * // AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
+         * // + actual - expected
+         * //
+         * // + 'Hello foobar'
+         * // - 'Hello World!'
+         * //          ^
+         *
+         * const apples = 1;
+         * const oranges = 2;
+         * assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`);
+         * // AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2
+         *
+         * assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));
+         * // TypeError: Inputs are not identical
+         * ```
+         *
+         * If the values are not strictly equal, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is undefined, a
+         * default error message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown
+         * instead of the `AssertionError`.
+         * @since v0.1.21
+         */
+        function strictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
+        /**
+         * Tests strict inequality between the `actual` and `expected` parameters as
+         * determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.notStrictEqual(1, 2);
+         * // OK
+         *
+         * assert.notStrictEqual(1, 1);
+         * // AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
+         * //
+         * // 1
+         *
+         * assert.notStrictEqual(1, '1');
+         * // OK
+         * ```
+         *
+         * If the values are strictly equal, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is undefined, a
+         * default error message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown
+         * instead of the `AssertionError`.
+         * @since v0.1.21
+         */
+        function notStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        /**
+         * Tests for deep equality between the `actual` and `expected` parameters.
+         * "Deep" equality means that the enumerable "own" properties of child objects
+         * are recursively evaluated also by the following rules.
+         * @since v1.2.0
+         */
+        function deepStrictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
+        /**
+         * Tests for deep strict inequality. Opposite of {@link deepStrictEqual}.
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
+         * // OK
+         * ```
+         *
+         * If the values are deeply and strictly equal, an `AssertionError` is thrown
+         * with a `message` property set equal to the value of the `message` parameter. If
+         * the `message` parameter is undefined, a default error message is assigned. If
+         * the `message` parameter is an instance of an `Error` then it will be thrown
+         * instead of the `AssertionError`.
+         * @since v1.2.0
+         */
+        function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        /**
+         * Expects the function `fn` to throw an error.
+         *
+         * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
+         * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function,
+         * a validation object where each property will be tested for strict deep equality,
+         * or an instance of error where each property will be tested for strict deep
+         * equality including the non-enumerable `message` and `name` properties. When
+         * using an object, it is also possible to use a regular expression, when
+         * validating against a string property. See below for examples.
+         *
+         * If specified, `message` will be appended to the message provided by the `AssertionError` if the `fn` call fails to throw or in case the error validation
+         * fails.
+         *
+         * Custom validation object/error instance:
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * const err = new TypeError('Wrong value');
+         * err.code = 404;
+         * err.foo = 'bar';
+         * err.info = {
+         *   nested: true,
+         *   baz: 'text',
+         * };
+         * err.reg = /abc/i;
+         *
+         * assert.throws(
+         *   () => {
+         *     throw err;
+         *   },
+         *   {
+         *     name: 'TypeError',
+         *     message: 'Wrong value',
+         *     info: {
+         *       nested: true,
+         *       baz: 'text',
+         *     },
+         *     // Only properties on the validation object will be tested for.
+         *     // Using nested objects requires all properties to be present. Otherwise
+         *     // the validation is going to fail.
+         *   },
+         * );
+         *
+         * // Using regular expressions to validate error properties:
+         * assert.throws(
+         *   () => {
+         *     throw err;
+         *   },
+         *   {
+         *     // The `name` and `message` properties are strings and using regular
+         *     // expressions on those will match against the string. If they fail, an
+         *     // error is thrown.
+         *     name: /^TypeError$/,
+         *     message: /Wrong/,
+         *     foo: 'bar',
+         *     info: {
+         *       nested: true,
+         *       // It is not possible to use regular expressions for nested properties!
+         *       baz: 'text',
+         *     },
+         *     // The `reg` property contains a regular expression and only if the
+         *     // validation object contains an identical regular expression, it is going
+         *     // to pass.
+         *     reg: /abc/i,
+         *   },
+         * );
+         *
+         * // Fails due to the different `message` and `name` properties:
+         * assert.throws(
+         *   () => {
+         *     const otherErr = new Error('Not found');
+         *     // Copy all enumerable properties from `err` to `otherErr`.
+         *     for (const [key, value] of Object.entries(err)) {
+         *       otherErr[key] = value;
+         *     }
+         *     throw otherErr;
+         *   },
+         *   // The error's `message` and `name` properties will also be checked when using
+         *   // an error as validation object.
+         *   err,
+         * );
+         * ```
+         *
+         * Validate instanceof using constructor:
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.throws(
+         *   () => {
+         *     throw new Error('Wrong value');
+         *   },
+         *   Error,
+         * );
+         * ```
+         *
+         * Validate error message using [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions):
+         *
+         * Using a regular expression runs `.toString` on the error object, and will
+         * therefore also include the error name.
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.throws(
+         *   () => {
+         *     throw new Error('Wrong value');
+         *   },
+         *   /^Error: Wrong value$/,
+         * );
+         * ```
+         *
+         * Custom error validation:
+         *
+         * The function must return `true` to indicate all internal validations passed.
+         * It will otherwise fail with an `AssertionError`.
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.throws(
+         *   () => {
+         *     throw new Error('Wrong value');
+         *   },
+         *   (err) => {
+         *     assert(err instanceof Error);
+         *     assert(/value/.test(err));
+         *     // Avoid returning anything from validation functions besides `true`.
+         *     // Otherwise, it's not clear what part of the validation failed. Instead,
+         *     // throw an error about the specific validation that failed (as done in this
+         *     // example) and add as much helpful debugging information to that error as
+         *     // possible.
+         *     return true;
+         *   },
+         *   'unexpected error',
+         * );
+         * ```
+         *
+         * `error` cannot be a string. If a string is provided as the second
+         * argument, then `error` is assumed to be omitted and the string will be used for `message` instead. This can lead to easy-to-miss mistakes. Using the same
+         * message as the thrown error message is going to result in an `ERR_AMBIGUOUS_ARGUMENT` error. Please read the example below carefully if using
+         * a string as the second argument gets considered:
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * function throwingFirst() {
+         *   throw new Error('First');
+         * }
+         *
+         * function throwingSecond() {
+         *   throw new Error('Second');
+         * }
+         *
+         * function notThrowing() {}
+         *
+         * // The second argument is a string and the input function threw an Error.
+         * // The first case will not throw as it does not match for the error message
+         * // thrown by the input function!
+         * assert.throws(throwingFirst, 'Second');
+         * // In the next example the message has no benefit over the message from the
+         * // error and since it is not clear if the user intended to actually match
+         * // against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
+         * assert.throws(throwingSecond, 'Second');
+         * // TypeError [ERR_AMBIGUOUS_ARGUMENT]
+         *
+         * // The string is only used (as message) in case the function does not throw:
+         * assert.throws(notThrowing, 'Second');
+         * // AssertionError [ERR_ASSERTION]: Missing expected exception: Second
+         *
+         * // If it was intended to match for the error message do this instead:
+         * // It does not throw because the error messages match.
+         * assert.throws(throwingSecond, /Second$/);
+         *
+         * // If the error message does not match, an AssertionError is thrown.
+         * assert.throws(throwingFirst, /Second$/);
+         * // AssertionError [ERR_ASSERTION]
+         * ```
+         *
+         * Due to the confusing error-prone notation, avoid a string as the second
+         * argument.
+         * @since v0.1.21
+         */
+        function throws(block: () => unknown, message?: string | Error): void;
+        function throws(block: () => unknown, error: AssertPredicate, message?: string | Error): void;
+        /**
+         * Asserts that the function `fn` does not throw an error.
+         *
+         * Using `assert.doesNotThrow()` is actually not useful because there
+         * is no benefit in catching an error and then rethrowing it. Instead, consider
+         * adding a comment next to the specific code path that should not throw and keep
+         * error messages as expressive as possible.
+         *
+         * When `assert.doesNotThrow()` is called, it will immediately call the `fn` function.
+         *
+         * If an error is thrown and it is the same type as that specified by the `error` parameter, then an `AssertionError` is thrown. If the error is of a
+         * different type, or if the `error` parameter is undefined, the error is
+         * propagated back to the caller.
+         *
+         * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
+         * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), or a validation
+         * function. See {@link throws} for more details.
+         *
+         * The following, for instance, will throw the `TypeError` because there is no
+         * matching error type in the assertion:
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.doesNotThrow(
+         *   () => {
+         *     throw new TypeError('Wrong value');
+         *   },
+         *   SyntaxError,
+         * );
+         * ```
+         *
+         * However, the following will result in an `AssertionError` with the message
+         * 'Got unwanted exception...':
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.doesNotThrow(
+         *   () => {
+         *     throw new TypeError('Wrong value');
+         *   },
+         *   TypeError,
+         * );
+         * ```
+         *
+         * If an `AssertionError` is thrown and a value is provided for the `message` parameter, the value of `message` will be appended to the `AssertionError` message:
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.doesNotThrow(
+         *   () => {
+         *     throw new TypeError('Wrong value');
+         *   },
+         *   /Wrong value/,
+         *   'Whoops',
+         * );
+         * // Throws: AssertionError: Got unwanted exception: Whoops
+         * ```
+         * @since v0.1.21
+         */
+        function doesNotThrow(block: () => unknown, message?: string | Error): void;
+        function doesNotThrow(block: () => unknown, error: AssertPredicate, message?: string | Error): void;
+        /**
+         * Throws `value` if `value` is not `undefined` or `null`. This is useful when
+         * testing the `error` argument in callbacks. The stack trace contains all frames
+         * from the error passed to `ifError()` including the potential new frames for `ifError()` itself.
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.ifError(null);
+         * // OK
+         * assert.ifError(0);
+         * // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
+         * assert.ifError('error');
+         * // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
+         * assert.ifError(new Error());
+         * // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error
+         *
+         * // Create some random error frames.
+         * let err;
+         * (function errorFrame() {
+         *   err = new Error('test error');
+         * })();
+         *
+         * (function ifErrorFrame() {
+         *   assert.ifError(err);
+         * })();
+         * // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
+         * //     at ifErrorFrame
+         * //     at errorFrame
+         * ```
+         * @since v0.1.97
+         */
+        function ifError(value: unknown): asserts value is null | undefined;
+        /**
+         * Awaits the `asyncFn` promise or, if `asyncFn` is a function, immediately
+         * calls the function and awaits the returned promise to complete. It will then
+         * check that the promise is rejected.
+         *
+         * If `asyncFn` is a function and it throws an error synchronously, `assert.rejects()` will return a rejected `Promise` with that error. If the
+         * function does not return a promise, `assert.rejects()` will return a rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v20.x/api/errors.html#err_invalid_return_value)
+         * error. In both cases the error handler is skipped.
+         *
+         * Besides the async nature to await the completion behaves identically to {@link throws}.
+         *
+         * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
+         * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function,
+         * an object where each property will be tested for, or an instance of error where
+         * each property will be tested for including the non-enumerable `message` and `name` properties.
+         *
+         * If specified, `message` will be the message provided by the `{@link AssertionError}` if the `asyncFn` fails to reject.
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * await assert.rejects(
+         *   async () => {
+         *     throw new TypeError('Wrong value');
+         *   },
+         *   {
+         *     name: 'TypeError',
+         *     message: 'Wrong value',
+         *   },
+         * );
+         * ```
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * await assert.rejects(
+         *   async () => {
+         *     throw new TypeError('Wrong value');
+         *   },
+         *   (err) => {
+         *     assert.strictEqual(err.name, 'TypeError');
+         *     assert.strictEqual(err.message, 'Wrong value');
+         *     return true;
+         *   },
+         * );
+         * ```
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.rejects(
+         *   Promise.reject(new Error('Wrong value')),
+         *   Error,
+         * ).then(() => {
+         *   // ...
+         * });
+         * ```
+         *
+         * `error` cannot be a string. If a string is provided as the second argument, then `error` is assumed to
+         * be omitted and the string will be used for `message` instead. This can lead to easy-to-miss mistakes. Please read the
+         * example in {@link throws} carefully if using a string as the second argument gets considered.
+         * @since v10.0.0
+         */
+        function rejects(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
+        function rejects(
+            block: (() => Promise<unknown>) | Promise<unknown>,
+            error: AssertPredicate,
+            message?: string | Error,
+        ): Promise<void>;
+        /**
+         * Awaits the `asyncFn` promise or, if `asyncFn` is a function, immediately
+         * calls the function and awaits the returned promise to complete. It will then
+         * check that the promise is not rejected.
+         *
+         * If `asyncFn` is a function and it throws an error synchronously, `assert.doesNotReject()` will return a rejected `Promise` with that error. If
+         * the function does not return a promise, `assert.doesNotReject()` will return a
+         * rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v20.x/api/errors.html#err_invalid_return_value) error. In both cases
+         * the error handler is skipped.
+         *
+         * Using `assert.doesNotReject()` is actually not useful because there is little
+         * benefit in catching a rejection and then rejecting it again. Instead, consider
+         * adding a comment next to the specific code path that should not reject and keep
+         * error messages as expressive as possible.
+         *
+         * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
+         * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), or a validation
+         * function. See {@link throws} for more details.
+         *
+         * Besides the async nature to await the completion behaves identically to {@link doesNotThrow}.
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * await assert.doesNotReject(
+         *   async () => {
+         *     throw new TypeError('Wrong value');
+         *   },
+         *   SyntaxError,
+         * );
+         * ```
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
+         *   .then(() => {
+         *     // ...
+         *   });
+         * ```
+         * @since v10.0.0
+         */
+        function doesNotReject(
+            block: (() => Promise<unknown>) | Promise<unknown>,
+            message?: string | Error,
+        ): Promise<void>;
+        function doesNotReject(
+            block: (() => Promise<unknown>) | Promise<unknown>,
+            error: AssertPredicate,
+            message?: string | Error,
+        ): Promise<void>;
+        /**
+         * Expects the `string` input to match the regular expression.
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.match('I will fail', /pass/);
+         * // AssertionError [ERR_ASSERTION]: The input did not match the regular ...
+         *
+         * assert.match(123, /pass/);
+         * // AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.
+         *
+         * assert.match('I will pass', /pass/);
+         * // OK
+         * ```
+         *
+         * If the values do not match, or if the `string` argument is of another type than `string`, an `{@link AssertionError}` is thrown with a `message` property set equal
+         * to the value of the `message` parameter. If the `message` parameter is
+         * undefined, a default error message is assigned. If the `message` parameter is an
+         * instance of an [Error](https://nodejs.org/docs/latest-v20.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
+         * @since v13.6.0, v12.16.0
+         */
+        function match(value: string, regExp: RegExp, message?: string | Error): void;
+        /**
+         * Expects the `string` input not to match the regular expression.
+         *
+         * ```js
+         * import assert from 'node:assert/strict';
+         *
+         * assert.doesNotMatch('I will fail', /fail/);
+         * // AssertionError [ERR_ASSERTION]: The input was expected to not match the ...
+         *
+         * assert.doesNotMatch(123, /pass/);
+         * // AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.
+         *
+         * assert.doesNotMatch('I will pass', /different/);
+         * // OK
+         * ```
+         *
+         * If the values do match, or if the `string` argument is of another type than `string`, an `{@link AssertionError}` is thrown with a `message` property set equal
+         * to the value of the `message` parameter. If the `message` parameter is
+         * undefined, a default error message is assigned. If the `message` parameter is an
+         * instance of an [Error](https://nodejs.org/docs/latest-v20.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
+         * @since v13.6.0, v12.16.0
+         */
+        function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
+        /**
+         * In strict assertion mode, non-strict methods behave like their corresponding strict methods. For example,
+         * {@link deepEqual} will behave like {@link deepStrictEqual}.
+         *
+         * In strict assertion mode, error messages for objects display a diff. In legacy assertion mode, error
+         * messages for objects display the objects, often truncated.
+         *
+         * To use strict assertion mode:
+         *
+         * ```js
+         * import { strict as assert } from 'node:assert';COPY
+         * import assert from 'node:assert/strict';
+         * ```
+         *
+         * Example error diff:
+         *
+         * ```js
+         * import { strict as assert } from 'node:assert';
+         *
+         * assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
+         * // AssertionError: Expected inputs to be strictly deep-equal:
+         * // + actual - expected ... Lines skipped
+         * //
+         * //   [
+         * //     [
+         * // ...
+         * //       2,
+         * // +     3
+         * // -     '3'
+         * //     ],
+         * // ...
+         * //     5
+         * //   ]
+         * ```
+         *
+         * To deactivate the colors, use the `NO_COLOR` or `NODE_DISABLE_COLORS` environment variables. This will also
+         * deactivate the colors in the REPL. For more on color support in terminal environments, read the tty
+         * `getColorDepth()` documentation.
+         *
+         * @since v15.0.0, v13.9.0, v12.16.2, v9.9.0
+         */
+        namespace strict {
+            type AssertionError = assert.AssertionError;
+            type AssertPredicate = assert.AssertPredicate;
+            type CallTrackerCall = assert.CallTrackerCall;
+            type CallTrackerReportInformation = assert.CallTrackerReportInformation;
+        }
+        const strict:
+            & Omit<
+                typeof assert,
+                | "equal"
+                | "notEqual"
+                | "deepEqual"
+                | "notDeepEqual"
+                | "ok"
+                | "strictEqual"
+                | "deepStrictEqual"
+                | "ifError"
+                | "strict"
+            >
+            & {
+                (value: unknown, message?: string | Error): asserts value;
+                equal: typeof strictEqual;
+                notEqual: typeof notStrictEqual;
+                deepEqual: typeof deepStrictEqual;
+                notDeepEqual: typeof notDeepStrictEqual;
+                // Mapped types and assertion functions are incompatible?
+                // TS2775: Assertions require every name in the call target
+                // to be declared with an explicit type annotation.
+                ok: typeof ok;
+                strictEqual: typeof strictEqual;
+                deepStrictEqual: typeof deepStrictEqual;
+                ifError: typeof ifError;
+                strict: typeof strict;
+            };
+    }
+    export = assert;
+}
+declare module "node:assert" {
+    import assert = require("assert");
+    export = assert;
+}

js/node_modules/@types/node/assert/strict.d.ts

@@ -0,0 +1,8 @@
+declare module "assert/strict" {
+    import { strict } from "node:assert";
+    export = strict;
+}
+declare module "node:assert/strict" {
+    import { strict } from "node:assert";
+    export = strict;
+}

js/node_modules/@types/node/async_hooks.d.ts

@@ -0,0 +1,541 @@
+/**
+ * We strongly discourage the use of the `async_hooks` API.
+ * Other APIs that can cover most of its use cases include:
+ *
+ * * [`AsyncLocalStorage`](https://nodejs.org/docs/latest-v20.x/api/async_context.html#class-asynclocalstorage) tracks async context
+ * * [`process.getActiveResourcesInfo()`](https://nodejs.org/docs/latest-v20.x/api/process.html#processgetactiveresourcesinfo) tracks active resources
+ *
+ * The `node:async_hooks` module provides an API to track asynchronous resources.
+ * It can be accessed using:
+ *
+ * ```js
+ * import async_hooks from 'node:async_hooks';
+ * ```
+ * @experimental
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/async_hooks.js)
+ */
+declare module "async_hooks" {
+    /**
+     * ```js
+     * import { executionAsyncId } from 'node:async_hooks';
+     * import fs from 'node:fs';
+     *
+     * console.log(executionAsyncId());  // 1 - bootstrap
+     * const path = '.';
+     * fs.open(path, 'r', (err, fd) => {
+     *   console.log(executionAsyncId());  // 6 - open()
+     * });
+     * ```
+     *
+     * The ID returned from `executionAsyncId()` is related to execution timing, not
+     * causality (which is covered by `triggerAsyncId()`):
+     *
+     * ```js
+     * const server = net.createServer((conn) => {
+     *   // Returns the ID of the server, not of the new connection, because the
+     *   // callback runs in the execution scope of the server's MakeCallback().
+     *   async_hooks.executionAsyncId();
+     *
+     * }).listen(port, () => {
+     *   // Returns the ID of a TickObject (process.nextTick()) because all
+     *   // callbacks passed to .listen() are wrapped in a nextTick().
+     *   async_hooks.executionAsyncId();
+     * });
+     * ```
+     *
+     * Promise contexts may not get precise `executionAsyncIds` by default.
+     * See the section on [promise execution tracking](https://nodejs.org/docs/latest-v20.x/api/async_hooks.html#promise-execution-tracking).
+     * @since v8.1.0
+     * @return The `asyncId` of the current execution context. Useful to track when something calls.
+     */
+    function executionAsyncId(): number;
+    /**
+     * Resource objects returned by `executionAsyncResource()` are most often internal
+     * Node.js handle objects with undocumented APIs. Using any functions or properties
+     * on the object is likely to crash your application and should be avoided.
+     *
+     * Using `executionAsyncResource()` in the top-level execution context will
+     * return an empty object as there is no handle or request object to use,
+     * but having an object representing the top-level can be helpful.
+     *
+     * ```js
+     * import { open } from 'node:fs';
+     * import { executionAsyncId, executionAsyncResource } from 'node:async_hooks';
+     *
+     * console.log(executionAsyncId(), executionAsyncResource());  // 1 {}
+     * open(new URL(import.meta.url), 'r', (err, fd) => {
+     *   console.log(executionAsyncId(), executionAsyncResource());  // 7 FSReqWrap
+     * });
+     * ```
+     *
+     * This can be used to implement continuation local storage without the
+     * use of a tracking `Map` to store the metadata:
+     *
+     * ```js
+     * import { createServer } from 'node:http';
+     * import {
+     *   executionAsyncId,
+     *   executionAsyncResource,
+     *   createHook,
+     * } from 'async_hooks';
+     * const sym = Symbol('state'); // Private symbol to avoid pollution
+     *
+     * createHook({
+     *   init(asyncId, type, triggerAsyncId, resource) {
+     *     const cr = executionAsyncResource();
+     *     if (cr) {
+     *       resource[sym] = cr[sym];
+     *     }
+     *   },
+     * }).enable();
+     *
+     * const server = createServer((req, res) => {
+     *   executionAsyncResource()[sym] = { state: req.url };
+     *   setTimeout(function() {
+     *     res.end(JSON.stringify(executionAsyncResource()[sym]));
+     *   }, 100);
+     * }).listen(3000);
+     * ```
+     * @since v13.9.0, v12.17.0
+     * @return The resource representing the current execution. Useful to store data within the resource.
+     */
+    function executionAsyncResource(): object;
+    /**
+     * ```js
+     * const server = net.createServer((conn) => {
+     *   // The resource that caused (or triggered) this callback to be called
+     *   // was that of the new connection. Thus the return value of triggerAsyncId()
+     *   // is the asyncId of "conn".
+     *   async_hooks.triggerAsyncId();
+     *
+     * }).listen(port, () => {
+     *   // Even though all callbacks passed to .listen() are wrapped in a nextTick()
+     *   // the callback itself exists because the call to the server's .listen()
+     *   // was made. So the return value would be the ID of the server.
+     *   async_hooks.triggerAsyncId();
+     * });
+     * ```
+     *
+     * Promise contexts may not get valid `triggerAsyncId`s by default. See
+     * the section on [promise execution tracking](https://nodejs.org/docs/latest-v20.x/api/async_hooks.html#promise-execution-tracking).
+     * @return The ID of the resource responsible for calling the callback that is currently being executed.
+     */
+    function triggerAsyncId(): number;
+    interface HookCallbacks {
+        /**
+         * Called when a class is constructed that has the possibility to emit an asynchronous event.
+         * @param asyncId A unique ID for the async resource
+         * @param type The type of the async resource
+         * @param triggerAsyncId The unique ID of the async resource in whose execution context this async resource was created
+         * @param resource Reference to the resource representing the async operation, needs to be released during destroy
+         */
+        init?(asyncId: number, type: string, triggerAsyncId: number, resource: object): void;
+        /**
+         * When an asynchronous operation is initiated or completes a callback is called to notify the user.
+         * The before callback is called just before said callback is executed.
+         * @param asyncId the unique identifier assigned to the resource about to execute the callback.
+         */
+        before?(asyncId: number): void;
+        /**
+         * Called immediately after the callback specified in `before` is completed.
+         *
+         * If an uncaught exception occurs during execution of the callback, then `after` will run after the `'uncaughtException'` event is emitted or a `domain`'s handler runs.
+         * @param asyncId the unique identifier assigned to the resource which has executed the callback.
+         */
+        after?(asyncId: number): void;
+        /**
+         * Called when a promise has resolve() called. This may not be in the same execution id
+         * as the promise itself.
+         * @param asyncId the unique id for the promise that was resolve()d.
+         */
+        promiseResolve?(asyncId: number): void;
+        /**
+         * Called after the resource corresponding to asyncId is destroyed
+         * @param asyncId a unique ID for the async resource
+         */
+        destroy?(asyncId: number): void;
+    }
+    interface AsyncHook {
+        /**
+         * Enable the callbacks for a given AsyncHook instance. If no callbacks are provided enabling is a noop.
+         */
+        enable(): this;
+        /**
+         * Disable the callbacks for a given AsyncHook instance from the global pool of AsyncHook callbacks to be executed. Once a hook has been disabled it will not be called again until enabled.
+         */
+        disable(): this;
+    }
+    /**
+     * Registers functions to be called for different lifetime events of each async
+     * operation.
+     *
+     * The callbacks `init()`/`before()`/`after()`/`destroy()` are called for the
+     * respective asynchronous event during a resource's lifetime.
+     *
+     * All callbacks are optional. For example, if only resource cleanup needs to
+     * be tracked, then only the `destroy` callback needs to be passed. The
+     * specifics of all functions that can be passed to `callbacks` is in the `Hook Callbacks` section.
+     *
+     * ```js
+     * import { createHook } from 'node:async_hooks';
+     *
+     * const asyncHook = createHook({
+     *   init(asyncId, type, triggerAsyncId, resource) { },
+     *   destroy(asyncId) { },
+     * });
+     * ```
+     *
+     * The callbacks will be inherited via the prototype chain:
+     *
+     * ```js
+     * class MyAsyncCallbacks {
+     *   init(asyncId, type, triggerAsyncId, resource) { }
+     *   destroy(asyncId) {}
+     * }
+     *
+     * class MyAddedCallbacks extends MyAsyncCallbacks {
+     *   before(asyncId) { }
+     *   after(asyncId) { }
+     * }
+     *
+     * const asyncHook = async_hooks.createHook(new MyAddedCallbacks());
+     * ```
+     *
+     * Because promises are asynchronous resources whose lifecycle is tracked
+     * via the async hooks mechanism, the `init()`, `before()`, `after()`, and`destroy()` callbacks _must not_ be async functions that return promises.
+     * @since v8.1.0
+     * @param callbacks The `Hook Callbacks` to register
+     * @return Instance used for disabling and enabling hooks
+     */
+    function createHook(callbacks: HookCallbacks): AsyncHook;
+    interface AsyncResourceOptions {
+        /**
+         * The ID of the execution context that created this async event.
+         * @default executionAsyncId()
+         */
+        triggerAsyncId?: number | undefined;
+        /**
+         * Disables automatic `emitDestroy` when the object is garbage collected.
+         * This usually does not need to be set (even if `emitDestroy` is called
+         * manually), unless the resource's `asyncId` is retrieved and the
+         * sensitive API's `emitDestroy` is called with it.
+         * @default false
+         */
+        requireManualDestroy?: boolean | undefined;
+    }
+    /**
+     * The class `AsyncResource` is designed to be extended by the embedder's async
+     * resources. Using this, users can easily trigger the lifetime events of their
+     * own resources.
+     *
+     * The `init` hook will trigger when an `AsyncResource` is instantiated.
+     *
+     * The following is an overview of the `AsyncResource` API.
+     *
+     * ```js
+     * import { AsyncResource, executionAsyncId } from 'node:async_hooks';
+     *
+     * // AsyncResource() is meant to be extended. Instantiating a
+     * // new AsyncResource() also triggers init. If triggerAsyncId is omitted then
+     * // async_hook.executionAsyncId() is used.
+     * const asyncResource = new AsyncResource(
+     *   type, { triggerAsyncId: executionAsyncId(), requireManualDestroy: false },
+     * );
+     *
+     * // Run a function in the execution context of the resource. This will
+     * // * establish the context of the resource
+     * // * trigger the AsyncHooks before callbacks
+     * // * call the provided function `fn` with the supplied arguments
+     * // * trigger the AsyncHooks after callbacks
+     * // * restore the original execution context
+     * asyncResource.runInAsyncScope(fn, thisArg, ...args);
+     *
+     * // Call AsyncHooks destroy callbacks.
+     * asyncResource.emitDestroy();
+     *
+     * // Return the unique ID assigned to the AsyncResource instance.
+     * asyncResource.asyncId();
+     *
+     * // Return the trigger ID for the AsyncResource instance.
+     * asyncResource.triggerAsyncId();
+     * ```
+     */
+    class AsyncResource {
+        /**
+         * AsyncResource() is meant to be extended. Instantiating a
+         * new AsyncResource() also triggers init. If triggerAsyncId is omitted then
+         * async_hook.executionAsyncId() is used.
+         * @param type The type of async event.
+         * @param triggerAsyncId The ID of the execution context that created
+         *   this async event (default: `executionAsyncId()`), or an
+         *   AsyncResourceOptions object (since v9.3.0)
+         */
+        constructor(type: string, triggerAsyncId?: number | AsyncResourceOptions);
+        /**
+         * Binds the given function to the current execution context.
+         * @since v14.8.0, v12.19.0
+         * @param fn The function to bind to the current execution context.
+         * @param type An optional name to associate with the underlying `AsyncResource`.
+         */
+        static bind<Func extends (this: ThisArg, ...args: any[]) => any, ThisArg>(
+            fn: Func,
+            type?: string,
+            thisArg?: ThisArg,
+        ): Func;
+        /**
+         * Binds the given function to execute to this `AsyncResource`'s scope.
+         * @since v14.8.0, v12.19.0
+         * @param fn The function to bind to the current `AsyncResource`.
+         */
+        bind<Func extends (...args: any[]) => any>(fn: Func): Func;
+        /**
+         * Call the provided function with the provided arguments in the execution context
+         * of the async resource. This will establish the context, trigger the AsyncHooks
+         * before callbacks, call the function, trigger the AsyncHooks after callbacks, and
+         * then restore the original execution context.
+         * @since v9.6.0
+         * @param fn The function to call in the execution context of this async resource.
+         * @param thisArg The receiver to be used for the function call.
+         * @param args Optional arguments to pass to the function.
+         */
+        runInAsyncScope<This, Result>(
+            fn: (this: This, ...args: any[]) => Result,
+            thisArg?: This,
+            ...args: any[]
+        ): Result;
+        /**
+         * Call all `destroy` hooks. This should only ever be called once. An error will
+         * be thrown if it is called more than once. This **must** be manually called. If
+         * the resource is left to be collected by the GC then the `destroy` hooks will
+         * never be called.
+         * @return A reference to `asyncResource`.
+         */
+        emitDestroy(): this;
+        /**
+         * @return The unique `asyncId` assigned to the resource.
+         */
+        asyncId(): number;
+        /**
+         * @return The same `triggerAsyncId` that is passed to the `AsyncResource` constructor.
+         */
+        triggerAsyncId(): number;
+    }
+    /**
+     * This class creates stores that stay coherent through asynchronous operations.
+     *
+     * While you can create your own implementation on top of the `node:async_hooks` module, `AsyncLocalStorage` should be preferred as it is a performant and memory
+     * safe implementation that involves significant optimizations that are non-obvious
+     * to implement.
+     *
+     * The following example uses `AsyncLocalStorage` to build a simple logger
+     * that assigns IDs to incoming HTTP requests and includes them in messages
+     * logged within each request.
+     *
+     * ```js
+     * import http from 'node:http';
+     * import { AsyncLocalStorage } from 'node:async_hooks';
+     *
+     * const asyncLocalStorage = new AsyncLocalStorage();
+     *
+     * function logWithId(msg) {
+     *   const id = asyncLocalStorage.getStore();
+     *   console.log(`${id !== undefined ? id : '-'}:`, msg);
+     * }
+     *
+     * let idSeq = 0;
+     * http.createServer((req, res) => {
+     *   asyncLocalStorage.run(idSeq++, () => {
+     *     logWithId('start');
+     *     // Imagine any chain of async operations here
+     *     setImmediate(() => {
+     *       logWithId('finish');
+     *       res.end();
+     *     });
+     *   });
+     * }).listen(8080);
+     *
+     * http.get('http://localhost:8080');
+     * http.get('http://localhost:8080');
+     * // Prints:
+     * //   0: start
+     * //   1: start
+     * //   0: finish
+     * //   1: finish
+     * ```
+     *
+     * Each instance of `AsyncLocalStorage` maintains an independent storage context.
+     * Multiple instances can safely exist simultaneously without risk of interfering
+     * with each other's data.
+     * @since v13.10.0, v12.17.0
+     */
+    class AsyncLocalStorage<T> {
+        /**
+         * Binds the given function to the current execution context.
+         * @since v19.8.0
+         * @experimental
+         * @param fn The function to bind to the current execution context.
+         * @return A new function that calls `fn` within the captured execution context.
+         */
+        static bind<Func extends (...args: any[]) => any>(fn: Func): Func;
+        /**
+         * Captures the current execution context and returns a function that accepts a
+         * function as an argument. Whenever the returned function is called, it
+         * calls the function passed to it within the captured context.
+         *
+         * ```js
+         * const asyncLocalStorage = new AsyncLocalStorage();
+         * const runInAsyncScope = asyncLocalStorage.run(123, () => AsyncLocalStorage.snapshot());
+         * const result = asyncLocalStorage.run(321, () => runInAsyncScope(() => asyncLocalStorage.getStore()));
+         * console.log(result);  // returns 123
+         * ```
+         *
+         * AsyncLocalStorage.snapshot() can replace the use of AsyncResource for simple
+         * async context tracking purposes, for example:
+         *
+         * ```js
+         * class Foo {
+         *   #runInAsyncScope = AsyncLocalStorage.snapshot();
+         *
+         *   get() { return this.#runInAsyncScope(() => asyncLocalStorage.getStore()); }
+         * }
+         *
+         * const foo = asyncLocalStorage.run(123, () => new Foo());
+         * console.log(asyncLocalStorage.run(321, () => foo.get())); // returns 123
+         * ```
+         * @since v19.8.0
+         * @experimental
+         * @return A new function with the signature `(fn: (...args) : R, ...args) : R`.
+         */
+        static snapshot(): <R, TArgs extends any[]>(fn: (...args: TArgs) => R, ...args: TArgs) => R;
+        /**
+         * Disables the instance of `AsyncLocalStorage`. All subsequent calls
+         * to `asyncLocalStorage.getStore()` will return `undefined` until `asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()` is called again.
+         *
+         * When calling `asyncLocalStorage.disable()`, all current contexts linked to the
+         * instance will be exited.
+         *
+         * Calling `asyncLocalStorage.disable()` is required before the `asyncLocalStorage` can be garbage collected. This does not apply to stores
+         * provided by the `asyncLocalStorage`, as those objects are garbage collected
+         * along with the corresponding async resources.
+         *
+         * Use this method when the `asyncLocalStorage` is not in use anymore
+         * in the current process.
+         * @since v13.10.0, v12.17.0
+         * @experimental
+         */
+        disable(): void;
+        /**
+         * Returns the current store.
+         * If called outside of an asynchronous context initialized by
+         * calling `asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()`, it
+         * returns `undefined`.
+         * @since v13.10.0, v12.17.0
+         */
+        getStore(): T | undefined;
+        /**
+         * Runs a function synchronously within a context and returns its
+         * return value. The store is not accessible outside of the callback function.
+         * The store is accessible to any asynchronous operations created within the
+         * callback.
+         *
+         * The optional `args` are passed to the callback function.
+         *
+         * If the callback function throws an error, the error is thrown by `run()` too.
+         * The stacktrace is not impacted by this call and the context is exited.
+         *
+         * Example:
+         *
+         * ```js
+         * const store = { id: 2 };
+         * try {
+         *   asyncLocalStorage.run(store, () => {
+         *     asyncLocalStorage.getStore(); // Returns the store object
+         *     setTimeout(() => {
+         *       asyncLocalStorage.getStore(); // Returns the store object
+         *     }, 200);
+         *     throw new Error();
+         *   });
+         * } catch (e) {
+         *   asyncLocalStorage.getStore(); // Returns undefined
+         *   // The error will be caught here
+         * }
+         * ```
+         * @since v13.10.0, v12.17.0
+         */
+        run<R>(store: T, callback: () => R): R;
+        run<R, TArgs extends any[]>(store: T, callback: (...args: TArgs) => R, ...args: TArgs): R;
+        /**
+         * Runs a function synchronously outside of a context and returns its
+         * return value. The store is not accessible within the callback function or
+         * the asynchronous operations created within the callback. Any `getStore()` call done within the callback function will always return `undefined`.
+         *
+         * The optional `args` are passed to the callback function.
+         *
+         * If the callback function throws an error, the error is thrown by `exit()` too.
+         * The stacktrace is not impacted by this call and the context is re-entered.
+         *
+         * Example:
+         *
+         * ```js
+         * // Within a call to run
+         * try {
+         *   asyncLocalStorage.getStore(); // Returns the store object or value
+         *   asyncLocalStorage.exit(() => {
+         *     asyncLocalStorage.getStore(); // Returns undefined
+         *     throw new Error();
+         *   });
+         * } catch (e) {
+         *   asyncLocalStorage.getStore(); // Returns the same object or value
+         *   // The error will be caught here
+         * }
+         * ```
+         * @since v13.10.0, v12.17.0
+         * @experimental
+         */
+        exit<R, TArgs extends any[]>(callback: (...args: TArgs) => R, ...args: TArgs): R;
+        /**
+         * Transitions into the context for the remainder of the current
+         * synchronous execution and then persists the store through any following
+         * asynchronous calls.
+         *
+         * Example:
+         *
+         * ```js
+         * const store = { id: 1 };
+         * // Replaces previous store with the given store object
+         * asyncLocalStorage.enterWith(store);
+         * asyncLocalStorage.getStore(); // Returns the store object
+         * someAsyncOperation(() => {
+         *   asyncLocalStorage.getStore(); // Returns the same object
+         * });
+         * ```
+         *
+         * This transition will continue for the _entire_ synchronous execution.
+         * This means that if, for example, the context is entered within an event
+         * handler subsequent event handlers will also run within that context unless
+         * specifically bound to another context with an `AsyncResource`. That is why `run()` should be preferred over `enterWith()` unless there are strong reasons
+         * to use the latter method.
+         *
+         * ```js
+         * const store = { id: 1 };
+         *
+         * emitter.on('my-event', () => {
+         *   asyncLocalStorage.enterWith(store);
+         * });
+         * emitter.on('my-event', () => {
+         *   asyncLocalStorage.getStore(); // Returns the same object
+         * });
+         *
+         * asyncLocalStorage.getStore(); // Returns undefined
+         * emitter.emit('my-event');
+         * asyncLocalStorage.getStore(); // Returns the same object
+         * ```
+         * @since v13.11.0, v12.17.0
+         * @experimental
+         */
+        enterWith(store: T): void;
+    }
+}
+declare module "node:async_hooks" {
+    export * from "async_hooks";
+}