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

package/transform/lib/builder.js

@@ -1,1275 +1,1353 @@
 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(">");
+    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);
-        break;
-      }
-      case 1: {
+        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(" as ");
-        if (node.toType) this.visitTypeNode(node.toType);
-        break;
-      }
-      case 2: {
+        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);
-        sb.push("!");
-        break;
-      }
-      case 3: {
+        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(" 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) {
-          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]);
+    }
+    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) {
+                    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("\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;
-  }
+        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