tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/transformers/declarations-pseudo.js

@@ -166,14 +166,14 @@ export class PseudoChecker {
         return this.mergedSymbols.get(symbol) ?? symbol;
     }
     getReturnTypeOfSignature(signature) {
-        if (signature.kind === 178 /* SyntaxKind.GetAccessor */)
+        if (signature.kind === 179 /* SyntaxKind.GetAccessor */)
             return this.getTypeOfAccessor(signature);
         return this.createReturnFromSignature(signature);
     }
     getTypeOfAccessor(accessor) {
         const accessors = getAllAccessorDeclarations(accessor);
         const annotation = this.getAccessorAnnotation(accessor, accessors.firstAccessor, accessors.secondAccessor);
-        if (annotation !== undefined && annotation.kind !== 183 /* SyntaxKind.TypePredicate */)
+        if (annotation !== undefined && annotation.kind !== 184 /* SyntaxKind.TypePredicate */)
             return new DirectType(annotation);
         const getter = accessors.getAccessor;
         if (getter !== undefined) {
@@ -202,32 +202,32 @@ export class PseudoChecker {
     }
     getTypeOfDeclaration(node) {
         switch (node.kind) {
-            case 170 /* SyntaxKind.Parameter */:
+            case 171 /* SyntaxKind.Parameter */:
                 if (node instanceof ParameterDeclaration) {
                     const narrowed = node;
                     return this.typeFromParameter(narrowed);
                 }
                 break;
-            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
                 if (node instanceof VariableDeclaration) {
                     const narrowed = node;
                     return this.typeFromVariable(narrowed);
                 }
                 break;
-            case 172 /* SyntaxKind.PropertySignature */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 340 /* SyntaxKind.JSDocPropertyTag */:
+            case 173 /* SyntaxKind.PropertySignature */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 341 /* SyntaxKind.JSDocPropertyTag */:
                 return this.typeFromProperty(node);
-            case 278 /* SyntaxKind.ExportAssignment */:
+            case 279 /* SyntaxKind.ExportAssignment */:
                 return this.typeFromExpression(getExpression(node));
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
-            case 213 /* SyntaxKind.ElementAccessExpression */:
-            case 227 /* SyntaxKind.BinaryExpression */: {
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
+            case 228 /* SyntaxKind.BinaryExpression */: {
                 const type = getType(node);
                 return type !== undefined ? new DirectType(type) : new NoResultType(node);
             }
-            case 303 /* SyntaxKind.PropertyAssignment */:
-            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
+            case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
                 return this.typeFromPropertyAssignment(node);
         }
         return new NoResultType(node);
@@ -256,7 +256,7 @@ export class PseudoChecker {
             const initializer = node.initializer;
             if (initializer !== undefined && !isContextuallyTyped(node)) {
                 // Readonly template literals may become literal types, so they aren't inferred.
-                if (hasSyntacticModifier(node, 8 /* ModifierFlags.Readonly */) && initializer.kind === 229 /* SyntaxKind.TemplateExpression */)
+                if (hasSyntacticModifier(node, 8 /* ModifierFlags.Readonly */) && initializer.kind === 230 /* SyntaxKind.TemplateExpression */)
                     return new NoResultType(node);
                 const result = this.typeFromExpression(initializer);
                 if (!isBareInferred(result)) {
@@ -278,12 +278,12 @@ export class PseudoChecker {
         const initializer = declaration.initializer;
         // As tsgo, the file's own declarations; merged ones are left to the checker's type comparison.
         const symbol = declaration.symbol;
-        if (initializer !== undefined &&
-            (symbol === undefined || countVariableDeclarations(getDeclarations(symbol)) === 1)) {
+        // A binding pattern has no symbol, and its initializer's type isn't the variable's.
+        if (initializer !== undefined && symbol !== undefined && countVariableDeclarations(getDeclarations(symbol)) === 1) {
             if (!isContextuallyTyped(declaration)) {
                 // Const template literals may become literal types, so they aren't inferred.
                 if ((getCombinedNodeFlags(declaration) & 2 /* NodeFlags.Const */) !== 0 &&
-                    initializer.kind === 229 /* SyntaxKind.TemplateExpression */)
+                    initializer.kind === 230 /* SyntaxKind.TemplateExpression */)
                     return new NoResultType(declaration);
                 const result = this.typeFromExpression(initializer);
                 if (!isBareInferred(result))
@@ -310,7 +310,7 @@ export class PseudoChecker {
             // An async function or generator returns a promise or generator of its returned values.
             if (hasSyntacticModifier(fn, 1024 /* ModifierFlags.Async */) || getAsteriskToken(fn) !== undefined)
                 return inferred(fn, true);
-            if (body.kind === 242 /* SyntaxKind.Block */) {
+            if (body.kind === 243 /* SyntaxKind.Block */) {
                 const returns = collectReturnStatements(body);
                 // Only a single return directly in the body.
                 if (returns.length === 1 && returns[0].parent === body)
@@ -323,7 +323,7 @@ export class PseudoChecker {
             if (!isContextuallyTyped(candidate))
                 return this.typeFromExpression(candidate);
             let type = undefined;
-            if (candidate.kind === 217 /* SyntaxKind.TypeAssertionExpression */ || candidate.kind === 235 /* SyntaxKind.AsExpression */)
+            if (candidate.kind === 218 /* SyntaxKind.TypeAssertionExpression */ || candidate.kind === 236 /* SyntaxKind.AsExpression */)
                 type = getType(candidate);
             if (type !== undefined && !isConstTypeReference(type))
                 return new DirectType(type);
@@ -333,9 +333,9 @@ export class PseudoChecker {
     /** `checkExpression` for pseudo-types. */
     typeFromExpression(node) {
         switch (node.kind) {
-            case 233 /* SyntaxKind.OmittedExpression */:
+            case 234 /* SyntaxKind.OmittedExpression */:
                 return undefinedType;
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
                 return this.typeFromExpression(getExpression(node));
             case 79 /* SyntaxKind.Identifier */:
                 // A declaration named `undefined` shadows it.
@@ -346,38 +346,38 @@ export class PseudoChecker {
                 break;
             case 105 /* SyntaxKind.NullKeyword */:
                 return nullType;
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 219 /* SyntaxKind.FunctionExpression */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 220 /* SyntaxKind.FunctionExpression */:
                 return this.typeFromFunctionLikeExpression(node);
-            case 217 /* SyntaxKind.TypeAssertionExpression */:
-            case 235 /* SyntaxKind.AsExpression */: {
+            case 218 /* SyntaxKind.TypeAssertionExpression */:
+            case 236 /* SyntaxKind.AsExpression */: {
                 const type = getType(node);
                 if (isConstTypeReference(type))
                     return this.typeFromExpression(getExpression(node));
                 return new DirectType(type);
             }
-            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            case 226 /* SyntaxKind.PrefixUnaryExpression */:
                 if (node instanceof PrefixUnaryExpression) {
                     const unary = node;
                     if (isSignedNumericLiteral(unary))
                         return typeFromSignedLiteral(unary);
                 }
                 break;
-            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            case 211 /* SyntaxKind.ArrayLiteralExpression */:
                 if (node instanceof ArrayLiteralExpression) {
                     const narrowed = node;
                     return this.typeFromArrayLiteral(narrowed);
                 }
                 break;
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 212 /* SyntaxKind.ObjectLiteralExpression */:
                 if (node instanceof ObjectLiteralExpression) {
                     const narrowed = node;
                     return this.typeFromObjectLiteral(narrowed);
                 }
                 break;
-            case 232 /* SyntaxKind.ClassExpression */:
+            case 233 /* SyntaxKind.ClassExpression */:
                 return new InferredType(node, false, [node]);
-            case 229 /* SyntaxKind.TemplateExpression */:
+            case 230 /* SyntaxKind.TemplateExpression */:
                 // Templates with substitutions aren't literal types, but `as const` would make them one.
                 if (isInConstContext(node))
                     return inferred(node, false);
@@ -403,7 +403,7 @@ export class PseudoChecker {
         const members = [];
         for (const property of node.properties.nodes) {
             switch (property.kind) {
-                case 175 /* SyntaxKind.MethodDeclaration */: {
+                case 176 /* SyntaxKind.MethodDeclaration */: {
                     const postfix = getPostfixToken(property);
                     const optional = postfix !== undefined && postfix.kind === 57 /* SyntaxKind.QuestionToken */;
                     const fullSignature = getFullSignature(property);
@@ -414,14 +414,14 @@ export class PseudoChecker {
                     members.push(new PseudoMember(0 /* PseudoMemberKind.Method */, getName(property), optional, false, property, nodesOf(getTypeParameters(property)), this.cloneParameters(getParameters(property).nodes), this.createReturnFromSignature(property)));
                     break;
                 }
-                case 303 /* SyntaxKind.PropertyAssignment */: {
+                case 304 /* SyntaxKind.PropertyAssignment */: {
                     const assignment = property;
                     const postfix = propertyAssignmentPostfixToken(assignment);
                     members.push(new PseudoMember(1 /* PseudoMemberKind.Property */, assignment.name, postfix !== undefined && postfix.kind === 57 /* SyntaxKind.QuestionToken */, false, undefined, [], [], this.typeFromExpression(assignment.initializer)));
                     break;
                 }
-                case 179 /* SyntaxKind.SetAccessor */:
-                case 178 /* SyntaxKind.GetAccessor */: {
+                case 180 /* SyntaxKind.SetAccessor */:
+                case 179 /* SyntaxKind.GetAccessor */: {
                     const member = this.getAccessorMember(property);
                     if (member !== undefined)
                         members.push(member);
@@ -442,21 +442,21 @@ export class PseudoChecker {
             setter instanceof SetAccessorDeclaration &&
             setter.parameters.nodes.length > 0 &&
             getType(setter.parameters.nodes[0]) !== undefined) {
-            if (accessor.kind === 178 /* SyntaxKind.GetAccessor */)
+            if (accessor.kind === 179 /* SyntaxKind.GetAccessor */)
                 return new PseudoMember(3 /* PseudoMemberKind.GetAccessor */, name, false, false, accessor, [], [], this.getTypeOfAccessor(accessor));
             const parameters = this.cloneParameters(accessor.parameters.nodes);
             return new PseudoMember(2 /* PseudoMemberKind.SetAccessor */, name, false, false, accessor, [], parameters, anyType);
         }
         // Otherwise the first accessor is a property, `readonly` for a lone getter.
         if (accessor === accessors.firstAccessor)
-            return new PseudoMember(1 /* PseudoMemberKind.Property */, name, false, accessor.kind === 178 /* SyntaxKind.GetAccessor */ && accessors.secondAccessor === undefined, undefined, [], [], this.getTypeOfAccessor(accessor));
+            return new PseudoMember(1 /* PseudoMemberKind.Property */, name, false, accessor.kind === 179 /* SyntaxKind.GetAccessor */ && accessors.secondAccessor === undefined, undefined, [], [], this.getTypeOfAccessor(accessor));
         return undefined;
     }
     typeFromArrayLiteral(node) {
         if (!isInConstContext(node))
             return new InferredType(node, false, [node]);
         for (const element of node.elements.nodes)
-            if (element.kind === 231 /* SyntaxKind.SpreadElement */)
+            if (element.kind === 232 /* SyntaxKind.SpreadElement */)
                 return new InferredType(node, false, [element]);
         // An `as const` array with a contextual type may or may not be readonly.
         if (isContextuallyTyped(node))
@@ -474,7 +474,7 @@ export class PseudoChecker {
     }
     typeFromParameter(node) {
         const parent = node.parent;
-        if (parent.kind === 179 /* SyntaxKind.SetAccessor */)
+        if (parent.kind === 180 /* SyntaxKind.SetAccessor */)
             return this.getTypeOfAccessor(parent);
         if (node.initializer === undefined)
             return node.type !== undefined ? new DirectType(node.type) : new NoResultType(node);
@@ -483,7 +483,7 @@ export class PseudoChecker {
     }
     typeFromParameterAt(node, index, lastRequired) {
         const parent = node.parent;
-        if (parent.kind === 179 /* SyntaxKind.SetAccessor */)
+        if (parent.kind === 180 /* SyntaxKind.SetAccessor */)
             return this.getTypeOfAccessor(parent);
         const hasRequiredAfter = index < lastRequired - 1;
         if (node.type !== undefined) {
@@ -536,19 +536,19 @@ function countVariableDeclarations(declarations) {
         return 1;
     let count = 0;
     for (const declaration of declarations)
-        if (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */)
+        if (declaration.kind === 262 /* SyntaxKind.VariableDeclaration */)
             count++;
     return count;
 }
 function isValueSignatureDeclaration(node) {
     switch (node.kind) {
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 177 /* SyntaxKind.Constructor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 178 /* SyntaxKind.Constructor */:
             return true;
     }
     return false;
@@ -563,25 +563,25 @@ class ReturnCollector extends NodeVisitor {
     statements = [];
     visitNode(node) {
         switch (node.kind) {
-            case 254 /* SyntaxKind.ReturnStatement */:
+            case 255 /* SyntaxKind.ReturnStatement */:
                 if (node instanceof ReturnStatement)
                     this.statements.push(node);
                 return false;
-            case 270 /* SyntaxKind.CaseBlock */:
-            case 242 /* SyntaxKind.Block */:
-            case 246 /* SyntaxKind.IfStatement */:
-            case 247 /* SyntaxKind.DoStatement */:
-            case 248 /* SyntaxKind.WhileStatement */:
-            case 249 /* SyntaxKind.ForStatement */:
-            case 250 /* SyntaxKind.ForInStatement */:
-            case 251 /* SyntaxKind.ForOfStatement */:
-            case 255 /* SyntaxKind.WithStatement */:
-            case 256 /* SyntaxKind.SwitchStatement */:
-            case 297 /* SyntaxKind.CaseClause */:
-            case 298 /* SyntaxKind.DefaultClause */:
-            case 257 /* SyntaxKind.LabeledStatement */:
-            case 259 /* SyntaxKind.TryStatement */:
-            case 300 /* SyntaxKind.CatchClause */:
+            case 271 /* SyntaxKind.CaseBlock */:
+            case 243 /* SyntaxKind.Block */:
+            case 247 /* SyntaxKind.IfStatement */:
+            case 248 /* SyntaxKind.DoStatement */:
+            case 249 /* SyntaxKind.WhileStatement */:
+            case 250 /* SyntaxKind.ForStatement */:
+            case 251 /* SyntaxKind.ForInStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
+            case 256 /* SyntaxKind.WithStatement */:
+            case 257 /* SyntaxKind.SwitchStatement */:
+            case 298 /* SyntaxKind.CaseClause */:
+            case 299 /* SyntaxKind.DefaultClause */:
+            case 258 /* SyntaxKind.LabeledStatement */:
+            case 260 /* SyntaxKind.TryStatement */:
+            case 301 /* SyntaxKind.CatchClause */:
                 return node.forEachChild(this);
         }
         return false;
@@ -605,7 +605,7 @@ export function isConstTypeReference(node) {
         isIdentifierNamed(node.typeName, 'const'));
 }
 function isConstAssertionNode(node) {
-    return ((node.kind === 235 /* SyntaxKind.AsExpression */ || node.kind === 217 /* SyntaxKind.TypeAssertionExpression */) &&
+    return ((node.kind === 236 /* SyntaxKind.AsExpression */ || node.kind === 218 /* SyntaxKind.TypeAssertionExpression */) &&
         isConstTypeReference(getType(node)));
 }
 /** Whether a nested expression is inside an `as const`, as far as syntax decides. */
@@ -613,17 +613,17 @@ export function isInConstContext(node) {
     let current = node.parent;
     while (current !== undefined) {
         switch (current.kind) {
-            case 235 /* SyntaxKind.AsExpression */:
-            case 217 /* SyntaxKind.TypeAssertionExpression */:
+            case 236 /* SyntaxKind.AsExpression */:
+            case 218 /* SyntaxKind.TypeAssertionExpression */:
                 return isConstAssertionNode(current);
-            case 210 /* SyntaxKind.ArrayLiteralExpression */:
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
-            case 231 /* SyntaxKind.SpreadElement */:
-            case 303 /* SyntaxKind.PropertyAssignment */:
-            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
-            case 240 /* SyntaxKind.TemplateSpan */:
-            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            case 211 /* SyntaxKind.ArrayLiteralExpression */:
+            case 212 /* SyntaxKind.ObjectLiteralExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
+            case 232 /* SyntaxKind.SpreadElement */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
+            case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 241 /* SyntaxKind.TemplateSpan */:
+            case 226 /* SyntaxKind.PrefixUnaryExpression */:
                 current = current.parent;
                 continue;
         }
@@ -635,17 +635,17 @@ export function isInConstContext(node) {
 function isContextuallyTyped(node) {
     for (let current = node.parent; current !== undefined; current = current.parent) {
         switch (current.kind) {
-            case 214 /* SyntaxKind.CallExpression */:
-            case 239 /* SyntaxKind.SatisfiesExpression */:
-            case 285 /* SyntaxKind.JsxElement */:
-            case 295 /* SyntaxKind.JsxExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
+            case 240 /* SyntaxKind.SatisfiesExpression */:
+            case 286 /* SyntaxKind.JsxElement */:
+            case 296 /* SyntaxKind.JsxExpression */:
                 return true;
-            case 261 /* SyntaxKind.VariableDeclaration */:
-            case 170 /* SyntaxKind.Parameter */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 172 /* SyntaxKind.PropertySignature */:
-            case 235 /* SyntaxKind.AsExpression */:
-            case 217 /* SyntaxKind.TypeAssertionExpression */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
+            case 171 /* SyntaxKind.Parameter */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 173 /* SyntaxKind.PropertySignature */:
+            case 236 /* SyntaxKind.AsExpression */:
+            case 218 /* SyntaxKind.TypeAssertionExpression */:
                 if (getType(current) !== undefined && !isConstAssertionNode(current))
                     return true;
                 break;
@@ -660,7 +660,7 @@ function objectLiteralErrorNodes(node) {
             errorNodes.push(property);
             continue;
         }
-        if (property.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */ || property.kind === 305 /* SyntaxKind.SpreadAssignment */) {
+        if (property.kind === 305 /* SyntaxKind.ShorthandPropertyAssignment */ || property.kind === 306 /* SyntaxKind.SpreadAssignment */) {
             errorNodes.push(property);
             continue;
         }
@@ -669,7 +669,7 @@ function objectLiteralErrorNodes(node) {
             errorNodes.push(name);
         else if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
             errorNodes.push(property);
-        else if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && !isPrimitiveLiteral(getExpression(name)))
+        else if (name.kind === 169 /* SyntaxKind.ComputedPropertyName */ && !isPrimitiveLiteral(getExpression(name)))
             errorNodes.push(name);
     }
     return errorNodes;
@@ -682,7 +682,7 @@ function isPrimitiveLiteral(node) {
         case 10 /* SyntaxKind.StringLiteral */:
         case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
             return true;
-        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+        case 226 /* SyntaxKind.PrefixUnaryExpression */: {
             const unary = node;
             return ((unary.operator === 40 /* SyntaxKind.MinusToken */ || unary.operator === 39 /* SyntaxKind.PlusToken */) &&
                 unary.operand.kind === 8 /* SyntaxKind.NumericLiteral */);
@@ -703,23 +703,23 @@ export function lastRequiredParameterIndex(parameters) {
 }
 function typeNodeCouldReferToUndefined(node) {
     let current = node;
-    while (current.kind === 197 /* SyntaxKind.ParenthesizedType */)
+    while (current.kind === 198 /* SyntaxKind.ParenthesizedType */)
         current = getType(current);
     switch (current.kind) {
         // These need symbols or types to know.
-        case 184 /* SyntaxKind.TypeReference */:
-        case 200 /* SyntaxKind.IndexedAccessType */:
-        case 187 /* SyntaxKind.TypeQuery */:
-        case 191 /* SyntaxKind.OptionalType */:
-        case 192 /* SyntaxKind.RestType */:
-        case 206 /* SyntaxKind.ImportType */:
-        case 195 /* SyntaxKind.ConditionalType */:
-        case 199 /* SyntaxKind.TypeOperator */:
-        case 183 /* SyntaxKind.TypePredicate */:
+        case 185 /* SyntaxKind.TypeReference */:
+        case 201 /* SyntaxKind.IndexedAccessType */:
+        case 188 /* SyntaxKind.TypeQuery */:
+        case 192 /* SyntaxKind.OptionalType */:
+        case 193 /* SyntaxKind.RestType */:
+        case 207 /* SyntaxKind.ImportType */:
+        case 196 /* SyntaxKind.ConditionalType */:
+        case 200 /* SyntaxKind.TypeOperator */:
+        case 184 /* SyntaxKind.TypePredicate */:
         case 157 /* SyntaxKind.UndefinedKeyword */:
             return true;
-        case 193 /* SyntaxKind.UnionType */:
-        case 194 /* SyntaxKind.IntersectionType */:
+        case 194 /* SyntaxKind.UnionType */:
+        case 195 /* SyntaxKind.IntersectionType */:
             // Intersections are treated like unions, as tsgo does.
             for (const type of typesOf(current))
                 if (typeNodeCouldReferToUndefined(type))
@@ -765,7 +765,7 @@ function typeNodeHasUndefined(node) {
         node.kind === 132 /* SyntaxKind.AnyKeyword */ ||
         node.kind === 159 /* SyntaxKind.UnknownKeyword */)
         return true;
-    if (node.kind === 197 /* SyntaxKind.ParenthesizedType */)
+    if (node.kind === 198 /* SyntaxKind.ParenthesizedType */)
         return typeNodeHasUndefined(getType(node));
     if (node instanceof UnionTypeNode) {
         for (const member of node.types.nodes)

package/dist/api/compiler/transformers/declarations-resolver.d.ts

@@ -1,6 +1,5 @@
 import type { ImportDeclaration, ModifierFlags, Node, SourceFile, FileReference } from '../ast.js';
 import type { EmitContext } from '../printer/emit-context.js';
-import type { ModuleKind } from '../options.js';
 import type { Symbol, SymbolFlags } from '../symbol.js';
 import { EmitResolver } from './emit-resolver.js';
 export declare const enum SymbolAccessibility {
@@ -125,8 +124,6 @@ export declare abstract class DeclarationEmitResolver extends EmitResolver {
     abstract isExpandoFunctionDeclaration(node: Node): boolean;
     /** Types: the declarations of properties assigned to a function. */
     abstract getExpandoPropertyDeclarations(node: Node): Node[];
-    /** The `resolution-mode` of import attributes, or undefined. */
-    abstract getResolutionModeOverride(node: Node): ModuleKind | undefined;
     /** The program file a `/// <reference path>` names. */
     abstract getSourceFileFromReference(file: SourceFile, reference: FileReference): SourceFile | undefined;
     /** The class member a JavaScript `this.x = …` assignment declares. */

package/dist/api/compiler/transformers/declarations-syntactic.d.ts

@@ -1,5 +1,5 @@
 import { FileReference, Identifier, type ImportDeclaration, ModifierFlags, type Node, SourceFile, type EntityName } from '../ast.js';
-import type { CompilerOptions, ModuleKind } from '../options.js';
+import type { CompilerOptions } from '../options.js';
 import type { EmitContext } from '../printer/emit-context.js';
 import type { SyntacticEmitResolver } from './emit-resolver.js';
 import type { TypeReferenceSerializationKind } from './type-serialization.js';
@@ -86,7 +86,6 @@ export declare class SyntacticDeclarationEmitResolver extends DeclarationEmitRes
     getJsxFactoryEntity(file: SourceFile): EntityName | undefined;
     getJsxFragmentFactoryEntity(file: SourceFile): EntityName | undefined;
     getTypeReferenceSerializationKind(typeName: Node, location: Node | undefined): TypeReferenceSerializationKind;
-    getResolutionModeOverride(node: Node): ModuleKind | undefined;
     getSourceFileFromReference(file: SourceFile, reference: FileReference): SourceFile | undefined;
     getReferencedMemberValueDeclaration(node: Node): Node | undefined;
     isThisPropertyAssignmentDeclarationRedundant(_node: Node): boolean;