tsc-ts 0.0.9 → 0.1.0

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

@@ -17,7 +17,7 @@ export function isParameterPropertyDeclaration(node, parent) {
     return (node instanceof ParameterDeclaration &&
         hasSyntacticModifier(node, 31 /* ModifierFlags.ParameterPropertyModifier */) &&
         parent !== undefined &&
-        parent.kind === 177 /* SyntaxKind.Constructor */);
+        parent.kind === 178 /* SyntaxKind.Constructor */);
 }
 /** `/** @type {T} *\/ (expr)` in a JavaScript file. */
 export function isJSDocTypeAssertion(node) {
@@ -68,21 +68,21 @@ class ModuleInstanceStates {
     }
     worker(node, ancestors) {
         switch (node.kind) {
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
-            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
                 return 1 /* ModuleInstanceState.NonInstantiated */;
-            case 267 /* SyntaxKind.EnumDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
                 if (hasSyntacticModifier(node, 4096 /* ModifierFlags.Const */))
                     return 3 /* ModuleInstanceState.ConstEnumOnly */;
                 break;
-            case 273 /* SyntaxKind.ImportDeclaration */:
-            case 346 /* SyntaxKind.JSImportDeclaration */:
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
+            case 347 /* SyntaxKind.JSImportDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
                 if (!hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
                     return 1 /* ModuleInstanceState.NonInstantiated */;
                 break;
-            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
                 if (node instanceof ExportDeclaration &&
                     node.moduleSpecifier === undefined &&
                     node.exportClause instanceof NamedExports) {
@@ -103,7 +103,7 @@ class ModuleInstanceStates {
                     return state;
                 }
                 break;
-            case 269 /* SyntaxKind.ModuleBlock */:
+            case 270 /* SyntaxKind.ModuleBlock */:
                 if (node instanceof ModuleBlock) {
                     let state = 1 /* ModuleInstanceState.NonInstantiated */;
                     const block = node;
@@ -119,7 +119,7 @@ class ModuleInstanceStates {
                     return state;
                 }
                 break;
-            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
                 if (node instanceof ModuleDeclaration)
                     return this.ofModule(node, ancestors);
                 break;
@@ -146,7 +146,7 @@ class ModuleInstanceStates {
                     found = state;
                 if (found === 2 /* ModuleInstanceState.Instantiated */)
                     return found;
-                if (statement.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */)
+                if (statement.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */)
                     found = 2 /* ModuleInstanceState.Instantiated */;
             }
             if (found !== 0 /* ModuleInstanceState.Unknown */)
@@ -172,81 +172,81 @@ export function isIdentifierReference(name, parent) {
     if (parent === undefined)
         return false;
     switch (parent.kind) {
-        case 227 /* SyntaxKind.BinaryExpression */:
-        case 225 /* SyntaxKind.PrefixUnaryExpression */:
-        case 226 /* SyntaxKind.PostfixUnaryExpression */:
-        case 230 /* SyntaxKind.YieldExpression */:
-        case 235 /* SyntaxKind.AsExpression */:
-        case 239 /* SyntaxKind.SatisfiesExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
-        case 236 /* SyntaxKind.NonNullExpression */:
-        case 231 /* SyntaxKind.SpreadElement */:
-        case 305 /* SyntaxKind.SpreadAssignment */:
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
-        case 221 /* SyntaxKind.DeleteExpression */:
-        case 222 /* SyntaxKind.TypeOfExpression */:
-        case 223 /* SyntaxKind.VoidExpression */:
-        case 224 /* SyntaxKind.AwaitExpression */:
-        case 217 /* SyntaxKind.TypeAssertionExpression */:
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
-        case 294 /* SyntaxKind.JsxSpreadAttribute */:
-        case 295 /* SyntaxKind.JsxExpression */:
-        case 348 /* SyntaxKind.PartiallyEmittedExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
+        case 226 /* SyntaxKind.PrefixUnaryExpression */:
+        case 227 /* SyntaxKind.PostfixUnaryExpression */:
+        case 231 /* SyntaxKind.YieldExpression */:
+        case 236 /* SyntaxKind.AsExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 232 /* SyntaxKind.SpreadElement */:
+        case 306 /* SyntaxKind.SpreadAssignment */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 222 /* SyntaxKind.DeleteExpression */:
+        case 223 /* SyntaxKind.TypeOfExpression */:
+        case 224 /* SyntaxKind.VoidExpression */:
+        case 225 /* SyntaxKind.AwaitExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 295 /* SyntaxKind.JsxSpreadAttribute */:
+        case 296 /* SyntaxKind.JsxExpression */:
+        case 349 /* SyntaxKind.PartiallyEmittedExpression */:
             return true;
-        case 168 /* SyntaxKind.ComputedPropertyName */:
-        case 171 /* SyntaxKind.Decorator */:
-        case 246 /* SyntaxKind.IfStatement */:
-        case 247 /* SyntaxKind.DoStatement */:
-        case 248 /* SyntaxKind.WhileStatement */:
-        case 255 /* SyntaxKind.WithStatement */:
-        case 254 /* SyntaxKind.ReturnStatement */:
-        case 256 /* SyntaxKind.SwitchStatement */:
-        case 297 /* SyntaxKind.CaseClause */:
-        case 258 /* SyntaxKind.ThrowStatement */:
-        case 245 /* SyntaxKind.ExpressionStatement */:
-        case 278 /* SyntaxKind.ExportAssignment */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 240 /* SyntaxKind.TemplateSpan */:
+        case 169 /* SyntaxKind.ComputedPropertyName */:
+        case 172 /* SyntaxKind.Decorator */:
+        case 247 /* SyntaxKind.IfStatement */:
+        case 248 /* SyntaxKind.DoStatement */:
+        case 249 /* SyntaxKind.WhileStatement */:
+        case 256 /* SyntaxKind.WithStatement */:
+        case 255 /* SyntaxKind.ReturnStatement */:
+        case 257 /* SyntaxKind.SwitchStatement */:
+        case 298 /* SyntaxKind.CaseClause */:
+        case 259 /* SyntaxKind.ThrowStatement */:
+        case 246 /* SyntaxKind.ExpressionStatement */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 241 /* SyntaxKind.TemplateSpan */:
             return getExpression(parent) === name;
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 170 /* SyntaxKind.Parameter */:
-        case 209 /* SyntaxKind.BindingElement */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 306 /* SyntaxKind.EnumMember */:
-        case 292 /* SyntaxKind.JsxAttribute */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 307 /* SyntaxKind.EnumMember */:
+        case 293 /* SyntaxKind.JsxAttribute */:
             return getInitializer(parent) === name;
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
             return parent instanceof ShorthandPropertyAssignment && parent.objectAssignmentInitializer === name;
-        case 249 /* SyntaxKind.ForStatement */:
+        case 250 /* SyntaxKind.ForStatement */:
             return (parent instanceof ForStatement &&
                 (parent.initializer === name || parent.condition === name || parent.incrementor === name));
-        case 250 /* SyntaxKind.ForInStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
             return getInitializer(parent) === name || getExpression(parent) === name;
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
             return parent instanceof ImportEqualsDeclaration && parent.moduleReference === name;
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return getBody(parent) === name;
-        case 228 /* SyntaxKind.ConditionalExpression */:
+        case 229 /* SyntaxKind.ConditionalExpression */:
             return (parent instanceof ConditionalExpression &&
                 (parent.condition === name || parent.whenTrue === name || parent.whenFalse === name));
-        case 214 /* SyntaxKind.CallExpression */:
-        case 215 /* SyntaxKind.NewExpression */: {
+        case 215 /* SyntaxKind.CallExpression */:
+        case 216 /* SyntaxKind.NewExpression */: {
             if (getExpression(parent) === name)
                 return true;
             const args = getArguments(parent);
             return args !== undefined && args.nodes.indexOf(name) >= 0;
         }
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
             return parent instanceof TaggedTemplateExpression && parent.tag === name;
-        case 302 /* SyntaxKind.ImportAttribute */:
+        case 303 /* SyntaxKind.ImportAttribute */:
             return parent instanceof ImportAttribute && parent.value === name;
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 288 /* SyntaxKind.JsxClosingElement */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 289 /* SyntaxKind.JsxClosingElement */:
             return getTagName(parent) === name;
     }
     return false;
@@ -294,21 +294,21 @@ export function restoreEnclosingLabel(factory, node, outermost) {
 }
 export function isOuterExpression(node, kinds) {
     switch (node.kind) {
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
             return ((kinds & 1 /* OuterExpressionKinds.Parentheses */) !== 0 &&
                 !((kinds & 64 /* OuterExpressionKinds.ExcludeJSDocTypeAssertion */) !== 0 && isJSDocTypeAssertion(node)));
-        case 217 /* SyntaxKind.TypeAssertionExpression */:
-        case 235 /* SyntaxKind.AsExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
+        case 236 /* SyntaxKind.AsExpression */:
             return (kinds & 2 /* OuterExpressionKinds.TypeAssertions */) !== 0;
-        case 239 /* SyntaxKind.SatisfiesExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
             return (kinds & (16 /* OuterExpressionKinds.ExpressionsWithTypeArguments */ | 32 /* OuterExpressionKinds.Satisfies */)) !== 0;
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
             return (kinds & 16 /* OuterExpressionKinds.ExpressionsWithTypeArguments */) !== 0;
-        case 236 /* SyntaxKind.NonNullExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
             return (kinds & 4 /* OuterExpressionKinds.NonNullAssertions */) !== 0;
-        case 348 /* SyntaxKind.PartiallyEmittedExpression */:
+        case 349 /* SyntaxKind.PartiallyEmittedExpression */:
             return (kinds & 8 /* OuterExpressionKinds.PartiallyEmittedExpressions */) !== 0;
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             if (node instanceof BinaryExpression) {
                 const operator = node.operatorToken.kind;
                 if (operator === 63 /* SyntaxKind.EqualsToken */)