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

lib/main.ts

 import * as dartStyle from 'dart-style';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
-
 import * as base from './base';
 import {ImportSummary, TranspilerBase} from './base';
 import DeclarationTranspiler from './declaration';
 import {FacadeConverter} from './facade_converter';
 import * as merge from './merge';
 import mkdirP from './mkdirp';
 import ModuleTranspiler from './module';
 import TypeTranspiler from './type';
 
 export interface TranspilerOptions {
@@ skipping 51 matching lines @@
 
 const NUM_OUTPUT_CONTEXTS = 3;
 
 export class Transpiler {
   private outputs: Output[];
   private outputStack: Output[];
   private currentFile: ts.SourceFile;
   /**
    * Map of import library path to a Set of identifier names being imported.
    */
-  imports: ts.Map<ImportSummary>;
+  imports: Map<String, ImportSummary>;
   // Comments attach to all following AST nodes before the next 'physical' token. Track the earliest
   // offset to avoid printing comments multiple times.
   private lastCommentIdx: number = -1;
   private errors: string[] = [];
 
   private transpilers: TranspilerBase[];
   private declarationTranspiler: DeclarationTranspiler;
   private fc: FacadeConverter;
   /* Number of nested levels of type arguments the current expression is within. */
   private typeArgumentDepth = 0;
 
-  constructor(private options: TranspilerOptions = {}) {
+  constructor(private options: TranspilerOptions) {
+    this.options = this.options || {};
     this.fc = new FacadeConverter(this, options.typingsRoot);
     this.declarationTranspiler = new DeclarationTranspiler(
         this, this.fc, options.enforceUnderscoreConventions, options.promoteFunctionLikeMembers);
     this.transpilers = [
       new ModuleTranspiler(this, this.fc, options.moduleName),
       this.declarationTranspiler,
       new TypeTranspiler(this, this.fc),
     ];
   }
 
@@ skipping 130 matching lines @@
     if (this.outputStack.length === 0) {
       this.reportError(null, 'Attempting to pop output stack when already empty');
     }
     this.outputStack.pop();
   }
 
   private translate(sourceFile: ts.SourceFile): string {
     this.currentFile = sourceFile;
     this.outputs = [];
     this.outputStack = [];
-    this.imports = {};
+    this.imports = new Map();
     for (let i = 0; i < NUM_OUTPUT_CONTEXTS; ++i) {
       this.outputs.push(new Output());
     }
 
     this.lastCommentIdx = -1;
     merge.normalizeSourceFile(sourceFile, this.fc);
     this.pushContext(OutputContext.Default);
     this.visit(sourceFile);
     this.popContext();
     if (this.outputStack.length > 0) {
       this.reportError(
           sourceFile, 'Internal error managing output contexts. ' +
               'Inconsistent push and pop context calls.');
     }
     this.pushContext(OutputContext.Import);
 
-    for (let name of Object.getOwnPropertyNames(this.imports)) {
-      let summary = this.imports[name];
+    this.imports.forEach((summary, name) => {
       this.emit(`import ${JSON.stringify(name)}`);
 
       if (!summary.showAll) {
-        let shownNames = Object.getOwnPropertyNames(summary.shown);
+        let shownNames = Array.from(summary.shown);
         if (shownNames.length > 0) {
           this.emit(`show ${shownNames.join(', ')}`);
         }
       }
       if (summary.asPrefix) {
         this.emit(`as ${summary.asPrefix}`);
       }
       this.emit(';\n');
-    }
+    });
     this.popContext();
 
     let result = '';
     for (let output of this.outputs) {
       result += output.getResult();
     }
     return this.formatCode(result, sourceFile);
   }
 
   private formatCode(code: string, context: ts.Node) {
@@ skipping 313 matching lines @@
   try {
     let transpiler = new Transpiler(args);
     if (args.destination) console.error('Transpiling', args._, 'to', args.destination);
     transpiler.transpile(args._, args.destination);
   } catch (e) {
     if (e.name !== 'DartFacadeError') throw e;
     console.error(e.message);
     process.exit(1);
   }
 }