Update package name, update and lock clang-format and tslint versions, and format all source files …

lib/merge.ts

 import ts = require('typescript');
 import base = require('./base');
 import {FacadeConverter} from './facade_converter';
 
 /**
  * To support arbitrary d.ts files in Dart we often have to merge two TypeScript
  * types into a single Dart type because Dart lacks features such as method
  * overloads, type aliases, and union types.
  */
 export class MergedType {
@@ skipping 114 matching lines @@
     nameIdentifier.text = Object.getOwnPropertyNames(this.name).join('_');
     ret.name = nameIdentifier;
     if (this.optional) {
       ret.questionToken = ts.createNode(ts.SyntaxKind.QuestionToken);
     }
     base.copyLocation(this.textRange, ret);
     ret.type = this.type.toTypeNode();
     return ret;
   }
 
-  setOptional() { this.optional = true; }
+  setOptional() {
+    this.optional = true;
+  }
 
   private name: {[s: string]: boolean} = {};
   private type: MergedType;
   private optional: boolean = false;
   private textRange: ts.TextRange;
 }
 
 /**
  * Handle a parameter that is the result of merging parameter declarations from
  * multiple method overloads.
@@ skipping 155 matching lines @@
                 // In JavaScript you could just write new X() and create an
                 // instance of XStatic. We don't
                 let typeRef = type as ts.TypeReferenceNode;
                 let typeName = typeRef.typeName;
                 let symbol = fc.tc.getSymbolAtLocation(typeName);
                 if (symbol == null) return;
                 let decl = fc.getSymbolDeclaration(symbol, typeName);
                 if (decl == null) return;
                 if (decl.kind !== ts.SyntaxKind.InterfaceDeclaration) return;
                 let interfaceDecl = decl as base.ExtendedInterfaceDeclaration;
-                if (!interfaceDecl.members.some(
-                        (member) => { return member.kind === ts.SyntaxKind.ConstructSignature; }))
+                if (!interfaceDecl.members.some((member) => {
+                      return member.kind === ts.SyntaxKind.ConstructSignature;
+                    }))
                   return;
 
                 if (interfaceDecl.classLikeVariableDeclaration == null) {
                   // We could add extra logic to be safer such as only infering that variable names
                   // are class like for cases where variable names are UpperCamelCase matching JS
                   // conventions that a variable is a Class definition.
                   interfaceDecl.classLikeVariableDeclaration = declaration;
                 }
               }
             }
@@ skipping 160 matching lines @@
         break;
       case ts.SyntaxKind.ModuleBlock:
         ts.forEachChild(n, (child) => gatherClasses(child, classes));
         break;
       default:
         break;
     }
   }
   gatherClasses(f, {});
 }