json-as 1.0.0-alpha.1 → 1.0.0-alpha.2

package/transform/lib/builder.js

@@ -1,1353 +1,1275 @@
 import { isTypeOmitted, operatorTokenToString, util } from "assemblyscript/dist/assemblyscript.js";
 import { Visitor } from "./visitor.js";
 function assert(isTruish, message = "assertion error") {
-    if (!isTruish)
-        throw new Error(message);
-    return isTruish;
+  if (!isTruish) throw new Error(message);
+  return isTruish;
 }
 export class ASTBuilder extends Visitor {
-    static build(node) {
-        var builder = new ASTBuilder();
-        builder.visitNode(node);
-        return builder.finish();
-    }
-    sb = [];
-    indentLevel = 0;
-    visitNode(node) {
-        return this.visit(node);
-    }
-    visitSource(source) {
-        var statements = source.statements;
-        for (let i = 0, k = statements.length; i < k; ++i) {
-            this.visitNodeAndTerminate(statements[i]);
-        }
-    }
-    visitTypeNode(node) {
-        switch (node.kind) {
-            case 1: {
-                this.visitNamedTypeNode(node);
-                break;
-            }
-            case 2: {
-                this.visitFunctionTypeNode(node);
-                break;
-            }
-            default:
-                assert(false);
-        }
-    }
-    visitTypeName(node) {
-        this.visitIdentifierExpression(node.identifier);
-        var sb = this.sb;
-        var current = node.next;
-        while (current) {
-            sb.push(".");
-            this.visitIdentifierExpression(current.identifier);
-            current = current.next;
-        }
-    }
-    visitNamedTypeNode(node) {
-        this.visitTypeName(node.name);
-        var typeArguments = node.typeArguments;
-        if (typeArguments) {
-            let numTypeArguments = typeArguments.length;
-            let sb = this.sb;
-            if (numTypeArguments) {
-                sb.push("<");
-                this.visitTypeNode(typeArguments[0]);
-                for (let i = 1; i < numTypeArguments; ++i) {
-                    sb.push(", ");
-                    this.visitTypeNode(typeArguments[i]);
-                }
-                sb.push(">");
-            }
-            if (node.isNullable)
-                sb.push(" | null");
-        }
-    }
-    visitFunctionTypeNode(node) {
-        var isNullable = node.isNullable;
-        var sb = this.sb;
-        sb.push(isNullable ? "((" : "(");
-        var explicitThisType = node.explicitThisType;
-        if (explicitThisType) {
-            sb.push("this: ");
-            this.visitTypeNode(explicitThisType);
-        }
-        var parameters = node.parameters;
-        var numParameters = parameters.length;
-        if (numParameters) {
-            if (explicitThisType)
-                sb.push(", ");
-            this.serializeParameter(parameters[0]);
-            for (let i = 1; i < numParameters; ++i) {
-                sb.push(", ");
-                this.serializeParameter(parameters[i]);
-            }
-        }
-        var returnType = node.returnType;
-        if (returnType) {
-            sb.push(") => ");
-            this.visitTypeNode(returnType);
-        }
-        else {
-            sb.push(") => void");
-        }
-        if (isNullable)
-            sb.push(") | null");
-    }
-    visitTypeParameter(node) {
-        this.visitIdentifierExpression(node.name);
-        var extendsType = node.extendsType;
-        if (extendsType) {
-            this.sb.push(" extends ");
-            this.visitTypeNode(extendsType);
-        }
-        var defaultType = node.defaultType;
-        if (defaultType) {
-            this.sb.push("=");
-            this.visitTypeNode(defaultType);
-        }
-    }
-    visitIdentifierExpression(node) {
-        if (node.isQuoted)
-            this.visitStringLiteral(node.text);
-        else
-            this.sb.push(node.text);
-    }
-    visitArrayLiteralExpression(node) {
-        var sb = this.sb;
-        sb.push("[");
-        var elements = node.elementExpressions;
-        var numElements = elements.length;
-        if (numElements) {
-            let element = elements[0];
-            if (element)
-                this.visitNode(element);
-            for (let i = 1; i < numElements; ++i) {
-                element = elements[i];
-                sb.push(", ");
-                if (element)
-                    this.visitNode(element);
-            }
-        }
-        sb.push("]");
-    }
-    visitObjectLiteralExpression(node) {
-        var sb = this.sb;
-        var names = node.names;
-        var values = node.values;
-        var numElements = names.length;
-        assert(numElements == values.length);
-        if (numElements) {
-            sb.push("{\n");
-            util.indent(sb, ++this.indentLevel);
-            this.visitNode(names[0]);
-            sb.push(": ");
-            this.visitNode(values[0]);
-            for (let i = 1; i < numElements; ++i) {
-                sb.push(",\n");
-                util.indent(sb, this.indentLevel);
-                let name = names[i];
-                let value = values[i];
-                if (name == value) {
-                    this.visitNode(name);
-                }
-                else {
-                    this.visitNode(name);
-                    sb.push(": ");
-                    this.visitNode(value);
-                }
-            }
-            sb.push("\n");
-            util.indent(sb, --this.indentLevel);
-            sb.push("}");
-        }
-        else {
-            sb.push("{}");
-        }
-    }
-    visitAssertionExpression(node) {
-        var sb = this.sb;
-        switch (node.assertionKind) {
-            case 0: {
-                sb.push("<");
-                if (node.toType)
-                    this.visitTypeNode(node.toType);
-                sb.push(">");
-                this.visitNode(node.expression);
-                break;
-            }
-            case 1: {
-                this.visitNode(node.expression);
-                sb.push(" as ");
-                if (node.toType)
-                    this.visitTypeNode(node.toType);
-                break;
-            }
-            case 2: {
-                this.visitNode(node.expression);
-                sb.push("!");
-                break;
-            }
-            case 3: {
-                this.visitNode(node.expression);
-                sb.push(" as const");
-                break;
-            }
-            default:
-                assert(false);
-        }
-    }
-    visitBinaryExpression(node) {
-        var sb = this.sb;
-        this.visitNode(node.left);
-        sb.push(" ");
-        sb.push(operatorTokenToString(node.operator));
-        sb.push(" ");
-        this.visitNode(node.right);
-    }
-    visitCallExpression(node) {
-        this.visitNode(node.expression);
-        this.visitArguments(node.typeArguments, node.args);
-    }
-    visitArguments(typeArguments, args) {
-        var sb = this.sb;
-        if (typeArguments) {
-            let numTypeArguments = typeArguments.length;
-            if (numTypeArguments) {
-                sb.push("<");
-                this.visitTypeNode(typeArguments[0]);
-                for (let i = 1; i < numTypeArguments; ++i) {
-                    sb.push(", ");
-                    this.visitTypeNode(typeArguments[i]);
-                }
-                sb.push(">(");
-            }
-        }
-        else {
-            sb.push("(");
-        }
-        var numArgs = args.length;
-        if (numArgs) {
-            this.visitNode(args[0]);
-            for (let i = 1; i < numArgs; ++i) {
-                sb.push(", ");
-                this.visitNode(args[i]);
-            }
-        }
-        sb.push(")");
-    }
-    visitClassExpression(node) {
-        var declaration = node.declaration;
-        this.visitClassDeclaration(declaration);
-    }
-    visitCommaExpression(node) {
-        var expressions = node.expressions;
-        var numExpressions = expressions.length;
-        this.visitNode(expressions[0]);
-        var sb = this.sb;
-        for (let i = 1; i < numExpressions; ++i) {
-            sb.push(",");
-            this.visitNode(expressions[i]);
-        }
-    }
-    visitElementAccessExpression(node) {
-        var sb = this.sb;
-        this.visitNode(node.expression);
-        sb.push("[");
-        this.visitNode(node.elementExpression);
-        sb.push("]");
-    }
-    visitFunctionExpression(node) {
-        var declaration = node.declaration;
-        if (!declaration.arrowKind) {
-            if (declaration.name.text.length) {
-                this.sb.push("function ");
-            }
-            else {
-                this.sb.push("function");
-            }
-        }
-        else {
-            assert(declaration.name.text.length == 0);
-        }
-        this.visitFunctionCommon(declaration);
-    }
-    visitLiteralExpression(node) {
-        switch (node.literalKind) {
-            case 0: {
-                this.visitFloatLiteralExpression(node);
-                break;
-            }
-            case 1: {
-                this.visitIntegerLiteralExpression(node);
-                break;
-            }
-            case 2: {
-                this.visitStringLiteralExpression(node);
-                break;
-            }
-            case 3: {
-                this.visitTemplateLiteralExpression(node);
-                break;
-            }
-            case 4: {
-                this.visitRegexpLiteralExpression(node);
-                break;
-            }
-            case 5: {
-                this.visitArrayLiteralExpression(node);
-                break;
-            }
-            case 6: {
-                this.visitObjectLiteralExpression(node);
-                break;
-            }
-            default: {
-                assert(false);
-                break;
-            }
-        }
-    }
-    visitFloatLiteralExpression(node) {
-        this.sb.push(node.value.toString());
-    }
-    visitInstanceOfExpression(node) {
+  static build(node) {
+    var builder = new ASTBuilder();
+    builder.visitNode(node);
+    return builder.finish();
+  }
+  sb = [];
+  indentLevel = 0;
+  visitNode(node) {
+    return this.visit(node);
+  }
+  visitSource(source) {
+    var statements = source.statements;
+    for (let i = 0, k = statements.length; i < k; ++i) {
+      this.visitNodeAndTerminate(statements[i]);
+    }
+  }
+  visitTypeNode(node) {
+    switch (node.kind) {
+      case 1: {
+        this.visitNamedTypeNode(node);
+        break;
+      }
+      case 2: {
+        this.visitFunctionTypeNode(node);
+        break;
+      }
+      default:
+        assert(false);
+    }
+  }
+  visitTypeName(node) {
+    this.visitIdentifierExpression(node.identifier);
+    var sb = this.sb;
+    var current = node.next;
+    while (current) {
+      sb.push(".");
+      this.visitIdentifierExpression(current.identifier);
+      current = current.next;
+    }
+  }
+  visitNamedTypeNode(node) {
+    this.visitTypeName(node.name);
+    var typeArguments = node.typeArguments;
+    if (typeArguments) {
+      let numTypeArguments = typeArguments.length;
+      let sb = this.sb;
+      if (numTypeArguments) {
+        sb.push("<");
+        this.visitTypeNode(typeArguments[0]);
+        for (let i = 1; i < numTypeArguments; ++i) {
+          sb.push(", ");
+          this.visitTypeNode(typeArguments[i]);
+        }
+        sb.push(">");
+      }
+      if (node.isNullable) sb.push(" | null");
+    }
+  }
+  visitFunctionTypeNode(node) {
+    var isNullable = node.isNullable;
+    var sb = this.sb;
+    sb.push(isNullable ? "((" : "(");
+    var explicitThisType = node.explicitThisType;
+    if (explicitThisType) {
+      sb.push("this: ");
+      this.visitTypeNode(explicitThisType);
+    }
+    var parameters = node.parameters;
+    var numParameters = parameters.length;
+    if (numParameters) {
+      if (explicitThisType) sb.push(", ");
+      this.serializeParameter(parameters[0]);
+      for (let i = 1; i < numParameters; ++i) {
+        sb.push(", ");
+        this.serializeParameter(parameters[i]);
+      }
+    }
+    var returnType = node.returnType;
+    if (returnType) {
+      sb.push(") => ");
+      this.visitTypeNode(returnType);
+    } else {
+      sb.push(") => void");
+    }
+    if (isNullable) sb.push(") | null");
+  }
+  visitTypeParameter(node) {
+    this.visitIdentifierExpression(node.name);
+    var extendsType = node.extendsType;
+    if (extendsType) {
+      this.sb.push(" extends ");
+      this.visitTypeNode(extendsType);
+    }
+    var defaultType = node.defaultType;
+    if (defaultType) {
+      this.sb.push("=");
+      this.visitTypeNode(defaultType);
+    }
+  }
+  visitIdentifierExpression(node) {
+    if (node.isQuoted) this.visitStringLiteral(node.text);
+    else this.sb.push(node.text);
+  }
+  visitArrayLiteralExpression(node) {
+    var sb = this.sb;
+    sb.push("[");
+    var elements = node.elementExpressions;
+    var numElements = elements.length;
+    if (numElements) {
+      let element = elements[0];
+      if (element) this.visitNode(element);
+      for (let i = 1; i < numElements; ++i) {
+        element = elements[i];
+        sb.push(", ");
+        if (element) this.visitNode(element);
+      }
+    }
+    sb.push("]");
+  }
+  visitObjectLiteralExpression(node) {
+    var sb = this.sb;
+    var names = node.names;
+    var values = node.values;
+    var numElements = names.length;
+    assert(numElements == values.length);
+    if (numElements) {
+      sb.push("{\n");
+      util.indent(sb, ++this.indentLevel);
+      this.visitNode(names[0]);
+      sb.push(": ");
+      this.visitNode(values[0]);
+      for (let i = 1; i < numElements; ++i) {
+        sb.push(",\n");
+        util.indent(sb, this.indentLevel);
+        let name = names[i];
+        let value = values[i];
+        if (name == value) {
+          this.visitNode(name);
+        } else {
+          this.visitNode(name);
+          sb.push(": ");
+          this.visitNode(value);
+        }
+      }
+      sb.push("\n");
+      util.indent(sb, --this.indentLevel);
+      sb.push("}");
+    } else {
+      sb.push("{}");
+    }
+  }
+  visitAssertionExpression(node) {
+    var sb = this.sb;
+    switch (node.assertionKind) {
+      case 0: {
+        sb.push("<");
+        if (node.toType) this.visitTypeNode(node.toType);
+        sb.push(">");
         this.visitNode(node.expression);
-        this.sb.push(" instanceof ");
-        this.visitTypeNode(node.isType);
-    }
-    visitIntegerLiteralExpression(node) {
-        this.sb.push(i64_to_string(node.value));
-    }
-    visitStringLiteral(str) {
-        var sb = this.sb;
-        sb.push('"');
-        this.visitRawString(str, 34);
-        sb.push('"');
-    }
-    visitRawString(str, quote) {
-        var sb = this.sb;
-        var off = 0;
-        var i = 0;
-        for (let k = str.length; i < k;) {
-            switch (str.charCodeAt(i)) {
-                case 0: {
-                    if (i > off)
-                        sb.push(str.substring(off, (off = i + 1)));
-                    sb.push("\\0");
-                    off = ++i;
-                    break;
-                }
-                case 92: {
-                    if (i > off)
-                        sb.push(str.substring(off, i));
-                    off = ++i;
-                    sb.push("\\b");
-                    break;
-                }
-                case 9: {
-                    if (i > off)
-                        sb.push(str.substring(off, i));
-                    off = ++i;
-                    sb.push("\\t");
-                    break;
-                }
-                case 10: {
-                    if (i > off)
-                        sb.push(str.substring(off, i));
-                    off = ++i;
-                    sb.push("\\n");
-                    break;
-                }
-                case 11: {
-                    if (i > off)
-                        sb.push(str.substring(off, i));
-                    off = ++i;
-                    sb.push("\\v");
-                    break;
-                }
-                case 12: {
-                    if (i > off)
-                        sb.push(str.substring(off, i));
-                    off = ++i;
-                    sb.push("\\f");
-                    break;
-                }
-                case 13: {
-                    if (i > off)
-                        sb.push(str.substring(off, i));
-                    sb.push("\\r");
-                    off = ++i;
-                    break;
-                }
-                case 34: {
-                    if (quote == 34) {
-                        if (i > off)
-                            sb.push(str.substring(off, i));
-                        sb.push('\\"');
-                        off = ++i;
-                    }
-                    else {
-                        ++i;
-                    }
-                    break;
-                }
-                case 39: {
-                    if (quote == 39) {
-                        if (i > off)
-                            sb.push(str.substring(off, i));
-                        sb.push("\\'");
-                        off = ++i;
-                    }
-                    else {
-                        ++i;
-                    }
-                    break;
-                }
-                case 92: {
-                    if (i > off)
-                        sb.push(str.substring(off, i));
-                    sb.push("\\\\");
-                    off = ++i;
-                    break;
-                }
-                case 96: {
-                    if (quote == 96) {
-                        if (i > off)
-                            sb.push(str.substring(off, i));
-                        sb.push("\\`");
-                        off = ++i;
-                    }
-                    else {
-                        ++i;
-                    }
-                    break;
-                }
-                default: {
-                    ++i;
-                    break;
-                }
-            }
-        }
-        if (i > off)
-            sb.push(str.substring(off, i));
-    }
-    visitStringLiteralExpression(node) {
-        this.visitStringLiteral(node.value);
-    }
-    visitTemplateLiteralExpression(node) {
-        var sb = this.sb;
-        var tag = node.tag;
-        var parts = node.parts;
-        var expressions = node.expressions;
-        if (tag)
-            this.visitNode(tag);
-        sb.push("`");
-        this.visitRawString(parts[0], 96);
-        assert(parts.length == expressions.length + 1);
-        for (let i = 0, k = expressions.length; i < k; ++i) {
-            sb.push("${");
-            this.visitNode(expressions[i]);
-            sb.push("}");
-            this.visitRawString(parts[i + 1], 96);
-        }
-        sb.push("`");
-    }
-    visitRegexpLiteralExpression(node) {
-        var sb = this.sb;
-        sb.push("/");
-        sb.push(node.pattern);
-        sb.push("/");
-        sb.push(node.patternFlags);
-    }
-    visitNewExpression(node) {
-        this.sb.push("new ");
-        this.visitTypeName(node.typeName);
-        this.visitArguments(node.typeArguments, node.args);
-    }
-    visitParenthesizedExpression(node) {
-        var sb = this.sb;
-        sb.push("(");
+        break;
+      }
+      case 1: {
         this.visitNode(node.expression);
-        sb.push(")");
-    }
-    visitPropertyAccessExpression(node) {
+        sb.push(" as ");
+        if (node.toType) this.visitTypeNode(node.toType);
+        break;
+      }
+      case 2: {
         this.visitNode(node.expression);
-        this.sb.push(".");
-        this.visitIdentifierExpression(node.property);
-    }
-    visitTernaryExpression(node) {
-        var sb = this.sb;
-        this.visitNode(node.condition);
-        sb.push(" ? ");
-        this.visitNode(node.ifThen);
-        sb.push(" : ");
-        this.visitNode(node.ifElse);
-    }
-    visitUnaryExpression(node) {
-        switch (node.kind) {
-            case 27: {
-                this.visitUnaryPostfixExpression(node);
-                break;
-            }
-            case 28: {
-                this.visitUnaryPrefixExpression(node);
-                break;
-            }
-            default:
-                assert(false);
-        }
-    }
-    visitUnaryPostfixExpression(node) {
-        this.visitNode(node.operand);
-        this.sb.push(operatorTokenToString(node.operator));
-    }
-    visitUnaryPrefixExpression(node) {
-        this.sb.push(operatorTokenToString(node.operator));
-        this.visitNode(node.operand);
-    }
-    visitNodeAndTerminate(node) {
-        this.visitNode(node);
-        var sb = this.sb;
-        if (!sb.length ||
-            node.kind == 47 ||
-            node.kind == 38) {
-            sb.push(";\n");
-        }
-        else {
-            let last = sb[sb.length - 1];
-            let lastCharPos = last.length - 1;
-            if (lastCharPos >= 0 && (last.charCodeAt(lastCharPos) == 125 || last.charCodeAt(lastCharPos) == 59)) {
-                sb.push("\n");
-            }
-            else {
-                sb.push(";\n");
-            }
-        }
-    }
-    visitBlockStatement(node) {
-        var sb = this.sb;
-        var statements = node.statements;
-        var numStatements = statements.length;
-        if (numStatements) {
-            sb.push("{\n");
-            let indentLevel = ++this.indentLevel;
-            for (let i = 0; i < numStatements; ++i) {
-                util.indent(sb, indentLevel);
-                this.visitNodeAndTerminate(statements[i]);
-            }
-            util.indent(sb, --this.indentLevel);
-            sb.push("}");
-        }
-        else {
-            sb.push("{}");
-        }
-    }
-    visitBreakStatement(node) {
-        var label = node.label;
-        if (label) {
-            this.sb.push("break ");
-            this.visitIdentifierExpression(label);
-        }
-        else {
-            this.sb.push("break");
-        }
-    }
-    visitContinueStatement(node) {
-        var label = node.label;
-        if (label) {
-            this.sb.push("continue ");
-            this.visitIdentifierExpression(label);
-        }
-        else {
-            this.sb.push("continue");
-        }
-    }
-    visitClassDeclaration(node, isDefault = false) {
-        var decorators = node.decorators;
-        if (decorators) {
-            for (let i = 0, k = decorators.length; i < k; ++i) {
-                this.serializeDecorator(decorators[i]);
-            }
-        }
-        var sb = this.sb;
-        if (isDefault) {
-            sb.push("export default ");
-        }
-        else {
-            this.serializeExternalModifiers(node);
-        }
-        if (node.is(128))
-            sb.push("abstract ");
-        if (node.name.text.length) {
-            sb.push("class ");
-            this.visitIdentifierExpression(node.name);
-        }
-        else {
-            sb.push("class");
-        }
-        var typeParameters = node.typeParameters;
-        if (typeParameters != null && typeParameters.length > 0) {
-            sb.push("<");
-            this.visitTypeParameter(typeParameters[0]);
-            for (let i = 1, k = typeParameters.length; i < k; ++i) {
-                sb.push(", ");
-                this.visitTypeParameter(typeParameters[i]);
-            }
-            sb.push(">");
-        }
-        var extendsType = node.extendsType;
-        if (extendsType) {
-            sb.push(" extends ");
-            this.visitTypeNode(extendsType);
-        }
-        var implementsTypes = node.implementsTypes;
-        if (implementsTypes) {
-            let numImplementsTypes = implementsTypes.length;
-            if (numImplementsTypes) {
-                sb.push(" implements ");
-                this.visitTypeNode(implementsTypes[0]);
-                for (let i = 1; i < numImplementsTypes; ++i) {
-                    sb.push(", ");
-                    this.visitTypeNode(implementsTypes[i]);
-                }
-            }
-        }
-        var indexSignature = node.indexSignature;
-        var members = node.members;
-        var numMembers = members.length;
-        if (indexSignature !== null || numMembers) {
-            sb.push(" {\n");
-            let indentLevel = ++this.indentLevel;
-            if (indexSignature) {
-                util.indent(sb, indentLevel);
-                this.visitNodeAndTerminate(indexSignature);
-            }
-            for (let i = 0, k = members.length; i < k; ++i) {
-                let member = members[i];
-                if (member.kind != 54 || member.parameterIndex < 0) {
-                    util.indent(sb, indentLevel);
-                    this.visitNodeAndTerminate(member);
-                }
-            }
-            util.indent(sb, --this.indentLevel);
-            sb.push("}");
-        }
-        else {
-            sb.push(" {}");
-        }
-    }
-    visitDoStatement(node) {
-        var sb = this.sb;
-        sb.push("do ");
-        this.visitNode(node.body);
-        if (node.body.kind == 30) {
-            sb.push(" while (");
-        }
-        else {
-            util.indent(sb, this.indentLevel);
-            sb.push("while (");
-        }
-        this.visitNode(node.condition);
-        sb.push(")");
-    }
-    visitEmptyStatement(node) {
-    }
-    visitEnumDeclaration(node, isDefault = false) {
-        var sb = this.sb;
-        if (isDefault) {
-            sb.push("export default ");
-        }
-        else {
-            this.serializeExternalModifiers(node);
-        }
-        if (node.is(8))
-            sb.push("const ");
-        sb.push("enum ");
-        this.visitIdentifierExpression(node.name);
-        var values = node.values;
-        var numValues = values.length;
-        if (numValues) {
-            sb.push(" {\n");
-            let indentLevel = ++this.indentLevel;
-            util.indent(sb, indentLevel);
-            this.visitEnumValueDeclaration(node.values[0]);
-            for (let i = 1; i < numValues; ++i) {
-                sb.push(",\n");
-                util.indent(sb, indentLevel);
-                this.visitEnumValueDeclaration(node.values[i]);
-            }
-            sb.push("\n");
-            util.indent(sb, --this.indentLevel);
-            sb.push("}");
-        }
-        else {
-            sb.push(" {}");
-        }
-    }
-    visitEnumValueDeclaration(node) {
-        this.visitIdentifierExpression(node.name);
-        var initializer = node.initializer;
-        if (initializer) {
-            this.sb.push(" = ");
-            this.visitNode(initializer);
-        }
-    }
-    visitExportImportStatement(node) {
-        var sb = this.sb;
-        sb.push("export import ");
-        this.visitIdentifierExpression(node.externalName);
-        sb.push(" = ");
-        this.visitIdentifierExpression(node.name);
-    }
-    visitExportMember(node) {
-        this.visitIdentifierExpression(node.localName);
-        if (node.exportedName.text != node.localName.text) {
-            this.sb.push(" as ");
-            this.visitIdentifierExpression(node.exportedName);
-        }
-    }
-    visitExportStatement(node) {
-        var sb = this.sb;
-        if (node.isDeclare) {
-            sb.push("declare ");
-        }
-        var members = node.members;
-        if (members == null) {
-            sb.push("export *");
-        }
-        else if (members.length > 0) {
-            let numMembers = members.length;
-            sb.push("export {\n");
-            let indentLevel = ++this.indentLevel;
-            util.indent(sb, indentLevel);
-            this.visitExportMember(members[0]);
-            for (let i = 1; i < numMembers; ++i) {
-                sb.push(",\n");
-                util.indent(sb, indentLevel);
-                this.visitExportMember(members[i]);
-            }
-            --this.indentLevel;
-            sb.push("\n}");
-        }
-        else {
-            sb.push("export {}");
-        }
-        var path = node.path;
-        if (path) {
-            sb.push(" from ");
-            this.visitStringLiteralExpression(path);
-        }
-        sb.push(";");
-    }
-    visitExportDefaultStatement(node) {
-        var declaration = node.declaration;
-        switch (declaration.kind) {
-            case 52: {
-                this.visitEnumDeclaration(declaration, true);
-                break;
-            }
-            case 55: {
-                this.visitFunctionDeclaration(declaration, true);
-                break;
-            }
-            case 51: {
-                this.visitClassDeclaration(declaration, true);
-                break;
-            }
-            case 57: {
-                this.visitInterfaceDeclaration(declaration, true);
-                break;
-            }
-            case 59: {
-                this.visitNamespaceDeclaration(declaration, true);
-                break;
-            }
-            default:
-                assert(false);
-        }
-    }
-    visitExpressionStatement(node) {
+        sb.push("!");
+        break;
+      }
+      case 3: {
         this.visitNode(node.expression);
-    }
-    visitFieldDeclaration(node) {
-        var decorators = node.decorators;
-        if (decorators) {
-            for (let i = 0, k = decorators.length; i < k; ++i) {
-                this.serializeDecorator(decorators[i]);
-            }
-        }
-        this.serializeAccessModifiers(node);
-        this.visitIdentifierExpression(node.name);
-        var sb = this.sb;
-        if (node.flags & 16384) {
-            sb.push("!");
-        }
-        var type = node.type;
-        if (type) {
-            sb.push(": ");
-            this.visitTypeNode(type);
-        }
-        var initializer = node.initializer;
-        if (initializer) {
-            sb.push(" = ");
-            this.visitNode(initializer);
-        }
-    }
-    visitForStatement(node) {
-        var sb = this.sb;
-        sb.push("for (");
-        var initializer = node.initializer;
-        if (initializer) {
-            this.visitNode(initializer);
-        }
-        var condition = node.condition;
-        if (condition) {
-            sb.push("; ");
-            this.visitNode(condition);
-        }
-        else {
-            sb.push(";");
-        }
-        var incrementor = node.incrementor;
-        if (incrementor) {
-            sb.push("; ");
-            this.visitNode(incrementor);
-        }
-        else {
-            sb.push(";");
-        }
-        sb.push(") ");
-        this.visitNode(node.body);
-    }
-    visitForOfStatement(node) {
-        var sb = this.sb;
-        sb.push("for (");
-        this.visitNode(node.variable);
-        sb.push(" of ");
-        this.visitNode(node.iterable);
-        sb.push(") ");
-        this.visitNode(node.body);
-    }
-    visitFunctionDeclaration(node, isDefault = false) {
-        var sb = this.sb;
-        var decorators = node.decorators;
-        if (decorators) {
-            for (let i = 0, k = decorators.length; i < k; ++i) {
-                this.serializeDecorator(decorators[i]);
-            }
-        }
-        if (isDefault) {
-            sb.push("export default ");
-        }
-        else {
-            this.serializeExternalModifiers(node);
-            this.serializeAccessModifiers(node);
-        }
-        if (node.name.text.length) {
-            sb.push("function ");
-        }
-        else {
-            sb.push("function");
-        }
-        this.visitFunctionCommon(node);
-    }
-    visitFunctionCommon(node) {
-        var sb = this.sb;
-        this.visitIdentifierExpression(node.name);
-        var signature = node.signature;
-        var typeParameters = node.typeParameters;
-        if (typeParameters) {
-            let numTypeParameters = typeParameters.length;
-            if (numTypeParameters) {
-                sb.push("<");
-                this.visitTypeParameter(typeParameters[0]);
-                for (let i = 1; i < numTypeParameters; ++i) {
-                    sb.push(", ");
-                    this.visitTypeParameter(typeParameters[i]);
-                }
-                sb.push(">");
-            }
-        }
+        sb.push(" as const");
+        break;
+      }
+      default:
+        assert(false);
+    }
+  }
+  visitBinaryExpression(node) {
+    var sb = this.sb;
+    this.visitNode(node.left);
+    sb.push(" ");
+    sb.push(operatorTokenToString(node.operator));
+    sb.push(" ");
+    this.visitNode(node.right);
+  }
+  visitCallExpression(node) {
+    this.visitNode(node.expression);
+    this.visitArguments(node.typeArguments, node.args);
+  }
+  visitArguments(typeArguments, args) {
+    var sb = this.sb;
+    if (typeArguments) {
+      let numTypeArguments = typeArguments.length;
+      if (numTypeArguments) {
+        sb.push("<");
+        this.visitTypeNode(typeArguments[0]);
+        for (let i = 1; i < numTypeArguments; ++i) {
+          sb.push(", ");
+          this.visitTypeNode(typeArguments[i]);
+        }
+        sb.push(">(");
+      }
+    } else {
+      sb.push("(");
+    }
+    var numArgs = args.length;
+    if (numArgs) {
+      this.visitNode(args[0]);
+      for (let i = 1; i < numArgs; ++i) {
+        sb.push(", ");
+        this.visitNode(args[i]);
+      }
+    }
+    sb.push(")");
+  }
+  visitClassExpression(node) {
+    var declaration = node.declaration;
+    this.visitClassDeclaration(declaration);
+  }
+  visitCommaExpression(node) {
+    var expressions = node.expressions;
+    var numExpressions = expressions.length;
+    this.visitNode(expressions[0]);
+    var sb = this.sb;
+    for (let i = 1; i < numExpressions; ++i) {
+      sb.push(",");
+      this.visitNode(expressions[i]);
+    }
+  }
+  visitElementAccessExpression(node) {
+    var sb = this.sb;
+    this.visitNode(node.expression);
+    sb.push("[");
+    this.visitNode(node.elementExpression);
+    sb.push("]");
+  }
+  visitFunctionExpression(node) {
+    var declaration = node.declaration;
+    if (!declaration.arrowKind) {
+      if (declaration.name.text.length) {
+        this.sb.push("function ");
+      } else {
+        this.sb.push("function");
+      }
+    } else {
+      assert(declaration.name.text.length == 0);
+    }
+    this.visitFunctionCommon(declaration);
+  }
+  visitLiteralExpression(node) {
+    switch (node.literalKind) {
+      case 0: {
+        this.visitFloatLiteralExpression(node);
+        break;
+      }
+      case 1: {
+        this.visitIntegerLiteralExpression(node);
+        break;
+      }
+      case 2: {
+        this.visitStringLiteralExpression(node);
+        break;
+      }
+      case 3: {
+        this.visitTemplateLiteralExpression(node);
+        break;
+      }
+      case 4: {
+        this.visitRegexpLiteralExpression(node);
+        break;
+      }
+      case 5: {
+        this.visitArrayLiteralExpression(node);
+        break;
+      }
+      case 6: {
+        this.visitObjectLiteralExpression(node);
+        break;
+      }
+      default: {
+        assert(false);
+        break;
+      }
+    }
+  }
+  visitFloatLiteralExpression(node) {
+    this.sb.push(node.value.toString());
+  }
+  visitInstanceOfExpression(node) {
+    this.visitNode(node.expression);
+    this.sb.push(" instanceof ");
+    this.visitTypeNode(node.isType);
+  }
+  visitIntegerLiteralExpression(node) {
+    this.sb.push(i64_to_string(node.value));
+  }
+  visitStringLiteral(str) {
+    var sb = this.sb;
+    sb.push('"');
+    this.visitRawString(str, 34);
+    sb.push('"');
+  }
+  visitRawString(str, quote) {
+    var sb = this.sb;
+    var off = 0;
+    var i = 0;
+    for (let k = str.length; i < k; ) {
+      switch (str.charCodeAt(i)) {
+        case 0: {
+          if (i > off) sb.push(str.substring(off, (off = i + 1)));
+          sb.push("\\0");
+          off = ++i;
+          break;
+        }
+        case 92: {
+          if (i > off) sb.push(str.substring(off, i));
+          off = ++i;
+          sb.push("\\b");
+          break;
+        }
+        case 9: {
+          if (i > off) sb.push(str.substring(off, i));
+          off = ++i;
+          sb.push("\\t");
+          break;
+        }
+        case 10: {
+          if (i > off) sb.push(str.substring(off, i));
+          off = ++i;
+          sb.push("\\n");
+          break;
+        }
+        case 11: {
+          if (i > off) sb.push(str.substring(off, i));
+          off = ++i;
+          sb.push("\\v");
+          break;
+        }
+        case 12: {
+          if (i > off) sb.push(str.substring(off, i));
+          off = ++i;
+          sb.push("\\f");
+          break;
+        }
+        case 13: {
+          if (i > off) sb.push(str.substring(off, i));
+          sb.push("\\r");
+          off = ++i;
+          break;
+        }
+        case 34: {
+          if (quote == 34) {
+            if (i > off) sb.push(str.substring(off, i));
+            sb.push('\\"');
+            off = ++i;
+          } else {
+            ++i;
+          }
+          break;
+        }
+        case 39: {
+          if (quote == 39) {
+            if (i > off) sb.push(str.substring(off, i));
+            sb.push("\\'");
+            off = ++i;
+          } else {
+            ++i;
+          }
+          break;
+        }
+        case 92: {
+          if (i > off) sb.push(str.substring(off, i));
+          sb.push("\\\\");
+          off = ++i;
+          break;
+        }
+        case 96: {
+          if (quote == 96) {
+            if (i > off) sb.push(str.substring(off, i));
+            sb.push("\\`");
+            off = ++i;
+          } else {
+            ++i;
+          }
+          break;
+        }
+        default: {
+          ++i;
+          break;
+        }
+      }
+    }
+    if (i > off) sb.push(str.substring(off, i));
+  }
+  visitStringLiteralExpression(node) {
+    this.visitStringLiteral(node.value);
+  }
+  visitTemplateLiteralExpression(node) {
+    var sb = this.sb;
+    var tag = node.tag;
+    var parts = node.parts;
+    var expressions = node.expressions;
+    if (tag) this.visitNode(tag);
+    sb.push("`");
+    this.visitRawString(parts[0], 96);
+    assert(parts.length == expressions.length + 1);
+    for (let i = 0, k = expressions.length; i < k; ++i) {
+      sb.push("${");
+      this.visitNode(expressions[i]);
+      sb.push("}");
+      this.visitRawString(parts[i + 1], 96);
+    }
+    sb.push("`");
+  }
+  visitRegexpLiteralExpression(node) {
+    var sb = this.sb;
+    sb.push("/");
+    sb.push(node.pattern);
+    sb.push("/");
+    sb.push(node.patternFlags);
+  }
+  visitNewExpression(node) {
+    this.sb.push("new ");
+    this.visitTypeName(node.typeName);
+    this.visitArguments(node.typeArguments, node.args);
+  }
+  visitParenthesizedExpression(node) {
+    var sb = this.sb;
+    sb.push("(");
+    this.visitNode(node.expression);
+    sb.push(")");
+  }
+  visitPropertyAccessExpression(node) {
+    this.visitNode(node.expression);
+    this.sb.push(".");
+    this.visitIdentifierExpression(node.property);
+  }
+  visitTernaryExpression(node) {
+    var sb = this.sb;
+    this.visitNode(node.condition);
+    sb.push(" ? ");
+    this.visitNode(node.ifThen);
+    sb.push(" : ");
+    this.visitNode(node.ifElse);
+  }
+  visitUnaryExpression(node) {
+    switch (node.kind) {
+      case 27: {
+        this.visitUnaryPostfixExpression(node);
+        break;
+      }
+      case 28: {
+        this.visitUnaryPrefixExpression(node);
+        break;
+      }
+      default:
+        assert(false);
+    }
+  }
+  visitUnaryPostfixExpression(node) {
+    this.visitNode(node.operand);
+    this.sb.push(operatorTokenToString(node.operator));
+  }
+  visitUnaryPrefixExpression(node) {
+    this.sb.push(operatorTokenToString(node.operator));
+    this.visitNode(node.operand);
+  }
+  visitNodeAndTerminate(node) {
+    this.visitNode(node);
+    var sb = this.sb;
+    if (!sb.length || node.kind == 47 || node.kind == 38) {
+      sb.push(";\n");
+    } else {
+      let last = sb[sb.length - 1];
+      let lastCharPos = last.length - 1;
+      if (lastCharPos >= 0 && (last.charCodeAt(lastCharPos) == 125 || last.charCodeAt(lastCharPos) == 59)) {
+        sb.push("\n");
+      } else {
+        sb.push(";\n");
+      }
+    }
+  }
+  visitBlockStatement(node) {
+    var sb = this.sb;
+    var statements = node.statements;
+    var numStatements = statements.length;
+    if (numStatements) {
+      sb.push("{\n");
+      let indentLevel = ++this.indentLevel;
+      for (let i = 0; i < numStatements; ++i) {
+        util.indent(sb, indentLevel);
+        this.visitNodeAndTerminate(statements[i]);
+      }
+      util.indent(sb, --this.indentLevel);
+      sb.push("}");
+    } else {
+      sb.push("{}");
+    }
+  }
+  visitBreakStatement(node) {
+    var label = node.label;
+    if (label) {
+      this.sb.push("break ");
+      this.visitIdentifierExpression(label);
+    } else {
+      this.sb.push("break");
+    }
+  }
+  visitContinueStatement(node) {
+    var label = node.label;
+    if (label) {
+      this.sb.push("continue ");
+      this.visitIdentifierExpression(label);
+    } else {
+      this.sb.push("continue");
+    }
+  }
+  visitClassDeclaration(node, isDefault = false) {
+    var decorators = node.decorators;
+    if (decorators) {
+      for (let i = 0, k = decorators.length; i < k; ++i) {
+        this.serializeDecorator(decorators[i]);
+      }
+    }
+    var sb = this.sb;
+    if (isDefault) {
+      sb.push("export default ");
+    } else {
+      this.serializeExternalModifiers(node);
+    }
+    if (node.is(128)) sb.push("abstract ");
+    if (node.name.text.length) {
+      sb.push("class ");
+      this.visitIdentifierExpression(node.name);
+    } else {
+      sb.push("class");
+    }
+    var typeParameters = node.typeParameters;
+    if (typeParameters != null && typeParameters.length > 0) {
+      sb.push("<");
+      this.visitTypeParameter(typeParameters[0]);
+      for (let i = 1, k = typeParameters.length; i < k; ++i) {
+        sb.push(", ");
+        this.visitTypeParameter(typeParameters[i]);
+      }
+      sb.push(">");
+    }
+    var extendsType = node.extendsType;
+    if (extendsType) {
+      sb.push(" extends ");
+      this.visitTypeNode(extendsType);
+    }
+    var implementsTypes = node.implementsTypes;
+    if (implementsTypes) {
+      let numImplementsTypes = implementsTypes.length;
+      if (numImplementsTypes) {
+        sb.push(" implements ");
+        this.visitTypeNode(implementsTypes[0]);
+        for (let i = 1; i < numImplementsTypes; ++i) {
+          sb.push(", ");
+          this.visitTypeNode(implementsTypes[i]);
+        }
+      }
+    }
+    var indexSignature = node.indexSignature;
+    var members = node.members;
+    var numMembers = members.length;
+    if (indexSignature !== null || numMembers) {
+      sb.push(" {\n");
+      let indentLevel = ++this.indentLevel;
+      if (indexSignature) {
+        util.indent(sb, indentLevel);
+        this.visitNodeAndTerminate(indexSignature);
+      }
+      for (let i = 0, k = members.length; i < k; ++i) {
+        let member = members[i];
+        if (member.kind != 54 || member.parameterIndex < 0) {
+          util.indent(sb, indentLevel);
+          this.visitNodeAndTerminate(member);
+        }
+      }
+      util.indent(sb, --this.indentLevel);
+      sb.push("}");
+    } else {
+      sb.push(" {}");
+    }
+  }
+  visitDoStatement(node) {
+    var sb = this.sb;
+    sb.push("do ");
+    this.visitNode(node.body);
+    if (node.body.kind == 30) {
+      sb.push(" while (");
+    } else {
+      util.indent(sb, this.indentLevel);
+      sb.push("while (");
+    }
+    this.visitNode(node.condition);
+    sb.push(")");
+  }
+  visitEmptyStatement(node) {}
+  visitEnumDeclaration(node, isDefault = false) {
+    var sb = this.sb;
+    if (isDefault) {
+      sb.push("export default ");
+    } else {
+      this.serializeExternalModifiers(node);
+    }
+    if (node.is(8)) sb.push("const ");
+    sb.push("enum ");
+    this.visitIdentifierExpression(node.name);
+    var values = node.values;
+    var numValues = values.length;
+    if (numValues) {
+      sb.push(" {\n");
+      let indentLevel = ++this.indentLevel;
+      util.indent(sb, indentLevel);
+      this.visitEnumValueDeclaration(node.values[0]);
+      for (let i = 1; i < numValues; ++i) {
+        sb.push(",\n");
+        util.indent(sb, indentLevel);
+        this.visitEnumValueDeclaration(node.values[i]);
+      }
+      sb.push("\n");
+      util.indent(sb, --this.indentLevel);
+      sb.push("}");
+    } else {
+      sb.push(" {}");
+    }
+  }
+  visitEnumValueDeclaration(node) {
+    this.visitIdentifierExpression(node.name);
+    var initializer = node.initializer;
+    if (initializer) {
+      this.sb.push(" = ");
+      this.visitNode(initializer);
+    }
+  }
+  visitExportImportStatement(node) {
+    var sb = this.sb;
+    sb.push("export import ");
+    this.visitIdentifierExpression(node.externalName);
+    sb.push(" = ");
+    this.visitIdentifierExpression(node.name);
+  }
+  visitExportMember(node) {
+    this.visitIdentifierExpression(node.localName);
+    if (node.exportedName.text != node.localName.text) {
+      this.sb.push(" as ");
+      this.visitIdentifierExpression(node.exportedName);
+    }
+  }
+  visitExportStatement(node) {
+    var sb = this.sb;
+    if (node.isDeclare) {
+      sb.push("declare ");
+    }
+    var members = node.members;
+    if (members == null) {
+      sb.push("export *");
+    } else if (members.length > 0) {
+      let numMembers = members.length;
+      sb.push("export {\n");
+      let indentLevel = ++this.indentLevel;
+      util.indent(sb, indentLevel);
+      this.visitExportMember(members[0]);
+      for (let i = 1; i < numMembers; ++i) {
+        sb.push(",\n");
+        util.indent(sb, indentLevel);
+        this.visitExportMember(members[i]);
+      }
+      --this.indentLevel;
+      sb.push("\n}");
+    } else {
+      sb.push("export {}");
+    }
+    var path = node.path;
+    if (path) {
+      sb.push(" from ");
+      this.visitStringLiteralExpression(path);
+    }
+    sb.push(";");
+  }
+  visitExportDefaultStatement(node) {
+    var declaration = node.declaration;
+    switch (declaration.kind) {
+      case 52: {
+        this.visitEnumDeclaration(declaration, true);
+        break;
+      }
+      case 55: {
+        this.visitFunctionDeclaration(declaration, true);
+        break;
+      }
+      case 51: {
+        this.visitClassDeclaration(declaration, true);
+        break;
+      }
+      case 57: {
+        this.visitInterfaceDeclaration(declaration, true);
+        break;
+      }
+      case 59: {
+        this.visitNamespaceDeclaration(declaration, true);
+        break;
+      }
+      default:
+        assert(false);
+    }
+  }
+  visitExpressionStatement(node) {
+    this.visitNode(node.expression);
+  }
+  visitFieldDeclaration(node) {
+    var decorators = node.decorators;
+    if (decorators) {
+      for (let i = 0, k = decorators.length; i < k; ++i) {
+        this.serializeDecorator(decorators[i]);
+      }
+    }
+    this.serializeAccessModifiers(node);
+    this.visitIdentifierExpression(node.name);
+    var sb = this.sb;
+    if (node.flags & 16384) {
+      sb.push("!");
+    }
+    var type = node.type;
+    if (type) {
+      sb.push(": ");
+      this.visitTypeNode(type);
+    }
+    var initializer = node.initializer;
+    if (initializer) {
+      sb.push(" = ");
+      this.visitNode(initializer);
+    }
+  }
+  visitForStatement(node) {
+    var sb = this.sb;
+    sb.push("for (");
+    var initializer = node.initializer;
+    if (initializer) {
+      this.visitNode(initializer);
+    }
+    var condition = node.condition;
+    if (condition) {
+      sb.push("; ");
+      this.visitNode(condition);
+    } else {
+      sb.push(";");
+    }
+    var incrementor = node.incrementor;
+    if (incrementor) {
+      sb.push("; ");
+      this.visitNode(incrementor);
+    } else {
+      sb.push(";");
+    }
+    sb.push(") ");
+    this.visitNode(node.body);
+  }
+  visitForOfStatement(node) {
+    var sb = this.sb;
+    sb.push("for (");
+    this.visitNode(node.variable);
+    sb.push(" of ");
+    this.visitNode(node.iterable);
+    sb.push(") ");
+    this.visitNode(node.body);
+  }
+  visitFunctionDeclaration(node, isDefault = false) {
+    var sb = this.sb;
+    var decorators = node.decorators;
+    if (decorators) {
+      for (let i = 0, k = decorators.length; i < k; ++i) {
+        this.serializeDecorator(decorators[i]);
+      }
+    }
+    if (isDefault) {
+      sb.push("export default ");
+    } else {
+      this.serializeExternalModifiers(node);
+      this.serializeAccessModifiers(node);
+    }
+    if (node.name.text.length) {
+      sb.push("function ");
+    } else {
+      sb.push("function");
+    }
+    this.visitFunctionCommon(node);
+  }
+  visitFunctionCommon(node) {
+    var sb = this.sb;
+    this.visitIdentifierExpression(node.name);
+    var signature = node.signature;
+    var typeParameters = node.typeParameters;
+    if (typeParameters) {
+      let numTypeParameters = typeParameters.length;
+      if (numTypeParameters) {
+        sb.push("<");
+        this.visitTypeParameter(typeParameters[0]);
+        for (let i = 1; i < numTypeParameters; ++i) {
+          sb.push(", ");
+          this.visitTypeParameter(typeParameters[i]);
+        }
+        sb.push(">");
+      }
+    }
+    if (node.arrowKind == 2) {
+      let parameters = signature.parameters;
+      assert(parameters.length == 1);
+      assert(!signature.explicitThisType);
+      this.serializeParameter(parameters[0]);
+    } else {
+      sb.push("(");
+      let parameters = signature.parameters;
+      let numParameters = parameters.length;
+      let explicitThisType = signature.explicitThisType;
+      if (explicitThisType) {
+        sb.push("this: ");
+        this.visitTypeNode(explicitThisType);
+      }
+      if (numParameters) {
+        if (explicitThisType) sb.push(", ");
+        this.serializeParameter(parameters[0]);
+        for (let i = 1; i < numParameters; ++i) {
+          sb.push(", ");
+          this.serializeParameter(parameters[i]);
+        }
+      }
+    }
+    var body = node.body;
+    var returnType = signature.returnType;
+    if (node.arrowKind) {
+      if (body) {
         if (node.arrowKind == 2) {
-            let parameters = signature.parameters;
-            assert(parameters.length == 1);
-            assert(!signature.explicitThisType);
-            this.serializeParameter(parameters[0]);
-        }
-        else {
-            sb.push("(");
-            let parameters = signature.parameters;
-            let numParameters = parameters.length;
-            let explicitThisType = signature.explicitThisType;
-            if (explicitThisType) {
-                sb.push("this: ");
-                this.visitTypeNode(explicitThisType);
-            }
-            if (numParameters) {
-                if (explicitThisType)
-                    sb.push(", ");
-                this.serializeParameter(parameters[0]);
-                for (let i = 1; i < numParameters; ++i) {
-                    sb.push(", ");
-                    this.serializeParameter(parameters[i]);
-                }
-            }
-        }
-        var body = node.body;
-        var returnType = signature.returnType;
-        if (node.arrowKind) {
-            if (body) {
-                if (node.arrowKind == 2) {
-                    assert(isTypeOmitted(returnType));
-                }
-                else {
-                    if (isTypeOmitted(returnType)) {
-                        sb.push(")");
-                    }
-                    else {
-                        sb.push("): ");
-                        this.visitTypeNode(returnType);
-                    }
-                }
-                sb.push(" => ");
-                this.visitNode(body);
-            }
-            else {
-                assert(!isTypeOmitted(returnType));
-                sb.push(" => ");
-                this.visitTypeNode(returnType);
-            }
-        }
-        else {
-            if (!isTypeOmitted(returnType) && !node.isAny(524288 | 4096)) {
-                sb.push("): ");
-                this.visitTypeNode(returnType);
-            }
-            else {
-                sb.push(")");
-            }
-            if (body) {
-                sb.push(" ");
-                this.visitNode(body);
-            }
-        }
-    }
-    visitIfStatement(node) {
-        var sb = this.sb;
-        sb.push("if (");
-        this.visitNode(node.condition);
-        sb.push(") ");
-        var ifTrue = node.ifTrue;
-        this.visitNode(ifTrue);
-        if (ifTrue.kind != 30) {
-            sb.push(";\n");
-        }
-        var ifFalse = node.ifFalse;
-        if (ifFalse) {
-            if (ifTrue.kind == 30) {
-                sb.push(" else ");
-            }
-            else {
-                sb.push("else ");
-            }
-            this.visitNode(ifFalse);
-        }
-    }
-    visitImportDeclaration(node) {
-        var externalName = node.foreignName;
-        var name = node.name;
-        this.visitIdentifierExpression(externalName);
-        if (externalName.text != name.text) {
-            this.sb.push(" as ");
-            this.visitIdentifierExpression(name);
-        }
-    }
-    visitImportStatement(node) {
-        var sb = this.sb;
-        sb.push("import ");
-        var declarations = node.declarations;
-        var namespaceName = node.namespaceName;
-        if (declarations) {
-            let numDeclarations = declarations.length;
-            if (numDeclarations) {
-                sb.push("{\n");
-                let indentLevel = ++this.indentLevel;
-                util.indent(sb, indentLevel);
-                this.visitImportDeclaration(declarations[0]);
-                for (let i = 1; i < numDeclarations; ++i) {
-                    sb.push(",\n");
-                    util.indent(sb, indentLevel);
-                    this.visitImportDeclaration(declarations[i]);
-                }
-                --this.indentLevel;
-                sb.push("\n} from ");
-            }
-            else {
-                sb.push("{} from ");
-            }
-        }
-        else if (namespaceName) {
-            sb.push("* as ");
-            this.visitIdentifierExpression(namespaceName);
-            sb.push(" from ");
-        }
-        this.visitStringLiteralExpression(node.path);
-    }
-    visitIndexSignature(node) {
-        var sb = this.sb;
-        sb.push("[key: ");
-        this.visitTypeNode(node.keyType);
-        sb.push("]: ");
-        this.visitTypeNode(node.valueType);
-    }
-    visitInterfaceDeclaration(node, isDefault = false) {
-        var decorators = node.decorators;
-        if (decorators) {
-            for (let i = 0, k = decorators.length; i < k; ++i) {
-                this.serializeDecorator(decorators[i]);
-            }
-        }
-        var sb = this.sb;
-        if (isDefault) {
-            sb.push("export default ");
-        }
-        else {
-            this.serializeExternalModifiers(node);
-        }
-        sb.push("interface ");
-        this.visitIdentifierExpression(node.name);
-        var typeParameters = node.typeParameters;
-        if (typeParameters != null && typeParameters.length > 0) {
-            sb.push("<");
-            this.visitTypeParameter(typeParameters[0]);
-            for (let i = 1, k = typeParameters.length; i < k; ++i) {
-                sb.push(", ");
-                this.visitTypeParameter(typeParameters[i]);
-            }
-            sb.push(">");
-        }
-        var extendsType = node.extendsType;
-        if (extendsType) {
-            sb.push(" extends ");
-            this.visitTypeNode(extendsType);
-        }
-        sb.push(" {\n");
-        var indentLevel = ++this.indentLevel;
-        var members = node.members;
-        for (let i = 0, k = members.length; i < k; ++i) {
-            util.indent(sb, indentLevel);
-            this.visitNodeAndTerminate(members[i]);
-        }
-        --this.indentLevel;
-        sb.push("}");
-    }
-    visitMethodDeclaration(node) {
-        var decorators = node.decorators;
-        if (decorators) {
-            for (let i = 0, k = decorators.length; i < k; ++i) {
-                this.serializeDecorator(decorators[i]);
-            }
-        }
-        this.serializeAccessModifiers(node);
-        if (node.is(2048)) {
-            this.sb.push("get ");
-        }
-        else if (node.is(4096)) {
-            this.sb.push("set ");
-        }
-        this.visitFunctionCommon(node);
-    }
-    visitNamespaceDeclaration(node, isDefault = false) {
-        var decorators = node.decorators;
-        if (decorators) {
-            for (let i = 0, k = decorators.length; i < k; ++i) {
-                this.serializeDecorator(decorators[i]);
-            }
-        }
-        var sb = this.sb;
-        if (isDefault) {
-            sb.push("export default ");
-        }
-        else {
-            this.serializeExternalModifiers(node);
-        }
-        sb.push("namespace ");
-        this.visitIdentifierExpression(node.name);
-        var members = node.members;
-        var numMembers = members.length;
-        if (numMembers) {
-            sb.push(" {\n");
-            let indentLevel = ++this.indentLevel;
-            for (let i = 0, k = members.length; i < k; ++i) {
-                util.indent(sb, indentLevel);
-                this.visitNodeAndTerminate(members[i]);
-            }
-            util.indent(sb, --this.indentLevel);
-            sb.push("}");
-        }
-        else {
-            sb.push(" {}");
-        }
-    }
-    visitReturnStatement(node) {
-        var value = node.value;
-        if (value) {
-            this.sb.push("return ");
-            this.visitNode(value);
-        }
-        else {
-            this.sb.push("return");
-        }
-    }
-    visitTrueExpression(node) {
-        this.sb.push("true");
-    }
-    visitFalseExpression(node) {
-        this.sb.push("false");
-    }
-    visitNullExpression(node) {
-        this.sb.push("null");
-    }
-    visitSwitchCase(node) {
-        var sb = this.sb;
-        var label = node.label;
-        if (label) {
-            sb.push("case ");
-            this.visitNode(label);
-            sb.push(":\n");
-        }
-        else {
-            sb.push("default:\n");
-        }
-        var statements = node.statements;
-        var numStatements = statements.length;
-        if (numStatements) {
-            let indentLevel = ++this.indentLevel;
-            util.indent(sb, indentLevel);
-            this.visitNodeAndTerminate(statements[0]);
-            for (let i = 1; i < numStatements; ++i) {
-                util.indent(sb, indentLevel);
-                this.visitNodeAndTerminate(statements[i]);
-            }
-            --this.indentLevel;
-        }
-    }
-    visitSwitchStatement(node) {
-        var sb = this.sb;
-        sb.push("switch (");
-        this.visitNode(node.condition);
-        sb.push(") {\n");
-        var indentLevel = ++this.indentLevel;
-        var cases = node.cases;
-        for (let i = 0, k = cases.length; i < k; ++i) {
-            util.indent(sb, indentLevel);
-            this.visitSwitchCase(cases[i]);
-            sb.push("\n");
-        }
-        --this.indentLevel;
-        sb.push("}");
-    }
-    visitThrowStatement(node) {
-        this.sb.push("throw ");
-        this.visitNode(node.value);
-    }
-    visitTryStatement(node) {
-        var sb = this.sb;
-        sb.push("try {\n");
-        var indentLevel = ++this.indentLevel;
-        var statements = node.bodyStatements;
-        for (let i = 0, k = statements.length; i < k; ++i) {
-            util.indent(sb, indentLevel);
-            this.visitNodeAndTerminate(statements[i]);
-        }
-        var catchVariable = node.catchVariable;
-        if (catchVariable) {
-            util.indent(sb, indentLevel - 1);
-            sb.push("} catch (");
-            this.visitIdentifierExpression(catchVariable);
-            sb.push(") {\n");
-            let catchStatements = node.catchStatements;
-            if (catchStatements) {
-                for (let i = 0, k = catchStatements.length; i < k; ++i) {
-                    util.indent(sb, indentLevel);
-                    this.visitNodeAndTerminate(catchStatements[i]);
-                }
-            }
-        }
-        var finallyStatements = node.finallyStatements;
-        if (finallyStatements) {
-            util.indent(sb, indentLevel - 1);
-            sb.push("} finally {\n");
-            for (let i = 0, k = finallyStatements.length; i < k; ++i) {
-                util.indent(sb, indentLevel);
-                this.visitNodeAndTerminate(finallyStatements[i]);
-            }
-        }
-        util.indent(sb, indentLevel - 1);
-        sb.push("}");
-    }
-    visitTypeDeclaration(node) {
-        var decorators = node.decorators;
-        if (decorators) {
-            for (let i = 0, k = decorators.length; i < k; ++i) {
-                this.serializeDecorator(decorators[i]);
-            }
-        }
-        var sb = this.sb;
-        this.serializeExternalModifiers(node);
-        sb.push("type ");
-        this.visitIdentifierExpression(node.name);
-        var typeParameters = node.typeParameters;
-        if (typeParameters) {
-            let numTypeParameters = typeParameters.length;
-            if (numTypeParameters) {
-                sb.push("<");
-                for (let i = 0; i < numTypeParameters; ++i) {
-                    this.visitTypeParameter(typeParameters[i]);
-                }
-                sb.push(">");
-            }
-        }
-        sb.push(" = ");
-        this.visitTypeNode(node.type);
-    }
-    visitVariableDeclaration(node) {
-        this.visitIdentifierExpression(node.name);
-        var type = node.type;
-        var sb = this.sb;
-        if (node.flags & 16384) {
-            sb.push("!");
-        }
-        if (type) {
-            sb.push(": ");
-            this.visitTypeNode(type);
-        }
-        var initializer = node.initializer;
-        if (initializer) {
-            sb.push(" = ");
-            this.visitNode(initializer);
-        }
-    }
-    visitVariableStatement(node) {
-        var decorators = node.decorators;
-        if (decorators) {
-            for (let i = 0, k = decorators.length; i < k; ++i) {
-                this.serializeDecorator(decorators[i]);
-            }
-        }
-        var sb = this.sb;
-        var declarations = node.declarations;
-        var numDeclarations = declarations.length;
-        var firstDeclaration = declarations[0];
-        this.serializeExternalModifiers(firstDeclaration);
-        sb.push(firstDeclaration.is(8) ? "const " : firstDeclaration.is(16) ? "let " : "var ");
-        this.visitVariableDeclaration(node.declarations[0]);
-        for (let i = 1; i < numDeclarations; ++i) {
-            sb.push(", ");
-            this.visitVariableDeclaration(node.declarations[i]);
-        }
-    }
-    visitWhileStatement(node) {
-        var sb = this.sb;
-        sb.push("while (");
-        this.visitNode(node.condition);
-        var statement = node.body;
-        if (statement.kind == 34) {
+          assert(isTypeOmitted(returnType));
+        } else {
+          if (isTypeOmitted(returnType)) {
             sb.push(")");
+          } else {
+            sb.push("): ");
+            this.visitTypeNode(returnType);
+          }
+        }
+        sb.push(" => ");
+        this.visitNode(body);
+      } else {
+        assert(!isTypeOmitted(returnType));
+        sb.push(" => ");
+        this.visitTypeNode(returnType);
+      }
+    } else {
+      if (!isTypeOmitted(returnType) && !node.isAny(524288 | 4096)) {
+        sb.push("): ");
+        this.visitTypeNode(returnType);
+      } else {
+        sb.push(")");
+      }
+      if (body) {
+        sb.push(" ");
+        this.visitNode(body);
+      }
+    }
+  }
+  visitIfStatement(node) {
+    var sb = this.sb;
+    sb.push("if (");
+    this.visitNode(node.condition);
+    sb.push(") ");
+    var ifTrue = node.ifTrue;
+    this.visitNode(ifTrue);
+    if (ifTrue.kind != 30) {
+      sb.push(";\n");
+    }
+    var ifFalse = node.ifFalse;
+    if (ifFalse) {
+      if (ifTrue.kind == 30) {
+        sb.push(" else ");
+      } else {
+        sb.push("else ");
+      }
+      this.visitNode(ifFalse);
+    }
+  }
+  visitImportDeclaration(node) {
+    var externalName = node.foreignName;
+    var name = node.name;
+    this.visitIdentifierExpression(externalName);
+    if (externalName.text != name.text) {
+      this.sb.push(" as ");
+      this.visitIdentifierExpression(name);
+    }
+  }
+  visitImportStatement(node) {
+    var sb = this.sb;
+    sb.push("import ");
+    var declarations = node.declarations;
+    var namespaceName = node.namespaceName;
+    if (declarations) {
+      let numDeclarations = declarations.length;
+      if (numDeclarations) {
+        sb.push("{\n");
+        let indentLevel = ++this.indentLevel;
+        util.indent(sb, indentLevel);
+        this.visitImportDeclaration(declarations[0]);
+        for (let i = 1; i < numDeclarations; ++i) {
+          sb.push(",\n");
+          util.indent(sb, indentLevel);
+          this.visitImportDeclaration(declarations[i]);
         }
-        else {
-            sb.push(") ");
-            this.visitNode(node.body);
-        }
-    }
-    serializeDecorator(node) {
-        var sb = this.sb;
-        sb.push("@");
-        this.visitNode(node.name);
-        var args = node.args;
-        if (args) {
-            sb.push("(");
-            let numArgs = args.length;
-            if (numArgs) {
-                this.visitNode(args[0]);
-                for (let i = 1; i < numArgs; ++i) {
-                    sb.push(", ");
-                    this.visitNode(args[i]);
-                }
-            }
-            sb.push(")\n");
-        }
-        else {
-            sb.push("\n");
-        }
-        util.indent(sb, this.indentLevel);
-    }
-    serializeParameter(node) {
-        var sb = this.sb;
-        var kind = node.parameterKind;
-        var implicitFieldDeclaration = node.implicitFieldDeclaration;
-        if (implicitFieldDeclaration) {
-            this.serializeAccessModifiers(implicitFieldDeclaration);
-        }
-        if (kind == 2) {
-            sb.push("...");
-        }
-        this.visitIdentifierExpression(node.name);
-        var type = node.type;
-        var initializer = node.initializer;
-        if (type) {
-            if (kind == 1 && !initializer)
-                sb.push("?");
-            if (!isTypeOmitted(type)) {
-                sb.push(": ");
-                this.visitTypeNode(type);
-            }
-        }
-        if (initializer) {
-            sb.push(" = ");
-            this.visitNode(initializer);
-        }
-    }
-    serializeExternalModifiers(node) {
-        var sb = this.sb;
-        if (node.is(2)) {
-            sb.push("export ");
-        }
-        else if (node.is(1)) {
-            sb.push("import ");
-        }
-        else if (node.is(4)) {
-            sb.push("declare ");
-        }
-    }
-    serializeAccessModifiers(node) {
-        var sb = this.sb;
-        if (node.is(256)) {
-            sb.push("public ");
-        }
-        else if (node.is(512)) {
-            sb.push("private ");
-        }
-        else if (node.is(1024)) {
-            sb.push("protected ");
-        }
-        if (node.is(32)) {
-            sb.push("static ");
-        }
-        else if (node.is(128)) {
-            sb.push("abstract ");
-        }
-        if (node.is(64)) {
-            sb.push("readonly ");
-        }
-    }
-    finish() {
-        var ret = this.sb.join("");
-        this.sb = [];
-        return ret;
-    }
+        --this.indentLevel;
+        sb.push("\n} from ");
+      } else {
+        sb.push("{} from ");
+      }
+    } else if (namespaceName) {
+      sb.push("* as ");
+      this.visitIdentifierExpression(namespaceName);
+      sb.push(" from ");
+    }
+    this.visitStringLiteralExpression(node.path);
+  }
+  visitIndexSignature(node) {
+    var sb = this.sb;
+    sb.push("[key: ");
+    this.visitTypeNode(node.keyType);
+    sb.push("]: ");
+    this.visitTypeNode(node.valueType);
+  }
+  visitInterfaceDeclaration(node, isDefault = false) {
+    var decorators = node.decorators;
+    if (decorators) {
+      for (let i = 0, k = decorators.length; i < k; ++i) {
+        this.serializeDecorator(decorators[i]);
+      }
+    }
+    var sb = this.sb;
+    if (isDefault) {
+      sb.push("export default ");
+    } else {
+      this.serializeExternalModifiers(node);
+    }
+    sb.push("interface ");
+    this.visitIdentifierExpression(node.name);
+    var typeParameters = node.typeParameters;
+    if (typeParameters != null && typeParameters.length > 0) {
+      sb.push("<");
+      this.visitTypeParameter(typeParameters[0]);
+      for (let i = 1, k = typeParameters.length; i < k; ++i) {
+        sb.push(", ");
+        this.visitTypeParameter(typeParameters[i]);
+      }
+      sb.push(">");
+    }
+    var extendsType = node.extendsType;
+    if (extendsType) {
+      sb.push(" extends ");
+      this.visitTypeNode(extendsType);
+    }
+    sb.push(" {\n");
+    var indentLevel = ++this.indentLevel;
+    var members = node.members;
+    for (let i = 0, k = members.length; i < k; ++i) {
+      util.indent(sb, indentLevel);
+      this.visitNodeAndTerminate(members[i]);
+    }
+    --this.indentLevel;
+    sb.push("}");
+  }
+  visitMethodDeclaration(node) {
+    var decorators = node.decorators;
+    if (decorators) {
+      for (let i = 0, k = decorators.length; i < k; ++i) {
+        this.serializeDecorator(decorators[i]);
+      }
+    }
+    this.serializeAccessModifiers(node);
+    if (node.is(2048)) {
+      this.sb.push("get ");
+    } else if (node.is(4096)) {
+      this.sb.push("set ");
+    }
+    this.visitFunctionCommon(node);
+  }
+  visitNamespaceDeclaration(node, isDefault = false) {
+    var decorators = node.decorators;
+    if (decorators) {
+      for (let i = 0, k = decorators.length; i < k; ++i) {
+        this.serializeDecorator(decorators[i]);
+      }
+    }
+    var sb = this.sb;
+    if (isDefault) {
+      sb.push("export default ");
+    } else {
+      this.serializeExternalModifiers(node);
+    }
+    sb.push("namespace ");
+    this.visitIdentifierExpression(node.name);
+    var members = node.members;
+    var numMembers = members.length;
+    if (numMembers) {
+      sb.push(" {\n");
+      let indentLevel = ++this.indentLevel;
+      for (let i = 0, k = members.length; i < k; ++i) {
+        util.indent(sb, indentLevel);
+        this.visitNodeAndTerminate(members[i]);
+      }
+      util.indent(sb, --this.indentLevel);
+      sb.push("}");
+    } else {
+      sb.push(" {}");
+    }
+  }
+  visitReturnStatement(node) {
+    var value = node.value;
+    if (value) {
+      this.sb.push("return ");
+      this.visitNode(value);
+    } else {
+      this.sb.push("return");
+    }
+  }
+  visitTrueExpression(node) {
+    this.sb.push("true");
+  }
+  visitFalseExpression(node) {
+    this.sb.push("false");
+  }
+  visitNullExpression(node) {
+    this.sb.push("null");
+  }
+  visitSwitchCase(node) {
+    var sb = this.sb;
+    var label = node.label;
+    if (label) {
+      sb.push("case ");
+      this.visitNode(label);
+      sb.push(":\n");
+    } else {
+      sb.push("default:\n");
+    }
+    var statements = node.statements;
+    var numStatements = statements.length;
+    if (numStatements) {
+      let indentLevel = ++this.indentLevel;
+      util.indent(sb, indentLevel);
+      this.visitNodeAndTerminate(statements[0]);
+      for (let i = 1; i < numStatements; ++i) {
+        util.indent(sb, indentLevel);
+        this.visitNodeAndTerminate(statements[i]);
+      }
+      --this.indentLevel;
+    }
+  }
+  visitSwitchStatement(node) {
+    var sb = this.sb;
+    sb.push("switch (");
+    this.visitNode(node.condition);
+    sb.push(") {\n");
+    var indentLevel = ++this.indentLevel;
+    var cases = node.cases;
+    for (let i = 0, k = cases.length; i < k; ++i) {
+      util.indent(sb, indentLevel);
+      this.visitSwitchCase(cases[i]);
+      sb.push("\n");
+    }
+    --this.indentLevel;
+    sb.push("}");
+  }
+  visitThrowStatement(node) {
+    this.sb.push("throw ");
+    this.visitNode(node.value);
+  }
+  visitTryStatement(node) {
+    var sb = this.sb;
+    sb.push("try {\n");
+    var indentLevel = ++this.indentLevel;
+    var statements = node.bodyStatements;
+    for (let i = 0, k = statements.length; i < k; ++i) {
+      util.indent(sb, indentLevel);
+      this.visitNodeAndTerminate(statements[i]);
+    }
+    var catchVariable = node.catchVariable;
+    if (catchVariable) {
+      util.indent(sb, indentLevel - 1);
+      sb.push("} catch (");
+      this.visitIdentifierExpression(catchVariable);
+      sb.push(") {\n");
+      let catchStatements = node.catchStatements;
+      if (catchStatements) {
+        for (let i = 0, k = catchStatements.length; i < k; ++i) {
+          util.indent(sb, indentLevel);
+          this.visitNodeAndTerminate(catchStatements[i]);
+        }
+      }
+    }
+    var finallyStatements = node.finallyStatements;
+    if (finallyStatements) {
+      util.indent(sb, indentLevel - 1);
+      sb.push("} finally {\n");
+      for (let i = 0, k = finallyStatements.length; i < k; ++i) {
+        util.indent(sb, indentLevel);
+        this.visitNodeAndTerminate(finallyStatements[i]);
+      }
+    }
+    util.indent(sb, indentLevel - 1);
+    sb.push("}");
+  }
+  visitTypeDeclaration(node) {
+    var decorators = node.decorators;
+    if (decorators) {
+      for (let i = 0, k = decorators.length; i < k; ++i) {
+        this.serializeDecorator(decorators[i]);
+      }
+    }
+    var sb = this.sb;
+    this.serializeExternalModifiers(node);
+    sb.push("type ");
+    this.visitIdentifierExpression(node.name);
+    var typeParameters = node.typeParameters;
+    if (typeParameters) {
+      let numTypeParameters = typeParameters.length;
+      if (numTypeParameters) {
+        sb.push("<");
+        for (let i = 0; i < numTypeParameters; ++i) {
+          this.visitTypeParameter(typeParameters[i]);
+        }
+        sb.push(">");
+      }
+    }
+    sb.push(" = ");
+    this.visitTypeNode(node.type);
+  }
+  visitVariableDeclaration(node) {
+    this.visitIdentifierExpression(node.name);
+    var type = node.type;
+    var sb = this.sb;
+    if (node.flags & 16384) {
+      sb.push("!");
+    }
+    if (type) {
+      sb.push(": ");
+      this.visitTypeNode(type);
+    }
+    var initializer = node.initializer;
+    if (initializer) {
+      sb.push(" = ");
+      this.visitNode(initializer);
+    }
+  }
+  visitVariableStatement(node) {
+    var decorators = node.decorators;
+    if (decorators) {
+      for (let i = 0, k = decorators.length; i < k; ++i) {
+        this.serializeDecorator(decorators[i]);
+      }
+    }
+    var sb = this.sb;
+    var declarations = node.declarations;
+    var numDeclarations = declarations.length;
+    var firstDeclaration = declarations[0];
+    this.serializeExternalModifiers(firstDeclaration);
+    sb.push(firstDeclaration.is(8) ? "const " : firstDeclaration.is(16) ? "let " : "var ");
+    this.visitVariableDeclaration(node.declarations[0]);
+    for (let i = 1; i < numDeclarations; ++i) {
+      sb.push(", ");
+      this.visitVariableDeclaration(node.declarations[i]);
+    }
+  }
+  visitWhileStatement(node) {
+    var sb = this.sb;
+    sb.push("while (");
+    this.visitNode(node.condition);
+    var statement = node.body;
+    if (statement.kind == 34) {
+      sb.push(")");
+    } else {
+      sb.push(") ");
+      this.visitNode(node.body);
+    }
+  }
+  serializeDecorator(node) {
+    var sb = this.sb;
+    sb.push("@");
+    this.visitNode(node.name);
+    var args = node.args;
+    if (args) {
+      sb.push("(");
+      let numArgs = args.length;
+      if (numArgs) {
+        this.visitNode(args[0]);
+        for (let i = 1; i < numArgs; ++i) {
+          sb.push(", ");
+          this.visitNode(args[i]);
+        }
+      }
+      sb.push(")\n");
+    } else {
+      sb.push("\n");
+    }
+    util.indent(sb, this.indentLevel);
+  }
+  serializeParameter(node) {
+    var sb = this.sb;
+    var kind = node.parameterKind;
+    var implicitFieldDeclaration = node.implicitFieldDeclaration;
+    if (implicitFieldDeclaration) {
+      this.serializeAccessModifiers(implicitFieldDeclaration);
+    }
+    if (kind == 2) {
+      sb.push("...");
+    }
+    this.visitIdentifierExpression(node.name);
+    var type = node.type;
+    var initializer = node.initializer;
+    if (type) {
+      if (kind == 1 && !initializer) sb.push("?");
+      if (!isTypeOmitted(type)) {
+        sb.push(": ");
+        this.visitTypeNode(type);
+      }
+    }
+    if (initializer) {
+      sb.push(" = ");
+      this.visitNode(initializer);
+    }
+  }
+  serializeExternalModifiers(node) {
+    var sb = this.sb;
+    if (node.is(2)) {
+      sb.push("export ");
+    } else if (node.is(1)) {
+      sb.push("import ");
+    } else if (node.is(4)) {
+      sb.push("declare ");
+    }
+  }
+  serializeAccessModifiers(node) {
+    var sb = this.sb;
+    if (node.is(256)) {
+      sb.push("public ");
+    } else if (node.is(512)) {
+      sb.push("private ");
+    } else if (node.is(1024)) {
+      sb.push("protected ");
+    }
+    if (node.is(32)) {
+      sb.push("static ");
+    } else if (node.is(128)) {
+      sb.push("abstract ");
+    }
+    if (node.is(64)) {
+      sb.push("readonly ");
+    }
+  }
+  finish() {
+    var ret = this.sb.join("");
+    this.sb = [];
+    return ret;
+  }
 }
-//# sourceMappingURL=builder.js.map
+//# sourceMappingURL=builder.js.map