@storm-software/linting-tools 1.132.110 → 1.132.111

package/bin/lint.js

@@ -3,7 +3,7 @@ import {
   require_clean,
   require_semver,
   require_valid
-} from "./chunk-EFYK7LSH.js";
+} from "./chunk-4GSPBIJ2.js";
 import {
   basename,
   be,
@@ -15,12 +15,12 @@ import {
   join,
   readPackageJSON,
   resolve
-} from "./chunk-XOSXF5GD.js";
-import "./chunk-367FWK47.js";
-import "./chunk-VLMX3NQP.js";
-import "./chunk-ZXEWM77C.js";
-import "./chunk-KM6YS7KN.js";
-import "./chunk-VTSQTSYF.js";
+} from "./chunk-UKQVLWVF.js";
+import "./chunk-6UYR65MZ.js";
+import "./chunk-4B2OZSS2.js";
+import "./chunk-KVYUIUHN.js";
+import "./chunk-NVXYMLZN.js";
+import "./chunk-JJF2V6EH.js";
 import {
   __commonJS,
   __dirname,
@@ -31,7 +31,7 @@ import {
   __require,
   __toESM,
   init_esm_shims
-} from "./chunk-6LJGNBH7.js";
+} from "./chunk-S5PY6M7X.js";
 
 // ../../node_modules/.pnpm/dotenv@16.6.1/node_modules/dotenv/package.json
 var package_exports = {};
@@ -36973,7 +36973,7 @@ var require_src4 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/flatted@3.3.4/node_modules/flatted/esm/index.js
+// ../../node_modules/.pnpm/flatted@3.4.1/node_modules/flatted/esm/index.js
 var esm_exports = {};
 __export(esm_exports, {
   fromJSON: () => fromJSON,
@@ -36981,9 +36981,9 @@ __export(esm_exports, {
   stringify: () => stringify3,
   toJSON: () => toJSON
 });
-var $parse, $stringify, keys3, Primitive, primitive, ignore, object2, noop, primitives, Primitives, revive, set2, parse6, stringify3, toJSON, fromJSON;
+var $parse, $stringify, keys3, Primitive, primitive, ignore, object2, noop, primitives, Primitives, resolver, set2, parse6, stringify3, toJSON, fromJSON;
 var init_esm = __esm({
-  "../../node_modules/.pnpm/flatted@3.3.4/node_modules/flatted/esm/index.js"() {
+  "../../node_modules/.pnpm/flatted@3.4.1/node_modules/flatted/esm/index.js"() {
     init_esm_shims();
     ({ parse: $parse, stringify: $stringify } = JSON);
     ({ keys: keys3 } = Object);
@@ -36994,8 +36994,7 @@ var init_esm = __esm({
     noop = (_2, value) => value;
     primitives = (value) => value instanceof Primitive ? Primitive(value) : value;
     Primitives = (_2, value) => typeof value === primitive ? new Primitive(value) : value;
-    revive = (input, parsed, output, $) => {
-      const lazy = [];
+    resolver = (input, lazy, parsed, $) => (output) => {
       for (let ke = keys3(output), { length } = ke, y3 = 0; y3 < length; y3++) {
         const k2 = ke[y3];
         const value = output[k2];
@@ -37004,16 +37003,12 @@ var init_esm = __esm({
           if (typeof tmp === object2 && !parsed.has(tmp)) {
             parsed.add(tmp);
             output[k2] = ignore;
-            lazy.push({ k: k2, a: [input, parsed, tmp, $] });
+            lazy.push({ o: output, k: k2, r: tmp });
           } else
             output[k2] = $.call(output, k2, tmp);
         } else if (output[k2] !== ignore)
           output[k2] = $.call(output, k2, value);
       }
-      for (let { length } = lazy, i2 = 0; i2 < length; i2++) {
-        const { k: k2, a: a4 } = lazy[i2];
-        output[k2] = $.call(output, k2, revive.apply(null, a4));
-      }
       return output;
     };
     set2 = (known, input, value) => {
@@ -37023,10 +37018,19 @@ var init_esm = __esm({
     };
     parse6 = (text, reviver) => {
       const input = $parse(text, Primitives).map(primitives);
-      const value = input[0];
       const $ = reviver || noop;
-      const tmp = typeof value === object2 && value ? revive(input, /* @__PURE__ */ new Set(), value, $) : value;
-      return $.call({ "": tmp }, "", tmp);
+      let value = input[0];
+      if (typeof value === object2 && value) {
+        const lazy = [];
+        const revive = resolver(input, lazy, /* @__PURE__ */ new Set(), $);
+        value = revive(value);
+        let i2 = 0;
+        while (i2 < lazy.length) {
+          const { o, k: k2, r } = lazy[i2++];
+          o[k2] = $.call(o, k2, revive(r));
+        }
+      }
+      return $.call({ "": value }, "", value);
     };
     stringify3 = (value, replacer, space) => {
       const $ = replacer && typeof replacer === object2 ? (k2, v2) => k2 === "" || -1 < replacer.indexOf(k2) ? v2 : void 0 : replacer || noop;
@@ -70349,8 +70353,8 @@ ${lanes.join("\n")}
       function getCanonicalAbsolutePath(host, path32) {
         return host.getCanonicalFileName(getNormalizedAbsolutePath(path32, host.getCurrentDirectory()));
       }
-      function getExternalModuleNameFromDeclaration(host, resolver, declaration) {
-        const file = resolver.getExternalModuleFileFromDeclaration(declaration);
+      function getExternalModuleNameFromDeclaration(host, resolver2, declaration) {
+        const file = resolver2.getExternalModuleFileFromDeclaration(declaration);
         if (!file || file.isDeclarationFile) {
           return void 0;
         }
@@ -83010,10 +83014,10 @@ ${lanes.join("\n")}
         }
         return void 0;
       }
-      function getExternalModuleNameLiteral(factory2, importNode, sourceFile, host, resolver, compilerOptions) {
+      function getExternalModuleNameLiteral(factory2, importNode, sourceFile, host, resolver2, compilerOptions) {
         const moduleName = getExternalModuleName(importNode);
         if (moduleName && isStringLiteral(moduleName)) {
-          return tryGetModuleNameFromDeclaration(importNode, host, factory2, resolver, compilerOptions) || tryRenameExternalModule(factory2, moduleName, sourceFile) || factory2.cloneNode(moduleName);
+          return tryGetModuleNameFromDeclaration(importNode, host, factory2, resolver2, compilerOptions) || tryRenameExternalModule(factory2, moduleName, sourceFile) || factory2.cloneNode(moduleName);
         }
         return void 0;
       }
@@ -83033,8 +83037,8 @@ ${lanes.join("\n")}
         }
         return void 0;
       }
-      function tryGetModuleNameFromDeclaration(declaration, host, factory2, resolver, compilerOptions) {
-        return tryGetModuleNameFromFile(factory2, resolver.getExternalModuleFileFromDeclaration(declaration), host, compilerOptions);
+      function tryGetModuleNameFromDeclaration(declaration, host, factory2, resolver2, compilerOptions) {
+        return tryGetModuleNameFromFile(factory2, resolver2.getExternalModuleFileFromDeclaration(declaration), host, compilerOptions);
       }
       function getInitializerOfBindingOrAssignmentElement(bindingElement) {
         if (isDeclarationBindingElement(bindingElement)) {
@@ -138822,30 +138826,30 @@ ${lanes.join("\n")}
           }
         }
         function createGeneratorType(yieldType, returnType, nextType, isAsyncGenerator) {
-          const resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
-          const globalGeneratorType = resolver.getGlobalGeneratorType(
+          const resolver2 = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
+          const globalGeneratorType = resolver2.getGlobalGeneratorType(
             /*reportErrors*/
             false
           );
-          yieldType = resolver.resolveIterationType(
+          yieldType = resolver2.resolveIterationType(
             yieldType,
             /*errorNode*/
             void 0
           ) || unknownType;
-          returnType = resolver.resolveIterationType(
+          returnType = resolver2.resolveIterationType(
             returnType,
             /*errorNode*/
             void 0
           ) || unknownType;
           if (globalGeneratorType === emptyGenericType) {
-            const globalIterableIteratorType = resolver.getGlobalIterableIteratorType(
+            const globalIterableIteratorType = resolver2.getGlobalIterableIteratorType(
               /*reportErrors*/
               false
             );
             if (globalIterableIteratorType !== emptyGenericType) {
               return createTypeFromGenericGlobalType(globalIterableIteratorType, [yieldType, returnType, nextType]);
             }
-            resolver.getGlobalIterableIteratorType(
+            resolver2.getGlobalIterableIteratorType(
               /*reportErrors*/
               true
             );
@@ -144587,43 +144591,43 @@ ${lanes.join("\n")}
           }
           return noIterationTypes;
         }
-        function getIterationTypesOfIterableCached(type2, resolver) {
-          return getCachedIterationTypes(type2, resolver.iterableCacheKey);
+        function getIterationTypesOfIterableCached(type2, resolver2) {
+          return getCachedIterationTypes(type2, resolver2.iterableCacheKey);
         }
-        function getIterationTypesOfIterableFast(type2, resolver) {
-          if (isReferenceToType2(type2, resolver.getGlobalIterableType(
+        function getIterationTypesOfIterableFast(type2, resolver2) {
+          if (isReferenceToType2(type2, resolver2.getGlobalIterableType(
             /*reportErrors*/
             false
-          )) || isReferenceToType2(type2, resolver.getGlobalIteratorObjectType(
+          )) || isReferenceToType2(type2, resolver2.getGlobalIteratorObjectType(
             /*reportErrors*/
             false
-          )) || isReferenceToType2(type2, resolver.getGlobalIterableIteratorType(
+          )) || isReferenceToType2(type2, resolver2.getGlobalIterableIteratorType(
             /*reportErrors*/
             false
-          )) || isReferenceToType2(type2, resolver.getGlobalGeneratorType(
+          )) || isReferenceToType2(type2, resolver2.getGlobalGeneratorType(
             /*reportErrors*/
             false
           ))) {
             const [yieldType, returnType, nextType] = getTypeArguments(type2);
-            return setCachedIterationTypes(type2, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(
+            return setCachedIterationTypes(type2, resolver2.iterableCacheKey, createIterationTypes(resolver2.resolveIterationType(
               yieldType,
               /*errorNode*/
               void 0
-            ) || yieldType, resolver.resolveIterationType(
+            ) || yieldType, resolver2.resolveIterationType(
               returnType,
               /*errorNode*/
               void 0
             ) || returnType, nextType));
           }
-          if (isReferenceToSomeType(type2, resolver.getGlobalBuiltinIteratorTypes())) {
+          if (isReferenceToSomeType(type2, resolver2.getGlobalBuiltinIteratorTypes())) {
             const [yieldType] = getTypeArguments(type2);
             const returnType = getBuiltinIteratorReturnType();
             const nextType = unknownType;
-            return setCachedIterationTypes(type2, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(
+            return setCachedIterationTypes(type2, resolver2.iterableCacheKey, createIterationTypes(resolver2.resolveIterationType(
               yieldType,
               /*errorNode*/
               void 0
-            ) || yieldType, resolver.resolveIterationType(
+            ) || yieldType, resolver2.resolveIterationType(
               returnType,
               /*errorNode*/
               void 0
@@ -144638,11 +144642,11 @@ ${lanes.join("\n")}
           const uniqueType = ctorType && getTypeOfPropertyOfType(getTypeOfSymbol(ctorType), escapeLeadingUnderscores(symbolName2));
           return uniqueType && isTypeUsableAsPropertyName(uniqueType) ? getPropertyNameFromType(uniqueType) : `__@${symbolName2}`;
         }
-        function getIterationTypesOfIterableSlow(type2, resolver, errorNode, errorOutputContainer, noCache) {
-          const method = getPropertyOfType(type2, getPropertyNameForKnownSymbolName(resolver.iteratorSymbolName));
+        function getIterationTypesOfIterableSlow(type2, resolver2, errorNode, errorOutputContainer, noCache) {
+          const method = getPropertyOfType(type2, getPropertyNameForKnownSymbolName(resolver2.iteratorSymbolName));
           const methodType = method && !(method.flags & 16777216) ? getTypeOfSymbol(method) : void 0;
           if (isTypeAny(methodType)) {
-            return noCache ? anyIterationTypes : setCachedIterationTypes(type2, resolver.iterableCacheKey, anyIterationTypes);
+            return noCache ? anyIterationTypes : setCachedIterationTypes(type2, resolver2.iterableCacheKey, anyIterationTypes);
           }
           const allSignatures = methodType ? getSignaturesOfType(
             methodType,
@@ -144654,7 +144658,7 @@ ${lanes.join("\n")}
             if (errorNode && some(allSignatures)) {
               checkTypeAssignableTo(
                 type2,
-                resolver.getGlobalIterableType(
+                resolver2.getGlobalIterableType(
                   /*reportErrors*/
                   true
                 ),
@@ -144666,11 +144670,11 @@ ${lanes.join("\n")}
                 errorOutputContainer
               );
             }
-            return noCache ? noIterationTypes : setCachedIterationTypes(type2, resolver.iterableCacheKey, noIterationTypes);
+            return noCache ? noIterationTypes : setCachedIterationTypes(type2, resolver2.iterableCacheKey, noIterationTypes);
           }
           const iteratorType = getIntersectionType(map4(validSignatures, getReturnTypeOfSignature));
-          const iterationTypes = getIterationTypesOfIteratorWorker(iteratorType, resolver, errorNode, errorOutputContainer, noCache) ?? noIterationTypes;
-          return noCache ? iterationTypes : setCachedIterationTypes(type2, resolver.iterableCacheKey, iterationTypes);
+          const iterationTypes = getIterationTypesOfIteratorWorker(iteratorType, resolver2, errorNode, errorOutputContainer, noCache) ?? noIterationTypes;
+          return noCache ? iterationTypes : setCachedIterationTypes(type2, resolver2.iterableCacheKey, iterationTypes);
         }
         function reportTypeNotIterableError(errorNode, type2, allowAsyncIterables) {
           const message = allowAsyncIterables ? Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator : Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator;
@@ -144686,53 +144690,53 @@ ${lanes.join("\n")}
           );
           return errorAndMaybeSuggestAwait(errorNode, suggestAwait, message, typeToString(type2));
         }
-        function getIterationTypesOfIterator(type2, resolver, errorNode, errorOutputContainer) {
+        function getIterationTypesOfIterator(type2, resolver2, errorNode, errorOutputContainer) {
           return getIterationTypesOfIteratorWorker(
             type2,
-            resolver,
+            resolver2,
             errorNode,
             errorOutputContainer,
             /*noCache*/
             false
           );
         }
-        function getIterationTypesOfIteratorWorker(type2, resolver, errorNode, errorOutputContainer, noCache) {
+        function getIterationTypesOfIteratorWorker(type2, resolver2, errorNode, errorOutputContainer, noCache) {
           if (isTypeAny(type2)) {
             return anyIterationTypes;
           }
-          let iterationTypes = getIterationTypesOfIteratorCached(type2, resolver) || getIterationTypesOfIteratorFast(type2, resolver);
+          let iterationTypes = getIterationTypesOfIteratorCached(type2, resolver2) || getIterationTypesOfIteratorFast(type2, resolver2);
           if (iterationTypes === noIterationTypes && errorNode) {
             iterationTypes = void 0;
             noCache = true;
           }
-          iterationTypes ?? (iterationTypes = getIterationTypesOfIteratorSlow(type2, resolver, errorNode, errorOutputContainer, noCache));
+          iterationTypes ?? (iterationTypes = getIterationTypesOfIteratorSlow(type2, resolver2, errorNode, errorOutputContainer, noCache));
           return iterationTypes === noIterationTypes ? void 0 : iterationTypes;
         }
-        function getIterationTypesOfIteratorCached(type2, resolver) {
-          return getCachedIterationTypes(type2, resolver.iteratorCacheKey);
+        function getIterationTypesOfIteratorCached(type2, resolver2) {
+          return getCachedIterationTypes(type2, resolver2.iteratorCacheKey);
         }
-        function getIterationTypesOfIteratorFast(type2, resolver) {
-          if (isReferenceToType2(type2, resolver.getGlobalIterableIteratorType(
+        function getIterationTypesOfIteratorFast(type2, resolver2) {
+          if (isReferenceToType2(type2, resolver2.getGlobalIterableIteratorType(
             /*reportErrors*/
             false
-          )) || isReferenceToType2(type2, resolver.getGlobalIteratorType(
+          )) || isReferenceToType2(type2, resolver2.getGlobalIteratorType(
             /*reportErrors*/
             false
-          )) || isReferenceToType2(type2, resolver.getGlobalIteratorObjectType(
+          )) || isReferenceToType2(type2, resolver2.getGlobalIteratorObjectType(
             /*reportErrors*/
             false
-          )) || isReferenceToType2(type2, resolver.getGlobalGeneratorType(
+          )) || isReferenceToType2(type2, resolver2.getGlobalGeneratorType(
             /*reportErrors*/
             false
           ))) {
             const [yieldType, returnType, nextType] = getTypeArguments(type2);
-            return setCachedIterationTypes(type2, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
+            return setCachedIterationTypes(type2, resolver2.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
           }
-          if (isReferenceToSomeType(type2, resolver.getGlobalBuiltinIteratorTypes())) {
+          if (isReferenceToSomeType(type2, resolver2.getGlobalBuiltinIteratorTypes())) {
             const [yieldType] = getTypeArguments(type2);
             const returnType = getBuiltinIteratorReturnType();
             const nextType = unknownType;
-            return setCachedIterationTypes(type2, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
+            return setCachedIterationTypes(type2, resolver2.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
           }
         }
         function isIteratorResult(type2, kind) {
@@ -144801,7 +144805,7 @@ ${lanes.join("\n")}
             void 0
           ));
         }
-        function getIterationTypesOfMethod(type2, resolver, methodName, errorNode, errorOutputContainer) {
+        function getIterationTypesOfMethod(type2, resolver2, methodName, errorNode, errorOutputContainer) {
           var _a4, _b, _c, _d;
           const method = getPropertyOfType(type2, methodName);
           if (!method && methodName !== "next") {
@@ -144822,7 +144826,7 @@ ${lanes.join("\n")}
           ) : emptyArray;
           if (methodSignatures.length === 0) {
             if (errorNode) {
-              const diagnostic = methodName === "next" ? resolver.mustHaveANextMethodDiagnostic : resolver.mustBeAMethodDiagnostic;
+              const diagnostic = methodName === "next" ? resolver2.mustHaveANextMethodDiagnostic : resolver2.mustBeAMethodDiagnostic;
               if (errorOutputContainer) {
                 errorOutputContainer.errors ?? (errorOutputContainer.errors = []);
                 errorOutputContainer.errors.push(createDiagnosticForNode(errorNode, diagnostic, methodName));
@@ -144833,11 +144837,11 @@ ${lanes.join("\n")}
             return methodName === "next" ? noIterationTypes : void 0;
           }
           if ((methodType == null ? void 0 : methodType.symbol) && methodSignatures.length === 1) {
-            const globalGeneratorType = resolver.getGlobalGeneratorType(
+            const globalGeneratorType = resolver2.getGlobalGeneratorType(
               /*reportErrors*/
               false
             );
-            const globalIteratorType = resolver.getGlobalIteratorType(
+            const globalIteratorType = resolver2.getGlobalIteratorType(
               /*reportErrors*/
               false
             );
@@ -144868,21 +144872,21 @@ ${lanes.join("\n")}
             if (methodName === "next") {
               nextType = methodParameterType;
             } else if (methodName === "return") {
-              const resolvedMethodParameterType = resolver.resolveIterationType(methodParameterType, errorNode) || anyType;
+              const resolvedMethodParameterType = resolver2.resolveIterationType(methodParameterType, errorNode) || anyType;
               returnTypes = append(returnTypes, resolvedMethodParameterType);
             }
           }
           let yieldType;
           const methodReturnType = methodReturnTypes ? getIntersectionType(methodReturnTypes) : neverType;
-          const resolvedMethodReturnType = resolver.resolveIterationType(methodReturnType, errorNode) || anyType;
+          const resolvedMethodReturnType = resolver2.resolveIterationType(methodReturnType, errorNode) || anyType;
           const iterationTypes = getIterationTypesOfIteratorResult(resolvedMethodReturnType);
           if (iterationTypes === noIterationTypes) {
             if (errorNode) {
               if (errorOutputContainer) {
                 errorOutputContainer.errors ?? (errorOutputContainer.errors = []);
-                errorOutputContainer.errors.push(createDiagnosticForNode(errorNode, resolver.mustHaveAValueDiagnostic, methodName));
+                errorOutputContainer.errors.push(createDiagnosticForNode(errorNode, resolver2.mustHaveAValueDiagnostic, methodName));
               } else {
-                error22(errorNode, resolver.mustHaveAValueDiagnostic, methodName);
+                error22(errorNode, resolver2.mustHaveAValueDiagnostic, methodName);
               }
             }
             yieldType = anyType;
@@ -144893,13 +144897,13 @@ ${lanes.join("\n")}
           }
           return createIterationTypes(yieldType, getUnionType(returnTypes), nextType);
         }
-        function getIterationTypesOfIteratorSlow(type2, resolver, errorNode, errorOutputContainer, noCache) {
+        function getIterationTypesOfIteratorSlow(type2, resolver2, errorNode, errorOutputContainer, noCache) {
           const iterationTypes = combineIterationTypes([
-            getIterationTypesOfMethod(type2, resolver, "next", errorNode, errorOutputContainer),
-            getIterationTypesOfMethod(type2, resolver, "return", errorNode, errorOutputContainer),
-            getIterationTypesOfMethod(type2, resolver, "throw", errorNode, errorOutputContainer)
+            getIterationTypesOfMethod(type2, resolver2, "next", errorNode, errorOutputContainer),
+            getIterationTypesOfMethod(type2, resolver2, "return", errorNode, errorOutputContainer),
+            getIterationTypesOfMethod(type2, resolver2, "throw", errorNode, errorOutputContainer)
           ]);
-          return noCache ? iterationTypes : setCachedIterationTypes(type2, resolver.iteratorCacheKey, iterationTypes);
+          return noCache ? iterationTypes : setCachedIterationTypes(type2, resolver2.iteratorCacheKey, iterationTypes);
         }
         function getIterationTypeOfGeneratorFunctionReturnType(kind, returnType, isAsyncGenerator) {
           if (isTypeAny(returnType)) {
@@ -144913,7 +144917,7 @@ ${lanes.join("\n")}
             return anyIterationTypes;
           }
           const use = isAsyncGenerator ? 2 : 1;
-          const resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
+          const resolver2 = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
           return getIterationTypesOfIterable(
             type2,
             use,
@@ -144921,7 +144925,7 @@ ${lanes.join("\n")}
             void 0
           ) || getIterationTypesOfIterator(
             type2,
-            resolver,
+            resolver2,
             /*errorNode*/
             void 0,
             /*errorOutputContainer*/
@@ -153744,7 +153748,7 @@ ${lanes.join("\n")}
         return !getImportNeedsImportStarHelper(node) && (isDefaultImport(node) || !!node.importClause && isNamedImports(node.importClause.namedBindings) && containsDefaultReference(node.importClause.namedBindings));
       }
       function collectExternalModuleInfo(context, sourceFile) {
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const compilerOptions = context.getCompilerOptions();
         const externalImports = [];
         const exportSpecifiers = new IdentifierNameMultiMap();
@@ -153873,7 +153877,7 @@ ${lanes.join("\n")}
                 if (!node.moduleSpecifier) {
                   exportSpecifiers.add(name3, specifier);
                 }
-                const decl = resolver.getReferencedImportDeclaration(name3) || resolver.getReferencedValueDeclaration(name3);
+                const decl = resolver2.getReferencedImportDeclaration(name3) || resolver2.getReferencedValueDeclaration(name3);
                 if (decl) {
                   if (decl.kind === 263) {
                     addExportedFunctionDeclaration(decl, specifier.name, moduleExportNameIsDefault(specifier.name));
@@ -155033,7 +155037,7 @@ ${lanes.join("\n")}
           endLexicalEnvironment,
           hoistVariableDeclaration
         } = context;
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const compilerOptions = context.getCompilerOptions();
         const languageVersion = getEmitScriptTarget(compilerOptions);
         const moduleKind = getEmitModuleKind(compilerOptions);
@@ -156346,7 +156350,7 @@ ${lanes.join("\n")}
             /*generateNameForComputedPropertyName*/
             false
           );
-          const evaluated = resolver.getEnumMemberValue(member);
+          const evaluated = resolver2.getEnumMemberValue(member);
           const valueExpression = transformEnumMemberDeclarationValue(member, evaluated == null ? void 0 : evaluated.value);
           const innerAssignment = factory2.createAssignment(
             factory2.createElementAccessExpression(
@@ -156627,7 +156631,7 @@ ${lanes.join("\n")}
           return !node.isTypeOnly && shouldEmitAliasDeclaration(node) ? node : void 0;
         }
         function visitExportAssignment(node) {
-          return compilerOptions.verbatimModuleSyntax || resolver.isValueAliasDeclaration(node) ? visitEachChild(node, visitor, context) : void 0;
+          return compilerOptions.verbatimModuleSyntax || resolver2.isValueAliasDeclaration(node) ? visitEachChild(node, visitor, context) : void 0;
         }
         function visitExportDeclaration(node) {
           if (node.isTypeOnly) {
@@ -156670,10 +156674,10 @@ ${lanes.join("\n")}
           return isNamespaceExport(node) ? visitNamespaceExports(node) : visitNamedExports(node, allowEmpty);
         }
         function visitExportSpecifier(node) {
-          return !node.isTypeOnly && (compilerOptions.verbatimModuleSyntax || resolver.isValueAliasDeclaration(node)) ? node : void 0;
+          return !node.isTypeOnly && (compilerOptions.verbatimModuleSyntax || resolver2.isValueAliasDeclaration(node)) ? node : void 0;
         }
         function shouldEmitImportEqualsDeclaration(node) {
-          return shouldEmitAliasDeclaration(node) || !isExternalModule(currentSourceFile) && resolver.isTopLevelValueImportEqualsWithEntityName(node);
+          return shouldEmitAliasDeclaration(node) || !isExternalModule(currentSourceFile) && resolver2.isTopLevelValueImportEqualsWithEntityName(node);
         }
         function visitImportEqualsDeclaration(node) {
           if (node.isTypeOnly) {
@@ -156902,7 +156906,7 @@ ${lanes.join("\n")}
         }
         function trySubstituteNamespaceExportedName(node) {
           if (enabledSubstitutions & applicableSubstitutions && !isGeneratedIdentifier(node) && !isLocalName(node)) {
-            const container = resolver.getReferencedExportContainer(
+            const container = resolver2.getReferencedExportContainer(
               node,
               /*prefixLocals*/
               false
@@ -156946,10 +156950,10 @@ ${lanes.join("\n")}
           if (getIsolatedModules(compilerOptions)) {
             return void 0;
           }
-          return isPropertyAccessExpression(node) || isElementAccessExpression(node) ? resolver.getConstantValue(node) : void 0;
+          return isPropertyAccessExpression(node) || isElementAccessExpression(node) ? resolver2.getConstantValue(node) : void 0;
         }
         function shouldEmitAliasDeclaration(node) {
-          return compilerOptions.verbatimModuleSyntax || isInJSFile(node) || resolver.isReferencedAliasDeclaration(node);
+          return compilerOptions.verbatimModuleSyntax || isInJSFile(node) || resolver2.isReferencedAliasDeclaration(node);
         }
       }
       function transformClassFields(context) {
@@ -156962,7 +156966,7 @@ ${lanes.join("\n")}
           resumeLexicalEnvironment,
           addBlockScopedVariable
         } = context;
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const compilerOptions = context.getCompilerOptions();
         const languageVersion = getEmitScriptTarget(compilerOptions);
         const useDefineForClassFields = getUseDefineForClassFields(compilerOptions);
@@ -158001,7 +158005,7 @@ ${lanes.join("\n")}
                 containsInstancePrivateElements || (containsInstancePrivateElements = isPrivateIdentifierClassElementDeclaration(member));
               } else if (isPrivateIdentifierClassElementDeclaration(member)) {
                 containsInstancePrivateElements = true;
-                if (resolver.hasNodeCheckFlag(
+                if (resolver2.hasNodeCheckFlag(
                   member,
                   262144
                   /* ContainsConstructorReference */
@@ -158112,7 +158116,7 @@ ${lanes.join("\n")}
           if ((_b = node.emitNode) == null ? void 0 : _b.classThis) {
             getClassLexicalEnvironment().classThis = node.emitNode.classThis;
           }
-          const isClassWithConstructorReference = resolver.hasNodeCheckFlag(
+          const isClassWithConstructorReference = resolver2.hasNodeCheckFlag(
             node,
             262144
             /* ContainsConstructorReference */
@@ -158186,12 +158190,12 @@ ${lanes.join("\n")}
           var _a4, _b, _c;
           const isDecoratedClassDeclaration = !!(facts & 1);
           const staticPropertiesOrClassStaticBlocks = getStaticPropertiesAndClassStaticBlock(node);
-          const isClassWithConstructorReference = resolver.hasNodeCheckFlag(
+          const isClassWithConstructorReference = resolver2.hasNodeCheckFlag(
             node,
             262144
             /* ContainsConstructorReference */
           );
-          const requiresBlockScopedVar = resolver.hasNodeCheckFlag(
+          const requiresBlockScopedVar = resolver2.hasNodeCheckFlag(
             node,
             32768
             /* BlockScopedBindingInLoop */
@@ -158836,7 +158840,7 @@ ${lanes.join("\n")}
             const alreadyTransformed = !!cacheAssignment || isAssignmentExpression(innerExpression) && isGeneratedIdentifier(innerExpression.left);
             if (!alreadyTransformed && !inlinable && shouldHoist) {
               const generatedName = factory2.getGeneratedNameForNode(name3);
-              if (resolver.hasNodeCheckFlag(
+              if (resolver2.hasNodeCheckFlag(
                 name3,
                 32768
                 /* BlockScopedBindingInLoop */
@@ -158994,7 +158998,7 @@ ${lanes.join("\n")}
             prefix,
             suffix
           );
-          if (resolver.hasNodeCheckFlag(
+          if (resolver2.hasNodeCheckFlag(
             node,
             32768
             /* BlockScopedBindingInLoop */
@@ -159239,12 +159243,12 @@ ${lanes.join("\n")}
         }
         function trySubstituteClassAlias(node) {
           if (enabledSubstitutions & 1) {
-            if (resolver.hasNodeCheckFlag(
+            if (resolver2.hasNodeCheckFlag(
               node,
               536870912
               /* ConstructorReference */
             )) {
-              const declaration = resolver.getReferencedValueDeclaration(node);
+              const declaration = resolver2.getReferencedValueDeclaration(node);
               if (declaration) {
                 const classAlias = classAliases[declaration.id];
                 if (classAlias) {
@@ -159300,7 +159304,7 @@ ${lanes.join("\n")}
           factory: factory2,
           hoistVariableDeclaration
         } = context;
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const compilerOptions = context.getCompilerOptions();
         const languageVersion = getEmitScriptTarget(compilerOptions);
         const strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks");
@@ -159562,7 +159566,7 @@ ${lanes.join("\n")}
           );
         }
         function serializeTypeReferenceNode(node) {
-          const kind = resolver.getTypeReferenceSerializationKind(node.typeName, currentNameScope ?? currentLexicalScope);
+          const kind = resolver2.getTypeReferenceSerializationKind(node.typeName, currentNameScope ?? currentLexicalScope);
           switch (kind) {
             case 0:
               if (findAncestor(node, (n) => n.parent && isConditionalTypeNode(n.parent) && (n.parent.trueType === n || n.parent.falseType === n))) {
@@ -159672,7 +159676,7 @@ ${lanes.join("\n")}
           getEmitHelperFactory: emitHelpers,
           hoistVariableDeclaration
         } = context;
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const compilerOptions = context.getCompilerOptions();
         const languageVersion = getEmitScriptTarget(compilerOptions);
         const previousOnSubstituteNode = context.onSubstituteNode;
@@ -160174,7 +160178,7 @@ ${lanes.join("\n")}
           }
         }
         function getClassAliasIfNeeded(node) {
-          if (resolver.hasNodeCheckFlag(
+          if (resolver2.hasNodeCheckFlag(
             node,
             262144
             /* ContainsConstructorReference */
@@ -160211,12 +160215,12 @@ ${lanes.join("\n")}
         }
         function trySubstituteClassAlias(node) {
           if (classAliases) {
-            if (resolver.hasNodeCheckFlag(
+            if (resolver2.hasNodeCheckFlag(
               node,
               536870912
               /* ConstructorReference */
             )) {
-              const declaration = resolver.getReferencedValueDeclaration(node);
+              const declaration = resolver2.getReferencedValueDeclaration(node);
               if (declaration) {
                 const classAlias = classAliases[declaration.id];
                 if (classAlias) {
@@ -162225,7 +162229,7 @@ ${lanes.join("\n")}
           endLexicalEnvironment,
           hoistVariableDeclaration
         } = context;
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const compilerOptions = context.getCompilerOptions();
         const languageVersion = getEmitScriptTarget(compilerOptions);
         let enabledSubstitutions = 0;
@@ -162304,7 +162308,7 @@ ${lanes.join("\n")}
             case 261:
               break;
             case 80:
-              if (lexicalArgumentsBinding && resolver.isArgumentsLocalBinding(node)) {
+              if (lexicalArgumentsBinding && resolver2.isArgumentsLocalBinding(node)) {
                 return lexicalArgumentsBinding;
               }
               break;
@@ -162656,11 +162660,11 @@ ${lanes.join("\n")}
           hasSuperElementAccess = false;
           let updated = visitFunctionBody(node.body, visitor, context);
           const originalMethod = getOriginalNode(node, isFunctionLikeDeclaration);
-          const emitSuperHelpers = languageVersion >= 2 && (resolver.hasNodeCheckFlag(
+          const emitSuperHelpers = languageVersion >= 2 && (resolver2.hasNodeCheckFlag(
             node,
             256
             /* MethodWithSuperPropertyAssignmentInAsync */
-          ) || resolver.hasNodeCheckFlag(
+          ) || resolver2.hasNodeCheckFlag(
             node,
             128
             /* MethodWithSuperPropertyAccessInAsync */
@@ -162668,20 +162672,20 @@ ${lanes.join("\n")}
           if (emitSuperHelpers) {
             enableSubstitutionForAsyncMethodsWithSuper();
             if (capturedSuperProperties.size) {
-              const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
+              const variableStatement = createSuperAccessVariableStatement(factory2, resolver2, node, capturedSuperProperties);
               substitutedSuperAccessors[getNodeId(variableStatement)] = true;
               const statements = updated.statements.slice();
               insertStatementsAfterStandardPrologue(statements, [variableStatement]);
               updated = factory2.updateBlock(updated, statements);
             }
             if (hasSuperElementAccess) {
-              if (resolver.hasNodeCheckFlag(
+              if (resolver2.hasNodeCheckFlag(
                 node,
                 256
                 /* MethodWithSuperPropertyAssignmentInAsync */
               )) {
                 addEmitHelper(updated, advancedAsyncSuperHelper);
-              } else if (resolver.hasNodeCheckFlag(
+              } else if (resolver2.hasNodeCheckFlag(
                 node,
                 128
                 /* MethodWithSuperPropertyAccessInAsync */
@@ -162767,7 +162771,7 @@ ${lanes.join("\n")}
           const promiseConstructor = languageVersion < 2 ? getPromiseConstructor(nodeType) : void 0;
           const isArrowFunction2 = node.kind === 220;
           const savedLexicalArgumentsBinding = lexicalArgumentsBinding;
-          const hasLexicalArguments = resolver.hasNodeCheckFlag(
+          const hasLexicalArguments = resolver2.hasNodeCheckFlag(
             node,
             512
             /* CaptureArguments */
@@ -162826,11 +162830,11 @@ ${lanes.join("\n")}
                 )
               )
             );
-            const emitSuperHelpers = languageVersion >= 2 && (resolver.hasNodeCheckFlag(
+            const emitSuperHelpers = languageVersion >= 2 && (resolver2.hasNodeCheckFlag(
               node,
               256
               /* MethodWithSuperPropertyAssignmentInAsync */
-            ) || resolver.hasNodeCheckFlag(
+            ) || resolver2.hasNodeCheckFlag(
               node,
               128
               /* MethodWithSuperPropertyAccessInAsync */
@@ -162838,7 +162842,7 @@ ${lanes.join("\n")}
             if (emitSuperHelpers) {
               enableSubstitutionForAsyncMethodsWithSuper();
               if (capturedSuperProperties.size) {
-                const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
+                const variableStatement = createSuperAccessVariableStatement(factory2, resolver2, node, capturedSuperProperties);
                 substitutedSuperAccessors[getNodeId(variableStatement)] = true;
                 insertStatementsAfterStandardPrologue(statements, [variableStatement]);
               }
@@ -162853,13 +162857,13 @@ ${lanes.join("\n")}
             );
             setTextRange(block, node.body);
             if (emitSuperHelpers && hasSuperElementAccess) {
-              if (resolver.hasNodeCheckFlag(
+              if (resolver2.hasNodeCheckFlag(
                 node,
                 256
                 /* MethodWithSuperPropertyAssignmentInAsync */
               )) {
                 addEmitHelper(block, advancedAsyncSuperHelper);
-              } else if (resolver.hasNodeCheckFlag(
+              } else if (resolver2.hasNodeCheckFlag(
                 node,
                 128
                 /* MethodWithSuperPropertyAccessInAsync */
@@ -162899,7 +162903,7 @@ ${lanes.join("\n")}
         function getPromiseConstructor(type2) {
           const typeName = type2 && getEntityNameFromTypeNode(type2);
           if (typeName && isEntityName(typeName)) {
-            const serializationKind = resolver.getTypeReferenceSerializationKind(typeName);
+            const serializationKind = resolver2.getTypeReferenceSerializationKind(typeName);
             if (serializationKind === 1 || serializationKind === 0) {
               return typeName;
             }
@@ -162949,11 +162953,11 @@ ${lanes.join("\n")}
         }
         function onEmitNode(hint, node, emitCallback) {
           if (enabledSubstitutions & 1 && isSuperContainer(node)) {
-            const superContainerFlags = (resolver.hasNodeCheckFlag(
+            const superContainerFlags = (resolver2.hasNodeCheckFlag(
               node,
               128
               /* MethodWithSuperPropertyAccessInAsync */
-            ) ? 128 : 0) | (resolver.hasNodeCheckFlag(
+            ) ? 128 : 0) | (resolver2.hasNodeCheckFlag(
               node,
               256
               /* MethodWithSuperPropertyAssignmentInAsync */
@@ -163072,8 +163076,8 @@ ${lanes.join("\n")}
           }
         }
       }
-      function createSuperAccessVariableStatement(factory2, resolver, node, names) {
-        const hasBinding = resolver.hasNodeCheckFlag(
+      function createSuperAccessVariableStatement(factory2, resolver2, node, names) {
+        const hasBinding = resolver2.hasNodeCheckFlag(
           node,
           256
           /* MethodWithSuperPropertyAssignmentInAsync */
@@ -163210,7 +163214,7 @@ ${lanes.join("\n")}
           endLexicalEnvironment,
           hoistVariableDeclaration
         } = context;
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const compilerOptions = context.getCompilerOptions();
         const languageVersion = getEmitScriptTarget(compilerOptions);
         const previousOnEmitNode = context.onEmitNode;
@@ -164219,31 +164223,31 @@ ${lanes.join("\n")}
               !!(hierarchyFacts & 1)
             )
           );
-          const emitSuperHelpers = languageVersion >= 2 && (resolver.hasNodeCheckFlag(
+          const emitSuperHelpers = languageVersion >= 2 && (resolver2.hasNodeCheckFlag(
             node,
             256
             /* MethodWithSuperPropertyAssignmentInAsync */
-          ) || resolver.hasNodeCheckFlag(
+          ) || resolver2.hasNodeCheckFlag(
             node,
             128
             /* MethodWithSuperPropertyAccessInAsync */
           ));
           if (emitSuperHelpers) {
             enableSubstitutionForAsyncMethodsWithSuper();
-            const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
+            const variableStatement = createSuperAccessVariableStatement(factory2, resolver2, node, capturedSuperProperties);
             substitutedSuperAccessors[getNodeId(variableStatement)] = true;
             insertStatementsAfterStandardPrologue(outerStatements, [variableStatement]);
           }
           outerStatements.push(returnStatement);
           const block = factory2.updateBlock(node.body, outerStatements);
           if (emitSuperHelpers && hasSuperElementAccess) {
-            if (resolver.hasNodeCheckFlag(
+            if (resolver2.hasNodeCheckFlag(
               node,
               256
               /* MethodWithSuperPropertyAssignmentInAsync */
             )) {
               addEmitHelper(block, advancedAsyncSuperHelper);
-            } else if (resolver.hasNodeCheckFlag(
+            } else if (resolver2.hasNodeCheckFlag(
               node,
               128
               /* MethodWithSuperPropertyAccessInAsync */
@@ -164439,11 +164443,11 @@ ${lanes.join("\n")}
         }
         function onEmitNode(hint, node, emitCallback) {
           if (enabledSubstitutions & 1 && isSuperContainer(node)) {
-            const superContainerFlags = (resolver.hasNodeCheckFlag(
+            const superContainerFlags = (resolver2.hasNodeCheckFlag(
               node,
               128
               /* MethodWithSuperPropertyAccessInAsync */
-            ) ? 128 : 0) | (resolver.hasNodeCheckFlag(
+            ) ? 128 : 0) | (resolver2.hasNodeCheckFlag(
               node,
               256
               /* MethodWithSuperPropertyAssignmentInAsync */
@@ -166540,7 +166544,7 @@ ${lanes.join("\n")}
           hoistVariableDeclaration
         } = context;
         const compilerOptions = context.getCompilerOptions();
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const previousOnSubstituteNode = context.onSubstituteNode;
         const previousOnEmitNode = context.onEmitNode;
         context.onEmitNode = onEmitNode;
@@ -166892,7 +166896,7 @@ ${lanes.join("\n")}
         }
         function visitIdentifier(node) {
           if (convertedLoopState) {
-            if (resolver.isArgumentsLocalBinding(node)) {
+            if (resolver2.isArgumentsLocalBinding(node)) {
               return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = factory2.createUniqueName("arguments"));
             }
           }
@@ -168496,18 +168500,18 @@ ${lanes.join("\n")}
           return createRange(pos, end);
         }
         function shouldEmitExplicitInitializerForLetDeclaration(node) {
-          const isCapturedInFunction = resolver.hasNodeCheckFlag(
+          const isCapturedInFunction = resolver2.hasNodeCheckFlag(
             node,
             16384
             /* CapturedBlockScopedBinding */
           );
-          const isDeclaredInLoop = resolver.hasNodeCheckFlag(
+          const isDeclaredInLoop = resolver2.hasNodeCheckFlag(
             node,
             32768
             /* BlockScopedBindingInLoop */
           );
           const emittedAsTopLevel = (hierarchyFacts & 64) !== 0 || isCapturedInFunction && isDeclaredInLoop && (hierarchyFacts & 512) !== 0;
-          const emitExplicitInitializer = !emittedAsTopLevel && (hierarchyFacts & 4096) === 0 && (!resolver.isDeclarationWithCollidingName(node) || isDeclaredInLoop && !isCapturedInFunction && (hierarchyFacts & (2048 | 4096)) === 0);
+          const emitExplicitInitializer = !emittedAsTopLevel && (hierarchyFacts & 4096) === 0 && (!resolver2.isDeclarationWithCollidingName(node) || isDeclaredInLoop && !isCapturedInFunction && (hierarchyFacts & (2048 | 4096)) === 0);
           return emitExplicitInitializer;
         }
         function visitVariableDeclarationInLetDeclarationList(node) {
@@ -168982,7 +168986,7 @@ ${lanes.join("\n")}
           return factory2.inlineExpressions(expressions);
         }
         function shouldConvertPartOfIterationStatement(node) {
-          return resolver.hasNodeCheckFlag(
+          return resolver2.hasNodeCheckFlag(
             node,
             8192
             /* ContainsCapturedBlockScopeBinding */
@@ -169001,7 +169005,7 @@ ${lanes.join("\n")}
           return shouldConvertBodyOfIterationStatement(node) || shouldConvertInitializerOfForStatement(node);
         }
         function shouldConvertBodyOfIterationStatement(node) {
-          return resolver.hasNodeCheckFlag(
+          return resolver2.hasNodeCheckFlag(
             node,
             4096
             /* LoopWithCapturedBlockScopedBinding */
@@ -169576,7 +169580,7 @@ ${lanes.join("\n")}
               void 0,
               name3
             ));
-            const needsOutParam = resolver.hasNodeCheckFlag(
+            const needsOutParam = resolver2.hasNodeCheckFlag(
               decl,
               65536
               /* NeedsLoopOutParameter */
@@ -169588,10 +169592,10 @@ ${lanes.join("\n")}
                 flags |= 1;
               }
               if (isForStatement(container)) {
-                if (container.initializer && resolver.isBindingCapturedByNode(container.initializer, decl)) {
+                if (container.initializer && resolver2.isBindingCapturedByNode(container.initializer, decl)) {
                   flags |= 2;
                 }
-                if (container.condition && resolver.isBindingCapturedByNode(container.condition, decl) || container.incrementor && resolver.isBindingCapturedByNode(container.incrementor, decl)) {
+                if (container.condition && resolver2.isBindingCapturedByNode(container.condition, decl) || container.incrementor && resolver2.isBindingCapturedByNode(container.incrementor, decl)) {
                   flags |= 1;
                 }
               }
@@ -170205,7 +170209,7 @@ ${lanes.join("\n")}
             case 264:
             case 267:
             case 261:
-              return node.parent.name === node && resolver.isDeclarationWithCollidingName(node.parent);
+              return node.parent.name === node && resolver2.isDeclarationWithCollidingName(node.parent);
           }
           return false;
         }
@@ -170220,7 +170224,7 @@ ${lanes.join("\n")}
         }
         function substituteExpressionIdentifier(node) {
           if (enabledSubstitutions & 2 && !isInternalName(node)) {
-            const declaration = resolver.getReferencedDeclarationWithCollidingName(node);
+            const declaration = resolver2.getReferencedDeclarationWithCollidingName(node);
             if (declaration && !(isClassLike(declaration) && isPartOfClassBody(declaration, node))) {
               return setTextRange(factory2.getGeneratedNameForNode(getNameOfDeclaration(declaration)), node);
             }
@@ -170307,7 +170311,7 @@ ${lanes.join("\n")}
         } = context;
         const compilerOptions = context.getCompilerOptions();
         const languageVersion = getEmitScriptTarget(compilerOptions);
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const previousOnSubstituteNode = context.onSubstituteNode;
         context.onSubstituteNode = onSubstituteNode;
         let renamedCatchVariables;
@@ -171454,7 +171458,7 @@ ${lanes.join("\n")}
           if (!isGeneratedIdentifier(node) && renamedCatchVariables && renamedCatchVariables.has(idText(node))) {
             const original = getOriginalNode(node);
             if (isIdentifier(original) && original.parent) {
-              const declaration = resolver.getReferencedValueDeclaration(original);
+              const declaration = resolver2.getReferencedValueDeclaration(original);
               if (declaration) {
                 const name3 = renamedCatchVariableDeclarations[getOriginalNodeId(declaration)];
                 if (name3) {
@@ -172365,7 +172369,7 @@ ${lanes.join("\n")}
           hoistVariableDeclaration
         } = context;
         const compilerOptions = context.getCompilerOptions();
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const host = context.getEmitHost();
         const languageVersion = getEmitScriptTarget(compilerOptions);
         const moduleKind = getEmitModuleKind(compilerOptions);
@@ -172736,7 +172740,7 @@ ${lanes.join("\n")}
             }
           }
           for (const importNode of currentModuleInfo.externalImports) {
-            const externalModuleName = getExternalModuleNameLiteral(factory2, importNode, currentSourceFile, host, resolver, compilerOptions);
+            const externalModuleName = getExternalModuleNameLiteral(factory2, importNode, currentSourceFile, host, resolver2, compilerOptions);
             const importAliasName = getLocalNameForExternalImport(factory2, importNode, currentSourceFile);
             if (externalModuleName) {
               if (includeNonAmdDependencies && importAliasName) {
@@ -172761,7 +172765,7 @@ ${lanes.join("\n")}
           return { aliasedModuleNames, unaliasedModuleNames, importAliasNames };
         }
         function getAMDImportExpressionForImport(node) {
-          if (isImportEqualsDeclaration(node) || isExportDeclaration(node) || !getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions)) {
+          if (isImportEqualsDeclaration(node) || isExportDeclaration(node) || !getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver2, compilerOptions)) {
             return void 0;
           }
           const name3 = getLocalNameForExternalImport(factory2, node, currentSourceFile);
@@ -173243,7 +173247,7 @@ ${lanes.join("\n")}
           if (moduleKind === 0 && languageVersion >= 7) {
             return visitEachChild(node, visitor, context);
           }
-          const externalModuleName = getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions);
+          const externalModuleName = getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver2, compilerOptions);
           const firstArgument = visitNode(firstOrUndefined(node.arguments), visitor, isExpression);
           const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument && rewriteOrShim ? isStringLiteral(firstArgument) ? rewriteModuleSpecifier(firstArgument, compilerOptions) : emitHelpers().createRewriteRelativeImportExtensionsHelper(firstArgument) : firstArgument;
           const containsLexicalThis = !!(node.transformFlags & 16384);
@@ -173583,7 +173587,7 @@ ${lanes.join("\n")}
           return singleOrMany(statements);
         }
         function createRequireCall2(importNode) {
-          const moduleName = getExternalModuleNameLiteral(factory2, importNode, currentSourceFile, host, resolver, compilerOptions);
+          const moduleName = getExternalModuleNameLiteral(factory2, importNode, currentSourceFile, host, resolver2, compilerOptions);
           const args = [];
           if (moduleName) {
             args.push(rewriteModuleSpecifier(moduleName, compilerOptions));
@@ -174295,7 +174299,7 @@ ${lanes.join("\n")}
             }
             return node;
           } else if (!(isGeneratedIdentifier(node) && !(node.emitNode.autoGenerate.flags & 64)) && !isLocalName(node)) {
-            const exportContainer = resolver.getReferencedExportContainer(node, isExportName(node));
+            const exportContainer = resolver2.getReferencedExportContainer(node, isExportName(node));
             if (exportContainer && exportContainer.kind === 308) {
               return setTextRange(
                 factory2.createPropertyAccessExpression(
@@ -174306,7 +174310,7 @@ ${lanes.join("\n")}
                 node
               );
             }
-            const importDeclaration = resolver.getReferencedImportDeclaration(node);
+            const importDeclaration = resolver2.getReferencedImportDeclaration(node);
             if (importDeclaration) {
               if (isImportClause(importDeclaration)) {
                 return setTextRange(
@@ -174351,12 +174355,12 @@ ${lanes.join("\n")}
         }
         function getExports(name3) {
           if (!isGeneratedIdentifier(name3)) {
-            const importDeclaration = resolver.getReferencedImportDeclaration(name3);
+            const importDeclaration = resolver2.getReferencedImportDeclaration(name3);
             if (importDeclaration) {
               return currentModuleInfo == null ? void 0 : currentModuleInfo.exportedBindings[getOriginalNodeId(importDeclaration)];
             }
             const bindingsSet = /* @__PURE__ */ new Set();
-            const declarations = resolver.getReferencedValueDeclarations(name3);
+            const declarations = resolver2.getReferencedValueDeclarations(name3);
             if (declarations) {
               for (const declaration of declarations) {
                 const bindings = currentModuleInfo == null ? void 0 : currentModuleInfo.exportedBindings[getOriginalNodeId(declaration)];
@@ -174396,7 +174400,7 @@ ${lanes.join("\n")}
           hoistVariableDeclaration
         } = context;
         const compilerOptions = context.getCompilerOptions();
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const host = context.getEmitHost();
         const previousOnSubstituteNode = context.onSubstituteNode;
         const previousOnEmitNode = context.onEmitNode;
@@ -174517,7 +174521,7 @@ ${lanes.join("\n")}
           const groupIndices = /* @__PURE__ */ new Map();
           const dependencyGroups = [];
           for (const externalImport of externalImports) {
-            const externalModuleName = getExternalModuleNameLiteral(factory2, externalImport, currentSourceFile, host, resolver, compilerOptions);
+            const externalModuleName = getExternalModuleNameLiteral(factory2, externalImport, currentSourceFile, host, resolver2, compilerOptions);
             if (externalModuleName) {
               const text = externalModuleName.text;
               const groupIndex = groupIndices.get(text);
@@ -175483,7 +175487,7 @@ ${lanes.join("\n")}
           return factory2.updatePartiallyEmittedExpression(node, visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, isExpression));
         }
         function visitImportCallExpression(node) {
-          const externalModuleName = getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions);
+          const externalModuleName = getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver2, compilerOptions);
           const firstArgument = visitNode(firstOrUndefined(node.arguments), visitor, isExpression);
           const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument;
           return factory2.createCallExpression(
@@ -175526,7 +175530,7 @@ ${lanes.join("\n")}
           } else if (isPropertyAssignment(node)) {
             return hasExportedReferenceInDestructuringTarget(node.initializer);
           } else if (isIdentifier(node)) {
-            const container = resolver.getReferencedExportContainer(node);
+            const container = resolver2.getReferencedExportContainer(node);
             return container !== void 0 && container.kind === 308;
           } else {
             return false;
@@ -175614,7 +175618,7 @@ ${lanes.join("\n")}
           var _a4, _b;
           const name3 = node.name;
           if (!isGeneratedIdentifier(name3) && !isLocalName(name3)) {
-            const importDeclaration = resolver.getReferencedImportDeclaration(name3);
+            const importDeclaration = resolver2.getReferencedImportDeclaration(name3);
             if (importDeclaration) {
               if (isImportClause(importDeclaration)) {
                 return setTextRange(
@@ -175665,7 +175669,7 @@ ${lanes.join("\n")}
             return node;
           }
           if (!isGeneratedIdentifier(node) && !isLocalName(node)) {
-            const importDeclaration = resolver.getReferencedImportDeclaration(node);
+            const importDeclaration = resolver2.getReferencedImportDeclaration(node);
             if (importDeclaration) {
               if (isImportClause(importDeclaration)) {
                 return setTextRange(
@@ -175712,7 +175716,7 @@ ${lanes.join("\n")}
           let exportedNames;
           const valueDeclaration = getReferencedDeclaration(name3);
           if (valueDeclaration) {
-            const exportContainer = resolver.getReferencedExportContainer(
+            const exportContainer = resolver2.getReferencedExportContainer(
               name3,
               /*prefixLocals*/
               false
@@ -175735,11 +175739,11 @@ ${lanes.join("\n")}
         }
         function getReferencedDeclaration(name3) {
           if (!isGeneratedIdentifier(name3)) {
-            const importDeclaration = resolver.getReferencedImportDeclaration(name3);
+            const importDeclaration = resolver2.getReferencedImportDeclaration(name3);
             if (importDeclaration) return importDeclaration;
-            const valueDeclaration = resolver.getReferencedValueDeclaration(name3);
+            const valueDeclaration = resolver2.getReferencedValueDeclaration(name3);
             if (valueDeclaration && (moduleInfo == null ? void 0 : moduleInfo.exportedBindings[getOriginalNodeId(valueDeclaration)])) return valueDeclaration;
-            const declarations = resolver.getReferencedValueDeclarations(name3);
+            const declarations = resolver2.getReferencedValueDeclarations(name3);
             if (declarations) {
               for (const declaration of declarations) {
                 if (declaration !== valueDeclaration && (moduleInfo == null ? void 0 : moduleInfo.exportedBindings[getOriginalNodeId(declaration)])) return declaration;
@@ -175763,7 +175767,7 @@ ${lanes.join("\n")}
           getEmitHelperFactory: emitHelpers
         } = context;
         const host = context.getEmitHost();
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const compilerOptions = context.getCompilerOptions();
         const languageVersion = getEmitScriptTarget(compilerOptions);
         const previousOnEmitNode = context.onEmitNode;
@@ -175890,7 +175894,7 @@ ${lanes.join("\n")}
           );
         }
         function createRequireCall2(importNode) {
-          const moduleName = getExternalModuleNameLiteral(factory2, importNode, Debug.checkDefined(currentSourceFile), host, resolver, compilerOptions);
+          const moduleName = getExternalModuleNameLiteral(factory2, importNode, Debug.checkDefined(currentSourceFile), host, resolver2, compilerOptions);
           const args = [];
           if (moduleName) {
             args.push(rewriteModuleSpecifier(moduleName, compilerOptions));
@@ -176476,7 +176480,7 @@ ${lanes.join("\n")}
           };
         }
       }
-      function createGetIsolatedDeclarationErrors(resolver) {
+      function createGetIsolatedDeclarationErrors(resolver2) {
         const relatedSuggestionByDeclarationKind = {
           [
             220
@@ -176706,7 +176710,7 @@ ${lanes.join("\n")}
           if (isSetAccessor(node.parent)) {
             return createAccessorTypeError(node.parent);
           }
-          const addUndefined = resolver.requiresAddingImplicitUndefined(node, node.parent);
+          const addUndefined = resolver2.requiresAddingImplicitUndefined(node, node.parent);
           if (!addUndefined && node.initializer) {
             return createExpressionError(node.initializer);
           }
@@ -176756,11 +176760,11 @@ ${lanes.join("\n")}
           return diag2;
         }
       }
-      function getDeclarationDiagnostics(host, resolver, file) {
+      function getDeclarationDiagnostics(host, resolver2, file) {
         const compilerOptions = host.getCompilerOptions();
         const files = filter6(getSourceFilesToEmit(host, file), isSourceFileNotJson);
         return contains(files, file) ? transformNodes(
-          resolver,
+          resolver2,
           host,
           factory,
           compilerOptions,
@@ -176818,13 +176822,13 @@ ${lanes.join("\n")}
         let rawReferencedFiles;
         let rawTypeReferenceDirectives;
         let rawLibReferenceDirectives;
-        const resolver = context.getEmitResolver();
+        const resolver2 = context.getEmitResolver();
         const options = context.getCompilerOptions();
-        const getIsolatedDeclarationError = createGetIsolatedDeclarationErrors(resolver);
+        const getIsolatedDeclarationError = createGetIsolatedDeclarationErrors(resolver2);
         const { stripInternal, isolatedDeclarations } = options;
         return transformRoot;
         function reportExpandoFunctionErrors(node) {
-          resolver.getPropertiesOfContainerFunction(node).forEach((p) => {
+          resolver2.getPropertiesOfContainerFunction(node).forEach((p) => {
             if (isExpandoPropertyDeclaration(p.valueDeclaration)) {
               const errorTarget = isBinaryExpression(p.valueDeclaration) ? p.valueDeclaration.left : p.valueDeclaration;
               context.addDiagnostic(createDiagnosticForNode(
@@ -176837,7 +176841,7 @@ ${lanes.join("\n")}
         function reportInferenceFallback(node) {
           if (!isolatedDeclarations || isSourceFileJS(currentSourceFile)) return;
           if (getSourceFileOfNode(node) !== currentSourceFile) return;
-          if (isVariableDeclaration(node) && resolver.isExpandoFunctionDeclaration(node)) {
+          if (isVariableDeclaration(node) && resolver2.isExpandoFunctionDeclaration(node)) {
             reportExpandoFunctionErrors(node);
           } else {
             context.addDiagnostic(getIsolatedDeclarationError(node));
@@ -176869,7 +176873,7 @@ ${lanes.join("\n")}
         }
         function trackSymbol(symbol, enclosingDeclaration2, meaning) {
           if (symbol.flags & 262144) return false;
-          const issuedDiagnostic = handleSymbolAccessibilityError(resolver.isSymbolAccessible(
+          const issuedDiagnostic = handleSymbolAccessibilityError(resolver2.isSymbolAccessible(
             symbol,
             enclosingDeclaration2,
             meaning,
@@ -176940,7 +176944,7 @@ ${lanes.join("\n")}
             diagnosticMessage: s.errorModuleName ? Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit : Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit,
             errorNode: s.errorNode || sourceFile
           };
-          const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
+          const result = resolver2.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
           getSymbolAccessibilityDiagnostic = oldDiag;
           return result;
         }
@@ -177161,7 +177165,7 @@ ${lanes.join("\n")}
             maskModifiers(factory2, p, modifierMask),
             p.dotDotDotToken,
             filterBindingPatternInitializers(p.name),
-            resolver.isOptionalParameter(p) ? p.questionToken || factory2.createToken(
+            resolver2.isOptionalParameter(p) ? p.questionToken || factory2.createToken(
               58
               /* QuestionToken */
             ) : void 0,
@@ -177179,7 +177183,7 @@ ${lanes.join("\n")}
           return newParam;
         }
         function shouldPrintWithInitializer(node) {
-          return canHaveLiteralInitializer(node) && !!node.initializer && resolver.isLiteralConstDeclaration(getParseTreeNode(node));
+          return canHaveLiteralInitializer(node) && !!node.initializer && resolver2.isLiteralConstDeclaration(getParseTreeNode(node));
         }
         function ensureNoInitializer(node) {
           if (shouldPrintWithInitializer(node)) {
@@ -177187,7 +177191,7 @@ ${lanes.join("\n")}
             if (!isPrimitiveLiteralValue(unwrappedInitializer)) {
               reportInferenceFallback(node);
             }
-            return resolver.createLiteralConstValue(getParseTreeNode(node, canHaveLiteralInitializer), symbolTracker);
+            return resolver2.createLiteralConstValue(getParseTreeNode(node, canHaveLiteralInitializer), symbolTracker);
           }
           return void 0;
         }
@@ -177202,7 +177206,7 @@ ${lanes.join("\n")}
           if (shouldPrintWithInitializer(node)) {
             return;
           }
-          if (!isExportAssignment(node) && !isBindingElement(node) && node.type && (!isParameter(node) || !resolver.requiresAddingImplicitUndefined(node, enclosingDeclaration))) {
+          if (!isExportAssignment(node) && !isBindingElement(node) && node.type && (!isParameter(node) || !resolver2.requiresAddingImplicitUndefined(node, enclosingDeclaration))) {
             return visitNode(node.type, visitDeclarationSubtree, isTypeNode);
           }
           const oldErrorNameNode = errorNameNode;
@@ -177216,9 +177220,9 @@ ${lanes.join("\n")}
           }
           let typeNode;
           if (hasInferredType(node)) {
-            typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
+            typeNode = resolver2.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
           } else if (isFunctionLike(node)) {
-            typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
+            typeNode = resolver2.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
           } else {
             Debug.assertNever(node);
           }
@@ -177240,7 +177244,7 @@ ${lanes.join("\n")}
             case 264:
             case 266:
             case 267:
-              return !resolver.isDeclarationVisible(node);
+              return !resolver2.isDeclarationVisible(node);
             // The following should be doing their own visibility checks based on filtering their members
             case 261:
               return !getBindingNameVisible(node);
@@ -177269,7 +177273,7 @@ ${lanes.join("\n")}
           if (isBindingPattern(elem.name)) {
             return some(elem.name.elements, getBindingNameVisible);
           } else {
-            return resolver.isDeclarationVisible(elem);
+            return resolver2.isDeclarationVisible(elem);
           }
         }
         function updateParamsList(node, params, modifierMask) {
@@ -177326,7 +177330,7 @@ ${lanes.join("\n")}
           return isSourceFile(node) || isTypeAliasDeclaration(node) || isModuleDeclaration(node) || isClassDeclaration(node) || isInterfaceDeclaration(node) || isFunctionLike(node) || isIndexSignatureDeclaration(node) || isMappedTypeNode(node);
         }
         function checkEntityNameVisibility(entityName, enclosingDeclaration2) {
-          const visibilityResult = resolver.isEntityNameVisible(entityName, enclosingDeclaration2);
+          const visibilityResult = resolver2.isEntityNameVisible(entityName, enclosingDeclaration2);
           handleSymbolAccessibilityError(visibilityResult);
         }
         function preserveJsDoc(updated, original) {
@@ -177340,7 +177344,7 @@ ${lanes.join("\n")}
           resultHasExternalModuleIndicator = resultHasExternalModuleIndicator || parent2.kind !== 268 && parent2.kind !== 206;
           if (isStringLiteralLike(input)) {
             if (isBundledEmit) {
-              const newName = getExternalModuleNameFromDeclaration(context.getEmitHost(), resolver, parent2);
+              const newName = getExternalModuleNameFromDeclaration(context.getEmitHost(), resolver2, parent2);
               if (newName) {
                 return factory2.createStringLiteral(newName);
               }
@@ -177349,7 +177353,7 @@ ${lanes.join("\n")}
           return input;
         }
         function transformImportEqualsDeclaration(decl) {
-          if (!resolver.isDeclarationVisible(decl)) return;
+          if (!resolver2.isDeclarationVisible(decl)) return;
           if (decl.moduleReference.kind === 284) {
             const specifier = getExternalModuleImportEqualsDeclarationExpression(decl);
             return factory2.updateImportEqualsDeclaration(
@@ -177378,7 +177382,7 @@ ${lanes.join("\n")}
             );
           }
           const phaseModifier = decl.importClause.phaseModifier === 166 ? void 0 : decl.importClause.phaseModifier;
-          const visibleDefaultBinding = decl.importClause && decl.importClause.name && resolver.isDeclarationVisible(decl.importClause) ? decl.importClause.name : void 0;
+          const visibleDefaultBinding = decl.importClause && decl.importClause.name && resolver2.isDeclarationVisible(decl.importClause) ? decl.importClause.name : void 0;
           if (!decl.importClause.namedBindings) {
             return visibleDefaultBinding && factory2.updateImportDeclaration(
               decl,
@@ -177395,7 +177399,7 @@ ${lanes.join("\n")}
             );
           }
           if (decl.importClause.namedBindings.kind === 275) {
-            const namedBindings = resolver.isDeclarationVisible(decl.importClause.namedBindings) ? decl.importClause.namedBindings : (
+            const namedBindings = resolver2.isDeclarationVisible(decl.importClause.namedBindings) ? decl.importClause.namedBindings : (
               /*namedBindings*/
               void 0
             );
@@ -177412,7 +177416,7 @@ ${lanes.join("\n")}
               tryGetResolutionModeOverride(decl.attributes)
             ) : void 0;
           }
-          const bindingList = mapDefined(decl.importClause.namedBindings.elements, (b) => resolver.isDeclarationVisible(b) ? b : void 0);
+          const bindingList = mapDefined(decl.importClause.namedBindings.elements, (b) => resolver2.isDeclarationVisible(b) ? b : void 0);
           if (bindingList && bindingList.length || visibleDefaultBinding) {
             return factory2.updateImportDeclaration(
               decl,
@@ -177427,7 +177431,7 @@ ${lanes.join("\n")}
               tryGetResolutionModeOverride(decl.attributes)
             );
           }
-          if (resolver.isImportRequiredByAugmentation(decl)) {
+          if (resolver2.isImportRequiredByAugmentation(decl)) {
             if (isolatedDeclarations) {
               context.addDiagnostic(createDiagnosticForNode(decl, Diagnostics.Declaration_emit_for_this_file_requires_preserving_this_import_for_augmentations_This_is_not_supported_with_isolatedDeclarations));
             }
@@ -177484,7 +177488,7 @@ ${lanes.join("\n")}
             if (isDeclarationAndNotVisible(input)) return;
             if (hasDynamicName(input)) {
               if (isolatedDeclarations) {
-                if (!resolver.isDefinitelyReferenceToGlobalSymbolObject(input.name.expression)) {
+                if (!resolver2.isDefinitelyReferenceToGlobalSymbolObject(input.name.expression)) {
                   if (isClassDeclaration(input.parent) || isObjectLiteralExpression(input.parent)) {
                     context.addDiagnostic(createDiagnosticForNode(input, Diagnostics.Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations));
                     return;
@@ -177496,12 +177500,12 @@ ${lanes.join("\n")}
                     return;
                   }
                 }
-              } else if (!resolver.isLateBound(getParseTreeNode(input)) || !isEntityNameExpression(input.name.expression)) {
+              } else if (!resolver2.isLateBound(getParseTreeNode(input)) || !isEntityNameExpression(input.name.expression)) {
                 return;
               }
             }
           }
-          if (isFunctionLike(input) && resolver.isImplementationOfOverload(input)) return;
+          if (isFunctionLike(input) && resolver2.isImplementationOfOverload(input)) return;
           if (isSemicolonClassElement(input)) return;
           let previousEnclosingDeclaration;
           if (isEnclosingDeclaration(input)) {
@@ -177922,7 +177926,7 @@ ${lanes.join("\n")}
           }
           if (isDeclaration(input) && isDeclarationAndNotVisible(input)) return;
           if (isJSDocImportTag(input)) return;
-          if (isFunctionLike(input) && resolver.isImplementationOfOverload(input)) return;
+          if (isFunctionLike(input) && resolver2.isImplementationOfOverload(input)) return;
           let previousEnclosingDeclaration;
           if (isEnclosingDeclaration(input)) {
             previousEnclosingDeclaration = enclosingDeclaration;
@@ -177970,8 +177974,8 @@ ${lanes.join("\n")}
                 /*body*/
                 void 0
               ));
-              if (clean22 && resolver.isExpandoFunctionDeclaration(input) && shouldEmitFunctionProperties(input)) {
-                const props = resolver.getPropertiesOfContainerFunction(input);
+              if (clean22 && resolver2.isExpandoFunctionDeclaration(input) && shouldEmitFunctionProperties(input)) {
+                const props = resolver2.getPropertiesOfContainerFunction(input);
                 if (isolatedDeclarations) {
                   reportExpandoFunctionErrors(input);
                 }
@@ -178000,7 +178004,7 @@ ${lanes.join("\n")}
                     return void 0;
                   }
                   getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(p.valueDeclaration);
-                  const type2 = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags | 2, symbolTracker);
+                  const type2 = resolver2.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags | 2, symbolTracker);
                   getSymbolAccessibilityDiagnostic = oldDiag;
                   const isNonContextualKeywordName = isStringANonContextualKeyword(nameStr);
                   const name3 = isNonContextualKeywordName ? factory2.getGeneratedNameForNode(p.valueDeclaration) : factory2.createIdentifier(nameStr);
@@ -178208,7 +178212,7 @@ ${lanes.join("\n")}
                   void 0
                 )
               ] : void 0;
-              const lateIndexes = resolver.createLateBoundIndexSignatures(input, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
+              const lateIndexes = resolver2.createLateBoundIndexSignatures(input, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
               const memberNodes = concatenate(concatenate(concatenate(privateIdentifier, lateIndexes), parameterProperties), visitNodes2(input.members, visitDeclarationSubtree, isClassElement));
               const members = factory2.createNodeArray(memberNodes);
               const extendsClause = getEffectiveBaseTypeNode(input);
@@ -178228,7 +178232,7 @@ ${lanes.join("\n")}
                   newId,
                   /*exclamationToken*/
                   void 0,
-                  resolver.createTypeOfExpression(extendsClause.expression, input, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker),
+                  resolver2.createTypeOfExpression(extendsClause.expression, input, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker),
                   /*initializer*/
                   void 0
                 );
@@ -178287,7 +178291,7 @@ ${lanes.join("\n")}
                 input.name,
                 factory2.createNodeArray(mapDefined(input.members, (m2) => {
                   if (shouldStripInternal(m2)) return;
-                  const enumValue = resolver.getEnumMemberValue(m2);
+                  const enumValue = resolver2.getEnumMemberValue(m2);
                   const constValue = enumValue == null ? void 0 : enumValue.value;
                   if (isolatedDeclarations && m2.initializer && (enumValue == null ? void 0 : enumValue.hasExternalReferences) && // This will be its own compiler error instead, so don't report.
                   !isComputedPropertyName(m2.name)) {
@@ -178596,7 +178600,7 @@ ${lanes.join("\n")}
       function noEmitNotification(hint, node, callback2) {
         callback2(hint, node);
       }
-      function transformNodes(resolver, host, factory2, options, nodes, transformers, allowDtsFiles) {
+      function transformNodes(resolver2, host, factory2, options, nodes, transformers, allowDtsFiles) {
         var _a4, _b;
         const enabledSyntaxKindFeatures = new Array(
           359
@@ -178623,7 +178627,7 @@ ${lanes.join("\n")}
         const context = {
           factory: factory2,
           getCompilerOptions: () => options,
-          getEmitResolver: () => resolver,
+          getEmitResolver: () => resolver2,
           // TODO: GH#18217
           getEmitHost: () => host,
           // TODO: GH#18217
@@ -179203,7 +179207,7 @@ ${lanes.join("\n")}
       function emitResolverSkipsTypeChecking(emitOnly, forceDtsEmit) {
         return !!forceDtsEmit && !!emitOnly;
       }
-      function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, declarationTransformers }, emitOnly, onlyBuildInfo, forceDtsEmit, skipBuildInfo) {
+      function emitFiles(resolver2, host, targetSourceFile, { scriptTransformers, declarationTransformers }, emitOnly, onlyBuildInfo, forceDtsEmit, skipBuildInfo) {
         var compilerOptions = host.getCompilerOptions();
         var sourceMapDataList = compilerOptions.sourceMap || compilerOptions.inlineSourceMap || getAreDeclarationMapsEnabled(compilerOptions) ? [] : void 0;
         var emittedFilesList = compilerOptions.listEmittedFiles ? [] : void 0;
@@ -179274,7 +179278,7 @@ ${lanes.join("\n")}
             }
           );
           const transform22 = transformNodes(
-            resolver,
+            resolver2,
             host,
             factory,
             compilerOptions,
@@ -179297,7 +179301,7 @@ ${lanes.join("\n")}
           };
           const printer = createPrinter(printerOptions, {
             // resolver hooks
-            hasGlobalName: resolver.hasGlobalName,
+            hasGlobalName: resolver2.hasGlobalName,
             // transform hooks
             onEmitNode: transform22.emitNodeWithNotification,
             isEmitNotificationEnabled: transform22.isEmitNotificationEnabled,
@@ -179328,7 +179332,7 @@ ${lanes.join("\n")}
             }
           });
           const declarationTransform = transformNodes(
-            resolver,
+            resolver2,
             host,
             factory,
             compilerOptions,
@@ -179361,7 +179365,7 @@ ${lanes.join("\n")}
             };
             const declarationPrinter = createPrinter(printerOptions, {
               // resolver hooks
-              hasGlobalName: resolver.hasGlobalName,
+              hasGlobalName: resolver2.hasGlobalName,
               // transform hooks
               onEmitNode: declarationTransform.emitNodeWithNotification,
               isEmitNotificationEnabled: declarationTransform.isEmitNotificationEnabled,
@@ -179392,7 +179396,7 @@ ${lanes.join("\n")}
         function collectLinkedAliases(node) {
           if (isExportAssignment(node)) {
             if (node.expression.kind === 80) {
-              resolver.collectLinkedAliases(
+              resolver2.collectLinkedAliases(
                 node.expression,
                 /*setVisibility*/
                 true
@@ -179400,7 +179404,7 @@ ${lanes.join("\n")}
             }
             return;
           } else if (isExportSpecifier(node)) {
-            resolver.collectLinkedAliases(
+            resolver2.collectLinkedAliases(
               node.propertyName || node.name,
               /*setVisibility*/
               true
@@ -179414,7 +179418,7 @@ ${lanes.join("\n")}
           forEachChildRecursively(file, (n) => {
             if (isImportEqualsDeclaration(n) && !(getSyntacticModifierFlags(n) & 32)) return "skip";
             if (isImportDeclaration(n)) return "skip";
-            resolver.markLinkedReferences(n);
+            resolver2.markLinkedReferences(n);
           });
         }
         function printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform22, printer, mapOptions) {
@@ -187055,8 +187059,8 @@ ${lanes.join("\n")}
         }
         function getDeclarationDiagnosticsForFileNoCache(sourceFile, cancellationToken) {
           return runWithCancellationToken(() => {
-            const resolver = getTypeChecker().getEmitResolver(sourceFile, cancellationToken);
-            return getDeclarationDiagnostics(getEmitHost(noop4), resolver, sourceFile) || emptyArray;
+            const resolver2 = getTypeChecker().getEmitResolver(sourceFile, cancellationToken);
+            return getDeclarationDiagnostics(getEmitHost(noop4), resolver2, sourceFile) || emptyArray;
           });
         }
         function getDeclarationDiagnosticsForFile(sourceFile, cancellationToken) {
@@ -196533,7 +196537,7 @@ ${lanes.join("\n")}
         /*reportFallback*/
         true
       );
-      function createSyntacticTypeNodeBuilder(options, resolver) {
+      function createSyntacticTypeNodeBuilder(options, resolver2) {
         const strictNullChecks = getStrictOptionValue(options, "strictNullChecks");
         return {
           serializeTypeOfDeclaration,
@@ -196541,17 +196545,17 @@ ${lanes.join("\n")}
           serializeTypeOfExpression,
           serializeTypeOfAccessor,
           tryReuseExistingTypeNode(context, existing) {
-            if (!resolver.canReuseTypeNode(context, existing)) {
+            if (!resolver2.canReuseTypeNode(context, existing)) {
               return void 0;
             }
             return tryReuseExistingTypeNode(context, existing);
           }
         };
         function reuseNode(context, node, range2 = node) {
-          return node === void 0 ? void 0 : resolver.markNodeReuse(context, node.flags & 16 ? node : factory.cloneNode(node), range2 ?? node);
+          return node === void 0 ? void 0 : resolver2.markNodeReuse(context, node.flags & 16 ? node : factory.cloneNode(node), range2 ?? node);
         }
         function tryReuseExistingTypeNode(context, existing) {
-          const { finalizeBoundary, startRecoveryScope, hadError, markError } = resolver.createRecoveryBoundary(context);
+          const { finalizeBoundary, startRecoveryScope, hadError, markError } = resolver2.createRecoveryBoundary(context);
           const transformed = visitNode(existing, visitExistingNodeTreeSymbols, isTypeNode);
           if (!finalizeBoundary()) {
             return void 0;
@@ -196561,17 +196565,17 @@ ${lanes.join("\n")}
           function visitExistingNodeTreeSymbols(node) {
             if (hadError()) return node;
             const recover = startRecoveryScope();
-            const onExitNewScope = isNewScopeNode(node) ? resolver.enterNewScope(context, node) : void 0;
+            const onExitNewScope = isNewScopeNode(node) ? resolver2.enterNewScope(context, node) : void 0;
             const result = visitExistingNodeTreeSymbolsWorker(node);
             onExitNewScope == null ? void 0 : onExitNewScope();
             if (hadError()) {
               if (isTypeNode(node) && !isTypePredicateNode(node)) {
                 recover();
-                return resolver.serializeExistingTypeNode(context, node);
+                return resolver2.serializeExistingTypeNode(context, node);
               }
               return node;
             }
-            return result ? resolver.markNodeReuse(context, result, node) : void 0;
+            return result ? resolver2.markNodeReuse(context, result, node) : void 0;
           }
           function tryVisitSimpleTypeNode(node) {
             const innerNode = skipTypeParentheses(node);
@@ -196610,7 +196614,7 @@ ${lanes.join("\n")}
             return factory.updateTypeOperatorNode(node, type2);
           }
           function tryVisitTypeQuery(node) {
-            const { introducesError, node: exprName } = resolver.trackExistingEntityName(context, node.exprName);
+            const { introducesError, node: exprName } = resolver2.trackExistingEntityName(context, node.exprName);
             if (!introducesError) {
               return factory.updateTypeQueryNode(
                 node,
@@ -196618,19 +196622,19 @@ ${lanes.join("\n")}
                 visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode)
               );
             }
-            const serializedName = resolver.serializeTypeName(
+            const serializedName = resolver2.serializeTypeName(
               context,
               node.exprName,
               /*isTypeOf*/
               true
             );
             if (serializedName) {
-              return resolver.markNodeReuse(context, serializedName, node.exprName);
+              return resolver2.markNodeReuse(context, serializedName, node.exprName);
             }
           }
           function tryVisitTypeReference(node) {
-            if (resolver.canReuseTypeNode(context, node)) {
-              const { introducesError, node: newName } = resolver.trackExistingEntityName(context, node.typeName);
+            if (resolver2.canReuseTypeNode(context, node)) {
+              const { introducesError, node: newName } = resolver2.trackExistingEntityName(context, node.typeName);
               const typeArguments = visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode);
               if (!introducesError) {
                 const updated = factory.updateTypeReferenceNode(
@@ -196638,9 +196642,9 @@ ${lanes.join("\n")}
                   newName,
                   typeArguments
                 );
-                return resolver.markNodeReuse(context, updated, node);
+                return resolver2.markNodeReuse(context, updated, node);
               } else {
-                const serializedName = resolver.serializeTypeName(
+                const serializedName = resolver2.serializeTypeName(
                   context,
                   node.typeName,
                   /*isTypeOf*/
@@ -196648,7 +196652,7 @@ ${lanes.join("\n")}
                   typeArguments
                 );
                 if (serializedName) {
-                  return resolver.markNodeReuse(context, serializedName, node.typeName);
+                  return resolver2.markNodeReuse(context, serializedName, node.typeName);
                 }
               }
             }
@@ -196688,7 +196692,7 @@ ${lanes.join("\n")}
             if (isJSDocTypeLiteral(node)) {
               return factory.createTypeLiteralNode(map4(node.jsDocPropertyTags, (t) => {
                 const name3 = visitNode(isIdentifier(t.name) ? t.name : t.name.right, visitExistingNodeTreeSymbols, isIdentifier);
-                const overrideTypeNode = resolver.getJsDocPropertyOverride(context, node, t);
+                const overrideTypeNode = resolver2.getJsDocPropertyOverride(context, node, t);
                 return factory.createPropertySignature(
                   /*modifiers*/
                   void 0,
@@ -196738,7 +196742,7 @@ ${lanes.join("\n")}
                     /*modifiers*/
                     void 0,
                     getEffectiveDotDotDotForParameter(p),
-                    resolver.markNodeReuse(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i2)), p),
+                    resolver2.markNodeReuse(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i2)), p),
                     factory.cloneNode(p.questionToken),
                     visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode),
                     /*initializer*/
@@ -196756,7 +196760,7 @@ ${lanes.join("\n")}
                     /*modifiers*/
                     void 0,
                     getEffectiveDotDotDotForParameter(p),
-                    resolver.markNodeReuse(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i2)), p),
+                    resolver2.markNodeReuse(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i2)), p),
                     factory.cloneNode(p.questionToken),
                     visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode),
                     /*initializer*/
@@ -196770,14 +196774,14 @@ ${lanes.join("\n")}
               }
             }
             if (isThisTypeNode(node)) {
-              if (resolver.canReuseTypeNode(context, node)) {
+              if (resolver2.canReuseTypeNode(context, node)) {
                 return node;
               }
               markError();
               return node;
             }
             if (isTypeParameterDeclaration(node)) {
-              const { node: newName } = resolver.trackExistingEntityName(context, node.name);
+              const { node: newName } = resolver2.trackExistingEntityName(context, node.name);
               return factory.updateTypeParameterDeclaration(
                 node,
                 visitNodes2(node.modifiers, visitExistingNodeTreeSymbols, isModifier),
@@ -196808,8 +196812,8 @@ ${lanes.join("\n")}
                 markError();
                 return node;
               }
-              if (!resolver.canReuseTypeNode(context, node)) {
-                return resolver.serializeExistingTypeNode(context, node);
+              if (!resolver2.canReuseTypeNode(context, node)) {
+                return resolver2.serializeExistingTypeNode(context, node);
               }
               const specifier = rewriteModuleSpecifier2(node, node.argument.literal);
               const literal2 = specifier === node.argument.literal ? reuseNode(context, node.argument.literal) : specifier;
@@ -196822,18 +196826,18 @@ ${lanes.join("\n")}
                 node.isTypeOf
               );
             }
-            if (isNamedDeclaration(node) && node.name.kind === 168 && !resolver.hasLateBindableName(node)) {
+            if (isNamedDeclaration(node) && node.name.kind === 168 && !resolver2.hasLateBindableName(node)) {
               if (!hasDynamicName(node)) {
                 return visitEachChild2(node, visitExistingNodeTreeSymbols);
               }
-              if (resolver.shouldRemoveDeclaration(context, node)) {
+              if (resolver2.shouldRemoveDeclaration(context, node)) {
                 return void 0;
               }
             }
             if (isFunctionLike(node) && !node.type || isPropertyDeclaration(node) && !node.type && !node.initializer || isPropertySignature(node) && !node.type && !node.initializer || isParameter(node) && !node.type && !node.initializer) {
               let visited = visitEachChild2(node, visitExistingNodeTreeSymbols);
               if (visited === node) {
-                visited = resolver.markNodeReuse(context, factory.cloneNode(node), node);
+                visited = resolver2.markNodeReuse(context, factory.cloneNode(node), node);
               }
               visited.type = factory.createKeywordTypeNode(
                 133
@@ -196853,16 +196857,16 @@ ${lanes.join("\n")}
               return result;
             }
             if (isComputedPropertyName(node) && isEntityNameExpression(node.expression)) {
-              const { node: result, introducesError } = resolver.trackExistingEntityName(context, node.expression);
+              const { node: result, introducesError } = resolver2.trackExistingEntityName(context, node.expression);
               if (!introducesError) {
                 return factory.updateComputedPropertyName(node, result);
               } else {
-                const computedPropertyNameType = resolver.serializeTypeOfExpression(context, node.expression);
+                const computedPropertyNameType = resolver2.serializeTypeOfExpression(context, node.expression);
                 let literal2;
                 if (isLiteralTypeNode(computedPropertyNameType)) {
                   literal2 = computedPropertyNameType.literal;
                 } else {
-                  const evaluated = resolver.evaluateEntityNameExpression(node.expression);
+                  const evaluated = resolver2.evaluateEntityNameExpression(node.expression);
                   const literalNode = typeof evaluated.value === "string" ? factory.createStringLiteral(
                     evaluated.value,
                     /*isSingleQuote*/
@@ -196874,7 +196878,7 @@ ${lanes.join("\n")}
                   ) : void 0;
                   if (!literalNode) {
                     if (isImportTypeNode(computedPropertyNameType)) {
-                      resolver.trackComputedName(context, node.expression);
+                      resolver2.trackComputedName(context, node.expression);
                     }
                     return node;
                   }
@@ -196892,7 +196896,7 @@ ${lanes.join("\n")}
             if (isTypePredicateNode(node)) {
               let parameterName;
               if (isIdentifier(node.parameterName)) {
-                const { node: result, introducesError } = resolver.trackExistingEntityName(context, node.parameterName);
+                const { node: result, introducesError } = resolver2.trackExistingEntityName(context, node.parameterName);
                 if (introducesError) markError();
                 parameterName = result;
               } else {
@@ -196902,7 +196906,7 @@ ${lanes.join("\n")}
             }
             if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
               const visited = visitEachChild2(node, visitExistingNodeTreeSymbols);
-              const clone22 = resolver.markNodeReuse(context, visited === node ? factory.cloneNode(node) : visited, node);
+              const clone22 = resolver2.markNodeReuse(context, visited === node ? factory.cloneNode(node) : visited, node);
               const flags = getEmitFlags(clone22);
               setEmitFlags(clone22, flags | (context.flags & 1024 && isTypeLiteralNode(node) ? 0 : 1));
               return clone22;
@@ -196914,7 +196918,7 @@ ${lanes.join("\n")}
             }
             if (isConditionalTypeNode(node)) {
               const checkType = visitNode(node.checkType, visitExistingNodeTreeSymbols, isTypeNode);
-              const disposeScope = resolver.enterNewScope(context, node);
+              const disposeScope = resolver2.enterNewScope(context, node);
               const extendType = visitNode(node.extendsType, visitExistingNodeTreeSymbols, isTypeNode);
               const trueType = visitNode(node.trueType, visitExistingNodeTreeSymbols, isTypeNode);
               disposeScope();
@@ -196929,7 +196933,7 @@ ${lanes.join("\n")}
             }
             if (isTypeOperatorNode(node)) {
               if (node.operator === 158 && node.type.kind === 155) {
-                if (!resolver.canReuseTypeNode(context, node)) {
+                if (!resolver2.canReuseTypeNode(context, node)) {
                   markError();
                   return node;
                 }
@@ -196975,7 +196979,7 @@ ${lanes.join("\n")}
               return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index2}`;
             }
             function rewriteModuleSpecifier2(parent2, lit) {
-              const newName = resolver.getModuleSpecifierOverride(context, parent2, lit);
+              const newName = resolver2.getModuleSpecifierOverride(context, parent2, lit);
               return newName ? setOriginalNode(factory.createStringLiteral(newName), lit) : lit;
             }
           }
@@ -196983,7 +196987,7 @@ ${lanes.join("\n")}
         function serializeExistingTypeNode(typeNode, context, addUndefined) {
           if (!typeNode) return void 0;
           let result;
-          if ((!addUndefined || canAddUndefined(typeNode)) && resolver.canReuseTypeNode(context, typeNode)) {
+          if ((!addUndefined || canAddUndefined(typeNode)) && resolver2.canReuseTypeNode(context, typeNode)) {
             result = tryReuseExistingTypeNode(context, typeNode);
             if (result !== void 0) {
               result = addUndefinedIfNeeded(
@@ -196999,8 +197003,8 @@ ${lanes.join("\n")}
         }
         function serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol, requiresAddingUndefined, useFallback = requiresAddingUndefined !== void 0) {
           if (!declaredType) return void 0;
-          if (!resolver.canReuseTypeNodeAnnotation(context, node, declaredType, symbol, requiresAddingUndefined)) {
-            if (!requiresAddingUndefined || !resolver.canReuseTypeNodeAnnotation(
+          if (!resolver2.canReuseTypeNodeAnnotation(context, node, declaredType, symbol, requiresAddingUndefined)) {
+            if (!requiresAddingUndefined || !resolver2.canReuseTypeNodeAnnotation(
               context,
               node,
               declaredType,
@@ -197019,7 +197023,7 @@ ${lanes.join("\n")}
             return result;
           }
           context.tracker.reportInferenceFallback(node);
-          return resolver.serializeExistingTypeNode(context, declaredType, requiresAddingUndefined) ?? factory.createKeywordTypeNode(
+          return resolver2.serializeExistingTypeNode(context, declaredType, requiresAddingUndefined) ?? factory.createKeywordTypeNode(
             133
             /* AnyKeyword */
           );
@@ -197031,13 +197035,13 @@ ${lanes.join("\n")}
             return result;
           }
           context.tracker.reportInferenceFallback(targetNode ?? typeNode);
-          return resolver.serializeExistingTypeNode(context, typeNode, addUndefined) ?? factory.createKeywordTypeNode(
+          return resolver2.serializeExistingTypeNode(context, typeNode, addUndefined) ?? factory.createKeywordTypeNode(
             133
             /* AnyKeyword */
           );
         }
         function serializeTypeOfAccessor(accessor, symbol, context) {
-          return typeFromAccessor(accessor, symbol, context) ?? inferAccessorType(accessor, resolver.getAllAccessorDeclarations(accessor), context, symbol);
+          return typeFromAccessor(accessor, symbol, context) ?? inferAccessorType(accessor, resolver2.getAllAccessorDeclarations(accessor), context, symbol);
         }
         function serializeTypeOfExpression(expr, context, addUndefined, preserveLiterals) {
           const result = typeFromExpression(
@@ -197086,13 +197090,13 @@ ${lanes.join("\n")}
         function typeFromPropertyAssignment(node, symbol, context) {
           const typeAnnotation = getEffectiveTypeAnnotationNode(node);
           let result;
-          if (typeAnnotation && resolver.canReuseTypeNodeAnnotation(context, node, typeAnnotation, symbol)) {
+          if (typeAnnotation && resolver2.canReuseTypeNodeAnnotation(context, node, typeAnnotation, symbol)) {
             result = serializeExistingTypeNode(typeAnnotation, context);
           }
           if (!result && node.kind === 304) {
             const initializer2 = node.initializer;
             const assertionNode = isJSDocTypeAssertion(initializer2) ? getJSDocTypeAssertionType(initializer2) : initializer2.kind === 235 || initializer2.kind === 217 ? initializer2.type : void 0;
-            if (assertionNode && !isConstTypeReference(assertionNode) && resolver.canReuseTypeNodeAnnotation(context, node, assertionNode, symbol)) {
+            if (assertionNode && !isConstTypeReference(assertionNode) && resolver2.canReuseTypeNodeAnnotation(context, node, assertionNode, symbol)) {
               result = serializeExistingTypeNode(assertionNode, context);
             }
           }
@@ -197143,7 +197147,7 @@ ${lanes.join("\n")}
           return accessorType;
         }
         function typeFromAccessor(node, symbol, context) {
-          const accessorDeclarations = resolver.getAllAccessorDeclarations(node);
+          const accessorDeclarations = resolver2.getAllAccessorDeclarations(node);
           const accessorType = getTypeAnnotationFromAllAccessorDeclarations(node, accessorDeclarations);
           if (accessorType && !isTypePredicateNode(accessorType)) {
             return withNewScope(context, node, () => serializeTypeAnnotationOfDeclaration(accessorType, context, node, symbol) ?? inferTypeOfDeclaration(node, symbol, context));
@@ -197160,7 +197164,7 @@ ${lanes.join("\n")}
           if (declaredType) {
             resultType = syntacticResult(serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol));
           } else if (node.initializer && (((_a4 = symbol.declarations) == null ? void 0 : _a4.length) === 1 || countWhere(symbol.declarations, isVariableDeclaration) === 1)) {
-            if (!resolver.isExpandoFunctionDeclaration(node) && !isContextuallyTyped(node)) {
+            if (!resolver2.isExpandoFunctionDeclaration(node) && !isContextuallyTyped(node)) {
               resultType = typeFromExpression(
                 node.initializer,
                 context,
@@ -197185,7 +197189,7 @@ ${lanes.join("\n")}
             );
           }
           const declaredType = getEffectiveTypeAnnotationNode(node);
-          const addUndefined = resolver.requiresAddingImplicitUndefined(node, symbol, context.enclosingDeclaration);
+          const addUndefined = resolver2.requiresAddingImplicitUndefined(node, symbol, context.enclosingDeclaration);
           let resultType = failed;
           if (declaredType) {
             resultType = syntacticResult(serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol, addUndefined));
@@ -197220,7 +197224,7 @@ ${lanes.join("\n")}
         }
         function typeFromProperty(node, symbol, context) {
           const declaredType = getEffectiveTypeAnnotationNode(node);
-          const requiresAddingUndefined = resolver.requiresAddingImplicitUndefined(node, symbol, context.enclosingDeclaration);
+          const requiresAddingUndefined = resolver2.requiresAddingImplicitUndefined(node, symbol, context.enclosingDeclaration);
           let resultType = failed;
           if (declaredType) {
             resultType = syntacticResult(serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol, requiresAddingUndefined));
@@ -197250,7 +197254,7 @@ ${lanes.join("\n")}
               /* AnyKeyword */
             );
           }
-          return resolver.serializeTypeOfDeclaration(context, node, symbol);
+          return resolver2.serializeTypeOfDeclaration(context, node, symbol);
         }
         function inferExpressionType(node, context, reportFallback = true, requiresAddingUndefined) {
           Debug.assert(!requiresAddingUndefined);
@@ -197263,7 +197267,7 @@ ${lanes.join("\n")}
               /* AnyKeyword */
             );
           }
-          return resolver.serializeTypeOfExpression(context, node) ?? factory.createKeywordTypeNode(
+          return resolver2.serializeTypeOfExpression(context, node) ?? factory.createKeywordTypeNode(
             133
             /* AnyKeyword */
           );
@@ -197278,7 +197282,7 @@ ${lanes.join("\n")}
               /* AnyKeyword */
             );
           }
-          return resolver.serializeReturnTypeForSignature(context, node, symbol) ?? factory.createKeywordTypeNode(
+          return resolver2.serializeReturnTypeForSignature(context, node, symbol) ?? factory.createKeywordTypeNode(
             133
             /* AnyKeyword */
           );
@@ -197291,14 +197295,14 @@ ${lanes.join("\n")}
               context.tracker.reportInferenceFallback(node);
             }
             const result = allAccessors.getAccessor && createReturnFromSignature(allAccessors.getAccessor, symbol, context, reportFallback);
-            return result ?? resolver.serializeTypeOfDeclaration(context, node, symbol) ?? factory.createKeywordTypeNode(
+            return result ?? resolver2.serializeTypeOfDeclaration(context, node, symbol) ?? factory.createKeywordTypeNode(
               133
               /* AnyKeyword */
             );
           }
         }
         function withNewScope(context, node, fn) {
-          const cleanup = resolver.enterNewScope(context, node);
+          const cleanup = resolver2.enterNewScope(context, node);
           const result = fn();
           cleanup();
           return result;
@@ -197323,7 +197327,7 @@ ${lanes.join("\n")}
               }
               return typeFromExpression(node.expression, context, isConstContext, requiresAddingUndefined);
             case 80:
-              if (resolver.isUndefinedIdentifierExpression(node)) {
+              if (resolver2.isUndefinedIdentifierExpression(node)) {
                 return syntacticResult(createUndefinedTypeNode());
               }
               break;
@@ -197491,7 +197495,7 @@ ${lanes.join("\n")}
                 expression,
                 /*includeBigInt*/
                 false
-              ) && !resolver.isDefinitelyReferenceToGlobalSymbolObject(expression)) {
+              ) && !resolver2.isDefinitelyReferenceToGlobalSymbolObject(expression)) {
                 context.tracker.reportInferenceFallback(prop.name);
                 result = false;
               }
@@ -197577,8 +197581,8 @@ ${lanes.join("\n")}
             /*modifiers*/
             void 0,
             reuseNode(context, p.dotDotDotToken),
-            resolver.serializeNameOfParameter(context, p),
-            resolver.isOptionalParameter(p) ? factory.createToken(
+            resolver2.serializeNameOfParameter(context, p),
+            resolver2.isOptionalParameter(p) ? factory.createToken(
               58
               /* QuestionToken */
             ) : void 0,
@@ -197596,7 +197600,7 @@ ${lanes.join("\n")}
         function reuseTypeParameters(typeParameters, context) {
           return typeParameters == null ? void 0 : typeParameters.map((tp) => {
             var _a4;
-            const { node: tpName } = resolver.trackExistingEntityName(context, tp.name);
+            const { node: tpName } = resolver2.trackExistingEntityName(context, tp.name);
             return factory.updateTypeParameterDeclaration(
               tp,
               (_a4 = tp.modifiers) == null ? void 0 : _a4.map((m2) => reuseNode(context, m2)),
@@ -197644,7 +197648,7 @@ ${lanes.join("\n")}
           }
         }
         function typeFromObjectLiteralAccessor(accessor, name3, context) {
-          const allAccessors = resolver.getAllAccessorDeclarations(accessor);
+          const allAccessors = resolver2.getAllAccessorDeclarations(accessor);
           const getAccessorType = allAccessors.getAccessor && getTypeAnnotationFromAccessor(allAccessors.getAccessor);
           const setAccessorType = allAccessors.setAccessor && getTypeAnnotationFromAccessor(allAccessors.setAccessor);
           if (getAccessorType !== void 0 && setAccessorType !== void 0) {
@@ -226856,7 +226860,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       function originIsComputedPropertyName(origin) {
         return !!(origin && origin.kind & 512);
       }
-      function resolvingModuleSpecifiers(logPrefix, host, resolver, program2, position3, preferences, isForImportStatementCompletion, isValidTypeOnlyUseSite, cb) {
+      function resolvingModuleSpecifiers(logPrefix, host, resolver2, program2, position3, preferences, isForImportStatementCompletion, isValidTypeOnlyUseSite, cb) {
         var _a4, _b, _c, _d;
         const start = timestamp2();
         const needsFullResolution = isForImportStatementCompletion || getResolvePackageJsonExports(program2.getCompilerOptions()) || ((_a4 = preferences.autoImportSpecifierExcludeRegexes) == null ? void 0 : _a4.length);
@@ -226878,7 +226882,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         return result;
         function tryResolve(exportInfo, isFromAmbientModule) {
           if (isFromAmbientModule) {
-            const result3 = resolver.getModuleSpecifierForBestExportInfo(exportInfo, position3, isValidTypeOnlyUseSite);
+            const result3 = resolver2.getModuleSpecifierForBestExportInfo(exportInfo, position3, isValidTypeOnlyUseSite);
             if (result3) {
               ambientCount++;
             }
@@ -226886,7 +226890,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           }
           const shouldResolveModuleSpecifier = needsFullResolution || preferences.allowIncompleteCompletions && resolvedCount < moduleSpecifierResolutionLimit;
           const shouldGetModuleSpecifierFromCache = !shouldResolveModuleSpecifier && preferences.allowIncompleteCompletions && cacheAttemptCount < moduleSpecifierResolutionCacheAttemptLimit;
-          const result2 = shouldResolveModuleSpecifier || shouldGetModuleSpecifierFromCache ? resolver.getModuleSpecifierForBestExportInfo(exportInfo, position3, isValidTypeOnlyUseSite, shouldGetModuleSpecifierFromCache) : void 0;
+          const result2 = shouldResolveModuleSpecifier || shouldGetModuleSpecifierFromCache ? resolver2.getModuleSpecifierForBestExportInfo(exportInfo, position3, isValidTypeOnlyUseSite, shouldGetModuleSpecifierFromCache) : void 0;
           if (!shouldResolveModuleSpecifier && !shouldGetModuleSpecifierFromCache || shouldGetModuleSpecifierFromCache && !result2) {
             skippedAny = true;
           }
@@ -283214,11 +283218,11 @@ function interpolate(target, source = {}, parse9 = (v2) => v2) {
 }
 var _normalize = (p) => p?.replace(/\\/g, "/");
 var ASYNC_LOADERS = {
-  ".yaml": () => import("./yaml-ZE3I2LDD.js").then((r) => r.parseYAML),
-  ".yml": () => import("./yaml-ZE3I2LDD.js").then((r) => r.parseYAML),
-  ".jsonc": () => import("./jsonc-FADPE5LI.js").then((r) => r.parseJSONC),
-  ".json5": () => import("./json5-H2TGPWGY.js").then((r) => r.parseJSON5),
-  ".toml": () => import("./toml-CJD72GZ3.js").then((r) => r.parseTOML)
+  ".yaml": () => import("./yaml-FGQHUFIW.js").then((r) => r.parseYAML),
+  ".yml": () => import("./yaml-FGQHUFIW.js").then((r) => r.parseYAML),
+  ".jsonc": () => import("./jsonc-LBXY5RKD.js").then((r) => r.parseJSONC),
+  ".json5": () => import("./json5-G2QRRXKH.js").then((r) => r.parseJSON5),
+  ".toml": () => import("./toml-7RFNJIC6.js").then((r) => r.parseTOML)
 };
 var SUPPORTED_EXTENSIONS = [
   // with jiti
@@ -283418,8 +283422,8 @@ async function resolveConfig(source, options, sourceOptions = {}) {
   }
   const _merger = options.merger || defu;
   if (options.giget !== false && GIGET_PREFIXES.some((prefix) => source.startsWith(prefix))) {
-    const { downloadTemplate } = await import("./dist-AJLZ2YE4.js");
-    const { digest } = await import("./dist-XSR3RQ2H.js");
+    const { downloadTemplate } = await import("./dist-BLCVU4KN.js");
+    const { digest } = await import("./dist-2S5JPQW5.js");
     const cloneName = source.replace(/\W+/g, "_").split("_").splice(0, 3).join("_") + "_" + digest(source).slice(0, 10).replace(/[-_]/g, "");
     let cloneDir;
     const localNodeModules = resolve(options.cwd, "node_modules");
@@ -301341,8 +301345,8 @@ function createFileResolver(fs18, templateVariables = envToTemplateVars(process.
   return loader3;
 }
 async function resolveFile(filename, relativeTo, fs18 = getFileSystem()) {
-  const resolver = createFileResolver(fs18);
-  return resolver.resolveFile(filename, relativeTo);
+  const resolver2 = createFileResolver(fs18);
+  return resolver2.resolveFile(filename, relativeTo);
 }
 
 // ../../node_modules/.pnpm/cspell-lib@8.19.4/node_modules/cspell-lib/dist/lib/Settings/DictionaryReferenceCollection.js
@@ -301567,11 +301571,11 @@ var StrongWeakMap = class {
   /**
    * Returns a specified element from the Map. If the element isn't found, the resolver function is called and the result is stored in the map and returned.
    */
-  autoGet(key, resolver) {
+  autoGet(key, resolver2) {
     const found = this.get(key);
     if (found)
       return found;
-    const created = resolver(key);
+    const created = resolver2(key);
     this.set(key, created);
     return created;
   }
@@ -307481,9 +307485,9 @@ function localesToList(locales) {
 function stringToList(sList) {
   return sList.replaceAll(/[|;]/g, ",").split(",").map((s) => s.trim()).filter((s) => !!s);
 }
-function memorizer(resolver) {
+function memorizer(resolver2) {
   const cache5 = createAutoResolveCache();
-  return (k2) => cache5.get(k2, resolver);
+  return (k2) => cache5.get(k2, resolver2);
 }
 var _normalizeLanguageId = memorizer(__normalizeLanguageId);
 function __normalizeLanguageId(langId) {
@@ -340930,7 +340934,7 @@ async function upgradeDependency([name3, tag = "latest"]) {
 var npmRequestLimit = (0, import_p_limit2.default)(40);
 function getPackageInfo(pkgName) {
   return npmRequestLimit(async () => {
-    const getPackageJson = (await import("./package-json-ZFCGQAYS.js")).default;
+    const getPackageJson = (await import("./package-json-FUXIBCXB.js")).default;
     return getPackageJson(pkgName, {
       allVersions: true
     });