Upload folder using huggingface_hub (part 14)

node_modules/@typescript-eslint/scope-manager/dist/lib/esnext.typedarrays.js

@@ -0,0 +1,16 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
+// npx nx generate-lib repo
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.esnext_typedarrays = void 0;
+const base_config_1 = require("./base-config");
+exports.esnext_typedarrays = {
+    libs: [],
+    variables: [
+        ['Uint8Array', base_config_1.TYPE],
+        ['Uint8ArrayConstructor', base_config_1.TYPE],
+    ],
+};
+//# sourceMappingURL=esnext.typedarrays.js.map

node_modules/@typescript-eslint/scope-manager/dist/lib/esnext.weakref.d.ts

@@ -0,0 +1,2 @@
+import type { LibDefinition } from '../variable';
+export declare const esnext_weakref: LibDefinition;

node_modules/@typescript-eslint/scope-manager/dist/lib/esnext.weakref.js

@@ -0,0 +1,19 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
+// npx nx generate-lib repo
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.esnext_weakref = void 0;
+const base_config_1 = require("./base-config");
+const es2015_symbol_wellknown_1 = require("./es2015.symbol.wellknown");
+exports.esnext_weakref = {
+    libs: [es2015_symbol_wellknown_1.es2015_symbol_wellknown],
+    variables: [
+        ['WeakRef', base_config_1.TYPE_VALUE],
+        ['WeakRefConstructor', base_config_1.TYPE],
+        ['FinalizationRegistry', base_config_1.TYPE_VALUE],
+        ['FinalizationRegistryConstructor', base_config_1.TYPE],
+    ],
+};
+//# sourceMappingURL=esnext.weakref.js.map

node_modules/@typescript-eslint/scope-manager/dist/lib/index.d.ts

@@ -0,0 +1,2 @@
+import type { LibDefinition } from '../variable';
+export declare const lib: ReadonlyMap<string, LibDefinition>;

node_modules/@typescript-eslint/scope-manager/dist/lib/index.js

@@ -0,0 +1,248 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
+// npx nx generate-lib repo
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lib = void 0;
+const decorators_1 = require("./decorators");
+const decorators_legacy_1 = require("./decorators.legacy");
+const dom_1 = require("./dom");
+const dom_asynciterable_1 = require("./dom.asynciterable");
+const dom_iterable_1 = require("./dom.iterable");
+const es5_1 = require("./es5");
+const es6_1 = require("./es6");
+const es7_1 = require("./es7");
+const es2015_1 = require("./es2015");
+const es2015_collection_1 = require("./es2015.collection");
+const es2015_core_1 = require("./es2015.core");
+const es2015_generator_1 = require("./es2015.generator");
+const es2015_iterable_1 = require("./es2015.iterable");
+const es2015_promise_1 = require("./es2015.promise");
+const es2015_proxy_1 = require("./es2015.proxy");
+const es2015_reflect_1 = require("./es2015.reflect");
+const es2015_symbol_1 = require("./es2015.symbol");
+const es2015_symbol_wellknown_1 = require("./es2015.symbol.wellknown");
+const es2016_1 = require("./es2016");
+const es2016_array_include_1 = require("./es2016.array.include");
+const es2016_full_1 = require("./es2016.full");
+const es2016_intl_1 = require("./es2016.intl");
+const es2017_1 = require("./es2017");
+const es2017_arraybuffer_1 = require("./es2017.arraybuffer");
+const es2017_date_1 = require("./es2017.date");
+const es2017_full_1 = require("./es2017.full");
+const es2017_intl_1 = require("./es2017.intl");
+const es2017_object_1 = require("./es2017.object");
+const es2017_sharedmemory_1 = require("./es2017.sharedmemory");
+const es2017_string_1 = require("./es2017.string");
+const es2017_typedarrays_1 = require("./es2017.typedarrays");
+const es2018_1 = require("./es2018");
+const es2018_asyncgenerator_1 = require("./es2018.asyncgenerator");
+const es2018_asynciterable_1 = require("./es2018.asynciterable");
+const es2018_full_1 = require("./es2018.full");
+const es2018_intl_1 = require("./es2018.intl");
+const es2018_promise_1 = require("./es2018.promise");
+const es2018_regexp_1 = require("./es2018.regexp");
+const es2019_1 = require("./es2019");
+const es2019_array_1 = require("./es2019.array");
+const es2019_full_1 = require("./es2019.full");
+const es2019_intl_1 = require("./es2019.intl");
+const es2019_object_1 = require("./es2019.object");
+const es2019_string_1 = require("./es2019.string");
+const es2019_symbol_1 = require("./es2019.symbol");
+const es2020_1 = require("./es2020");
+const es2020_bigint_1 = require("./es2020.bigint");
+const es2020_date_1 = require("./es2020.date");
+const es2020_full_1 = require("./es2020.full");
+const es2020_intl_1 = require("./es2020.intl");
+const es2020_number_1 = require("./es2020.number");
+const es2020_promise_1 = require("./es2020.promise");
+const es2020_sharedmemory_1 = require("./es2020.sharedmemory");
+const es2020_string_1 = require("./es2020.string");
+const es2020_symbol_wellknown_1 = require("./es2020.symbol.wellknown");
+const es2021_1 = require("./es2021");
+const es2021_full_1 = require("./es2021.full");
+const es2021_intl_1 = require("./es2021.intl");
+const es2021_promise_1 = require("./es2021.promise");
+const es2021_string_1 = require("./es2021.string");
+const es2021_weakref_1 = require("./es2021.weakref");
+const es2022_1 = require("./es2022");
+const es2022_array_1 = require("./es2022.array");
+const es2022_error_1 = require("./es2022.error");
+const es2022_full_1 = require("./es2022.full");
+const es2022_intl_1 = require("./es2022.intl");
+const es2022_object_1 = require("./es2022.object");
+const es2022_regexp_1 = require("./es2022.regexp");
+const es2022_string_1 = require("./es2022.string");
+const es2023_1 = require("./es2023");
+const es2023_array_1 = require("./es2023.array");
+const es2023_collection_1 = require("./es2023.collection");
+const es2023_full_1 = require("./es2023.full");
+const es2023_intl_1 = require("./es2023.intl");
+const es2024_1 = require("./es2024");
+const es2024_arraybuffer_1 = require("./es2024.arraybuffer");
+const es2024_collection_1 = require("./es2024.collection");
+const es2024_full_1 = require("./es2024.full");
+const es2024_object_1 = require("./es2024.object");
+const es2024_promise_1 = require("./es2024.promise");
+const es2024_regexp_1 = require("./es2024.regexp");
+const es2024_sharedmemory_1 = require("./es2024.sharedmemory");
+const es2024_string_1 = require("./es2024.string");
+const es2025_1 = require("./es2025");
+const es2025_collection_1 = require("./es2025.collection");
+const es2025_float16_1 = require("./es2025.float16");
+const es2025_full_1 = require("./es2025.full");
+const es2025_intl_1 = require("./es2025.intl");
+const es2025_iterator_1 = require("./es2025.iterator");
+const es2025_promise_1 = require("./es2025.promise");
+const es2025_regexp_1 = require("./es2025.regexp");
+const esnext_1 = require("./esnext");
+const esnext_array_1 = require("./esnext.array");
+const esnext_asynciterable_1 = require("./esnext.asynciterable");
+const esnext_bigint_1 = require("./esnext.bigint");
+const esnext_collection_1 = require("./esnext.collection");
+const esnext_date_1 = require("./esnext.date");
+const esnext_decorators_1 = require("./esnext.decorators");
+const esnext_disposable_1 = require("./esnext.disposable");
+const esnext_error_1 = require("./esnext.error");
+const esnext_float16_1 = require("./esnext.float16");
+const esnext_full_1 = require("./esnext.full");
+const esnext_intl_1 = require("./esnext.intl");
+const esnext_iterator_1 = require("./esnext.iterator");
+const esnext_object_1 = require("./esnext.object");
+const esnext_promise_1 = require("./esnext.promise");
+const esnext_regexp_1 = require("./esnext.regexp");
+const esnext_sharedmemory_1 = require("./esnext.sharedmemory");
+const esnext_string_1 = require("./esnext.string");
+const esnext_symbol_1 = require("./esnext.symbol");
+const esnext_temporal_1 = require("./esnext.temporal");
+const esnext_typedarrays_1 = require("./esnext.typedarrays");
+const esnext_weakref_1 = require("./esnext.weakref");
+const lib_1 = require("./lib");
+const scripthost_1 = require("./scripthost");
+const webworker_1 = require("./webworker");
+const webworker_asynciterable_1 = require("./webworker.asynciterable");
+const webworker_importscripts_1 = require("./webworker.importscripts");
+const webworker_iterable_1 = require("./webworker.iterable");
+exports.lib = new Map([
+    ['es5', es5_1.es5],
+    ['es6', es6_1.es6],
+    ['es2015', es2015_1.es2015],
+    ['es7', es7_1.es7],
+    ['es2016', es2016_1.es2016],
+    ['es2017', es2017_1.es2017],
+    ['es2018', es2018_1.es2018],
+    ['es2019', es2019_1.es2019],
+    ['es2020', es2020_1.es2020],
+    ['es2021', es2021_1.es2021],
+    ['es2022', es2022_1.es2022],
+    ['es2023', es2023_1.es2023],
+    ['es2024', es2024_1.es2024],
+    ['es2025', es2025_1.es2025],
+    ['esnext', esnext_1.esnext],
+    ['dom', dom_1.dom],
+    ['dom.iterable', dom_iterable_1.dom_iterable],
+    ['dom.asynciterable', dom_asynciterable_1.dom_asynciterable],
+    ['webworker', webworker_1.webworker],
+    ['webworker.importscripts', webworker_importscripts_1.webworker_importscripts],
+    ['webworker.iterable', webworker_iterable_1.webworker_iterable],
+    ['webworker.asynciterable', webworker_asynciterable_1.webworker_asynciterable],
+    ['scripthost', scripthost_1.scripthost],
+    ['es2015.core', es2015_core_1.es2015_core],
+    ['es2015.collection', es2015_collection_1.es2015_collection],
+    ['es2015.generator', es2015_generator_1.es2015_generator],
+    ['es2015.iterable', es2015_iterable_1.es2015_iterable],
+    ['es2015.promise', es2015_promise_1.es2015_promise],
+    ['es2015.proxy', es2015_proxy_1.es2015_proxy],
+    ['es2015.reflect', es2015_reflect_1.es2015_reflect],
+    ['es2015.symbol', es2015_symbol_1.es2015_symbol],
+    ['es2015.symbol.wellknown', es2015_symbol_wellknown_1.es2015_symbol_wellknown],
+    ['es2016.array.include', es2016_array_include_1.es2016_array_include],
+    ['es2016.intl', es2016_intl_1.es2016_intl],
+    ['es2017.arraybuffer', es2017_arraybuffer_1.es2017_arraybuffer],
+    ['es2017.date', es2017_date_1.es2017_date],
+    ['es2017.object', es2017_object_1.es2017_object],
+    ['es2017.sharedmemory', es2017_sharedmemory_1.es2017_sharedmemory],
+    ['es2017.string', es2017_string_1.es2017_string],
+    ['es2017.intl', es2017_intl_1.es2017_intl],
+    ['es2017.typedarrays', es2017_typedarrays_1.es2017_typedarrays],
+    ['es2018.asyncgenerator', es2018_asyncgenerator_1.es2018_asyncgenerator],
+    ['es2018.asynciterable', es2018_asynciterable_1.es2018_asynciterable],
+    ['es2018.intl', es2018_intl_1.es2018_intl],
+    ['es2018.promise', es2018_promise_1.es2018_promise],
+    ['es2018.regexp', es2018_regexp_1.es2018_regexp],
+    ['es2019.array', es2019_array_1.es2019_array],
+    ['es2019.object', es2019_object_1.es2019_object],
+    ['es2019.string', es2019_string_1.es2019_string],
+    ['es2019.symbol', es2019_symbol_1.es2019_symbol],
+    ['es2019.intl', es2019_intl_1.es2019_intl],
+    ['es2020.bigint', es2020_bigint_1.es2020_bigint],
+    ['es2020.date', es2020_date_1.es2020_date],
+    ['es2020.promise', es2020_promise_1.es2020_promise],
+    ['es2020.sharedmemory', es2020_sharedmemory_1.es2020_sharedmemory],
+    ['es2020.string', es2020_string_1.es2020_string],
+    ['es2020.symbol.wellknown', es2020_symbol_wellknown_1.es2020_symbol_wellknown],
+    ['es2020.intl', es2020_intl_1.es2020_intl],
+    ['es2020.number', es2020_number_1.es2020_number],
+    ['es2021.promise', es2021_promise_1.es2021_promise],
+    ['es2021.string', es2021_string_1.es2021_string],
+    ['es2021.weakref', es2021_weakref_1.es2021_weakref],
+    ['es2021.intl', es2021_intl_1.es2021_intl],
+    ['es2022.array', es2022_array_1.es2022_array],
+    ['es2022.error', es2022_error_1.es2022_error],
+    ['es2022.intl', es2022_intl_1.es2022_intl],
+    ['es2022.object', es2022_object_1.es2022_object],
+    ['es2022.string', es2022_string_1.es2022_string],
+    ['es2022.regexp', es2022_regexp_1.es2022_regexp],
+    ['es2023.array', es2023_array_1.es2023_array],
+    ['es2023.collection', es2023_collection_1.es2023_collection],
+    ['es2023.intl', es2023_intl_1.es2023_intl],
+    ['es2024.arraybuffer', es2024_arraybuffer_1.es2024_arraybuffer],
+    ['es2024.collection', es2024_collection_1.es2024_collection],
+    ['es2024.object', es2024_object_1.es2024_object],
+    ['es2024.promise', es2024_promise_1.es2024_promise],
+    ['es2024.regexp', es2024_regexp_1.es2024_regexp],
+    ['es2024.sharedmemory', es2024_sharedmemory_1.es2024_sharedmemory],
+    ['es2024.string', es2024_string_1.es2024_string],
+    ['es2025.collection', es2025_collection_1.es2025_collection],
+    ['es2025.float16', es2025_float16_1.es2025_float16],
+    ['es2025.intl', es2025_intl_1.es2025_intl],
+    ['es2025.iterator', es2025_iterator_1.es2025_iterator],
+    ['es2025.promise', es2025_promise_1.es2025_promise],
+    ['es2025.regexp', es2025_regexp_1.es2025_regexp],
+    ['esnext.asynciterable', esnext_asynciterable_1.esnext_asynciterable],
+    ['esnext.symbol', esnext_symbol_1.esnext_symbol],
+    ['esnext.bigint', esnext_bigint_1.esnext_bigint],
+    ['esnext.weakref', esnext_weakref_1.esnext_weakref],
+    ['esnext.object', esnext_object_1.esnext_object],
+    ['esnext.regexp', esnext_regexp_1.esnext_regexp],
+    ['esnext.string', esnext_string_1.esnext_string],
+    ['esnext.float16', esnext_float16_1.esnext_float16],
+    ['esnext.iterator', esnext_iterator_1.esnext_iterator],
+    ['esnext.promise', esnext_promise_1.esnext_promise],
+    ['esnext.array', esnext_array_1.esnext_array],
+    ['esnext.collection', esnext_collection_1.esnext_collection],
+    ['esnext.date', esnext_date_1.esnext_date],
+    ['esnext.decorators', esnext_decorators_1.esnext_decorators],
+    ['esnext.disposable', esnext_disposable_1.esnext_disposable],
+    ['esnext.error', esnext_error_1.esnext_error],
+    ['esnext.intl', esnext_intl_1.esnext_intl],
+    ['esnext.sharedmemory', esnext_sharedmemory_1.esnext_sharedmemory],
+    ['esnext.temporal', esnext_temporal_1.esnext_temporal],
+    ['esnext.typedarrays', esnext_typedarrays_1.esnext_typedarrays],
+    ['decorators', decorators_1.decorators],
+    ['decorators.legacy', decorators_legacy_1.decorators_legacy],
+    ['es2016.full', es2016_full_1.es2016_full],
+    ['es2017.full', es2017_full_1.es2017_full],
+    ['es2018.full', es2018_full_1.es2018_full],
+    ['es2019.full', es2019_full_1.es2019_full],
+    ['es2020.full', es2020_full_1.es2020_full],
+    ['es2021.full', es2021_full_1.es2021_full],
+    ['es2022.full', es2022_full_1.es2022_full],
+    ['es2023.full', es2023_full_1.es2023_full],
+    ['es2024.full', es2024_full_1.es2024_full],
+    ['es2025.full', es2025_full_1.es2025_full],
+    ['esnext.full', esnext_full_1.esnext_full],
+    ['lib', lib_1.lib],
+]);
+//# sourceMappingURL=index.js.map

node_modules/@typescript-eslint/scope-manager/dist/lib/lib.d.ts

@@ -0,0 +1,2 @@
+import type { LibDefinition } from '../variable';
+export declare const lib: LibDefinition;

node_modules/@typescript-eslint/scope-manager/dist/lib/lib.js

@@ -0,0 +1,16 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
+// npx nx generate-lib repo
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lib = void 0;
+const dom_1 = require("./dom");
+const es5_1 = require("./es5");
+const scripthost_1 = require("./scripthost");
+const webworker_importscripts_1 = require("./webworker.importscripts");
+exports.lib = {
+    libs: [es5_1.es5, dom_1.dom, webworker_importscripts_1.webworker_importscripts, scripthost_1.scripthost],
+    variables: [],
+};
+//# sourceMappingURL=lib.js.map

node_modules/@typescript-eslint/scope-manager/dist/lib/scripthost.d.ts

@@ -0,0 +1,2 @@
+import type { LibDefinition } from '../variable';
+export declare const scripthost: LibDefinition;

node_modules/@typescript-eslint/scope-manager/dist/lib/scripthost.js

@@ -0,0 +1,27 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
+// npx nx generate-lib repo
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scripthost = void 0;
+const base_config_1 = require("./base-config");
+exports.scripthost = {
+    libs: [],
+    variables: [
+        ['ActiveXObject', base_config_1.TYPE_VALUE],
+        ['ITextWriter', base_config_1.TYPE],
+        ['TextStreamBase', base_config_1.TYPE],
+        ['TextStreamWriter', base_config_1.TYPE],
+        ['TextStreamReader', base_config_1.TYPE],
+        ['SafeArray', base_config_1.TYPE_VALUE],
+        ['Enumerator', base_config_1.TYPE_VALUE],
+        ['EnumeratorConstructor', base_config_1.TYPE],
+        ['VBArray', base_config_1.TYPE_VALUE],
+        ['VBArrayConstructor', base_config_1.TYPE],
+        ['VarDate', base_config_1.TYPE_VALUE],
+        ['DateConstructor', base_config_1.TYPE],
+        ['Date', base_config_1.TYPE],
+    ],
+};
+//# sourceMappingURL=scripthost.js.map

node_modules/@typescript-eslint/scope-manager/dist/lib/webworker.asynciterable.d.ts

@@ -0,0 +1,2 @@
+import type { LibDefinition } from '../variable';
+export declare const webworker_asynciterable: LibDefinition;

node_modules/@typescript-eslint/scope-manager/dist/lib/webworker.asynciterable.js

@@ -0,0 +1,12 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
+// npx nx generate-lib repo
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webworker_asynciterable = void 0;
+exports.webworker_asynciterable = {
+    libs: [],
+    variables: [],
+};
+//# sourceMappingURL=webworker.asynciterable.js.map

node_modules/@typescript-eslint/scope-manager/dist/lib/webworker.d.ts

@@ -0,0 +1,2 @@
+import type { LibDefinition } from '../variable';
+export declare const webworker: LibDefinition;

node_modules/@typescript-eslint/scope-manager/dist/lib/webworker.importscripts.d.ts

@@ -0,0 +1,2 @@
+import type { LibDefinition } from '../variable';
+export declare const webworker_importscripts: LibDefinition;

node_modules/@typescript-eslint/scope-manager/dist/lib/webworker.importscripts.js

@@ -0,0 +1,12 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
+// npx nx generate-lib repo
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webworker_importscripts = void 0;
+exports.webworker_importscripts = {
+    libs: [],
+    variables: [],
+};
+//# sourceMappingURL=webworker.importscripts.js.map

node_modules/@typescript-eslint/scope-manager/dist/lib/webworker.iterable.d.ts

@@ -0,0 +1,2 @@
+import type { LibDefinition } from '../variable';
+export declare const webworker_iterable: LibDefinition;

node_modules/@typescript-eslint/scope-manager/dist/lib/webworker.iterable.js

@@ -0,0 +1,12 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
+// npx nx generate-lib repo
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webworker_iterable = void 0;
+exports.webworker_iterable = {
+    libs: [],
+    variables: [],
+};
+//# sourceMappingURL=webworker.iterable.js.map

node_modules/@typescript-eslint/scope-manager/dist/lib/webworker.js

@@ -0,0 +1,843 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
+// npx nx generate-lib repo
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webworker = void 0;
+const base_config_1 = require("./base-config");
+const es2015_1 = require("./es2015");
+const es2018_asynciterable_1 = require("./es2018.asynciterable");
+exports.webworker = {
+    libs: [es2015_1.es2015, es2018_asynciterable_1.es2018_asynciterable],
+    variables: [
+        ['AacEncoderConfig', base_config_1.TYPE],
+        ['AddEventListenerOptions', base_config_1.TYPE],
+        ['AesCbcParams', base_config_1.TYPE],
+        ['AesCtrParams', base_config_1.TYPE],
+        ['AesDerivedKeyParams', base_config_1.TYPE],
+        ['AesGcmParams', base_config_1.TYPE],
+        ['AesKeyAlgorithm', base_config_1.TYPE],
+        ['AesKeyGenParams', base_config_1.TYPE],
+        ['Algorithm', base_config_1.TYPE],
+        ['AudioConfiguration', base_config_1.TYPE],
+        ['AudioDataCopyToOptions', base_config_1.TYPE],
+        ['AudioDataInit', base_config_1.TYPE],
+        ['AudioDecoderConfig', base_config_1.TYPE],
+        ['AudioDecoderInit', base_config_1.TYPE],
+        ['AudioDecoderSupport', base_config_1.TYPE],
+        ['AudioEncoderConfig', base_config_1.TYPE],
+        ['AudioEncoderInit', base_config_1.TYPE],
+        ['AudioEncoderSupport', base_config_1.TYPE],
+        ['AvcEncoderConfig', base_config_1.TYPE],
+        ['BlobPropertyBag', base_config_1.TYPE],
+        ['CSSMatrixComponentOptions', base_config_1.TYPE],
+        ['CSSNumericType', base_config_1.TYPE],
+        ['CacheQueryOptions', base_config_1.TYPE],
+        ['ClientQueryOptions', base_config_1.TYPE],
+        ['CloseEventInit', base_config_1.TYPE],
+        ['CookieInit', base_config_1.TYPE],
+        ['CookieListItem', base_config_1.TYPE],
+        ['CookieStoreDeleteOptions', base_config_1.TYPE],
+        ['CookieStoreGetOptions', base_config_1.TYPE],
+        ['CryptoKeyPair', base_config_1.TYPE],
+        ['CustomEventInit', base_config_1.TYPE],
+        ['DOMMatrix2DInit', base_config_1.TYPE],
+        ['DOMMatrixInit', base_config_1.TYPE],
+        ['DOMPointInit', base_config_1.TYPE],
+        ['DOMQuadInit', base_config_1.TYPE],
+        ['DOMRectInit', base_config_1.TYPE],
+        ['EcKeyGenParams', base_config_1.TYPE],
+        ['EcKeyImportParams', base_config_1.TYPE],
+        ['EcdhKeyDeriveParams', base_config_1.TYPE],
+        ['EcdsaParams', base_config_1.TYPE],
+        ['EncodedAudioChunkInit', base_config_1.TYPE],
+        ['EncodedAudioChunkMetadata', base_config_1.TYPE],
+        ['EncodedVideoChunkInit', base_config_1.TYPE],
+        ['EncodedVideoChunkMetadata', base_config_1.TYPE],
+        ['ErrorEventInit', base_config_1.TYPE],
+        ['EventInit', base_config_1.TYPE],
+        ['EventListenerOptions', base_config_1.TYPE],
+        ['EventSourceInit', base_config_1.TYPE],
+        ['ExtendableCookieChangeEventInit', base_config_1.TYPE],
+        ['ExtendableEventInit', base_config_1.TYPE],
+        ['ExtendableMessageEventInit', base_config_1.TYPE],
+        ['FetchEventInit', base_config_1.TYPE],
+        ['FilePropertyBag', base_config_1.TYPE],
+        ['FileSystemCreateWritableOptions', base_config_1.TYPE],
+        ['FileSystemGetDirectoryOptions', base_config_1.TYPE],
+        ['FileSystemGetFileOptions', base_config_1.TYPE],
+        ['FileSystemReadWriteOptions', base_config_1.TYPE],
+        ['FileSystemRemoveOptions', base_config_1.TYPE],
+        ['FontFaceDescriptors', base_config_1.TYPE],
+        ['FontFaceSetLoadEventInit', base_config_1.TYPE],
+        ['GPUBindGroupDescriptor', base_config_1.TYPE],
+        ['GPUBindGroupEntry', base_config_1.TYPE],
+        ['GPUBindGroupLayoutDescriptor', base_config_1.TYPE],
+        ['GPUBindGroupLayoutEntry', base_config_1.TYPE],
+        ['GPUBlendComponent', base_config_1.TYPE],
+        ['GPUBlendState', base_config_1.TYPE],
+        ['GPUBufferBinding', base_config_1.TYPE],
+        ['GPUBufferBindingLayout', base_config_1.TYPE],
+        ['GPUBufferDescriptor', base_config_1.TYPE],
+        ['GPUCanvasConfiguration', base_config_1.TYPE],
+        ['GPUCanvasToneMapping', base_config_1.TYPE],
+        ['GPUColorDict', base_config_1.TYPE],
+        ['GPUColorTargetState', base_config_1.TYPE],
+        ['GPUCommandBufferDescriptor', base_config_1.TYPE],
+        ['GPUCommandEncoderDescriptor', base_config_1.TYPE],
+        ['GPUComputePassDescriptor', base_config_1.TYPE],
+        ['GPUComputePassTimestampWrites', base_config_1.TYPE],
+        ['GPUComputePipelineDescriptor', base_config_1.TYPE],
+        ['GPUCopyExternalImageDestInfo', base_config_1.TYPE],
+        ['GPUCopyExternalImageSourceInfo', base_config_1.TYPE],
+        ['GPUDepthStencilState', base_config_1.TYPE],
+        ['GPUDeviceDescriptor', base_config_1.TYPE],
+        ['GPUExtent3DDict', base_config_1.TYPE],
+        ['GPUExternalTextureBindingLayout', base_config_1.TYPE],
+        ['GPUExternalTextureDescriptor', base_config_1.TYPE],
+        ['GPUFragmentState', base_config_1.TYPE],
+        ['GPUMultisampleState', base_config_1.TYPE],
+        ['GPUObjectDescriptorBase', base_config_1.TYPE],
+        ['GPUOrigin2DDict', base_config_1.TYPE],
+        ['GPUOrigin3DDict', base_config_1.TYPE],
+        ['GPUPipelineDescriptorBase', base_config_1.TYPE],
+        ['GPUPipelineErrorInit', base_config_1.TYPE],
+        ['GPUPipelineLayoutDescriptor', base_config_1.TYPE],
+        ['GPUPrimitiveState', base_config_1.TYPE],
+        ['GPUProgrammableStage', base_config_1.TYPE],
+        ['GPUQuerySetDescriptor', base_config_1.TYPE],
+        ['GPUQueueDescriptor', base_config_1.TYPE],
+        ['GPURenderBundleDescriptor', base_config_1.TYPE],
+        ['GPURenderBundleEncoderDescriptor', base_config_1.TYPE],
+        ['GPURenderPassColorAttachment', base_config_1.TYPE],
+        ['GPURenderPassDepthStencilAttachment', base_config_1.TYPE],
+        ['GPURenderPassDescriptor', base_config_1.TYPE],
+        ['GPURenderPassLayout', base_config_1.TYPE],
+        ['GPURenderPassTimestampWrites', base_config_1.TYPE],
+        ['GPURenderPipelineDescriptor', base_config_1.TYPE],
+        ['GPURequestAdapterOptions', base_config_1.TYPE],
+        ['GPUSamplerBindingLayout', base_config_1.TYPE],
+        ['GPUSamplerDescriptor', base_config_1.TYPE],
+        ['GPUShaderModuleDescriptor', base_config_1.TYPE],
+        ['GPUStencilFaceState', base_config_1.TYPE],
+        ['GPUStorageTextureBindingLayout', base_config_1.TYPE],
+        ['GPUTexelCopyBufferInfo', base_config_1.TYPE],
+        ['GPUTexelCopyBufferLayout', base_config_1.TYPE],
+        ['GPUTexelCopyTextureInfo', base_config_1.TYPE],
+        ['GPUTextureBindingLayout', base_config_1.TYPE],
+        ['GPUTextureDescriptor', base_config_1.TYPE],
+        ['GPUTextureViewDescriptor', base_config_1.TYPE],
+        ['GPUUncapturedErrorEventInit', base_config_1.TYPE],
+        ['GPUVertexAttribute', base_config_1.TYPE],
+        ['GPUVertexBufferLayout', base_config_1.TYPE],
+        ['GPUVertexState', base_config_1.TYPE],
+        ['GetNotificationOptions', base_config_1.TYPE],
+        ['HkdfParams', base_config_1.TYPE],
+        ['HmacImportParams', base_config_1.TYPE],
+        ['HmacKeyGenParams', base_config_1.TYPE],
+        ['IDBDatabaseInfo', base_config_1.TYPE],
+        ['IDBIndexParameters', base_config_1.TYPE],
+        ['IDBObjectStoreParameters', base_config_1.TYPE],
+        ['IDBTransactionOptions', base_config_1.TYPE],
+        ['IDBVersionChangeEventInit', base_config_1.TYPE],
+        ['ImageBitmapOptions', base_config_1.TYPE],
+        ['ImageBitmapRenderingContextSettings', base_config_1.TYPE],
+        ['ImageDataSettings', base_config_1.TYPE],
+        ['ImageDecodeOptions', base_config_1.TYPE],
+        ['ImageDecodeResult', base_config_1.TYPE],
+        ['ImageDecoderInit', base_config_1.TYPE],
+        ['ImageEncodeOptions', base_config_1.TYPE],
+        ['JsonWebKey', base_config_1.TYPE],
+        ['KeyAlgorithm', base_config_1.TYPE],
+        ['KeySystemTrackConfiguration', base_config_1.TYPE],
+        ['LockInfo', base_config_1.TYPE],
+        ['LockManagerSnapshot', base_config_1.TYPE],
+        ['LockOptions', base_config_1.TYPE],
+        ['MediaCapabilitiesDecodingInfo', base_config_1.TYPE],
+        ['MediaCapabilitiesEncodingInfo', base_config_1.TYPE],
+        ['MediaCapabilitiesInfo', base_config_1.TYPE],
+        ['MediaCapabilitiesKeySystemConfiguration', base_config_1.TYPE],
+        ['MediaConfiguration', base_config_1.TYPE],
+        ['MediaDecodingConfiguration', base_config_1.TYPE],
+        ['MediaEncodingConfiguration', base_config_1.TYPE],
+        ['MediaStreamTrackProcessorInit', base_config_1.TYPE],
+        ['MessageEventInit', base_config_1.TYPE],
+        ['MultiCacheQueryOptions', base_config_1.TYPE],
+        ['NavigationPreloadState', base_config_1.TYPE],
+        ['NotificationEventInit', base_config_1.TYPE],
+        ['NotificationOptions', base_config_1.TYPE],
+        ['OpusEncoderConfig', base_config_1.TYPE],
+        ['Pbkdf2Params', base_config_1.TYPE],
+        ['PerformanceMarkOptions', base_config_1.TYPE],
+        ['PerformanceMeasureOptions', base_config_1.TYPE],
+        ['PerformanceObserverInit', base_config_1.TYPE],
+        ['PermissionDescriptor', base_config_1.TYPE],
+        ['PlaneLayout', base_config_1.TYPE],
+        ['ProgressEventInit', base_config_1.TYPE],
+        ['PromiseRejectionEventInit', base_config_1.TYPE],
+        ['PushEventInit', base_config_1.TYPE],
+        ['PushSubscriptionChangeEventInit', base_config_1.TYPE],
+        ['PushSubscriptionJSON', base_config_1.TYPE],
+        ['PushSubscriptionOptionsInit', base_config_1.TYPE],
+        ['QueuingStrategy', base_config_1.TYPE],
+        ['QueuingStrategyInit', base_config_1.TYPE],
+        ['RTCEncodedAudioFrameMetadata', base_config_1.TYPE],
+        ['RTCEncodedFrameMetadata', base_config_1.TYPE],
+        ['RTCEncodedVideoFrameMetadata', base_config_1.TYPE],
+        ['ReadableStreamBYOBReaderReadOptions', base_config_1.TYPE],
+        ['ReadableStreamGetReaderOptions', base_config_1.TYPE],
+        ['ReadableStreamIteratorOptions', base_config_1.TYPE],
+        ['ReadableStreamReadDoneResult', base_config_1.TYPE],
+        ['ReadableStreamReadValueResult', base_config_1.TYPE],
+        ['ReadableWritablePair', base_config_1.TYPE],
+        ['RegistrationOptions', base_config_1.TYPE],
+        ['Report', base_config_1.TYPE],
+        ['ReportBody', base_config_1.TYPE],
+        ['ReportingObserverOptions', base_config_1.TYPE],
+        ['RequestInit', base_config_1.TYPE],
+        ['ResponseInit', base_config_1.TYPE],
+        ['RsaHashedImportParams', base_config_1.TYPE],
+        ['RsaHashedKeyGenParams', base_config_1.TYPE],
+        ['RsaKeyGenParams', base_config_1.TYPE],
+        ['RsaOaepParams', base_config_1.TYPE],
+        ['RsaOtherPrimesInfo', base_config_1.TYPE],
+        ['RsaPssParams', base_config_1.TYPE],
+        ['SchedulerPostTaskOptions', base_config_1.TYPE],
+        ['SecurityPolicyViolationEventInit', base_config_1.TYPE],
+        ['StorageEstimate', base_config_1.TYPE],
+        ['StreamPipeOptions', base_config_1.TYPE],
+        ['StructuredSerializeOptions', base_config_1.TYPE],
+        ['SvcOutputMetadata', base_config_1.TYPE],
+        ['TaskControllerInit', base_config_1.TYPE],
+        ['TaskPriorityChangeEventInit', base_config_1.TYPE],
+        ['TaskSignalAnyInit', base_config_1.TYPE],
+        ['TextDecodeOptions', base_config_1.TYPE],
+        ['TextDecoderOptions', base_config_1.TYPE],
+        ['TextEncoderEncodeIntoResult', base_config_1.TYPE],
+        ['Transformer', base_config_1.TYPE],
+        ['URLPatternComponentResult', base_config_1.TYPE],
+        ['URLPatternInit', base_config_1.TYPE],
+        ['URLPatternOptions', base_config_1.TYPE],
+        ['URLPatternResult', base_config_1.TYPE],
+        ['UnderlyingByteSource', base_config_1.TYPE],
+        ['UnderlyingDefaultSource', base_config_1.TYPE],
+        ['UnderlyingSink', base_config_1.TYPE],
+        ['UnderlyingSource', base_config_1.TYPE],
+        ['VideoColorSpaceInit', base_config_1.TYPE],
+        ['VideoConfiguration', base_config_1.TYPE],
+        ['VideoDecoderConfig', base_config_1.TYPE],
+        ['VideoDecoderInit', base_config_1.TYPE],
+        ['VideoDecoderSupport', base_config_1.TYPE],
+        ['VideoEncoderConfig', base_config_1.TYPE],
+        ['VideoEncoderEncodeOptions', base_config_1.TYPE],
+        ['VideoEncoderEncodeOptionsForAvc', base_config_1.TYPE],
+        ['VideoEncoderInit', base_config_1.TYPE],
+        ['VideoEncoderSupport', base_config_1.TYPE],
+        ['VideoFrameBufferInit', base_config_1.TYPE],
+        ['VideoFrameCopyToOptions', base_config_1.TYPE],
+        ['VideoFrameInit', base_config_1.TYPE],
+        ['WebGLContextAttributes', base_config_1.TYPE],
+        ['WebGLContextEventInit', base_config_1.TYPE],
+        ['WebTransportCloseInfo', base_config_1.TYPE],
+        ['WebTransportErrorOptions', base_config_1.TYPE],
+        ['WebTransportHash', base_config_1.TYPE],
+        ['WebTransportOptions', base_config_1.TYPE],
+        ['WebTransportSendOptions', base_config_1.TYPE],
+        ['WebTransportSendStreamOptions', base_config_1.TYPE],
+        ['WorkerOptions', base_config_1.TYPE],
+        ['WriteParams', base_config_1.TYPE],
+        ['ANGLE_instanced_arrays', base_config_1.TYPE],
+        ['AbortController', base_config_1.TYPE_VALUE],
+        ['AbortSignalEventMap', base_config_1.TYPE],
+        ['AbortSignal', base_config_1.TYPE_VALUE],
+        ['AbstractWorkerEventMap', base_config_1.TYPE],
+        ['AbstractWorker', base_config_1.TYPE],
+        ['AnimationFrameProvider', base_config_1.TYPE],
+        ['AudioData', base_config_1.TYPE_VALUE],
+        ['AudioDecoderEventMap', base_config_1.TYPE],
+        ['AudioDecoder', base_config_1.TYPE_VALUE],
+        ['AudioEncoderEventMap', base_config_1.TYPE],
+        ['AudioEncoder', base_config_1.TYPE_VALUE],
+        ['Blob', base_config_1.TYPE_VALUE],
+        ['Body', base_config_1.TYPE],
+        ['BroadcastChannelEventMap', base_config_1.TYPE],
+        ['BroadcastChannel', base_config_1.TYPE_VALUE],
+        ['ByteLengthQueuingStrategy', base_config_1.TYPE_VALUE],
+        ['CSSImageValue', base_config_1.TYPE_VALUE],
+        ['CSSKeywordValue', base_config_1.TYPE_VALUE],
+        ['CSSMathClamp', base_config_1.TYPE_VALUE],
+        ['CSSMathInvert', base_config_1.TYPE_VALUE],
+        ['CSSMathMax', base_config_1.TYPE_VALUE],
+        ['CSSMathMin', base_config_1.TYPE_VALUE],
+        ['CSSMathNegate', base_config_1.TYPE_VALUE],
+        ['CSSMathProduct', base_config_1.TYPE_VALUE],
+        ['CSSMathSum', base_config_1.TYPE_VALUE],
+        ['CSSMathValue', base_config_1.TYPE_VALUE],
+        ['CSSMatrixComponent', base_config_1.TYPE_VALUE],
+        ['CSSNumericArray', base_config_1.TYPE_VALUE],
+        ['CSSNumericValue', base_config_1.TYPE_VALUE],
+        ['CSSPerspective', base_config_1.TYPE_VALUE],
+        ['CSSRotate', base_config_1.TYPE_VALUE],
+        ['CSSScale', base_config_1.TYPE_VALUE],
+        ['CSSSkew', base_config_1.TYPE_VALUE],
+        ['CSSSkewX', base_config_1.TYPE_VALUE],
+        ['CSSSkewY', base_config_1.TYPE_VALUE],
+        ['CSSStyleValue', base_config_1.TYPE_VALUE],
+        ['CSSTransformComponent', base_config_1.TYPE_VALUE],
+        ['CSSTransformValue', base_config_1.TYPE_VALUE],
+        ['CSSTranslate', base_config_1.TYPE_VALUE],
+        ['CSSUnitValue', base_config_1.TYPE_VALUE],
+        ['CSSUnparsedValue', base_config_1.TYPE_VALUE],
+        ['CSSVariableReferenceValue', base_config_1.TYPE_VALUE],
+        ['Cache', base_config_1.TYPE_VALUE],
+        ['CacheStorage', base_config_1.TYPE_VALUE],
+        ['CanvasCompositing', base_config_1.TYPE],
+        ['CanvasDrawImage', base_config_1.TYPE],
+        ['CanvasDrawPath', base_config_1.TYPE],
+        ['CanvasFillStrokeStyles', base_config_1.TYPE],
+        ['CanvasFilters', base_config_1.TYPE],
+        ['CanvasGradient', base_config_1.TYPE_VALUE],
+        ['CanvasImageData', base_config_1.TYPE],
+        ['CanvasImageSmoothing', base_config_1.TYPE],
+        ['CanvasPath', base_config_1.TYPE],
+        ['CanvasPathDrawingStyles', base_config_1.TYPE],
+        ['CanvasPattern', base_config_1.TYPE_VALUE],
+        ['CanvasRect', base_config_1.TYPE],
+        ['CanvasShadowStyles', base_config_1.TYPE],
+        ['CanvasState', base_config_1.TYPE],
+        ['CanvasText', base_config_1.TYPE],
+        ['CanvasTextDrawingStyles', base_config_1.TYPE],
+        ['CanvasTransform', base_config_1.TYPE],
+        ['Client', base_config_1.TYPE_VALUE],
+        ['Clients', base_config_1.TYPE_VALUE],
+        ['CloseEvent', base_config_1.TYPE_VALUE],
+        ['CompressionStream', base_config_1.TYPE_VALUE],
+        ['CookieStore', base_config_1.TYPE_VALUE],
+        ['CookieStoreManager', base_config_1.TYPE_VALUE],
+        ['CountQueuingStrategy', base_config_1.TYPE_VALUE],
+        ['Crypto', base_config_1.TYPE_VALUE],
+        ['CryptoKey', base_config_1.TYPE_VALUE],
+        ['CustomEvent', base_config_1.TYPE_VALUE],
+        ['DOMException', base_config_1.TYPE_VALUE],
+        ['DOMMatrix', base_config_1.TYPE_VALUE],
+        ['DOMMatrixReadOnly', base_config_1.TYPE_VALUE],
+        ['DOMPoint', base_config_1.TYPE_VALUE],
+        ['DOMPointReadOnly', base_config_1.TYPE_VALUE],
+        ['DOMQuad', base_config_1.TYPE_VALUE],
+        ['DOMRect', base_config_1.TYPE_VALUE],
+        ['DOMRectReadOnly', base_config_1.TYPE_VALUE],
+        ['DOMStringList', base_config_1.TYPE_VALUE],
+        ['DecompressionStream', base_config_1.TYPE_VALUE],
+        ['DedicatedWorkerGlobalScopeEventMap', base_config_1.TYPE],
+        ['DedicatedWorkerGlobalScope', base_config_1.TYPE_VALUE],
+        ['EXT_blend_minmax', base_config_1.TYPE],
+        ['EXT_color_buffer_float', base_config_1.TYPE],
+        ['EXT_color_buffer_half_float', base_config_1.TYPE],
+        ['EXT_float_blend', base_config_1.TYPE],
+        ['EXT_frag_depth', base_config_1.TYPE],
+        ['EXT_sRGB', base_config_1.TYPE],
+        ['EXT_shader_texture_lod', base_config_1.TYPE],
+        ['EXT_texture_compression_bptc', base_config_1.TYPE],
+        ['EXT_texture_compression_rgtc', base_config_1.TYPE],
+        ['EXT_texture_filter_anisotropic', base_config_1.TYPE],
+        ['EXT_texture_norm16', base_config_1.TYPE],
+        ['EncodedAudioChunk', base_config_1.TYPE_VALUE],
+        ['EncodedVideoChunk', base_config_1.TYPE_VALUE],
+        ['ErrorEvent', base_config_1.TYPE_VALUE],
+        ['Event', base_config_1.TYPE_VALUE],
+        ['EventListener', base_config_1.TYPE],
+        ['EventListenerObject', base_config_1.TYPE],
+        ['EventSourceEventMap', base_config_1.TYPE],
+        ['EventSource', base_config_1.TYPE_VALUE],
+        ['EventTarget', base_config_1.TYPE_VALUE],
+        ['ExtendableCookieChangeEvent', base_config_1.TYPE_VALUE],
+        ['ExtendableEvent', base_config_1.TYPE_VALUE],
+        ['ExtendableMessageEvent', base_config_1.TYPE_VALUE],
+        ['FetchEvent', base_config_1.TYPE_VALUE],
+        ['File', base_config_1.TYPE_VALUE],
+        ['FileList', base_config_1.TYPE_VALUE],
+        ['FileReaderEventMap', base_config_1.TYPE],
+        ['FileReader', base_config_1.TYPE_VALUE],
+        ['FileReaderSync', base_config_1.TYPE_VALUE],
+        ['FileSystemDirectoryHandle', base_config_1.TYPE_VALUE],
+        ['FileSystemFileHandle', base_config_1.TYPE_VALUE],
+        ['FileSystemHandle', base_config_1.TYPE_VALUE],
+        ['FileSystemSyncAccessHandle', base_config_1.TYPE_VALUE],
+        ['FileSystemWritableFileStream', base_config_1.TYPE_VALUE],
+        ['FontFace', base_config_1.TYPE_VALUE],
+        ['FontFaceSetEventMap', base_config_1.TYPE],
+        ['FontFaceSet', base_config_1.TYPE_VALUE],
+        ['FontFaceSetLoadEvent', base_config_1.TYPE_VALUE],
+        ['FontFaceSource', base_config_1.TYPE],
+        ['FormData', base_config_1.TYPE_VALUE],
+        ['GPU', base_config_1.TYPE_VALUE],
+        ['GPUAdapter', base_config_1.TYPE_VALUE],
+        ['GPUAdapterInfo', base_config_1.TYPE_VALUE],
+        ['GPUBindGroup', base_config_1.TYPE_VALUE],
+        ['GPUBindGroupLayout', base_config_1.TYPE_VALUE],
+        ['GPUBindingCommandsMixin', base_config_1.TYPE],
+        ['GPUBuffer', base_config_1.TYPE_VALUE],
+        ['GPUCanvasContext', base_config_1.TYPE_VALUE],
+        ['GPUCommandBuffer', base_config_1.TYPE_VALUE],
+        ['GPUCommandEncoder', base_config_1.TYPE_VALUE],
+        ['GPUCompilationInfo', base_config_1.TYPE_VALUE],
+        ['GPUCompilationMessage', base_config_1.TYPE_VALUE],
+        ['GPUComputePassEncoder', base_config_1.TYPE_VALUE],
+        ['GPUComputePipeline', base_config_1.TYPE_VALUE],
+        ['GPUDebugCommandsMixin', base_config_1.TYPE],
+        ['GPUDeviceEventMap', base_config_1.TYPE],
+        ['GPUDevice', base_config_1.TYPE_VALUE],
+        ['GPUDeviceLostInfo', base_config_1.TYPE_VALUE],
+        ['GPUError', base_config_1.TYPE_VALUE],
+        ['GPUExternalTexture', base_config_1.TYPE_VALUE],
+        ['GPUInternalError', base_config_1.TYPE_VALUE],
+        ['GPUObjectBase', base_config_1.TYPE],
+        ['GPUOutOfMemoryError', base_config_1.TYPE_VALUE],
+        ['GPUPipelineBase', base_config_1.TYPE],
+        ['GPUPipelineError', base_config_1.TYPE_VALUE],
+        ['GPUPipelineLayout', base_config_1.TYPE_VALUE],
+        ['GPUQuerySet', base_config_1.TYPE_VALUE],
+        ['GPUQueue', base_config_1.TYPE_VALUE],
+        ['GPURenderBundle', base_config_1.TYPE_VALUE],
+        ['GPURenderBundleEncoder', base_config_1.TYPE_VALUE],
+        ['GPURenderCommandsMixin', base_config_1.TYPE],
+        ['GPURenderPassEncoder', base_config_1.TYPE_VALUE],
+        ['GPURenderPipeline', base_config_1.TYPE_VALUE],
+        ['GPUSampler', base_config_1.TYPE_VALUE],
+        ['GPUShaderModule', base_config_1.TYPE_VALUE],
+        ['GPUSupportedFeatures', base_config_1.TYPE_VALUE],
+        ['GPUSupportedLimits', base_config_1.TYPE_VALUE],
+        ['GPUTexture', base_config_1.TYPE_VALUE],
+        ['GPUTextureView', base_config_1.TYPE_VALUE],
+        ['GPUUncapturedErrorEvent', base_config_1.TYPE_VALUE],
+        ['GPUValidationError', base_config_1.TYPE_VALUE],
+        ['GenericTransformStream', base_config_1.TYPE],
+        ['Headers', base_config_1.TYPE_VALUE],
+        ['IDBCursor', base_config_1.TYPE_VALUE],
+        ['IDBCursorWithValue', base_config_1.TYPE_VALUE],
+        ['IDBDatabaseEventMap', base_config_1.TYPE],
+        ['IDBDatabase', base_config_1.TYPE_VALUE],
+        ['IDBFactory', base_config_1.TYPE_VALUE],
+        ['IDBIndex', base_config_1.TYPE_VALUE],
+        ['IDBKeyRange', base_config_1.TYPE_VALUE],
+        ['IDBObjectStore', base_config_1.TYPE_VALUE],
+        ['IDBOpenDBRequestEventMap', base_config_1.TYPE],
+        ['IDBOpenDBRequest', base_config_1.TYPE_VALUE],
+        ['IDBRequestEventMap', base_config_1.TYPE],
+        ['IDBRequest', base_config_1.TYPE_VALUE],
+        ['IDBTransactionEventMap', base_config_1.TYPE],
+        ['IDBTransaction', base_config_1.TYPE_VALUE],
+        ['IDBVersionChangeEvent', base_config_1.TYPE_VALUE],
+        ['ImageBitmap', base_config_1.TYPE_VALUE],
+        ['ImageBitmapRenderingContext', base_config_1.TYPE_VALUE],
+        ['ImageData', base_config_1.TYPE_VALUE],
+        ['ImageDecoder', base_config_1.TYPE_VALUE],
+        ['ImageTrack', base_config_1.TYPE_VALUE],
+        ['ImageTrackList', base_config_1.TYPE_VALUE],
+        ['ImportMeta', base_config_1.TYPE],
+        ['KHR_parallel_shader_compile', base_config_1.TYPE],
+        ['Lock', base_config_1.TYPE_VALUE],
+        ['LockManager', base_config_1.TYPE_VALUE],
+        ['MediaCapabilities', base_config_1.TYPE_VALUE],
+        ['MediaSourceHandle', base_config_1.TYPE_VALUE],
+        ['MediaStreamTrackProcessor', base_config_1.TYPE_VALUE],
+        ['MessageChannel', base_config_1.TYPE_VALUE],
+        ['MessageEvent', base_config_1.TYPE_VALUE],
+        ['MessageEventTargetEventMap', base_config_1.TYPE],
+        ['MessageEventTarget', base_config_1.TYPE],
+        ['MessagePortEventMap', base_config_1.TYPE],
+        ['MessagePort', base_config_1.TYPE_VALUE],
+        ['NavigationPreloadManager', base_config_1.TYPE_VALUE],
+        ['NavigatorBadge', base_config_1.TYPE],
+        ['NavigatorConcurrentHardware', base_config_1.TYPE],
+        ['NavigatorGPU', base_config_1.TYPE],
+        ['NavigatorID', base_config_1.TYPE],
+        ['NavigatorLanguage', base_config_1.TYPE],
+        ['NavigatorLocks', base_config_1.TYPE],
+        ['NavigatorOnLine', base_config_1.TYPE],
+        ['NavigatorStorage', base_config_1.TYPE],
+        ['NotificationEventMap', base_config_1.TYPE],
+        ['Notification', base_config_1.TYPE_VALUE],
+        ['NotificationEvent', base_config_1.TYPE_VALUE],
+        ['OES_draw_buffers_indexed', base_config_1.TYPE],
+        ['OES_element_index_uint', base_config_1.TYPE],
+        ['OES_fbo_render_mipmap', base_config_1.TYPE],
+        ['OES_standard_derivatives', base_config_1.TYPE],
+        ['OES_texture_float', base_config_1.TYPE],
+        ['OES_texture_float_linear', base_config_1.TYPE],
+        ['OES_texture_half_float', base_config_1.TYPE],
+        ['OES_texture_half_float_linear', base_config_1.TYPE],
+        ['OES_vertex_array_object', base_config_1.TYPE],
+        ['OVR_multiview2', base_config_1.TYPE],
+        ['OffscreenCanvasEventMap', base_config_1.TYPE],
+        ['OffscreenCanvas', base_config_1.TYPE_VALUE],
+        ['OffscreenCanvasRenderingContext2D', base_config_1.TYPE_VALUE],
+        ['Path2D', base_config_1.TYPE_VALUE],
+        ['PerformanceEventMap', base_config_1.TYPE],
+        ['Performance', base_config_1.TYPE_VALUE],
+        ['PerformanceEntry', base_config_1.TYPE_VALUE],
+        ['PerformanceMark', base_config_1.TYPE_VALUE],
+        ['PerformanceMeasure', base_config_1.TYPE_VALUE],
+        ['PerformanceObserver', base_config_1.TYPE_VALUE],
+        ['PerformanceObserverEntryList', base_config_1.TYPE_VALUE],
+        ['PerformanceResourceTiming', base_config_1.TYPE_VALUE],
+        ['PerformanceServerTiming', base_config_1.TYPE_VALUE],
+        ['PermissionStatusEventMap', base_config_1.TYPE],
+        ['PermissionStatus', base_config_1.TYPE_VALUE],
+        ['Permissions', base_config_1.TYPE_VALUE],
+        ['ProgressEvent', base_config_1.TYPE_VALUE],
+        ['PromiseRejectionEvent', base_config_1.TYPE_VALUE],
+        ['PushEvent', base_config_1.TYPE_VALUE],
+        ['PushManager', base_config_1.TYPE_VALUE],
+        ['PushManagerAttribute', base_config_1.TYPE],
+        ['PushMessageData', base_config_1.TYPE_VALUE],
+        ['PushSubscription', base_config_1.TYPE_VALUE],
+        ['PushSubscriptionChangeEvent', base_config_1.TYPE_VALUE],
+        ['PushSubscriptionOptions', base_config_1.TYPE_VALUE],
+        ['RTCDataChannelEventMap', base_config_1.TYPE],
+        ['RTCDataChannel', base_config_1.TYPE_VALUE],
+        ['RTCEncodedAudioFrame', base_config_1.TYPE_VALUE],
+        ['RTCEncodedVideoFrame', base_config_1.TYPE_VALUE],
+        ['RTCRtpScriptTransformer', base_config_1.TYPE_VALUE],
+        ['RTCTransformEvent', base_config_1.TYPE_VALUE],
+        ['ReadableByteStreamController', base_config_1.TYPE_VALUE],
+        ['ReadableStream', base_config_1.TYPE_VALUE],
+        ['ReadableStreamBYOBReader', base_config_1.TYPE_VALUE],
+        ['ReadableStreamBYOBRequest', base_config_1.TYPE_VALUE],
+        ['ReadableStreamDefaultController', base_config_1.TYPE_VALUE],
+        ['ReadableStreamDefaultReader', base_config_1.TYPE_VALUE],
+        ['ReadableStreamGenericReader', base_config_1.TYPE],
+        ['ReportingObserver', base_config_1.TYPE_VALUE],
+        ['Request', base_config_1.TYPE_VALUE],
+        ['Response', base_config_1.TYPE_VALUE],
+        ['Scheduler', base_config_1.TYPE_VALUE],
+        ['SecurityPolicyViolationEvent', base_config_1.TYPE_VALUE],
+        ['ServiceWorkerEventMap', base_config_1.TYPE],
+        ['ServiceWorker', base_config_1.TYPE_VALUE],
+        ['ServiceWorkerContainerEventMap', base_config_1.TYPE],
+        ['ServiceWorkerContainer', base_config_1.TYPE_VALUE],
+        ['ServiceWorkerGlobalScopeEventMap', base_config_1.TYPE],
+        ['ServiceWorkerGlobalScope', base_config_1.TYPE_VALUE],
+        ['ServiceWorkerRegistrationEventMap', base_config_1.TYPE],
+        ['ServiceWorkerRegistration', base_config_1.TYPE_VALUE],
+        ['SharedWorkerGlobalScopeEventMap', base_config_1.TYPE],
+        ['SharedWorkerGlobalScope', base_config_1.TYPE_VALUE],
+        ['StorageManager', base_config_1.TYPE_VALUE],
+        ['StylePropertyMapReadOnly', base_config_1.TYPE_VALUE],
+        ['SubtleCrypto', base_config_1.TYPE_VALUE],
+        ['TaskController', base_config_1.TYPE_VALUE],
+        ['TaskPriorityChangeEvent', base_config_1.TYPE_VALUE],
+        ['TaskSignalEventMap', base_config_1.TYPE],
+        ['TaskSignal', base_config_1.TYPE_VALUE],
+        ['TextDecoder', base_config_1.TYPE_VALUE],
+        ['TextDecoderCommon', base_config_1.TYPE],
+        ['TextDecoderStream', base_config_1.TYPE_VALUE],
+        ['TextEncoder', base_config_1.TYPE_VALUE],
+        ['TextEncoderCommon', base_config_1.TYPE],
+        ['TextEncoderStream', base_config_1.TYPE_VALUE],
+        ['TextMetrics', base_config_1.TYPE_VALUE],
+        ['TransformStream', base_config_1.TYPE_VALUE],
+        ['TransformStreamDefaultController', base_config_1.TYPE_VALUE],
+        ['URL', base_config_1.TYPE_VALUE],
+        ['URLPattern', base_config_1.TYPE_VALUE],
+        ['URLSearchParams', base_config_1.TYPE_VALUE],
+        ['VideoColorSpace', base_config_1.TYPE_VALUE],
+        ['VideoDecoderEventMap', base_config_1.TYPE],
+        ['VideoDecoder', base_config_1.TYPE_VALUE],
+        ['VideoEncoderEventMap', base_config_1.TYPE],
+        ['VideoEncoder', base_config_1.TYPE_VALUE],
+        ['VideoFrame', base_config_1.TYPE_VALUE],
+        ['WEBGL_color_buffer_float', base_config_1.TYPE],
+        ['WEBGL_compressed_texture_astc', base_config_1.TYPE],
+        ['WEBGL_compressed_texture_etc', base_config_1.TYPE],
+        ['WEBGL_compressed_texture_etc1', base_config_1.TYPE],
+        ['WEBGL_compressed_texture_pvrtc', base_config_1.TYPE],
+        ['WEBGL_compressed_texture_s3tc', base_config_1.TYPE],
+        ['WEBGL_compressed_texture_s3tc_srgb', base_config_1.TYPE],
+        ['WEBGL_debug_renderer_info', base_config_1.TYPE],
+        ['WEBGL_debug_shaders', base_config_1.TYPE],
+        ['WEBGL_depth_texture', base_config_1.TYPE],
+        ['WEBGL_draw_buffers', base_config_1.TYPE],
+        ['WEBGL_lose_context', base_config_1.TYPE],
+        ['WEBGL_multi_draw', base_config_1.TYPE],
+        ['WGSLLanguageFeatures', base_config_1.TYPE_VALUE],
+        ['WebGL2RenderingContext', base_config_1.TYPE_VALUE],
+        ['WebGL2RenderingContextBase', base_config_1.TYPE],
+        ['WebGL2RenderingContextOverloads', base_config_1.TYPE],
+        ['WebGLActiveInfo', base_config_1.TYPE_VALUE],
+        ['WebGLBuffer', base_config_1.TYPE_VALUE],
+        ['WebGLContextEvent', base_config_1.TYPE_VALUE],
+        ['WebGLFramebuffer', base_config_1.TYPE_VALUE],
+        ['WebGLProgram', base_config_1.TYPE_VALUE],
+        ['WebGLQuery', base_config_1.TYPE_VALUE],
+        ['WebGLRenderbuffer', base_config_1.TYPE_VALUE],
+        ['WebGLRenderingContext', base_config_1.TYPE_VALUE],
+        ['WebGLRenderingContextBase', base_config_1.TYPE],
+        ['WebGLRenderingContextOverloads', base_config_1.TYPE],
+        ['WebGLSampler', base_config_1.TYPE_VALUE],
+        ['WebGLShader', base_config_1.TYPE_VALUE],
+        ['WebGLShaderPrecisionFormat', base_config_1.TYPE_VALUE],
+        ['WebGLSync', base_config_1.TYPE_VALUE],
+        ['WebGLTexture', base_config_1.TYPE_VALUE],
+        ['WebGLTransformFeedback', base_config_1.TYPE_VALUE],
+        ['WebGLUniformLocation', base_config_1.TYPE_VALUE],
+        ['WebGLVertexArrayObject', base_config_1.TYPE_VALUE],
+        ['WebGLVertexArrayObjectOES', base_config_1.TYPE],
+        ['WebSocketEventMap', base_config_1.TYPE],
+        ['WebSocket', base_config_1.TYPE_VALUE],
+        ['WebTransport', base_config_1.TYPE_VALUE],
+        ['WebTransportBidirectionalStream', base_config_1.TYPE_VALUE],
+        ['WebTransportDatagramDuplexStream', base_config_1.TYPE_VALUE],
+        ['WebTransportError', base_config_1.TYPE_VALUE],
+        ['WindowClient', base_config_1.TYPE_VALUE],
+        ['WindowOrWorkerGlobalScope', base_config_1.TYPE],
+        ['WorkerEventMap', base_config_1.TYPE],
+        ['Worker', base_config_1.TYPE_VALUE],
+        ['WorkerGlobalScopeEventMap', base_config_1.TYPE],
+        ['WorkerGlobalScope', base_config_1.TYPE_VALUE],
+        ['WorkerLocation', base_config_1.TYPE_VALUE],
+        ['WorkerNavigator', base_config_1.TYPE_VALUE],
+        ['WritableStream', base_config_1.TYPE_VALUE],
+        ['WritableStreamDefaultController', base_config_1.TYPE_VALUE],
+        ['WritableStreamDefaultWriter', base_config_1.TYPE_VALUE],
+        ['XMLHttpRequestEventMap', base_config_1.TYPE],
+        ['XMLHttpRequest', base_config_1.TYPE_VALUE],
+        ['XMLHttpRequestEventTargetEventMap', base_config_1.TYPE],
+        ['XMLHttpRequestEventTarget', base_config_1.TYPE_VALUE],
+        ['XMLHttpRequestUpload', base_config_1.TYPE_VALUE],
+        ['WebAssembly', base_config_1.TYPE_VALUE],
+        ['Console', base_config_1.TYPE],
+        ['AudioDataOutputCallback', base_config_1.TYPE],
+        ['EncodedAudioChunkOutputCallback', base_config_1.TYPE],
+        ['EncodedVideoChunkOutputCallback', base_config_1.TYPE],
+        ['FrameRequestCallback', base_config_1.TYPE],
+        ['LockGrantedCallback', base_config_1.TYPE],
+        ['OnErrorEventHandlerNonNull', base_config_1.TYPE],
+        ['PerformanceObserverCallback', base_config_1.TYPE],
+        ['QueuingStrategySize', base_config_1.TYPE],
+        ['ReportingObserverCallback', base_config_1.TYPE],
+        ['SchedulerPostTaskCallback', base_config_1.TYPE],
+        ['TransformerFlushCallback', base_config_1.TYPE],
+        ['TransformerStartCallback', base_config_1.TYPE],
+        ['TransformerTransformCallback', base_config_1.TYPE],
+        ['UnderlyingSinkAbortCallback', base_config_1.TYPE],
+        ['UnderlyingSinkCloseCallback', base_config_1.TYPE],
+        ['UnderlyingSinkStartCallback', base_config_1.TYPE],
+        ['UnderlyingSinkWriteCallback', base_config_1.TYPE],
+        ['UnderlyingSourceCancelCallback', base_config_1.TYPE],
+        ['UnderlyingSourcePullCallback', base_config_1.TYPE],
+        ['UnderlyingSourceStartCallback', base_config_1.TYPE],
+        ['VideoFrameOutputCallback', base_config_1.TYPE],
+        ['VoidFunction', base_config_1.TYPE],
+        ['WebCodecsErrorCallback', base_config_1.TYPE],
+        ['AlgorithmIdentifier', base_config_1.TYPE],
+        ['AllowSharedBufferSource', base_config_1.TYPE],
+        ['BigInteger', base_config_1.TYPE],
+        ['BlobPart', base_config_1.TYPE],
+        ['BodyInit', base_config_1.TYPE],
+        ['BufferSource', base_config_1.TYPE],
+        ['CSSKeywordish', base_config_1.TYPE],
+        ['CSSNumberish', base_config_1.TYPE],
+        ['CSSPerspectiveValue', base_config_1.TYPE],
+        ['CSSUnparsedSegment', base_config_1.TYPE],
+        ['CanvasImageSource', base_config_1.TYPE],
+        ['CookieList', base_config_1.TYPE],
+        ['DOMHighResTimeStamp', base_config_1.TYPE],
+        ['EpochTimeStamp', base_config_1.TYPE],
+        ['EventListenerOrEventListenerObject', base_config_1.TYPE],
+        ['FileSystemWriteChunkType', base_config_1.TYPE],
+        ['Float32List', base_config_1.TYPE],
+        ['FormDataEntryValue', base_config_1.TYPE],
+        ['GLbitfield', base_config_1.TYPE],
+        ['GLboolean', base_config_1.TYPE],
+        ['GLclampf', base_config_1.TYPE],
+        ['GLenum', base_config_1.TYPE],
+        ['GLfloat', base_config_1.TYPE],
+        ['GLint', base_config_1.TYPE],
+        ['GLint64', base_config_1.TYPE],
+        ['GLintptr', base_config_1.TYPE],
+        ['GLsizei', base_config_1.TYPE],
+        ['GLsizeiptr', base_config_1.TYPE],
+        ['GLuint', base_config_1.TYPE],
+        ['GLuint64', base_config_1.TYPE],
+        ['GPUBindingResource', base_config_1.TYPE],
+        ['GPUBufferDynamicOffset', base_config_1.TYPE],
+        ['GPUBufferUsageFlags', base_config_1.TYPE],
+        ['GPUColor', base_config_1.TYPE],
+        ['GPUColorWriteFlags', base_config_1.TYPE],
+        ['GPUCopyExternalImageSource', base_config_1.TYPE],
+        ['GPUDepthBias', base_config_1.TYPE],
+        ['GPUExtent3D', base_config_1.TYPE],
+        ['GPUFlagsConstant', base_config_1.TYPE],
+        ['GPUIndex32', base_config_1.TYPE],
+        ['GPUIntegerCoordinate', base_config_1.TYPE],
+        ['GPUIntegerCoordinateOut', base_config_1.TYPE],
+        ['GPUMapModeFlags', base_config_1.TYPE],
+        ['GPUOrigin2D', base_config_1.TYPE],
+        ['GPUOrigin3D', base_config_1.TYPE],
+        ['GPUPipelineConstantValue', base_config_1.TYPE],
+        ['GPUSampleMask', base_config_1.TYPE],
+        ['GPUShaderStageFlags', base_config_1.TYPE],
+        ['GPUSignedOffset32', base_config_1.TYPE],
+        ['GPUSize32', base_config_1.TYPE],
+        ['GPUSize32Out', base_config_1.TYPE],
+        ['GPUSize64', base_config_1.TYPE],
+        ['GPUSize64Out', base_config_1.TYPE],
+        ['GPUStencilValue', base_config_1.TYPE],
+        ['GPUTextureUsageFlags', base_config_1.TYPE],
+        ['HashAlgorithmIdentifier', base_config_1.TYPE],
+        ['HeadersInit', base_config_1.TYPE],
+        ['IDBValidKey', base_config_1.TYPE],
+        ['ImageBitmapSource', base_config_1.TYPE],
+        ['ImageBufferSource', base_config_1.TYPE],
+        ['ImageDataArray', base_config_1.TYPE],
+        ['Int32List', base_config_1.TYPE],
+        ['MessageEventSource', base_config_1.TYPE],
+        ['NamedCurve', base_config_1.TYPE],
+        ['OffscreenRenderingContext', base_config_1.TYPE],
+        ['OnErrorEventHandler', base_config_1.TYPE],
+        ['PerformanceEntryList', base_config_1.TYPE],
+        ['PushMessageDataInit', base_config_1.TYPE],
+        ['ReadableStreamController', base_config_1.TYPE],
+        ['ReadableStreamReadResult', base_config_1.TYPE],
+        ['ReadableStreamReader', base_config_1.TYPE],
+        ['ReportList', base_config_1.TYPE],
+        ['RequestInfo', base_config_1.TYPE],
+        ['TexImageSource', base_config_1.TYPE],
+        ['TimerHandler', base_config_1.TYPE],
+        ['Transferable', base_config_1.TYPE],
+        ['URLPatternInput', base_config_1.TYPE],
+        ['Uint32List', base_config_1.TYPE],
+        ['XMLHttpRequestBodyInit', base_config_1.TYPE],
+        ['AacBitstreamFormat', base_config_1.TYPE],
+        ['AlphaOption', base_config_1.TYPE],
+        ['AudioSampleFormat', base_config_1.TYPE],
+        ['AvcBitstreamFormat', base_config_1.TYPE],
+        ['BinaryType', base_config_1.TYPE],
+        ['BitrateMode', base_config_1.TYPE],
+        ['CSSMathOperator', base_config_1.TYPE],
+        ['CSSNumericBaseType', base_config_1.TYPE],
+        ['CanvasDirection', base_config_1.TYPE],
+        ['CanvasFillRule', base_config_1.TYPE],
+        ['CanvasFontKerning', base_config_1.TYPE],
+        ['CanvasFontStretch', base_config_1.TYPE],
+        ['CanvasFontVariantCaps', base_config_1.TYPE],
+        ['CanvasLineCap', base_config_1.TYPE],
+        ['CanvasLineJoin', base_config_1.TYPE],
+        ['CanvasTextAlign', base_config_1.TYPE],
+        ['CanvasTextBaseline', base_config_1.TYPE],
+        ['CanvasTextRendering', base_config_1.TYPE],
+        ['ClientTypes', base_config_1.TYPE],
+        ['CodecState', base_config_1.TYPE],
+        ['ColorGamut', base_config_1.TYPE],
+        ['ColorSpaceConversion', base_config_1.TYPE],
+        ['CompressionFormat', base_config_1.TYPE],
+        ['CookieSameSite', base_config_1.TYPE],
+        ['DocumentVisibilityState', base_config_1.TYPE],
+        ['EncodedAudioChunkType', base_config_1.TYPE],
+        ['EncodedVideoChunkType', base_config_1.TYPE],
+        ['EndingType', base_config_1.TYPE],
+        ['FileSystemHandleKind', base_config_1.TYPE],
+        ['FontDisplay', base_config_1.TYPE],
+        ['FontFaceLoadStatus', base_config_1.TYPE],
+        ['FontFaceSetLoadStatus', base_config_1.TYPE],
+        ['FrameType', base_config_1.TYPE],
+        ['GPUAddressMode', base_config_1.TYPE],
+        ['GPUAutoLayoutMode', base_config_1.TYPE],
+        ['GPUBlendFactor', base_config_1.TYPE],
+        ['GPUBlendOperation', base_config_1.TYPE],
+        ['GPUBufferBindingType', base_config_1.TYPE],
+        ['GPUBufferMapState', base_config_1.TYPE],
+        ['GPUCanvasAlphaMode', base_config_1.TYPE],
+        ['GPUCanvasToneMappingMode', base_config_1.TYPE],
+        ['GPUCompareFunction', base_config_1.TYPE],
+        ['GPUCompilationMessageType', base_config_1.TYPE],
+        ['GPUCullMode', base_config_1.TYPE],
+        ['GPUDeviceLostReason', base_config_1.TYPE],
+        ['GPUErrorFilter', base_config_1.TYPE],
+        ['GPUFeatureName', base_config_1.TYPE],
+        ['GPUFilterMode', base_config_1.TYPE],
+        ['GPUFrontFace', base_config_1.TYPE],
+        ['GPUIndexFormat', base_config_1.TYPE],
+        ['GPULoadOp', base_config_1.TYPE],
+        ['GPUMipmapFilterMode', base_config_1.TYPE],
+        ['GPUPipelineErrorReason', base_config_1.TYPE],
+        ['GPUPowerPreference', base_config_1.TYPE],
+        ['GPUPrimitiveTopology', base_config_1.TYPE],
+        ['GPUQueryType', base_config_1.TYPE],
+        ['GPUSamplerBindingType', base_config_1.TYPE],
+        ['GPUStencilOperation', base_config_1.TYPE],
+        ['GPUStorageTextureAccess', base_config_1.TYPE],
+        ['GPUStoreOp', base_config_1.TYPE],
+        ['GPUTextureAspect', base_config_1.TYPE],
+        ['GPUTextureDimension', base_config_1.TYPE],
+        ['GPUTextureFormat', base_config_1.TYPE],
+        ['GPUTextureSampleType', base_config_1.TYPE],
+        ['GPUTextureViewDimension', base_config_1.TYPE],
+        ['GPUVertexFormat', base_config_1.TYPE],
+        ['GPUVertexStepMode', base_config_1.TYPE],
+        ['GlobalCompositeOperation', base_config_1.TYPE],
+        ['HardwareAcceleration', base_config_1.TYPE],
+        ['HdrMetadataType', base_config_1.TYPE],
+        ['IDBCursorDirection', base_config_1.TYPE],
+        ['IDBRequestReadyState', base_config_1.TYPE],
+        ['IDBTransactionDurability', base_config_1.TYPE],
+        ['IDBTransactionMode', base_config_1.TYPE],
+        ['ImageDataPixelFormat', base_config_1.TYPE],
+        ['ImageOrientation', base_config_1.TYPE],
+        ['ImageSmoothingQuality', base_config_1.TYPE],
+        ['KeyFormat', base_config_1.TYPE],
+        ['KeyType', base_config_1.TYPE],
+        ['KeyUsage', base_config_1.TYPE],
+        ['LatencyMode', base_config_1.TYPE],
+        ['LockMode', base_config_1.TYPE],
+        ['MediaDecodingType', base_config_1.TYPE],
+        ['MediaEncodingType', base_config_1.TYPE],
+        ['MediaKeysRequirement', base_config_1.TYPE],
+        ['NotificationDirection', base_config_1.TYPE],
+        ['NotificationPermission', base_config_1.TYPE],
+        ['OffscreenRenderingContextId', base_config_1.TYPE],
+        ['OpusBitstreamFormat', base_config_1.TYPE],
+        ['PermissionName', base_config_1.TYPE],
+        ['PermissionState', base_config_1.TYPE],
+        ['PredefinedColorSpace', base_config_1.TYPE],
+        ['PremultiplyAlpha', base_config_1.TYPE],
+        ['PushEncryptionKeyName', base_config_1.TYPE],
+        ['RTCDataChannelState', base_config_1.TYPE],
+        ['ReadableStreamReaderMode', base_config_1.TYPE],
+        ['ReadableStreamType', base_config_1.TYPE],
+        ['ReferrerPolicy', base_config_1.TYPE],
+        ['RequestCache', base_config_1.TYPE],
+        ['RequestCredentials', base_config_1.TYPE],
+        ['RequestDestination', base_config_1.TYPE],
+        ['RequestMode', base_config_1.TYPE],
+        ['RequestPriority', base_config_1.TYPE],
+        ['RequestRedirect', base_config_1.TYPE],
+        ['ResizeQuality', base_config_1.TYPE],
+        ['ResponseType', base_config_1.TYPE],
+        ['SecurityPolicyViolationEventDisposition', base_config_1.TYPE],
+        ['ServiceWorkerState', base_config_1.TYPE],
+        ['ServiceWorkerUpdateViaCache', base_config_1.TYPE],
+        ['TaskPriority', base_config_1.TYPE],
+        ['TransferFunction', base_config_1.TYPE],
+        ['VideoColorPrimaries', base_config_1.TYPE],
+        ['VideoEncoderBitrateMode', base_config_1.TYPE],
+        ['VideoMatrixCoefficients', base_config_1.TYPE],
+        ['VideoPixelFormat', base_config_1.TYPE],
+        ['VideoTransferCharacteristics', base_config_1.TYPE],
+        ['WebGLPowerPreference', base_config_1.TYPE],
+        ['WebTransportCongestionControl', base_config_1.TYPE],
+        ['WebTransportErrorSource', base_config_1.TYPE],
+        ['WorkerType', base_config_1.TYPE],
+        ['WriteCommandType', base_config_1.TYPE],
+        ['XMLHttpRequestResponseType', base_config_1.TYPE],
+        ['FormDataIterator', base_config_1.TYPE],
+        ['HeadersIterator', base_config_1.TYPE],
+        ['StylePropertyMapReadOnlyIterator', base_config_1.TYPE],
+        ['URLSearchParamsIterator', base_config_1.TYPE],
+        ['FileSystemDirectoryHandleAsyncIterator', base_config_1.TYPE],
+        ['ReadableStreamAsyncIterator', base_config_1.TYPE],
+    ],
+};
+//# sourceMappingURL=webworker.js.map

node_modules/@typescript-eslint/scope-manager/dist/referencer/ClassVisitor.d.ts

@@ -0,0 +1,27 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { Referencer } from './Referencer';
+import { Visitor } from './Visitor';
+export declare class ClassVisitor extends Visitor {
+    #private;
+    constructor(referencer: Referencer);
+    static visit(referencer: Referencer, node: TSESTree.ClassDeclaration | TSESTree.ClassExpression): void;
+    visit(node: TSESTree.Node | null | undefined): void;
+    protected visitClass(node: TSESTree.ClassDeclaration | TSESTree.ClassExpression): void;
+    protected visitFunctionParameterTypeAnnotation(node: TSESTree.Parameter): void;
+    protected visitMethod(node: TSESTree.MethodDefinition): void;
+    protected visitMethodFunction(node: TSESTree.FunctionExpression): void;
+    protected visitPropertyBase(node: TSESTree.AccessorProperty | TSESTree.PropertyDefinition | TSESTree.TSAbstractAccessorProperty | TSESTree.TSAbstractMethodDefinition | TSESTree.TSAbstractPropertyDefinition): void;
+    protected visitPropertyDefinition(node: TSESTree.AccessorProperty | TSESTree.PropertyDefinition | TSESTree.TSAbstractAccessorProperty | TSESTree.TSAbstractPropertyDefinition): void;
+    protected visitType(node: TSESTree.Node | null | undefined): void;
+    protected AccessorProperty(node: TSESTree.AccessorProperty): void;
+    protected ClassBody(node: TSESTree.ClassBody): void;
+    protected Identifier(node: TSESTree.Identifier): void;
+    protected MethodDefinition(node: TSESTree.MethodDefinition): void;
+    protected PrivateIdentifier(): void;
+    protected PropertyDefinition(node: TSESTree.PropertyDefinition): void;
+    protected StaticBlock(node: TSESTree.StaticBlock): void;
+    protected TSAbstractAccessorProperty(node: TSESTree.TSAbstractAccessorProperty): void;
+    protected TSAbstractMethodDefinition(node: TSESTree.TSAbstractMethodDefinition): void;
+    protected TSAbstractPropertyDefinition(node: TSESTree.TSAbstractPropertyDefinition): void;
+    protected TSIndexSignature(node: TSESTree.TSIndexSignature): void;
+}

node_modules/@typescript-eslint/scope-manager/dist/referencer/ClassVisitor.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassVisitor = void 0;
+const types_1 = require("@typescript-eslint/types");
+const definition_1 = require("../definition");
+const TypeVisitor_1 = require("./TypeVisitor");
+const Visitor_1 = require("./Visitor");
+class ClassVisitor extends Visitor_1.Visitor {
+    #referencer;
+    constructor(referencer) {
+        super(referencer);
+        this.#referencer = referencer;
+    }
+    static visit(referencer, node) {
+        const classVisitor = new ClassVisitor(referencer);
+        classVisitor.visitClass(node);
+    }
+    visit(node) {
+        // make sure we only handle the nodes we are designed to handle
+        if (node && node.type in this) {
+            super.visit(node);
+        }
+        else {
+            this.#referencer.visit(node);
+        }
+    }
+    ///////////////////
+    // Visit helpers //
+    ///////////////////
+    visitClass(node) {
+        if (node.type === types_1.AST_NODE_TYPES.ClassDeclaration && node.id) {
+            this.#referencer
+                .currentScope()
+                .defineIdentifier(node.id, new definition_1.ClassNameDefinition(node.id, node));
+        }
+        node.decorators.forEach(d => this.#referencer.visit(d));
+        this.#referencer.scopeManager.nestClassScope(node);
+        if (node.id) {
+            // define the class name again inside the new scope
+            // references to the class should not resolve directly to the parent class
+            this.#referencer
+                .currentScope()
+                .defineIdentifier(node.id, new definition_1.ClassNameDefinition(node.id, node));
+        }
+        this.#referencer.visit(node.superClass);
+        // visit the type param declarations
+        this.visitType(node.typeParameters);
+        // then the usages
+        this.visitType(node.superTypeArguments);
+        node.implements.forEach(imp => this.visitType(imp));
+        this.visit(node.body);
+        this.#referencer.close(node);
+    }
+    visitFunctionParameterTypeAnnotation(node) {
+        switch (node.type) {
+            case types_1.AST_NODE_TYPES.AssignmentPattern:
+                this.visitType(node.left.typeAnnotation);
+                break;
+            case types_1.AST_NODE_TYPES.TSParameterProperty:
+                this.visitFunctionParameterTypeAnnotation(node.parameter);
+                break;
+            default:
+                this.visitType(node.typeAnnotation);
+        }
+    }
+    visitMethod(node) {
+        if (node.computed) {
+            this.#referencer.visit(node.key);
+        }
+        if (node.value.type === types_1.AST_NODE_TYPES.FunctionExpression) {
+            this.visitMethodFunction(node.value);
+        }
+        else {
+            this.#referencer.visit(node.value);
+        }
+        node.decorators.forEach(d => this.#referencer.visit(d));
+    }
+    visitMethodFunction(node) {
+        if (node.id) {
+            // FunctionExpression with name creates its special scope;
+            // FunctionExpressionNameScope.
+            this.#referencer.scopeManager.nestFunctionExpressionNameScope(node);
+        }
+        node.params.forEach(param => {
+            param.decorators.forEach(d => this.visit(d));
+        });
+        // Consider this function is in the MethodDefinition.
+        this.#referencer.scopeManager.nestFunctionScope(node, true);
+        // Process parameter declarations.
+        for (const param of node.params) {
+            this.visitPattern(param, (pattern, info) => {
+                this.#referencer
+                    .currentScope()
+                    .defineIdentifier(pattern, new definition_1.ParameterDefinition(pattern, node, info.rest));
+                this.#referencer.referencingDefaultValue(pattern, info.assignments, null, true);
+            }, { processRightHandNodes: true });
+            this.visitFunctionParameterTypeAnnotation(param);
+        }
+        this.visitType(node.returnType);
+        this.visitType(node.typeParameters);
+        this.#referencer.visitChildren(node.body);
+        this.#referencer.close(node);
+    }
+    visitPropertyBase(node) {
+        if (node.computed) {
+            this.#referencer.visit(node.key);
+        }
+        if (node.value) {
+            if (node.type === types_1.AST_NODE_TYPES.PropertyDefinition ||
+                node.type === types_1.AST_NODE_TYPES.AccessorProperty) {
+                this.#referencer.scopeManager.nestClassFieldInitializerScope(node.value);
+            }
+            this.#referencer.visit(node.value);
+            if (node.type === types_1.AST_NODE_TYPES.PropertyDefinition ||
+                node.type === types_1.AST_NODE_TYPES.AccessorProperty) {
+                this.#referencer.close(node.value);
+            }
+        }
+        node.decorators.forEach(d => this.#referencer.visit(d));
+    }
+    visitPropertyDefinition(node) {
+        this.visitPropertyBase(node);
+        /**
+         * class A {
+         *   @meta     // <--- check this
+         *   foo: Type;
+         * }
+         */
+        this.visitType(node.typeAnnotation);
+    }
+    visitType(node) {
+        if (!node) {
+            return;
+        }
+        TypeVisitor_1.TypeVisitor.visit(this.#referencer, node);
+    }
+    /////////////////////
+    // Visit selectors //
+    /////////////////////
+    AccessorProperty(node) {
+        this.visitPropertyDefinition(node);
+    }
+    ClassBody(node) {
+        // this is here on purpose so that this visitor explicitly declares visitors
+        // for all nodes it cares about (see the instance visit method above)
+        this.visitChildren(node);
+    }
+    Identifier(node) {
+        this.#referencer.visit(node);
+    }
+    MethodDefinition(node) {
+        this.visitMethod(node);
+    }
+    PrivateIdentifier() {
+        // intentionally skip
+    }
+    PropertyDefinition(node) {
+        this.visitPropertyDefinition(node);
+    }
+    StaticBlock(node) {
+        this.#referencer.scopeManager.nestClassStaticBlockScope(node);
+        node.body.forEach(b => this.visit(b));
+        this.#referencer.close(node);
+    }
+    TSAbstractAccessorProperty(node) {
+        this.visitPropertyDefinition(node);
+    }
+    TSAbstractMethodDefinition(node) {
+        this.visitPropertyBase(node);
+    }
+    TSAbstractPropertyDefinition(node) {
+        this.visitPropertyDefinition(node);
+    }
+    TSIndexSignature(node) {
+        this.visitType(node);
+    }
+}
+exports.ClassVisitor = ClassVisitor;
+//# sourceMappingURL=ClassVisitor.js.map

node_modules/@typescript-eslint/scope-manager/dist/referencer/ExportVisitor.d.ts

@@ -0,0 +1,13 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { Referencer } from './Referencer';
+import { Visitor } from './Visitor';
+export type ExportNode = TSESTree.ExportAllDeclaration | TSESTree.ExportDefaultDeclaration | TSESTree.ExportNamedDeclaration;
+export declare class ExportVisitor extends Visitor {
+    #private;
+    constructor(node: ExportNode, referencer: Referencer);
+    static visit(referencer: Referencer, node: ExportNode): void;
+    protected ExportDefaultDeclaration(node: TSESTree.ExportDefaultDeclaration): void;
+    protected ExportNamedDeclaration(node: TSESTree.ExportNamedDeclaration): void;
+    protected ExportSpecifier(node: TSESTree.ExportSpecifier): void;
+    protected Identifier(node: TSESTree.Identifier): void;
+}

node_modules/@typescript-eslint/scope-manager/dist/referencer/ExportVisitor.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportVisitor = void 0;
+const types_1 = require("@typescript-eslint/types");
+const Visitor_1 = require("./Visitor");
+class ExportVisitor extends Visitor_1.Visitor {
+    #exportNode;
+    #referencer;
+    constructor(node, referencer) {
+        super(referencer);
+        this.#exportNode = node;
+        this.#referencer = referencer;
+    }
+    static visit(referencer, node) {
+        const exportReferencer = new ExportVisitor(node, referencer);
+        exportReferencer.visit(node);
+    }
+    ExportDefaultDeclaration(node) {
+        if (node.declaration.type === types_1.AST_NODE_TYPES.Identifier) {
+            // export default A;
+            // this could be a type or a variable
+            this.visit(node.declaration);
+        }
+        else {
+            // export const a = 1;
+            // export something();
+            // etc
+            // these not included in the scope of this visitor as they are all guaranteed to be values or declare variables
+        }
+    }
+    ExportNamedDeclaration(node) {
+        if (node.source) {
+            // export ... from 'foo';
+            // these are external identifiers so there shouldn't be references or defs
+            return;
+        }
+        if (!node.declaration) {
+            // export { x };
+            this.visitChildren(node);
+        }
+        else {
+            // export const x = 1;
+            // this is not included in the scope of this visitor as it creates a variable
+        }
+    }
+    ExportSpecifier(node) {
+        if (node.exportKind === 'type' &&
+            node.local.type === types_1.AST_NODE_TYPES.Identifier) {
+            // export { type T };
+            // type exports can only reference types
+            //
+            // we can't let this fall through to the Identifier selector because the exportKind is on this node
+            // and we don't have access to the `.parent` during scope analysis
+            this.#referencer.currentScope().referenceType(node.local);
+        }
+        else {
+            this.visit(node.local);
+        }
+    }
+    Identifier(node) {
+        if (this.#exportNode.exportKind === 'type') {
+            // export type { T };
+            // type exports can only reference types
+            this.#referencer.currentScope().referenceType(node);
+        }
+        else {
+            this.#referencer.currentScope().referenceDualValueType(node);
+        }
+    }
+}
+exports.ExportVisitor = ExportVisitor;
+//# sourceMappingURL=ExportVisitor.js.map

node_modules/@typescript-eslint/scope-manager/dist/referencer/ImportVisitor.d.ts

@@ -0,0 +1,12 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { Referencer } from './Referencer';
+import { Visitor } from './Visitor';
+export declare class ImportVisitor extends Visitor {
+    #private;
+    constructor(declaration: TSESTree.ImportDeclaration, referencer: Referencer);
+    static visit(referencer: Referencer, declaration: TSESTree.ImportDeclaration): void;
+    protected ImportDefaultSpecifier(node: TSESTree.ImportDefaultSpecifier): void;
+    protected ImportNamespaceSpecifier(node: TSESTree.ImportNamespaceSpecifier): void;
+    protected ImportSpecifier(node: TSESTree.ImportSpecifier): void;
+    protected visitImport(id: TSESTree.Identifier, specifier: TSESTree.ImportDefaultSpecifier | TSESTree.ImportNamespaceSpecifier | TSESTree.ImportSpecifier): void;
+}

node_modules/@typescript-eslint/scope-manager/dist/referencer/ImportVisitor.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportVisitor = void 0;
+const definition_1 = require("../definition");
+const Visitor_1 = require("./Visitor");
+class ImportVisitor extends Visitor_1.Visitor {
+    #declaration;
+    #referencer;
+    constructor(declaration, referencer) {
+        super(referencer);
+        this.#declaration = declaration;
+        this.#referencer = referencer;
+    }
+    static visit(referencer, declaration) {
+        const importReferencer = new ImportVisitor(declaration, referencer);
+        importReferencer.visit(declaration);
+    }
+    ImportDefaultSpecifier(node) {
+        const local = node.local;
+        this.visitImport(local, node);
+    }
+    ImportNamespaceSpecifier(node) {
+        const local = node.local;
+        this.visitImport(local, node);
+    }
+    ImportSpecifier(node) {
+        const local = node.local;
+        this.visitImport(local, node);
+    }
+    visitImport(id, specifier) {
+        this.#referencer
+            .currentScope()
+            .defineIdentifier(id, new definition_1.ImportBindingDefinition(id, specifier, this.#declaration));
+    }
+}
+exports.ImportVisitor = ImportVisitor;
+//# sourceMappingURL=ImportVisitor.js.map

node_modules/@typescript-eslint/scope-manager/dist/referencer/PatternVisitor.d.ts

@@ -0,0 +1,27 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { VisitorOptions } from './VisitorBase';
+import { VisitorBase } from './VisitorBase';
+export type PatternVisitorCallback = (pattern: TSESTree.Identifier, info: {
+    assignments: (TSESTree.AssignmentExpression | TSESTree.AssignmentPattern)[];
+    rest: boolean;
+    topLevel: boolean;
+}) => void;
+export type PatternVisitorOptions = VisitorOptions;
+export declare class PatternVisitor extends VisitorBase {
+    #private;
+    readonly rightHandNodes: TSESTree.Node[];
+    constructor(options: PatternVisitorOptions, rootPattern: TSESTree.Node, callback: PatternVisitorCallback);
+    static isPattern(node: TSESTree.Node): node is TSESTree.ArrayPattern | TSESTree.AssignmentPattern | TSESTree.Identifier | TSESTree.ObjectPattern | TSESTree.RestElement | TSESTree.SpreadElement;
+    protected ArrayExpression(node: TSESTree.ArrayExpression): void;
+    protected ArrayPattern(pattern: TSESTree.ArrayPattern): void;
+    protected AssignmentExpression(node: TSESTree.AssignmentExpression): void;
+    protected AssignmentPattern(pattern: TSESTree.AssignmentPattern): void;
+    protected CallExpression(node: TSESTree.CallExpression): void;
+    protected Decorator(): void;
+    protected Identifier(pattern: TSESTree.Identifier): void;
+    protected MemberExpression(node: TSESTree.MemberExpression): void;
+    protected Property(property: TSESTree.Property): void;
+    protected RestElement(pattern: TSESTree.RestElement): void;
+    protected SpreadElement(node: TSESTree.SpreadElement): void;
+    protected TSTypeAnnotation(): void;
+}

node_modules/@typescript-eslint/scope-manager/dist/referencer/PatternVisitor.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternVisitor = void 0;
+const types_1 = require("@typescript-eslint/types");
+const VisitorBase_1 = require("./VisitorBase");
+class PatternVisitor extends VisitorBase_1.VisitorBase {
+    #assignments = [];
+    #callback;
+    #restElements = [];
+    #rootPattern;
+    rightHandNodes = [];
+    constructor(options, rootPattern, callback) {
+        super(options);
+        this.#rootPattern = rootPattern;
+        this.#callback = callback;
+    }
+    static isPattern(node) {
+        const nodeType = node.type;
+        return (nodeType === types_1.AST_NODE_TYPES.Identifier ||
+            nodeType === types_1.AST_NODE_TYPES.ObjectPattern ||
+            nodeType === types_1.AST_NODE_TYPES.ArrayPattern ||
+            nodeType === types_1.AST_NODE_TYPES.SpreadElement ||
+            nodeType === types_1.AST_NODE_TYPES.RestElement ||
+            nodeType === types_1.AST_NODE_TYPES.AssignmentPattern);
+    }
+    ArrayExpression(node) {
+        node.elements.forEach(this.visit, this);
+    }
+    ArrayPattern(pattern) {
+        for (const element of pattern.elements) {
+            this.visit(element);
+        }
+    }
+    AssignmentExpression(node) {
+        this.#assignments.push(node);
+        this.visit(node.left);
+        this.rightHandNodes.push(node.right);
+        this.#assignments.pop();
+    }
+    AssignmentPattern(pattern) {
+        this.#assignments.push(pattern);
+        this.visit(pattern.left);
+        this.rightHandNodes.push(pattern.right);
+        this.#assignments.pop();
+    }
+    CallExpression(node) {
+        // arguments are right hand nodes.
+        node.arguments.forEach(a => {
+            this.rightHandNodes.push(a);
+        });
+        this.visit(node.callee);
+    }
+    Decorator() {
+        // don't visit any decorators when exploring a pattern
+    }
+    Identifier(pattern) {
+        const lastRestElement = this.#restElements.at(-1);
+        this.#callback(pattern, {
+            assignments: this.#assignments,
+            rest: lastRestElement?.argument === pattern,
+            topLevel: pattern === this.#rootPattern,
+        });
+    }
+    MemberExpression(node) {
+        // Computed property's key is a right hand node.
+        if (node.computed) {
+            this.rightHandNodes.push(node.property);
+        }
+        // the object is only read, write to its property.
+        this.rightHandNodes.push(node.object);
+    }
+    Property(property) {
+        // Computed property's key is a right hand node.
+        if (property.computed) {
+            this.rightHandNodes.push(property.key);
+        }
+        // If it's shorthand, its key is same as its value.
+        // If it's shorthand and has its default value, its key is same as its value.left (the value is AssignmentPattern).
+        // If it's not shorthand, the name of new variable is its value's.
+        this.visit(property.value);
+    }
+    RestElement(pattern) {
+        this.#restElements.push(pattern);
+        this.visit(pattern.argument);
+        this.#restElements.pop();
+    }
+    SpreadElement(node) {
+        this.visit(node.argument);
+    }
+    TSTypeAnnotation() {
+        // we don't want to visit types
+    }
+}
+exports.PatternVisitor = PatternVisitor;
+//# sourceMappingURL=PatternVisitor.js.map

node_modules/@typescript-eslint/scope-manager/dist/referencer/Reference.d.ts

@@ -0,0 +1,87 @@
+import type { NodeWithParent, TSESTree } from '@typescript-eslint/types';
+import type { Scope } from '../scope';
+import type { Variable } from '../variable';
+export declare enum ReferenceFlag {
+    Read = 1,
+    Write = 2,
+    ReadWrite = 3
+}
+export interface ReferenceImplicitGlobal {
+    node: NodeWithParent;
+    pattern: TSESTree.BindingName;
+    ref?: Reference;
+}
+export declare enum ReferenceTypeFlag {
+    Value = 1,
+    Type = 2
+}
+/**
+ * A Reference represents a single occurrence of an identifier in code.
+ */
+export declare class Reference {
+    #private;
+    /**
+     * A unique ID for this instance - primarily used to help debugging and testing
+     */
+    readonly $id: number;
+    /**
+     * Reference to the enclosing Scope.
+     * @public
+     */
+    readonly from: Scope;
+    /**
+     * Identifier syntax node.
+     * @public
+     */
+    readonly identifier: TSESTree.Identifier | TSESTree.JSXIdentifier;
+    /**
+     * `true` if this writing reference is a variable initializer or a default value.
+     * @public
+     */
+    readonly init?: boolean;
+    readonly maybeImplicitGlobal?: ReferenceImplicitGlobal | null;
+    /**
+     * The {@link Variable} object that this reference refers to. If such variable was not defined, this is `null`.
+     * @public
+     */
+    resolved: Variable | null;
+    /**
+     * If reference is writeable, this is the node being written to it.
+     * @public
+     */
+    readonly writeExpr?: TSESTree.Node | null;
+    constructor(identifier: TSESTree.Identifier | TSESTree.JSXIdentifier, scope: Scope, flag: ReferenceFlag, writeExpr?: TSESTree.Node | null, maybeImplicitGlobal?: ReferenceImplicitGlobal | null, init?: boolean, referenceType?: ReferenceTypeFlag);
+    /**
+     * True if this reference can reference types
+     */
+    get isTypeReference(): boolean;
+    /**
+     * True if this reference can reference values
+     */
+    get isValueReference(): boolean;
+    /**
+     * Whether the reference is writeable.
+     * @public
+     */
+    isWrite(): boolean;
+    /**
+     * Whether the reference is readable.
+     * @public
+     */
+    isRead(): boolean;
+    /**
+     * Whether the reference is read-only.
+     * @public
+     */
+    isReadOnly(): boolean;
+    /**
+     * Whether the reference is write-only.
+     * @public
+     */
+    isWriteOnly(): boolean;
+    /**
+     * Whether the reference is read-write.
+     * @public
+     */
+    isReadWrite(): boolean;
+}

node_modules/@typescript-eslint/scope-manager/dist/referencer/Reference.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reference = exports.ReferenceTypeFlag = exports.ReferenceFlag = void 0;
+const ID_1 = require("../ID");
+var ReferenceFlag;
+(function (ReferenceFlag) {
+    ReferenceFlag[ReferenceFlag["Read"] = 1] = "Read";
+    ReferenceFlag[ReferenceFlag["Write"] = 2] = "Write";
+    ReferenceFlag[ReferenceFlag["ReadWrite"] = 3] = "ReadWrite";
+})(ReferenceFlag || (exports.ReferenceFlag = ReferenceFlag = {}));
+const generator = (0, ID_1.createIdGenerator)();
+var ReferenceTypeFlag;
+(function (ReferenceTypeFlag) {
+    ReferenceTypeFlag[ReferenceTypeFlag["Value"] = 1] = "Value";
+    ReferenceTypeFlag[ReferenceTypeFlag["Type"] = 2] = "Type";
+})(ReferenceTypeFlag || (exports.ReferenceTypeFlag = ReferenceTypeFlag = {}));
+/**
+ * A Reference represents a single occurrence of an identifier in code.
+ */
+class Reference {
+    /**
+     * A unique ID for this instance - primarily used to help debugging and testing
+     */
+    $id = generator();
+    /**
+     * The read-write mode of the reference.
+     */
+    #flag;
+    /**
+     * Reference to the enclosing Scope.
+     * @public
+     */
+    from;
+    /**
+     * Identifier syntax node.
+     * @public
+     */
+    identifier;
+    /**
+     * `true` if this writing reference is a variable initializer or a default value.
+     * @public
+     */
+    init;
+    maybeImplicitGlobal;
+    /**
+     * The {@link Variable} object that this reference refers to. If such variable was not defined, this is `null`.
+     * @public
+     */
+    resolved;
+    /**
+     * If reference is writeable, this is the node being written to it.
+     * @public
+     */
+    writeExpr;
+    /**
+     * In some cases, a reference may be a type, value or both a type and value reference.
+     */
+    #referenceType;
+    constructor(identifier, scope, flag, writeExpr, maybeImplicitGlobal, init, referenceType = ReferenceTypeFlag.Value) {
+        this.identifier = identifier;
+        this.from = scope;
+        this.resolved = null;
+        this.#flag = flag;
+        if (this.isWrite()) {
+            this.writeExpr = writeExpr;
+            this.init = init;
+        }
+        this.maybeImplicitGlobal = maybeImplicitGlobal;
+        this.#referenceType = referenceType;
+    }
+    /**
+     * True if this reference can reference types
+     */
+    get isTypeReference() {
+        return (this.#referenceType & ReferenceTypeFlag.Type) !== 0;
+    }
+    /**
+     * True if this reference can reference values
+     */
+    get isValueReference() {
+        return (this.#referenceType & ReferenceTypeFlag.Value) !== 0;
+    }
+    /**
+     * Whether the reference is writeable.
+     * @public
+     */
+    isWrite() {
+        return !!(this.#flag & ReferenceFlag.Write);
+    }
+    /**
+     * Whether the reference is readable.
+     * @public
+     */
+    isRead() {
+        return !!(this.#flag & ReferenceFlag.Read);
+    }
+    /**
+     * Whether the reference is read-only.
+     * @public
+     */
+    isReadOnly() {
+        return this.#flag === ReferenceFlag.Read;
+    }
+    /**
+     * Whether the reference is write-only.
+     * @public
+     */
+    isWriteOnly() {
+        return this.#flag === ReferenceFlag.Write;
+    }
+    /**
+     * Whether the reference is read-write.
+     * @public
+     */
+    isReadWrite() {
+        return this.#flag === ReferenceFlag.ReadWrite;
+    }
+}
+exports.Reference = Reference;
+//# sourceMappingURL=Reference.js.map

node_modules/@typescript-eslint/scope-manager/dist/referencer/Referencer.d.ts

@@ -0,0 +1,91 @@
+import type { Lib, TSESTree } from '@typescript-eslint/types';
+import type { Scope } from '../scope';
+import type { ScopeManager } from '../ScopeManager';
+import type { ReferenceImplicitGlobal } from './Reference';
+import type { VisitorOptions } from './Visitor';
+import { Visitor } from './Visitor';
+export interface ReferencerOptions extends VisitorOptions {
+    jsxFragmentName: string | null;
+    jsxPragma: string | null;
+    lib: Lib[];
+}
+export declare class Referencer extends Visitor {
+    #private;
+    readonly scopeManager: ScopeManager;
+    constructor(options: ReferencerOptions, scopeManager: ScopeManager);
+    private populateGlobalsFromLib;
+    /**
+     * Resolves lib names into a deduplicated set of LibDefinitions,
+     * including all transitive dependencies.
+     */
+    private resolveLibDefinitions;
+    close(node: TSESTree.Node): void;
+    currentScope(): Scope;
+    currentScope(throwOnNull: true): Scope | null;
+    referencingDefaultValue(pattern: TSESTree.Identifier, assignments: (TSESTree.AssignmentExpression | TSESTree.AssignmentPattern)[], maybeImplicitGlobal: ReferenceImplicitGlobal | null, init: boolean): void;
+    /**
+     * Searches for a variable named "name" in the upper scopes and adds a pseudo-reference from itself to itself
+     */
+    private referenceInSomeUpperScope;
+    private referenceJsxFragment;
+    private referenceJsxPragma;
+    protected visitClass(node: TSESTree.ClassDeclaration | TSESTree.ClassExpression): void;
+    protected visitForIn(node: TSESTree.ForInStatement | TSESTree.ForOfStatement): void;
+    protected visitFunction(node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.TSDeclareFunction | TSESTree.TSEmptyBodyFunctionExpression): void;
+    protected visitFunctionParameterTypeAnnotation(node: TSESTree.Parameter): void;
+    protected visitJSXElement(node: TSESTree.JSXClosingElement | TSESTree.JSXOpeningElement): void;
+    protected visitProperty(node: TSESTree.Property): void;
+    protected visitType(node: TSESTree.Node | null | undefined): void;
+    protected visitTypeAssertion(node: TSESTree.TSAsExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion): void;
+    protected ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression): void;
+    protected AssignmentExpression(node: TSESTree.AssignmentExpression): void;
+    protected BlockStatement(node: TSESTree.BlockStatement): void;
+    protected BreakStatement(): void;
+    protected CallExpression(node: TSESTree.CallExpression): void;
+    protected CatchClause(node: TSESTree.CatchClause): void;
+    protected ClassDeclaration(node: TSESTree.ClassDeclaration): void;
+    protected ClassExpression(node: TSESTree.ClassExpression): void;
+    protected ContinueStatement(): void;
+    protected ExportAllDeclaration(): void;
+    protected ExportDefaultDeclaration(node: TSESTree.ExportDefaultDeclaration): void;
+    protected ExportNamedDeclaration(node: TSESTree.ExportNamedDeclaration): void;
+    protected ForInStatement(node: TSESTree.ForInStatement): void;
+    protected ForOfStatement(node: TSESTree.ForOfStatement): void;
+    protected ForStatement(node: TSESTree.ForStatement): void;
+    protected FunctionDeclaration(node: TSESTree.FunctionDeclaration): void;
+    protected FunctionExpression(node: TSESTree.FunctionExpression): void;
+    protected Identifier(node: TSESTree.Identifier): void;
+    protected ImportAttribute(): void;
+    protected ImportDeclaration(node: TSESTree.ImportDeclaration): void;
+    protected JSXAttribute(node: TSESTree.JSXAttribute): void;
+    protected JSXClosingElement(node: TSESTree.JSXClosingElement): void;
+    protected JSXFragment(node: TSESTree.JSXFragment): void;
+    protected JSXIdentifier(node: TSESTree.JSXIdentifier): void;
+    protected JSXMemberExpression(node: TSESTree.JSXMemberExpression): void;
+    protected JSXOpeningElement(node: TSESTree.JSXOpeningElement): void;
+    protected LabeledStatement(node: TSESTree.LabeledStatement): void;
+    protected MemberExpression(node: TSESTree.MemberExpression): void;
+    protected MetaProperty(): void;
+    protected NewExpression(node: TSESTree.NewExpression): void;
+    protected PrivateIdentifier(): void;
+    protected Program(node: TSESTree.Program): void;
+    protected Property(node: TSESTree.Property): void;
+    protected SwitchStatement(node: TSESTree.SwitchStatement): void;
+    protected TaggedTemplateExpression(node: TSESTree.TaggedTemplateExpression): void;
+    protected TSAsExpression(node: TSESTree.TSAsExpression): void;
+    protected TSDeclareFunction(node: TSESTree.TSDeclareFunction): void;
+    protected TSEmptyBodyFunctionExpression(node: TSESTree.TSEmptyBodyFunctionExpression): void;
+    protected TSEnumDeclaration(node: TSESTree.TSEnumDeclaration): void;
+    protected TSExportAssignment(node: TSESTree.TSExportAssignment): void;
+    protected TSImportEqualsDeclaration(node: TSESTree.TSImportEqualsDeclaration): void;
+    protected TSInstantiationExpression(node: TSESTree.TSInstantiationExpression): void;
+    protected TSInterfaceDeclaration(node: TSESTree.TSInterfaceDeclaration): void;
+    protected TSModuleDeclaration(node: TSESTree.TSModuleDeclaration): void;
+    protected TSSatisfiesExpression(node: TSESTree.TSSatisfiesExpression): void;
+    protected TSTypeAliasDeclaration(node: TSESTree.TSTypeAliasDeclaration): void;
+    protected TSTypeAssertion(node: TSESTree.TSTypeAssertion): void;
+    protected UpdateExpression(node: TSESTree.UpdateExpression): void;
+    protected VariableDeclaration(node: TSESTree.VariableDeclaration): void;
+    protected WithStatement(node: TSESTree.WithStatement): void;
+    private visitExpressionTarget;
+}

node_modules/@typescript-eslint/scope-manager/dist/referencer/Referencer.js

@@ -0,0 +1,559 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Referencer = void 0;
+const types_1 = require("@typescript-eslint/types");
+const assert_1 = require("../assert");
+const definition_1 = require("../definition");
+const lib_1 = require("../lib");
+const ClassVisitor_1 = require("./ClassVisitor");
+const ExportVisitor_1 = require("./ExportVisitor");
+const ImportVisitor_1 = require("./ImportVisitor");
+const PatternVisitor_1 = require("./PatternVisitor");
+const Reference_1 = require("./Reference");
+const TypeVisitor_1 = require("./TypeVisitor");
+const Visitor_1 = require("./Visitor");
+// Referencing variables and creating bindings.
+class Referencer extends Visitor_1.Visitor {
+    #hasReferencedJsxFactory = false;
+    #hasReferencedJsxFragmentFactory = false;
+    #jsxFragmentName;
+    #jsxPragma;
+    #lib;
+    scopeManager;
+    constructor(options, scopeManager) {
+        super(options);
+        this.scopeManager = scopeManager;
+        this.#jsxPragma = options.jsxPragma;
+        this.#jsxFragmentName = options.jsxFragmentName;
+        this.#lib = options.lib;
+    }
+    populateGlobalsFromLib(globalScope) {
+        const libs = this.resolveLibDefinitions();
+        for (const lib of libs) {
+            for (const [name, variable] of lib.variables) {
+                globalScope.defineImplicitVariable(name, variable);
+            }
+        }
+        // Special implicit global for const assertions (`{} as const`, `<const>{}`)
+        globalScope.defineImplicitVariable('const', {
+            eslintImplicitGlobalSetting: 'readonly',
+            isTypeVariable: true,
+            isValueVariable: false,
+        });
+    }
+    /**
+     * Resolves lib names into a deduplicated set of LibDefinitions,
+     * including all transitive dependencies.
+     */
+    resolveLibDefinitions() {
+        const resolvedLibs = new Set();
+        // Resolve the top-level lib names into LibDefinition objects
+        for (const lib of this.#lib) {
+            const definition = lib_1.lib.get(lib);
+            if (!definition) {
+                throw new Error(`Invalid value for lib provided: ${lib}`);
+            }
+            resolvedLibs.add(definition);
+        }
+        // Expand transitive lib dependencies.
+        // New entries added to the Set during iteration will be visited exactly once.
+        for (const lib of resolvedLibs) {
+            for (const dependency of lib.libs) {
+                resolvedLibs.add(dependency);
+            }
+        }
+        return resolvedLibs;
+    }
+    close(node) {
+        while (this.currentScope(true) && node === this.currentScope().block) {
+            this.scopeManager.currentScope = this.currentScope().close(this.scopeManager);
+        }
+    }
+    currentScope(dontThrowOnNull) {
+        if (!dontThrowOnNull) {
+            (0, assert_1.assert)(this.scopeManager.currentScope, 'Expected currentScope to exist. This usually happens when analyze() is called with an incomplete AST node instead of a complete Program node.');
+        }
+        return this.scopeManager.currentScope;
+    }
+    referencingDefaultValue(pattern, assignments, maybeImplicitGlobal, init) {
+        assignments.forEach(assignment => {
+            this.currentScope().referenceValue(pattern, Reference_1.ReferenceFlag.Write, assignment.right, maybeImplicitGlobal, init);
+        });
+    }
+    /**
+     * Searches for a variable named "name" in the upper scopes and adds a pseudo-reference from itself to itself
+     */
+    referenceInSomeUpperScope(name) {
+        let scope = this.scopeManager.currentScope;
+        while (scope) {
+            const variable = scope.set.get(name);
+            if (!variable) {
+                scope = scope.upper;
+                continue;
+            }
+            scope.referenceValue(variable.identifiers[0]);
+            return true;
+        }
+        return false;
+    }
+    referenceJsxFragment() {
+        if (this.#jsxFragmentName == null ||
+            this.#hasReferencedJsxFragmentFactory) {
+            return;
+        }
+        this.#hasReferencedJsxFragmentFactory = this.referenceInSomeUpperScope(this.#jsxFragmentName);
+    }
+    referenceJsxPragma() {
+        if (this.#jsxPragma == null || this.#hasReferencedJsxFactory) {
+            return;
+        }
+        this.#hasReferencedJsxFactory = this.referenceInSomeUpperScope(this.#jsxPragma);
+    }
+    ///////////////////
+    // Visit helpers //
+    ///////////////////
+    visitClass(node) {
+        ClassVisitor_1.ClassVisitor.visit(this, node);
+    }
+    visitForIn(node) {
+        if (node.left.type === types_1.AST_NODE_TYPES.VariableDeclaration &&
+            node.left.kind !== 'var') {
+            this.scopeManager.nestForScope(node);
+        }
+        if (node.left.type === types_1.AST_NODE_TYPES.VariableDeclaration) {
+            this.visit(node.left);
+            this.visitPattern(node.left.declarations[0].id, pattern => {
+                this.currentScope().referenceValue(pattern, Reference_1.ReferenceFlag.Write, node.right, null, true);
+            });
+        }
+        else {
+            this.visitPattern(node.left, (pattern, info) => {
+                const maybeImplicitGlobal = !this.currentScope().isStrict
+                    ? {
+                        node,
+                        pattern,
+                    }
+                    : null;
+                this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);
+                this.currentScope().referenceValue(pattern, Reference_1.ReferenceFlag.Write, node.right, maybeImplicitGlobal, false);
+            }, { processRightHandNodes: true });
+        }
+        this.visit(node.right);
+        this.visit(node.body);
+        this.close(node);
+    }
+    visitFunction(node) {
+        // FunctionDeclaration name is defined in upper scope
+        // NOTE: Not referring variableScope. It is intended.
+        // Since
+        //  in ES5, FunctionDeclaration should be in FunctionBody.
+        //  in ES6, FunctionDeclaration should be block scoped.
+        if (node.type === types_1.AST_NODE_TYPES.FunctionExpression) {
+            if (node.id) {
+                // FunctionExpression with name creates its special scope;
+                // FunctionExpressionNameScope.
+                this.scopeManager.nestFunctionExpressionNameScope(node);
+            }
+        }
+        else if (node.id) {
+            // id is defined in upper scope
+            this.currentScope().defineIdentifier(node.id, new definition_1.FunctionNameDefinition(node.id, node));
+        }
+        // Consider this function is in the MethodDefinition.
+        this.scopeManager.nestFunctionScope(node, false);
+        // Process parameter declarations.
+        for (const param of node.params) {
+            this.visitPattern(param, (pattern, info) => {
+                this.currentScope().defineIdentifier(pattern, new definition_1.ParameterDefinition(pattern, node, info.rest));
+                this.referencingDefaultValue(pattern, info.assignments, null, true);
+            }, { processRightHandNodes: true });
+            this.visitFunctionParameterTypeAnnotation(param);
+            param.decorators.forEach(d => this.visit(d));
+        }
+        this.visitType(node.returnType);
+        this.visitType(node.typeParameters);
+        // In TypeScript there are a number of function-like constructs which have no body,
+        // so check it exists before traversing
+        if (node.body) {
+            // Skip BlockStatement to prevent creating BlockStatement scope.
+            if (node.body.type === types_1.AST_NODE_TYPES.BlockStatement) {
+                this.visitChildren(node.body);
+            }
+            else {
+                this.visit(node.body);
+            }
+        }
+        this.close(node);
+    }
+    visitFunctionParameterTypeAnnotation(node) {
+        switch (node.type) {
+            case types_1.AST_NODE_TYPES.AssignmentPattern:
+                this.visitType(node.left.typeAnnotation);
+                break;
+            case types_1.AST_NODE_TYPES.TSParameterProperty:
+                this.visitFunctionParameterTypeAnnotation(node.parameter);
+                break;
+            default:
+                this.visitType(node.typeAnnotation);
+                break;
+        }
+    }
+    visitJSXElement(node) {
+        if (node.name.type === types_1.AST_NODE_TYPES.JSXIdentifier) {
+            if (node.name.name[0].toUpperCase() === node.name.name[0] ||
+                node.name.name === 'this') {
+                // lower cased component names are always treated as "intrinsic" names, and are converted to a string,
+                // not a variable by JSX transforms:
+                // <div /> => React.createElement("div", null)
+                // the only case we want to visit a lower-cased component has its name as "this",
+                this.visit(node.name);
+            }
+        }
+        else {
+            this.visit(node.name);
+        }
+    }
+    visitProperty(node) {
+        if (node.computed) {
+            this.visit(node.key);
+        }
+        this.visit(node.value);
+    }
+    visitType(node) {
+        if (!node) {
+            return;
+        }
+        TypeVisitor_1.TypeVisitor.visit(this, node);
+    }
+    visitTypeAssertion(node) {
+        this.visit(node.expression);
+        this.visitType(node.typeAnnotation);
+    }
+    /////////////////////
+    // Visit selectors //
+    /////////////////////
+    ArrowFunctionExpression(node) {
+        this.visitFunction(node);
+    }
+    AssignmentExpression(node) {
+        const left = this.visitExpressionTarget(node.left);
+        if (PatternVisitor_1.PatternVisitor.isPattern(left)) {
+            if (node.operator === '=') {
+                this.visitPattern(left, (pattern, info) => {
+                    const maybeImplicitGlobal = !this.currentScope().isStrict
+                        ? {
+                            node,
+                            pattern,
+                        }
+                        : null;
+                    this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);
+                    this.currentScope().referenceValue(pattern, Reference_1.ReferenceFlag.Write, node.right, maybeImplicitGlobal, false);
+                }, { processRightHandNodes: true });
+            }
+            else if (left.type === types_1.AST_NODE_TYPES.Identifier) {
+                this.currentScope().referenceValue(left, Reference_1.ReferenceFlag.ReadWrite, node.right);
+            }
+        }
+        else {
+            this.visit(left);
+        }
+        this.visit(node.right);
+    }
+    BlockStatement(node) {
+        this.scopeManager.nestBlockScope(node);
+        this.visitChildren(node);
+        this.close(node);
+    }
+    BreakStatement() {
+        // don't reference the break statement's label
+    }
+    CallExpression(node) {
+        this.visitChildren(node, ['typeArguments']);
+        this.visitType(node.typeArguments);
+    }
+    CatchClause(node) {
+        this.scopeManager.nestCatchScope(node);
+        if (node.param) {
+            this.visitPattern(node.param, (pattern, info) => {
+                this.currentScope().defineIdentifier(pattern, new definition_1.CatchClauseDefinition(pattern, node));
+                this.referencingDefaultValue(pattern, info.assignments, null, true);
+            }, { processRightHandNodes: true });
+        }
+        this.visit(node.body);
+        this.close(node);
+    }
+    ClassDeclaration(node) {
+        this.visitClass(node);
+    }
+    ClassExpression(node) {
+        this.visitClass(node);
+    }
+    ContinueStatement() {
+        // don't reference the continue statement's label
+    }
+    ExportAllDeclaration() {
+        // this defines no local variables
+    }
+    ExportDefaultDeclaration(node) {
+        if (node.declaration.type === types_1.AST_NODE_TYPES.Identifier) {
+            ExportVisitor_1.ExportVisitor.visit(this, node);
+        }
+        else {
+            this.visit(node.declaration);
+        }
+    }
+    ExportNamedDeclaration(node) {
+        if (node.declaration) {
+            this.visit(node.declaration);
+        }
+        else {
+            ExportVisitor_1.ExportVisitor.visit(this, node);
+        }
+    }
+    ForInStatement(node) {
+        this.visitForIn(node);
+    }
+    ForOfStatement(node) {
+        this.visitForIn(node);
+    }
+    ForStatement(node) {
+        // Create ForStatement declaration.
+        // NOTE: In ES6, ForStatement dynamically generates per iteration environment. However, this is
+        // a static analyzer, we only generate one scope for ForStatement.
+        if (node.init?.type === types_1.AST_NODE_TYPES.VariableDeclaration &&
+            node.init.kind !== 'var') {
+            this.scopeManager.nestForScope(node);
+        }
+        this.visitChildren(node);
+        this.close(node);
+    }
+    FunctionDeclaration(node) {
+        this.visitFunction(node);
+    }
+    FunctionExpression(node) {
+        this.visitFunction(node);
+    }
+    Identifier(node) {
+        this.currentScope().referenceValue(node);
+        this.visitType(node.typeAnnotation);
+    }
+    ImportAttribute() {
+        // import assertions are module metadata and thus have no variables to reference
+    }
+    ImportDeclaration(node) {
+        (0, assert_1.assert)(this.scopeManager.isModule(), 'ImportDeclaration should appear when the mode is ES6 and in the module context.');
+        ImportVisitor_1.ImportVisitor.visit(this, node);
+    }
+    JSXAttribute(node) {
+        this.visit(node.value);
+    }
+    JSXClosingElement(node) {
+        this.visitJSXElement(node);
+    }
+    JSXFragment(node) {
+        this.referenceJsxPragma();
+        this.referenceJsxFragment();
+        this.visitChildren(node);
+    }
+    JSXIdentifier(node) {
+        this.currentScope().referenceValue(node);
+    }
+    JSXMemberExpression(node) {
+        if (node.object.type !== types_1.AST_NODE_TYPES.JSXIdentifier ||
+            node.object.name !== 'this') {
+            this.visit(node.object);
+        }
+        // we don't ever reference the property as it's always going to be a property on the thing
+    }
+    JSXOpeningElement(node) {
+        this.referenceJsxPragma();
+        this.visitJSXElement(node);
+        this.visitType(node.typeArguments);
+        for (const attr of node.attributes) {
+            this.visit(attr);
+        }
+    }
+    LabeledStatement(node) {
+        this.visit(node.body);
+    }
+    MemberExpression(node) {
+        this.visit(node.object);
+        if (node.computed) {
+            this.visit(node.property);
+        }
+    }
+    MetaProperty() {
+        // meta properties all builtin globals
+    }
+    NewExpression(node) {
+        this.visitChildren(node, ['typeArguments']);
+        this.visitType(node.typeArguments);
+    }
+    PrivateIdentifier() {
+        // private identifiers are members on classes and thus have no variables to reference
+    }
+    Program(node) {
+        const globalScope = this.scopeManager.nestGlobalScope(node);
+        this.populateGlobalsFromLib(globalScope);
+        if (this.scopeManager.isGlobalReturn()) {
+            // Force strictness of GlobalScope to false when using node.js scope.
+            this.currentScope().isStrict = false;
+            this.scopeManager.nestFunctionScope(node, false);
+        }
+        if (this.scopeManager.isModule()) {
+            this.scopeManager.nestModuleScope(node);
+        }
+        if (this.scopeManager.isImpliedStrict()) {
+            this.currentScope().isStrict = true;
+        }
+        this.visitChildren(node);
+        this.close(node);
+    }
+    Property(node) {
+        this.visitProperty(node);
+    }
+    SwitchStatement(node) {
+        this.visit(node.discriminant);
+        this.scopeManager.nestSwitchScope(node);
+        for (const switchCase of node.cases) {
+            this.visit(switchCase);
+        }
+        this.close(node);
+    }
+    TaggedTemplateExpression(node) {
+        this.visit(node.tag);
+        this.visit(node.quasi);
+        this.visitType(node.typeArguments);
+    }
+    TSAsExpression(node) {
+        this.visitTypeAssertion(node);
+    }
+    TSDeclareFunction(node) {
+        this.visitFunction(node);
+    }
+    TSEmptyBodyFunctionExpression(node) {
+        this.visitFunction(node);
+    }
+    TSEnumDeclaration(node) {
+        this.currentScope().defineIdentifier(node.id, new definition_1.TSEnumNameDefinition(node.id, node));
+        // enum members can be referenced within the enum body
+        this.scopeManager.nestTSEnumScope(node);
+        for (const member of node.body.members) {
+            // TS resolves literal named members to be actual names
+            // enum Foo {
+            //   'a' = 1,
+            //   b = a, // this references the 'a' member
+            // }
+            if (member.id.type === types_1.AST_NODE_TYPES.Literal &&
+                typeof member.id.value === 'string') {
+                const name = member.id;
+                this.currentScope().defineLiteralIdentifier(name, new definition_1.TSEnumMemberDefinition(name, member));
+            }
+            else if (member.id.type === types_1.AST_NODE_TYPES.Identifier) {
+                this.currentScope().defineIdentifier(member.id, new definition_1.TSEnumMemberDefinition(member.id, member));
+            }
+            this.visit(member.initializer);
+        }
+        this.close(node);
+    }
+    TSExportAssignment(node) {
+        if (node.expression.type === types_1.AST_NODE_TYPES.Identifier) {
+            // this is a special case - you can `export = T` where `T` is a type OR a
+            // value however `T[U]` is illegal when `T` is a type and `T.U` is illegal
+            // when `T.U` is a type
+            // i.e. if the expression is JUST an Identifier - it could be either ref
+            // kind; otherwise the standard rules apply
+            this.currentScope().referenceDualValueType(node.expression);
+        }
+        else {
+            this.visit(node.expression);
+        }
+    }
+    TSImportEqualsDeclaration(node) {
+        this.currentScope().defineIdentifier(node.id, new definition_1.ImportBindingDefinition(node.id, node, node));
+        if (node.moduleReference.type === types_1.AST_NODE_TYPES.TSQualifiedName) {
+            let moduleIdentifier = node.moduleReference.left;
+            while (moduleIdentifier.type === types_1.AST_NODE_TYPES.TSQualifiedName) {
+                moduleIdentifier = moduleIdentifier.left;
+            }
+            this.visit(moduleIdentifier);
+        }
+        else {
+            this.visit(node.moduleReference);
+        }
+    }
+    TSInstantiationExpression(node) {
+        this.visitChildren(node, ['typeArguments']);
+        this.visitType(node.typeArguments);
+    }
+    TSInterfaceDeclaration(node) {
+        this.visitType(node);
+    }
+    TSModuleDeclaration(node) {
+        if (node.id.type === types_1.AST_NODE_TYPES.Identifier && node.kind !== 'global') {
+            this.currentScope().defineIdentifier(node.id, new definition_1.TSModuleNameDefinition(node.id, node));
+        }
+        this.scopeManager.nestTSModuleScope(node);
+        this.visit(node.body);
+        this.close(node);
+    }
+    TSSatisfiesExpression(node) {
+        this.visitTypeAssertion(node);
+    }
+    TSTypeAliasDeclaration(node) {
+        this.visitType(node);
+    }
+    TSTypeAssertion(node) {
+        this.visitTypeAssertion(node);
+    }
+    UpdateExpression(node) {
+        const argument = this.visitExpressionTarget(node.argument);
+        if (PatternVisitor_1.PatternVisitor.isPattern(argument)) {
+            this.visitPattern(argument, pattern => {
+                this.currentScope().referenceValue(pattern, Reference_1.ReferenceFlag.ReadWrite, null);
+            });
+        }
+        else {
+            this.visitChildren(node);
+        }
+    }
+    VariableDeclaration(node) {
+        const variableTargetScope = node.kind === 'var'
+            ? this.currentScope().variableScope
+            : this.currentScope();
+        for (const decl of node.declarations) {
+            const init = decl.init;
+            this.visitPattern(decl.id, (pattern, info) => {
+                variableTargetScope.defineIdentifier(pattern, new definition_1.VariableDefinition(pattern, decl, node));
+                this.referencingDefaultValue(pattern, info.assignments, null, true);
+                if (init) {
+                    this.currentScope().referenceValue(pattern, Reference_1.ReferenceFlag.Write, init, null, true);
+                }
+            }, { processRightHandNodes: true });
+            this.visit(decl.init);
+            this.visitType(decl.id.typeAnnotation);
+        }
+    }
+    WithStatement(node) {
+        this.visit(node.object);
+        // Then nest scope for WithStatement.
+        this.scopeManager.nestWithScope(node);
+        this.visit(node.body);
+        this.close(node);
+    }
+    visitExpressionTarget(left) {
+        switch (left.type) {
+            case types_1.AST_NODE_TYPES.TSAsExpression:
+            case types_1.AST_NODE_TYPES.TSTypeAssertion:
+                // explicitly visit the type annotation
+                this.visitType(left.typeAnnotation);
+            // intentional fallthrough
+            case types_1.AST_NODE_TYPES.TSNonNullExpression:
+                // unwrap the expression
+                left = left.expression;
+        }
+        return left;
+    }
+}
+exports.Referencer = Referencer;
+//# sourceMappingURL=Referencer.js.map

node_modules/@typescript-eslint/scope-manager/dist/referencer/TypeVisitor.d.ts

@@ -0,0 +1,31 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { Referencer } from './Referencer';
+import { Visitor } from './Visitor';
+export declare class TypeVisitor extends Visitor {
+    #private;
+    constructor(referencer: Referencer);
+    static visit(referencer: Referencer, node: TSESTree.Node): void;
+    protected visitFunctionType(node: TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSFunctionType | TSESTree.TSMethodSignature): void;
+    protected visitPropertyKey(node: TSESTree.TSMethodSignature | TSESTree.TSPropertySignature): void;
+    protected Identifier(node: TSESTree.Identifier): void;
+    protected MemberExpression(node: TSESTree.MemberExpression): void;
+    protected TSCallSignatureDeclaration(node: TSESTree.TSCallSignatureDeclaration): void;
+    protected TSConditionalType(node: TSESTree.TSConditionalType): void;
+    protected TSConstructorType(node: TSESTree.TSConstructorType): void;
+    protected TSConstructSignatureDeclaration(node: TSESTree.TSConstructSignatureDeclaration): void;
+    protected TSFunctionType(node: TSESTree.TSFunctionType): void;
+    protected TSImportType(node: TSESTree.TSImportType): void;
+    protected TSIndexSignature(node: TSESTree.TSIndexSignature): void;
+    protected TSInferType(node: TSESTree.TSInferType): void;
+    protected TSInterfaceDeclaration(node: TSESTree.TSInterfaceDeclaration): void;
+    protected TSMappedType(node: TSESTree.TSMappedType): void;
+    protected TSMethodSignature(node: TSESTree.TSMethodSignature): void;
+    protected TSNamedTupleMember(node: TSESTree.TSNamedTupleMember): void;
+    protected TSPropertySignature(node: TSESTree.TSPropertySignature): void;
+    protected TSQualifiedName(node: TSESTree.TSQualifiedName): void;
+    protected TSTypeAliasDeclaration(node: TSESTree.TSTypeAliasDeclaration): void;
+    protected TSTypeParameter(node: TSESTree.TSTypeParameter): void;
+    protected TSTypePredicate(node: TSESTree.TSTypePredicate): void;
+    protected TSTypeAnnotation(node: TSESTree.TSTypeAnnotation): void;
+    protected TSTypeQuery(node: TSESTree.TSTypeQuery): void;
+}

node_modules/@typescript-eslint/scope-manager/dist/referencer/TypeVisitor.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeVisitor = void 0;
+const types_1 = require("@typescript-eslint/types");
+const definition_1 = require("../definition");
+const scope_1 = require("../scope");
+const Visitor_1 = require("./Visitor");
+class TypeVisitor extends Visitor_1.Visitor {
+    #referencer;
+    constructor(referencer) {
+        super(referencer);
+        this.#referencer = referencer;
+    }
+    static visit(referencer, node) {
+        const typeReferencer = new TypeVisitor(referencer);
+        typeReferencer.visit(node);
+    }
+    ///////////////////
+    // Visit helpers //
+    ///////////////////
+    visitFunctionType(node) {
+        // arguments and type parameters can only be referenced from within the function
+        this.#referencer.scopeManager.nestFunctionTypeScope(node);
+        this.visit(node.typeParameters);
+        for (const param of node.params) {
+            let didVisitAnnotation = false;
+            this.visitPattern(param, (pattern, info) => {
+                // a parameter name creates a value type variable which can be referenced later via typeof arg
+                this.#referencer
+                    .currentScope()
+                    .defineIdentifier(pattern, new definition_1.ParameterDefinition(pattern, node, info.rest));
+                if (pattern.typeAnnotation) {
+                    this.visit(pattern.typeAnnotation);
+                    didVisitAnnotation = true;
+                }
+            });
+            // there are a few special cases where the type annotation is owned by the parameter, not the pattern
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (!didVisitAnnotation && 'typeAnnotation' in param) {
+                this.visit(param.typeAnnotation);
+            }
+        }
+        this.visit(node.returnType);
+        this.#referencer.close(node);
+    }
+    visitPropertyKey(node) {
+        if (!node.computed) {
+            return;
+        }
+        // computed members are treated as value references, and TS expects they have a literal type
+        this.#referencer.visit(node.key);
+    }
+    /////////////////////
+    // Visit selectors //
+    /////////////////////
+    Identifier(node) {
+        this.#referencer.currentScope().referenceType(node);
+    }
+    MemberExpression(node) {
+        this.visit(node.object);
+        // don't visit the property
+    }
+    TSCallSignatureDeclaration(node) {
+        this.visitFunctionType(node);
+    }
+    TSConditionalType(node) {
+        // conditional types can define inferred type parameters
+        // which are only accessible from inside the conditional parameter
+        this.#referencer.scopeManager.nestConditionalTypeScope(node);
+        // type parameters inferred in the condition clause are not accessible within the false branch
+        this.visitChildren(node, ['falseType']);
+        this.#referencer.close(node);
+        this.visit(node.falseType);
+    }
+    TSConstructorType(node) {
+        this.visitFunctionType(node);
+    }
+    TSConstructSignatureDeclaration(node) {
+        this.visitFunctionType(node);
+    }
+    TSFunctionType(node) {
+        this.visitFunctionType(node);
+    }
+    TSImportType(node) {
+        // the TS parser allows any type to be the parameter, but it's a syntax error - so we can ignore it
+        this.visit(node.typeArguments);
+        // the qualifier is just part of a standard EntityName, so it should not be visited
+    }
+    TSIndexSignature(node) {
+        for (const param of node.parameters) {
+            if (param.type === types_1.AST_NODE_TYPES.Identifier) {
+                this.visit(param.typeAnnotation);
+            }
+        }
+        this.visit(node.typeAnnotation);
+    }
+    TSInferType(node) {
+        const typeParameter = node.typeParameter;
+        let scope = this.#referencer.currentScope();
+        /*
+        In cases where there is a sub-type scope created within a conditional type, then the generic should be defined in the
+        conditional type's scope, not the child type scope.
+        If we define it within the child type's scope then it won't be able to be referenced outside the child type
+        */
+        if (scope.type === scope_1.ScopeType.functionType ||
+            scope.type === scope_1.ScopeType.mappedType) {
+            // search up the scope tree to figure out if we're in a nested type scope
+            let currentScope = scope.upper;
+            while (currentScope) {
+                if (currentScope.type === scope_1.ScopeType.functionType ||
+                    currentScope.type === scope_1.ScopeType.mappedType) {
+                    // ensure valid type parents only
+                    currentScope = currentScope.upper;
+                    continue;
+                }
+                if (currentScope.type === scope_1.ScopeType.conditionalType) {
+                    scope = currentScope;
+                    break;
+                }
+                break;
+            }
+        }
+        scope.defineIdentifier(typeParameter.name, new definition_1.TypeDefinition(typeParameter.name, typeParameter));
+        this.visit(typeParameter.constraint);
+    }
+    TSInterfaceDeclaration(node) {
+        this.#referencer
+            .currentScope()
+            .defineIdentifier(node.id, new definition_1.TypeDefinition(node.id, node));
+        if (node.typeParameters) {
+            // type parameters cannot be referenced from outside their current scope
+            this.#referencer.scopeManager.nestTypeScope(node);
+            this.visit(node.typeParameters);
+        }
+        node.extends.forEach(this.visit, this);
+        this.visit(node.body);
+        if (node.typeParameters) {
+            this.#referencer.close(node);
+        }
+    }
+    TSMappedType(node) {
+        // mapped types key can only be referenced within their return value
+        this.#referencer.scopeManager.nestMappedTypeScope(node);
+        this.#referencer
+            .currentScope()
+            .defineIdentifier(node.key, new definition_1.TypeDefinition(node.key, node));
+        this.visit(node.constraint);
+        this.visit(node.nameType);
+        this.visit(node.typeAnnotation);
+        this.#referencer.close(node);
+    }
+    TSMethodSignature(node) {
+        this.visitPropertyKey(node);
+        this.visitFunctionType(node);
+    }
+    TSNamedTupleMember(node) {
+        this.visit(node.elementType);
+        // we don't visit the label as the label only exists for the purposes of documentation
+    }
+    TSPropertySignature(node) {
+        this.visitPropertyKey(node);
+        this.visit(node.typeAnnotation);
+    }
+    TSQualifiedName(node) {
+        this.visit(node.left);
+        // we don't visit the right as it a name on the thing, not a name to reference
+    }
+    TSTypeAliasDeclaration(node) {
+        this.#referencer
+            .currentScope()
+            .defineIdentifier(node.id, new definition_1.TypeDefinition(node.id, node));
+        if (node.typeParameters) {
+            // type parameters cannot be referenced from outside their current scope
+            this.#referencer.scopeManager.nestTypeScope(node);
+            this.visit(node.typeParameters);
+        }
+        this.visit(node.typeAnnotation);
+        if (node.typeParameters) {
+            this.#referencer.close(node);
+        }
+    }
+    TSTypeParameter(node) {
+        this.#referencer
+            .currentScope()
+            .defineIdentifier(node.name, new definition_1.TypeDefinition(node.name, node));
+        this.visit(node.constraint);
+        this.visit(node.default);
+    }
+    TSTypePredicate(node) {
+        if (node.parameterName.type !== types_1.AST_NODE_TYPES.TSThisType) {
+            this.#referencer.currentScope().referenceValue(node.parameterName);
+        }
+        this.visit(node.typeAnnotation);
+    }
+    // a type query `typeof foo` is a special case that references a _non-type_ variable,
+    TSTypeAnnotation(node) {
+        // check
+        this.visitChildren(node);
+    }
+    TSTypeQuery(node) {
+        let entityName;
+        if (node.exprName.type === types_1.AST_NODE_TYPES.TSQualifiedName) {
+            let iter = node.exprName;
+            while (iter.left.type === types_1.AST_NODE_TYPES.TSQualifiedName) {
+                iter = iter.left;
+            }
+            entityName = iter.left;
+        }
+        else {
+            entityName = node.exprName;
+            if (node.exprName.type === types_1.AST_NODE_TYPES.TSImportType) {
+                this.visit(node.exprName);
+            }
+        }
+        if (entityName.type === types_1.AST_NODE_TYPES.Identifier) {
+            this.#referencer.currentScope().referenceValue(entityName);
+        }
+        this.visit(node.typeArguments);
+    }
+}
+exports.TypeVisitor = TypeVisitor;
+//# sourceMappingURL=TypeVisitor.js.map

node_modules/@typescript-eslint/scope-manager/dist/referencer/Visitor.d.ts

@@ -0,0 +1,13 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { PatternVisitorCallback, PatternVisitorOptions } from './PatternVisitor';
+import type { VisitorOptions } from './VisitorBase';
+import { VisitorBase } from './VisitorBase';
+interface VisitPatternOptions extends PatternVisitorOptions {
+    processRightHandNodes?: boolean;
+}
+export declare class Visitor extends VisitorBase {
+    #private;
+    constructor(optionsOrVisitor: Visitor | VisitorOptions);
+    protected visitPattern(node: TSESTree.Node, callback: PatternVisitorCallback, options?: VisitPatternOptions): void;
+}
+export { VisitorBase, type VisitorOptions } from './VisitorBase';

node_modules/@typescript-eslint/scope-manager/dist/referencer/Visitor.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisitorBase = exports.Visitor = void 0;
+const PatternVisitor_1 = require("./PatternVisitor");
+const VisitorBase_1 = require("./VisitorBase");
+class Visitor extends VisitorBase_1.VisitorBase {
+    #options;
+    constructor(optionsOrVisitor) {
+        super(optionsOrVisitor instanceof Visitor
+            ? optionsOrVisitor.#options
+            : optionsOrVisitor);
+        this.#options =
+            optionsOrVisitor instanceof Visitor
+                ? optionsOrVisitor.#options
+                : optionsOrVisitor;
+    }
+    visitPattern(node, callback, options = { processRightHandNodes: false }) {
+        // Call the callback at left hand identifier nodes, and Collect right hand nodes.
+        const visitor = new PatternVisitor_1.PatternVisitor(this.#options, node, callback);
+        visitor.visit(node);
+        // Process the right hand nodes recursively.
+        if (options.processRightHandNodes) {
+            visitor.rightHandNodes.forEach(this.visit, this);
+        }
+    }
+}
+exports.Visitor = Visitor;
+var VisitorBase_2 = require("./VisitorBase");
+Object.defineProperty(exports, "VisitorBase", { enumerable: true, get: function () { return VisitorBase_2.VisitorBase; } });
+//# sourceMappingURL=Visitor.js.map

node_modules/@typescript-eslint/scope-manager/dist/referencer/VisitorBase.d.ts

@@ -0,0 +1,21 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { VisitorKeys } from '@typescript-eslint/visitor-keys';
+export interface VisitorOptions {
+    childVisitorKeys?: VisitorKeys | null;
+    visitChildrenEvenIfSelectorExists?: boolean;
+}
+export declare abstract class VisitorBase {
+    #private;
+    constructor(options: VisitorOptions);
+    /**
+     * Default method for visiting children.
+     * @param node the node whose children should be visited
+     * @param excludeArr a list of keys to not visit
+     */
+    visitChildren<T extends TSESTree.Node>(node: T | null | undefined, excludeArr?: (keyof T)[]): void;
+    /**
+     * Dispatching node.
+     */
+    visit(node: TSESTree.Node | null | undefined): void;
+}
+export type { VisitorKeys } from '@typescript-eslint/visitor-keys';

node_modules/@typescript-eslint/scope-manager/dist/referencer/VisitorBase.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisitorBase = void 0;
+const visitor_keys_1 = require("@typescript-eslint/visitor-keys");
+function isObject(obj) {
+    return typeof obj === 'object' && obj != null;
+}
+function isNode(node) {
+    return isObject(node) && typeof node.type === 'string';
+}
+class VisitorBase {
+    #childVisitorKeys;
+    #visitChildrenEvenIfSelectorExists;
+    constructor(options) {
+        this.#childVisitorKeys = options.childVisitorKeys ?? visitor_keys_1.visitorKeys;
+        this.#visitChildrenEvenIfSelectorExists =
+            options.visitChildrenEvenIfSelectorExists ?? false;
+    }
+    /**
+     * Default method for visiting children.
+     * @param node the node whose children should be visited
+     * @param excludeArr a list of keys to not visit
+     */
+    visitChildren(node, excludeArr = []) {
+        if (node?.type == null) {
+            return;
+        }
+        const exclude = new Set([...excludeArr, 'parent']);
+        const children = this.#childVisitorKeys[node.type] ?? Object.keys(node);
+        for (const key of children) {
+            if (exclude.has(key)) {
+                continue;
+            }
+            const child = node[key];
+            if (!child) {
+                continue;
+            }
+            if (Array.isArray(child)) {
+                for (const subChild of child) {
+                    if (isNode(subChild)) {
+                        this.visit(subChild);
+                    }
+                }
+            }
+            else if (isNode(child)) {
+                this.visit(child);
+            }
+        }
+    }
+    /**
+     * Dispatching node.
+     */
+    visit(node) {
+        if (node?.type == null) {
+            return;
+        }
+        const visitor = this[node.type];
+        if (visitor) {
+            visitor.call(this, node);
+            if (!this.#visitChildrenEvenIfSelectorExists) {
+                return;
+            }
+        }
+        this.visitChildren(node);
+    }
+}
+exports.VisitorBase = VisitorBase;
+//# sourceMappingURL=VisitorBase.js.map

node_modules/@typescript-eslint/scope-manager/dist/referencer/index.d.ts

@@ -0,0 +1 @@
+export { Referencer, type ReferencerOptions } from './Referencer';

node_modules/@typescript-eslint/scope-manager/dist/referencer/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Referencer = void 0;
+var Referencer_1 = require("./Referencer");
+Object.defineProperty(exports, "Referencer", { enumerable: true, get: function () { return Referencer_1.Referencer; } });
+//# sourceMappingURL=index.js.map

node_modules/@typescript-eslint/scope-manager/dist/scope/BlockScope.d.ts

@@ -0,0 +1,8 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { ScopeManager } from '../ScopeManager';
+import type { Scope } from './Scope';
+import { ScopeBase } from './ScopeBase';
+import { ScopeType } from './ScopeType';
+export declare class BlockScope extends ScopeBase<ScopeType.block, TSESTree.BlockStatement, Scope> {
+    constructor(scopeManager: ScopeManager, upperScope: BlockScope['upper'], block: BlockScope['block']);
+}

node_modules/@typescript-eslint/scope-manager/dist/scope/BlockScope.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockScope = void 0;
+const ScopeBase_1 = require("./ScopeBase");
+const ScopeType_1 = require("./ScopeType");
+class BlockScope extends ScopeBase_1.ScopeBase {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, ScopeType_1.ScopeType.block, upperScope, block, false);
+    }
+}
+exports.BlockScope = BlockScope;
+//# sourceMappingURL=BlockScope.js.map

node_modules/@typescript-eslint/scope-manager/dist/scope/CatchScope.d.ts

@@ -0,0 +1,8 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { ScopeManager } from '../ScopeManager';
+import type { Scope } from './Scope';
+import { ScopeBase } from './ScopeBase';
+import { ScopeType } from './ScopeType';
+export declare class CatchScope extends ScopeBase<ScopeType.catch, TSESTree.CatchClause, Scope> {
+    constructor(scopeManager: ScopeManager, upperScope: CatchScope['upper'], block: CatchScope['block']);
+}

node_modules/@typescript-eslint/scope-manager/dist/scope/CatchScope.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatchScope = void 0;
+const ScopeBase_1 = require("./ScopeBase");
+const ScopeType_1 = require("./ScopeType");
+class CatchScope extends ScopeBase_1.ScopeBase {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, ScopeType_1.ScopeType.catch, upperScope, block, false);
+    }
+}
+exports.CatchScope = CatchScope;
+//# sourceMappingURL=CatchScope.js.map

node_modules/@typescript-eslint/scope-manager/dist/scope/ClassFieldInitializerScope.d.ts

@@ -0,0 +1,8 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { ScopeManager } from '../ScopeManager';
+import type { Scope } from './Scope';
+import { ScopeBase } from './ScopeBase';
+import { ScopeType } from './ScopeType';
+export declare class ClassFieldInitializerScope extends ScopeBase<ScopeType.classFieldInitializer, TSESTree.Expression, Scope> {
+    constructor(scopeManager: ScopeManager, upperScope: ClassFieldInitializerScope['upper'], block: ClassFieldInitializerScope['block']);
+}

node_modules/@typescript-eslint/scope-manager/dist/scope/ClassFieldInitializerScope.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassFieldInitializerScope = void 0;
+const ScopeBase_1 = require("./ScopeBase");
+const ScopeType_1 = require("./ScopeType");
+class ClassFieldInitializerScope extends ScopeBase_1.ScopeBase {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, ScopeType_1.ScopeType.classFieldInitializer, upperScope, block, false);
+    }
+}
+exports.ClassFieldInitializerScope = ClassFieldInitializerScope;
+//# sourceMappingURL=ClassFieldInitializerScope.js.map

node_modules/@typescript-eslint/scope-manager/dist/scope/ClassScope.d.ts

@@ -0,0 +1,8 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { ScopeManager } from '../ScopeManager';
+import type { Scope } from './Scope';
+import { ScopeBase } from './ScopeBase';
+import { ScopeType } from './ScopeType';
+export declare class ClassScope extends ScopeBase<ScopeType.class, TSESTree.ClassDeclaration | TSESTree.ClassExpression, Scope> {
+    constructor(scopeManager: ScopeManager, upperScope: ClassScope['upper'], block: ClassScope['block']);
+}

node_modules/@typescript-eslint/scope-manager/dist/scope/ClassScope.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassScope = void 0;
+const ScopeBase_1 = require("./ScopeBase");
+const ScopeType_1 = require("./ScopeType");
+class ClassScope extends ScopeBase_1.ScopeBase {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, ScopeType_1.ScopeType.class, upperScope, block, false);
+    }
+}
+exports.ClassScope = ClassScope;
+//# sourceMappingURL=ClassScope.js.map

node_modules/@typescript-eslint/scope-manager/dist/scope/ClassStaticBlockScope.d.ts

@@ -0,0 +1,8 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { ScopeManager } from '../ScopeManager';
+import type { Scope } from './Scope';
+import { ScopeBase } from './ScopeBase';
+import { ScopeType } from './ScopeType';
+export declare class ClassStaticBlockScope extends ScopeBase<ScopeType.classStaticBlock, TSESTree.StaticBlock, Scope> {
+    constructor(scopeManager: ScopeManager, upperScope: ClassStaticBlockScope['upper'], block: ClassStaticBlockScope['block']);
+}

node_modules/@typescript-eslint/scope-manager/dist/scope/ClassStaticBlockScope.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassStaticBlockScope = void 0;
+const ScopeBase_1 = require("./ScopeBase");
+const ScopeType_1 = require("./ScopeType");
+class ClassStaticBlockScope extends ScopeBase_1.ScopeBase {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, ScopeType_1.ScopeType.classStaticBlock, upperScope, block, false);
+    }
+}
+exports.ClassStaticBlockScope = ClassStaticBlockScope;
+//# sourceMappingURL=ClassStaticBlockScope.js.map

node_modules/@typescript-eslint/scope-manager/dist/scope/ConditionalTypeScope.d.ts

@@ -0,0 +1,8 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { ScopeManager } from '../ScopeManager';
+import type { Scope } from './Scope';
+import { ScopeBase } from './ScopeBase';
+import { ScopeType } from './ScopeType';
+export declare class ConditionalTypeScope extends ScopeBase<ScopeType.conditionalType, TSESTree.TSConditionalType, Scope> {
+    constructor(scopeManager: ScopeManager, upperScope: ConditionalTypeScope['upper'], block: ConditionalTypeScope['block']);
+}

node_modules/@typescript-eslint/scope-manager/dist/scope/ConditionalTypeScope.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalTypeScope = void 0;
+const ScopeBase_1 = require("./ScopeBase");
+const ScopeType_1 = require("./ScopeType");
+class ConditionalTypeScope extends ScopeBase_1.ScopeBase {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, ScopeType_1.ScopeType.conditionalType, upperScope, block, false);
+    }
+}
+exports.ConditionalTypeScope = ConditionalTypeScope;
+//# sourceMappingURL=ConditionalTypeScope.js.map

node_modules/@typescript-eslint/scope-manager/dist/scope/ForScope.d.ts

@@ -0,0 +1,8 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { ScopeManager } from '../ScopeManager';
+import type { Scope } from './Scope';
+import { ScopeBase } from './ScopeBase';
+import { ScopeType } from './ScopeType';
+export declare class ForScope extends ScopeBase<ScopeType.for, TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement, Scope> {
+    constructor(scopeManager: ScopeManager, upperScope: ForScope['upper'], block: ForScope['block']);
+}