tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/transformers/decorator-metadata.d.ts

@@ -8,7 +8,7 @@ export declare class DecoratorMetadata extends Transformer {
     private readonly legacyDecorators;
     private readonly facts;
     private readonly serializer;
-    /** The class whose members are visited. */
+    /** The class, or object literal, whose members are visited. */
     private parentClass;
     constructor(context: EmitContext, options: CompilerOptions, resolver: EmitResolver, facts: SyntaxFacts);
     visit(node: Node): Node | undefined;

package/dist/api/compiler/transformers/decorator-metadata.js

@@ -14,7 +14,7 @@ export class DecoratorMetadata extends Transformer {
     legacyDecorators;
     facts;
     serializer;
-    /** The class whose members are visited. */
+    /** The class, or object literal, whose members are visited. */
     parentClass;
     constructor(context, options, resolver, facts) {
         super(context);
@@ -27,38 +27,46 @@ export class DecoratorMetadata extends Transformer {
         if (!this.facts.has(node, 262144 /* SubtreeFacts.ContainsDecorators */))
             return node;
         switch (node.kind) {
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 232 /* SyntaxKind.ClassExpression */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */:
                 return this.visitClass(node);
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 212 /* SyntaxKind.ObjectLiteralExpression */: {
+                // Members of an object literal are not class elements and get no metadata.
+                const saved = this.parentClass;
+                this.parentClass = node;
+                const updated = this.visitEachChild(node);
+                this.parentClass = saved;
+                return updated;
+            }
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 if (node instanceof PropertyDeclaration) {
                     if (!hasDecorators(node))
                         return this.visitEachChild(node);
                     return this.factory.updatePropertyDeclaration(node, this.injectClassElementTypeMetadata(this.visitModifiers(node.modifiers), node), this.visitNode(node.name), node.postfixToken, this.visitNode(node.type), this.visitNode(node.initializer));
                 }
                 break;
-            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
                 if (node instanceof MethodDeclaration) {
                     if (!hasDecorators(node) && !hasDecoratedParameter(node))
                         return this.visitEachChild(node);
                     return this.factory.updateMethodDeclaration(node, this.injectClassElementTypeMetadata(this.visitModifiers(node.modifiers), node), node.asteriskToken, this.visitNode(node.name), node.postfixToken, this.visitNodes(node.typeParameters), this.visitNodes(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), this.visitNode(node.body));
                 }
                 break;
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 if (node instanceof SetAccessorDeclaration) {
                     if (!hasDecorators(node) && !hasDecoratedParameter(node))
                         return this.visitEachChild(node);
                     return this.factory.updateSetAccessorDeclaration(node, this.injectClassElementTypeMetadata(this.visitModifiers(node.modifiers), node), this.visitNode(node.name), this.visitNodes(node.typeParameters), this.visitNodes(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), this.visitNode(node.body));
                 }
                 break;
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 if (node instanceof GetAccessorDeclaration) {
                     if (!hasDecorators(node))
                         return this.visitEachChild(node);
                     return this.factory.updateGetAccessorDeclaration(node, this.injectClassElementTypeMetadata(this.visitModifiers(node.modifiers), node), this.visitNode(node.name), this.visitNodes(node.typeParameters), this.visitNodes(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), this.visitNode(node.body));
                 }
                 break;
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 if (node instanceof SourceFile) {
                     this.parentClass = undefined;
                     this.serializer.currentLexicalScope = node;
@@ -70,9 +78,9 @@ export class DecoratorMetadata extends Transformer {
                     return updated;
                 }
                 break;
-            case 269 /* SyntaxKind.ModuleBlock */:
-            case 242 /* SyntaxKind.Block */:
-            case 270 /* SyntaxKind.CaseBlock */: {
+            case 270 /* SyntaxKind.ModuleBlock */:
+            case 243 /* SyntaxKind.Block */:
+            case 271 /* SyntaxKind.CaseBlock */: {
                 const saved = this.serializer.currentLexicalScope;
                 this.serializer.currentLexicalScope = node;
                 const updated = this.visitEachChild(node);
@@ -166,15 +174,15 @@ export class DecoratorMetadata extends Transformer {
         const serializer = this.serializer;
         serializer.currentNameScope = container;
         switch (node.kind) {
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 decorators.push(factory.created(new Decorator(createMetadataHelper(factory, 'design:type', serializer.serializeTypeOfNode(node, container)))));
         }
         if (shouldAddParamTypesMetadata(node))
             decorators.push(factory.created(new Decorator(createMetadataHelper(factory, 'design:paramtypes', serializer.serializeParameterTypesOfNode(node, container)))));
-        if (node.kind === 175 /* SyntaxKind.MethodDeclaration */)
+        if (node.kind === 176 /* SyntaxKind.MethodDeclaration */)
             decorators.push(factory.created(new Decorator(createMetadataHelper(factory, 'design:returntype', serializer.serializeReturnTypeOfNode(node)))));
         serializer.currentNameScope = undefined;
         return decorators;
@@ -182,12 +190,12 @@ export class DecoratorMetadata extends Transformer {
 }
 function shouldAddParamTypesMetadata(node) {
     switch (node.kind) {
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 232 /* SyntaxKind.ClassExpression */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 233 /* SyntaxKind.ClassExpression */:
             return getFirstConstructorWithBody(node) !== undefined;
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
             return true;
     }
     return false;
@@ -228,15 +236,15 @@ export class MetadataSerializer {
     serializeTypeOfNode(node, container) {
         const factory = this.context.factory;
         switch (node.kind) {
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 170 /* SyntaxKind.Parameter */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 171 /* SyntaxKind.Parameter */:
                 return this.serializeTypeNode(getType(node));
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 return this.serializeTypeNode(getAccessorTypeNode(node, container));
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 232 /* SyntaxKind.ClassExpression */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
                 return factory.createIdentifier('Function');
         }
         return factory.createVoidZero();
@@ -282,24 +290,24 @@ export class MetadataSerializer {
             case 157 /* SyntaxKind.UndefinedKeyword */:
             case 146 /* SyntaxKind.NeverKeyword */:
                 return factory.createVoidZero();
-            case 185 /* SyntaxKind.FunctionType */:
-            case 186 /* SyntaxKind.ConstructorType */:
+            case 186 /* SyntaxKind.FunctionType */:
+            case 187 /* SyntaxKind.ConstructorType */:
                 return factory.createIdentifier('Function');
-            case 189 /* SyntaxKind.ArrayType */:
-            case 190 /* SyntaxKind.TupleType */:
+            case 190 /* SyntaxKind.ArrayType */:
+            case 191 /* SyntaxKind.TupleType */:
                 return factory.createIdentifier('Array');
-            case 183 /* SyntaxKind.TypePredicate */:
+            case 184 /* SyntaxKind.TypePredicate */:
                 if (node instanceof TypePredicateNode && node.assertsModifier !== undefined)
                     return factory.createVoidZero();
                 return factory.createIdentifier('Boolean');
             case 135 /* SyntaxKind.BooleanKeyword */:
                 return factory.createIdentifier('Boolean');
-            case 204 /* SyntaxKind.TemplateLiteralType */:
+            case 205 /* SyntaxKind.TemplateLiteralType */:
             case 154 /* SyntaxKind.StringKeyword */:
                 return factory.createIdentifier('String');
             case 151 /* SyntaxKind.ObjectKeyword */:
                 return factory.createIdentifier('Object');
-            case 202 /* SyntaxKind.LiteralType */:
+            case 203 /* SyntaxKind.LiteralType */:
                 if (node instanceof LiteralTypeNode)
                     return this.serializeLiteralOfLiteralTypeNode(node.literal);
                 break;
@@ -309,19 +317,19 @@ export class MetadataSerializer {
                 return this.serializeBigIntConstructor();
             case 155 /* SyntaxKind.SymbolKeyword */:
                 return factory.createIdentifier('Symbol');
-            case 184 /* SyntaxKind.TypeReference */:
+            case 185 /* SyntaxKind.TypeReference */:
                 if (node instanceof TypeReferenceNode)
                     return this.serializeTypeReferenceNode(node);
                 break;
-            case 194 /* SyntaxKind.IntersectionType */:
+            case 195 /* SyntaxKind.IntersectionType */:
                 if (node instanceof IntersectionTypeNode)
                     return this.serializeUnionOrIntersectionConstituents(node.types.nodes, true);
                 break;
-            case 193 /* SyntaxKind.UnionType */:
+            case 194 /* SyntaxKind.UnionType */:
                 if (node instanceof UnionTypeNode)
                     return this.serializeUnionOrIntersectionConstituents(node.types.nodes, false);
                 break;
-            case 195 /* SyntaxKind.ConditionalType */:
+            case 196 /* SyntaxKind.ConditionalType */:
                 if (node instanceof ConditionalTypeNode) {
                     const saved = this.serializingConditionalTypeBranch;
                     this.serializingConditionalTypeBranch = true;
@@ -330,20 +338,20 @@ export class MetadataSerializer {
                     return result;
                 }
                 break;
-            case 199 /* SyntaxKind.TypeOperator */:
+            case 200 /* SyntaxKind.TypeOperator */:
                 // `unique symbol` falls back to `Object` as in tsgo.
                 if (node instanceof TypeOperatorNode && node.operator === 148 /* SyntaxKind.ReadonlyKeyword */)
                     return this.serializeTypeNode(node.type);
                 break;
-            case 311 /* SyntaxKind.JSDocNullableType */:
+            case 312 /* SyntaxKind.JSDocNullableType */:
                 if (node instanceof JSDocNullableType)
                     return this.serializeTypeNode(node.type);
                 break;
-            case 312 /* SyntaxKind.JSDocNonNullableType */:
+            case 313 /* SyntaxKind.JSDocNonNullableType */:
                 if (node instanceof JSDocNonNullableType)
                     return this.serializeTypeNode(node.type);
                 break;
-            case 313 /* SyntaxKind.JSDocOptionalType */:
+            case 314 /* SyntaxKind.JSDocOptionalType */:
                 if (node instanceof JSDocOptionalType)
                     return this.serializeTypeNode(node.type);
                 break;
@@ -387,7 +395,7 @@ export class MetadataSerializer {
             case 10 /* SyntaxKind.StringLiteral */:
             case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
                 return factory.createIdentifier('String');
-            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            case 226 /* SyntaxKind.PrefixUnaryExpression */:
                 if (node instanceof PrefixUnaryExpression)
                     return this.serializeLiteralOfLiteralTypeNode(node.operand);
                 break;
@@ -542,7 +550,7 @@ function getAccessorTypeNode(node, container) {
 }
 /** A getter's metadata uses the parameters of its setter. */
 function getParametersOfDecoratedDeclaration(node, container) {
-    if (node.kind === 178 /* SyntaxKind.GetAccessor */) {
+    if (node.kind === 179 /* SyntaxKind.GetAccessor */) {
         const accessors = getAllAccessorDeclarations(getMembers(container).nodes, node);
         if (accessors.setAccessor !== undefined)
             return getParameters(accessors.setAccessor).nodes;

package/dist/api/compiler/transformers/decorator-utilities.js

@@ -18,7 +18,7 @@ export function getDecorators(node) {
     return decorators;
 }
 export function isAccessor(node) {
-    return node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */;
+    return node.kind === 179 /* SyntaxKind.GetAccessor */ || node.kind === 180 /* SyntaxKind.SetAccessor */;
 }
 export function getFirstConstructorWithBody(node) {
     const members = getMembers(node);
@@ -26,7 +26,7 @@ export function getFirstConstructorWithBody(node) {
         return undefined;
     for (let i = 0; i < members.nodes.length; i++) {
         const member = members.nodes[i];
-        if (member.kind === 177 /* SyntaxKind.Constructor */ && nodeIsPresent(getBody(member)))
+        if (member.kind === 178 /* SyntaxKind.Constructor */ && nodeIsPresent(getBody(member)))
             return member;
     }
     return undefined;
@@ -38,34 +38,34 @@ export function nodeCanBeDecorated(legacy, node, parent, grandparent) {
     if (legacy && name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
         return false;
     switch (node.kind) {
-        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
             return true;
-        case 232 /* SyntaxKind.ClassExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
             return !legacy;
-        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
             return (parent !== undefined &&
                 (legacy
-                    ? parent.kind === 264 /* SyntaxKind.ClassDeclaration */
+                    ? parent.kind === 265 /* SyntaxKind.ClassDeclaration */
                     : isClassLike(parent) && !hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */ | 128 /* ModifierFlags.Ambient */)));
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             return (parent !== undefined &&
                 getBody(node) !== undefined &&
-                (legacy ? parent.kind === 264 /* SyntaxKind.ClassDeclaration */ : isClassLike(parent)));
-        case 170 /* SyntaxKind.Parameter */: {
+                (legacy ? parent.kind === 265 /* SyntaxKind.ClassDeclaration */ : isClassLike(parent)));
+        case 171 /* SyntaxKind.Parameter */: {
             // Parameter decorators aren't standard yet.
             if (!legacy || parent === undefined || getBody(parent) === undefined)
                 return false;
-            if (parent.kind !== 177 /* SyntaxKind.Constructor */ &&
-                parent.kind !== 175 /* SyntaxKind.MethodDeclaration */ &&
-                parent.kind !== 179 /* SyntaxKind.SetAccessor */)
+            if (parent.kind !== 178 /* SyntaxKind.Constructor */ &&
+                parent.kind !== 176 /* SyntaxKind.MethodDeclaration */ &&
+                parent.kind !== 180 /* SyntaxKind.SetAccessor */)
                 return false;
             const parameters = getParameters(parent);
             const thisParameter = parameters !== undefined && parameters.nodes.length > 0 && isThisParameter(parameters.nodes[0])
                 ? parameters.nodes[0]
                 : undefined;
-            return thisParameter !== node && grandparent !== undefined && grandparent.kind === 264 /* SyntaxKind.ClassDeclaration */;
+            return thisParameter !== node && grandparent !== undefined && grandparent.kind === 265 /* SyntaxKind.ClassDeclaration */;
         }
     }
     return false;
@@ -79,17 +79,17 @@ export function nodeOrChildIsDecorated(legacy, node, parent, grandparent) {
 /** Whether a member of a class, or a parameter of a method, setter or constructor, is decorated. */
 export function childIsDecorated(legacy, node, parent) {
     switch (node.kind) {
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 232 /* SyntaxKind.ClassExpression */: {
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 233 /* SyntaxKind.ClassExpression */: {
             const members = getMembers(node).nodes;
             for (let i = 0; i < members.length; i++)
                 if (nodeOrChildIsDecorated(legacy, members[i], node, parent))
                     return true;
             return false;
         }
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 177 /* SyntaxKind.Constructor */: {
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 178 /* SyntaxKind.Constructor */: {
             const parameters = getParameters(node).nodes;
             for (let i = 0; i < parameters.length; i++)
                 if (nodeIsDecorated(legacy, parameters[i], node, parent))
@@ -115,7 +115,7 @@ export function classElementOrClassElementParameterIsDecorated(legacy, node, par
         if (accessors.setAccessor !== undefined)
             parameters = getParameters(accessors.setAccessor).nodes;
     }
-    else if (node.kind === 175 /* SyntaxKind.MethodDeclaration */)
+    else if (node.kind === 176 /* SyntaxKind.MethodDeclaration */)
         parameters = getParameters(node).nodes;
     if (nodeIsDecorated(legacy, node, parent, undefined))
         return true;
@@ -150,7 +150,7 @@ export class AllAccessorDeclarations {
 }
 /** `accessor` and the other accessor among `members` with the same name and staticness. */
 export function getAllAccessorDeclarations(members, accessor) {
-    const otherKind = accessor.kind === 179 /* SyntaxKind.SetAccessor */ ? 178 /* SyntaxKind.GetAccessor */ : 179 /* SyntaxKind.SetAccessor */;
+    const otherKind = accessor.kind === 180 /* SyntaxKind.SetAccessor */ ? 179 /* SyntaxKind.GetAccessor */ : 180 /* SyntaxKind.SetAccessor */;
     let other = undefined;
     // Dynamic names only match through the checker's symbols.
     if (!hasDynamicName(accessor)) {
@@ -167,7 +167,7 @@ export function getAllAccessorDeclarations(members, accessor) {
     const otherFirst = other !== undefined && other.pos < accessor.pos;
     const first = otherFirst ? other : accessor;
     const second = otherFirst ? accessor : other;
-    return accessor.kind === 179 /* SyntaxKind.SetAccessor */
+    return accessor.kind === 180 /* SyntaxKind.SetAccessor */
         ? new AllAccessorDeclarations(first, second, other, accessor)
         : new AllAccessorDeclarations(first, second, accessor, other);
 }
@@ -187,7 +187,7 @@ export function getPropertyNameForPropertyNameNode(name) {
 }
 /** The range of `node` after its modifiers, for source maps of what replaces it. */
 export function moveRangePastModifiers(node) {
-    if (node.kind === 173 /* SyntaxKind.PropertyDeclaration */ || node.kind === 175 /* SyntaxKind.MethodDeclaration */)
+    if (node.kind === 174 /* SyntaxKind.PropertyDeclaration */ || node.kind === 176 /* SyntaxKind.MethodDeclaration */)
         return new TextRange(getName(node).pos, node.end);
     const modifiers = getModifiers(node);
     if (modifiers !== undefined && modifiers.nodes.length > 0) {

package/dist/api/compiler/transformers/destructuring.js

@@ -124,7 +124,8 @@ class Flattener {
             if (this.hoistTempVariables) {
                 const value = factory.inlineExpressions(this.expressions);
                 this.expressions = [];
-                this.emitBinding(temp, value, -1, -1, undefined);
+                // tsgo gives this declaration the empty range at the start of the file (core.TextRange{}), not a synthesized one.
+                this.emitBinding(temp, value, 0, 0, undefined);
             }
             else {
                 this.visitor.context.addVariableDeclaration(temp);
@@ -189,7 +190,7 @@ class Flattener {
         const factory = this.visitor.factory;
         const list = factory.createNodeList(elements);
         if (this.binding)
-            return factory.created(new BindingPattern(object ? 207 /* SyntaxKind.ObjectBindingPattern */ : 208 /* SyntaxKind.ArrayBindingPattern */, list));
+            return factory.created(new BindingPattern(object ? 208 /* SyntaxKind.ObjectBindingPattern */ : 209 /* SyntaxKind.ArrayBindingPattern */, list));
         if (object)
             return factory.created(new ObjectLiteralExpression(list, false));
         return factory.created(new ArrayLiteralExpression(list, false));
@@ -255,9 +256,9 @@ class Flattener {
             else if (value === undefined)
                 value = this.visitor.factory.createVoidZero();
         }
-        if (target instanceof ObjectLiteralExpression || target.kind === 207 /* SyntaxKind.ObjectBindingPattern */)
+        if (target instanceof ObjectLiteralExpression || target.kind === 208 /* SyntaxKind.ObjectBindingPattern */)
             return this.flattenObjectPattern(element, target, value, pos, end);
-        if (target instanceof ArrayLiteralExpression || target.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+        if (target instanceof ArrayLiteralExpression || target.kind === 209 /* SyntaxKind.ArrayBindingPattern */)
             return this.flattenArrayPattern(element, target, value, pos, end);
         return this.emitBindingOrAssignment(target, value, pos, end, element);
     }
@@ -392,10 +393,10 @@ function isEmptyPattern(node) {
 }
 function isPattern(node) {
     switch (node.kind) {
-        case 207 /* SyntaxKind.ObjectBindingPattern */:
-        case 208 /* SyntaxKind.ArrayBindingPattern */:
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 208 /* SyntaxKind.ObjectBindingPattern */:
+        case 209 /* SyntaxKind.ArrayBindingPattern */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
             return true;
     }
     return false;
@@ -409,12 +410,12 @@ export function isSimpleCopiableExpression(node) {
         case 79 /* SyntaxKind.Identifier */:
             return true;
     }
-    return node.kind >= 82 /* SyntaxKind.FirstKeyword */ && node.kind <= 166 /* SyntaxKind.LastKeyword */;
+    return node.kind >= 82 /* SyntaxKind.FirstKeyword */ && node.kind <= 167 /* SyntaxKind.LastKeyword */;
 }
 function isDeclarationBindingElement(node) {
-    return (node.kind === 261 /* SyntaxKind.VariableDeclaration */ ||
-        node.kind === 170 /* SyntaxKind.Parameter */ ||
-        node.kind === 209 /* SyntaxKind.BindingElement */);
+    return (node.kind === 262 /* SyntaxKind.VariableDeclaration */ ||
+        node.kind === 171 /* SyntaxKind.Parameter */ ||
+        node.kind === 210 /* SyntaxKind.BindingElement */);
 }
 /** Whether an element binds identifiers to literal property names with simple defaults. */
 function isSimpleBindingOrAssignmentElement(element) {
@@ -454,9 +455,9 @@ export function getTargetOfBindingOrAssignmentElement(element) {
         return element.name;
     if (element instanceof SpreadAssignment)
         return getTargetOfBindingOrAssignmentElement(element.expression);
-    if (element.kind === 175 /* SyntaxKind.MethodDeclaration */ || element.kind === 178 /* SyntaxKind.GetAccessor */)
+    if (element.kind === 176 /* SyntaxKind.MethodDeclaration */ || element.kind === 179 /* SyntaxKind.GetAccessor */)
         return undefined;
-    if (element.kind === 179 /* SyntaxKind.SetAccessor */)
+    if (element.kind === 180 /* SyntaxKind.SetAccessor */)
         return undefined;
     if (element instanceof BinaryExpression && isAssignmentExpression(element, true))
         return getTargetOfBindingOrAssignmentElement(element.left);
@@ -522,7 +523,7 @@ function isPropertyName(node) {
         case 80 /* SyntaxKind.PrivateIdentifier */:
         case 10 /* SyntaxKind.StringLiteral */:
         case 8 /* SyntaxKind.NumericLiteral */:
-        case 168 /* SyntaxKind.ComputedPropertyName */:
+        case 169 /* SyntaxKind.ComputedPropertyName */:
         case 9 /* SyntaxKind.BigIntLiteral */:
             return true;
     }
@@ -576,7 +577,7 @@ export function convertBindingNameToTarget(visitor, name) {
     const context = visitor.context;
     const elements = name.elements.nodes;
     const converted = [];
-    const object = name.kind === 207 /* SyntaxKind.ObjectBindingPattern */;
+    const object = name.kind === 208 /* SyntaxKind.ObjectBindingPattern */;
     for (const element of elements) {
         if (element instanceof BindingElement)
             converted.push(object
@@ -604,9 +605,9 @@ function convertToArrayElement(visitor, element) {
     const name = element.name;
     if (name === undefined)
         return converted(visitor, factory.created(new OmittedExpression()), element);
-    if (element.dotDotDotToken !== undefined)
-        return converted(visitor, factory.created(new SpreadElement(name)), element);
     const target = convertBindingNameToTarget(visitor, name);
+    if (element.dotDotDotToken !== undefined)
+        return converted(visitor, factory.created(new SpreadElement(target)), element);
     if (element.initializer === undefined)
         return target;
     return converted(visitor, factory.createAssignment(target, element.initializer), element);

package/dist/api/compiler/transformers/emit-resolver.js

@@ -91,7 +91,7 @@ export class SyntacticEmitResolver extends EmitResolver {
     isTopLevelValueImportEqualsWithEntityName(node) {
         if (!(node instanceof ImportEqualsDeclaration) ||
             node.isTypeOnly ||
-            node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */ ||
+            node.moduleReference.kind === 285 /* SyntaxKind.ExternalModuleReference */ ||
             nodeIsMissing(node.moduleReference) ||
             !(node.parent instanceof SourceFile))
             return false;