flow-remove-types 1.0.5 → 1.2.0

package/LICENSE

@@ -0,0 +1,30 @@
+BSD License
+
+For flow-remove-types software
+
+Copyright (c) 2014-2016, Facebook, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+ * Neither the name Facebook nor the names of its contributors may be used to
+   endorse or promote products derived from this software without specific
+   prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/PATENTS

@@ -0,0 +1,11 @@
+Additional Grant of Patent Rights Version 2
+
+"Software" means the flow-remove-types software distributed by Facebook, Inc.
+
+Facebook, Inc. (“Facebook”) hereby grants to each recipient of the Software (“you”) a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (subject to the termination provision below) license under any Necessary Claims, to make, have made, use, sell, offer to sell, import, and otherwise transfer the Software. For avoidance of doubt, no license is granted under Facebook’s rights in any patent claims that are infringed by (i) modifications to the Software made by you or any third party or (ii) the Software in combination with any software or other technology.
+
+The license granted hereunder will terminate, automatically and without notice, if you (or any of your subsidiaries, corporate affiliates or agents) initiate directly or indirectly, or take a direct financial interest in, any Patent Assertion: (i) against Facebook or any of its subsidiaries or corporate affiliates, (ii) against any party if such Patent Assertion arises in whole or in part from any software, technology, product or service of Facebook or any of its subsidiaries or corporate affiliates, or (iii) against any party relating to the Software. Notwithstanding the foregoing, if Facebook or any of its subsidiaries or corporate affiliates files a lawsuit alleging patent infringement against you in the first instance, and you respond by filing a patent infringement counterclaim in that lawsuit against that party that is unrelated to the Software, the license granted hereunder will not terminate under section (i) of this paragraph due to such counterclaim.
+
+A “Necessary Claim” is a claim of a patent owned by Facebook that is necessarily infringed by the Software standing alone.
+
+A “Patent Assertion” is any lawsuit or other action alleging direct, indirect, or contributory infringement or inducement to infringe any patent, including a cross-claim or counterclaim.

package/README.md

@@ -2,7 +2,7 @@ flow-remove-types
 =================
 
 [![npm](https://img.shields.io/npm/v/flow-remove-types.svg?maxAge=86400)](https://www.npmjs.com/package/flow-remove-types)
-[![Build Status](https://img.shields.io/travis/leebyron/flow-remove-types.svg?style=flat&label=travis&branch=master)](https://travis-ci.org/leebyron/flow-remove-types)
+[![Build Status](https://img.shields.io/travis/flowtype/flow-remove-types.svg?style=flat&label=travis&branch=master)](https://travis-ci.org/flowtype/flow-remove-types)
 
 Turn your JavaScript with [Flow](https://flowtype.org/) type annotations into
 standard JavaScript in an instant with no configuration and minimal setup.
@@ -46,16 +46,24 @@ var fs = require('fs');
 
 var input = fs.readFileSync('input.js', 'utf8');
 var output = flowRemoveTypes(input);
-fs.writeFileSync('output.js', output);
+fs.writeFileSync('output.js', output.toString());
 ```
 
 
 ## Use in Build Systems:
 
-**Rollup**: [`rollup-plugin-flow`](https://github.com/leebyron/rollup-plugin-flow)
+**Rollup:** [`rollup-plugin-flow`](https://github.com/leebyron/rollup-plugin-flow)
 
 **Browserify:** [`unflowify`](https://github.com/leebyron/unflowify)
 
+**Webpack:** [`remove-flow-types-loader`](https://github.com/conorhastings/remove-flow-types-loader)
+
+
+## Use with existing development tools
+
+ * ESLint: [eslint-plugin-flowtype](https://github.com/gajus/eslint-plugin-flowtype)
+ * Mocha: `mocha -r flow-remove-types/register`
+
 
 ## Use `flow-node`
 
@@ -74,13 +82,33 @@ undefined
 ## Use the require hook
 
 Using the require hook allows you to automatically compile files on the fly when
-requiring in node:
+requiring in node, useful during development:
 
 ```js
 require('flow-remove-types/register')
 require('./some-module-with-flow-type-syntax')
 ```
 
+You can also provide options to the require hook:
+
+```js
+// Transforms all files, not just those with a "@flow" comment.
+require('flow-remove-types/register')({ all: true })
+```
+
+Use options to define exactly which files to `includes` or `excludes` with regular
+expressions. All files are included by default except those found in the
+`node_modules` folder, which is excluded by default.
+
+```js
+require('flow-remove-types/register')({ includes: /\/custom_path\// })
+```
+
+> #### Don't use the require hook in packages distributed on NPM
+> As always, don't forget to use `flow-remove-types` to compile files before distributing
+> your code on npm, as using the require hook affects the whole runtime and not
+> just your module and may hurt the runtime performance of code that includes it.
+
 
 ## Dead-Simple Transforms
 
@@ -138,6 +166,27 @@ export class MyClass    extends SomeClass                          {
 }
 ```
 
+### Pretty Transform
+
+Rather not have the whitespace? Pass the `--pretty` flag to remove the whitespace.
+
+```
+flow-remove-types --pretty --sourcemaps source.js
+```
+
+Or using the JS API:
+
+```js
+var flowRemoveTypes = require('flow-remove-types');
+var fs = require('fs');
+
+var input = fs.readFileSync('input.js', 'utf8');
+var output = flowRemoveTypes(input, { pretty: true });
+fs.writeFileSync('output.js', output.toString());
+var sourceMap = output.generateMap();
+fs.writeFileSync('output.js.map', JSON.stringify(sourceMap));
+```
+
 
 ## Performance
 

package/flow-node

@@ -7,8 +7,7 @@ var repl = require('repl');
 var util = require('util');
 var vm = require('vm');
 
-var removeTypes = require('./index');
-require('./register');
+var flowRemoveTypes = require('./index');
 
 var usage = 'Usage: flow-node [options] [ script.js ] [arguments] \n' +
 
@@ -18,11 +17,13 @@ var usage = 'Usage: flow-node [options] [ script.js ] [arguments] \n' +
 '  -e, --eval script     Evaluate script\n' +
 '  -p, --print script    Evaluate script and print result\n' +
 '  -c, --check           Syntax check script without executing\n';
+'  -a, --all             Interpret all files as flow-typed, not just those with a @flow comment\n';
 
 // Collect arguments
 var evalScript;
 var printScript;
 var checkSource;
+var all;
 var source;
 var i = 2;
 while (i < process.argv.length) {
@@ -47,12 +48,16 @@ while (i < process.argv.length) {
     }
   } else if (arg === '-c' || arg === '--check') {
     checkSource = true;
+  } else if (arg === '-a' || arg === '--all') {
+    all = true;
   } else if (arg[0] !== '-') {
     source = arg;
     break;
   }
 }
 
+require('./register')({ all: all });
+
 // Evaluate and possibly also print a script.
 if (evalScript || printScript) {
   global.__filename = '[eval]';
@@ -64,7 +69,7 @@ if (evalScript || printScript) {
   global.module = evalModule;
   global.require = evalModule.require.bind(evalModule);
   var result = vm.runInThisContext(
-    removeTypes(evalScript || printScript, { checkPragma: false }),
+    flowRemoveTypes(evalScript || printScript, { all: true }).toString(),
     { filename: global.__filename }
   );
 
@@ -76,7 +81,7 @@ if (evalScript || printScript) {
 } else if (source && checkSource) {
   var code = fs.readFileSync(source, 'utf8');
   try {
-    removeTypes(code);
+    flowRemoveTypes(code, { all: all });
   } catch (error) {
     var lines = code.split(/\r\n?|\n|\u2028|\u2029/);
     process.stdout.write(source + ':' + error.loc.line + '\n');
@@ -108,7 +113,7 @@ if (evalScript || printScript) {
       var error;
       var result;
       try {
-        var runCode = removeTypes(code, { checkPragma: false });
+        var runCode = flowRemoveTypes(code, { all: true }).toString();
         try {
           result = vm.runInThisContext(runCode, { filename: filename });
         } catch (runError) {

package/flow-remove-types

@@ -14,6 +14,11 @@ var usage = 'Usage: flow-remove-types [options] [sources] \n' +
 '  -x, --extensions  File extensions to transform\n' +
 '  -o, --out-file    The file path to write transformed file to\n' +
 '  -d, --out-dir     The directory path to write transformed files within\n' +
+'  -a, --all         Transform all files, not just those with a @flow comment\n' +
+'  -p, --pretty      Remove flow types without replacing with spaces, \n' +
+'                    producing prettier output but may require using source maps\n' +
+'  -m, --sourcemaps  Also output source map files. Optionally pass "inline"\n' +
+'  -q, --quiet       Does not produce any output concerning successful progress.\n' +
 
 '\nExamples:\n' +
 
@@ -26,14 +31,15 @@ var usage = 'Usage: flow-remove-types [options] [sources] \n' +
 '\nTransform files in directory:\n' +
 '  flow-remove-types --out-dir out/ indir/\n' +
 
+'\nTransform files with source maps:\n' +
+'  flow-remove-types --out-dir out/ indir/ --sourcemaps\n' +
+
+'\nTransform files with inline source maps:\n' +
+'  flow-remove-types --out-dir out/ indir/ --sourcemaps inline\n' +
+
 '\nTransform stdin:\n' +
 '  cat input.js | flow-remove-types > output.js\n';
 
-function error(msg) {
-  process.stderr.write('\n\033[31m  ' + msg + '\033[0m\n\n');
-  process.exit(1);
-}
-
 var _memo = {};
 
 function mkdirp(dirpath) {
@@ -65,6 +71,11 @@ var ignore = /node_modules/;
 var extensions = [ '.js', '.jsx', '.flow', '.es6' ];
 var outDir;
 var outFile;
+var all;
+var pretty;
+var sourceMaps;
+var inlineSourceMaps;
+var quiet;
 var sources = [];
 var i = 2;
 while (i < process.argv.length) {
@@ -83,11 +94,34 @@ while (i < process.argv.length) {
     outFile = process.argv[i++];
   } else if (arg === '-d' || arg === '--out-dir') {
     outDir = process.argv[i++];
+  } else if (arg === '-a' || arg === '--all') {
+    all = true;
+  } else if (arg === '-p' || arg === '--pretty') {
+    pretty = true;
+  } else if (arg === '-m' || arg === '--sourcemaps') {
+    sourceMaps = true;
+    if (process.argv[i] === 'inline') {
+      inlineSourceMaps = true;
+      i++;
+    }
+  } else if (arg === '-q' || arg === '--quiet') {
+    quiet = true;
   } else {
     sources.push(arg);
   }
 }
 
+function info(msg) {
+  if (!quiet) {
+    process.stderr.write(msg);
+  }
+}
+
+function error(msg) {
+  process.stderr.write('\n\033[31m  ' + msg + '\033[0m\n\n');
+  process.exit(1);
+}
+
 // Validate arguments
 if (outDir && outFile) {
   error('Only specify one of --out-dir or --out-file');
@@ -97,6 +131,10 @@ if (outDir && sources.length === 0) {
   error('Must specify files when providing --out-dir');
 }
 
+if (!outDir && !outFile && sourceMaps && !inlineSourceMaps) {
+  error('Must specify either an output path or inline source maps');
+}
+
 // Ensure all sources exist
 for (var i = 0; i < sources.length; i++) {
   try {
@@ -116,12 +154,7 @@ if (sources.length === 0) {
   process.stdin.resume();
   process.stdin.on('data', function (str) { content += str; });
   process.stdin.on('end', function () {
-    var result = transformSource(content, '<stdin>');
-    if (outFile) {
-      fs.writeFileSync(outFile, result);
-    } else {
-      process.stdout.write(result);
-    }
+    transformAndOutput(content, outFile);
   });
   return;
 }
@@ -145,24 +178,60 @@ for (var i = 0; i < sources.length; i++) {
       }
     }
   } else if (stat.isFile() && extensions.indexOf(path.extname(source)) !== -1) {
-    var content = fs.readFileSync(source, 'utf8');
-    var result = transformSource(content, source);
     if (outDir) {
       outFile = path.join(outDir, isDirSource ? path.relative(sources[0], source) : source);
       mkdirp(path.dirname(outFile));
     }
-    if (outFile) {
-      fs.writeFileSync(outFile, result);
-      process.stdout.write(source + '\n \u21B3 \033[32m' + outFile + '\033[0m\n');
+    var content = fs.readFileSync(source, 'utf8');
+    transformAndOutput(content, outFile, source);
+  }
+}
+
+function transformAndOutput(content, outFile, source) {
+  var fileName = source || '<stdin>';
+  var result = transformSource(content, fileName);
+  var code = result.toString();
+
+  if (sourceMaps) {
+    var map = result.generateMap();
+    delete map.file;
+    map.sources[0] = fileName;
+
+    if (source) {
+      delete map.sourcesContent;
+      if (outFile) {
+        map.sources[0] = path.join(path.relative(path.dirname(outFile), path.dirname(source)), path.basename(source));
+      }
     } else {
-      process.stdout.write(result);
+      map.sourcesContent[0] = content;
+    }
+
+    code += '\n//# sourceMappingURL=' + (inlineSourceMaps ?
+      'data:application/json;charset=utf-8;base64,' + btoa(JSON.stringify(map)) :
+      path.basename(outFile) + '.map'
+    ) + '\n';
+  }
+
+  if (outFile) {
+    fs.writeFileSync(outFile, code);
+    info(fileName + '\n \u21B3 \033[32m' + outFile + '\033[0m\n');
+    if (sourceMaps && !inlineSourceMaps) {
+      var mapOutFile = outFile + '.map';
+      fs.writeFileSync(mapOutFile, JSON.stringify(map) + '\n');
+      info('\033[2m \u21B3 \033[32m' + mapOutFile + '\033[0m\n');
     }
+  } else {
+    process.stdout.write(code);
   }
 }
 
+function btoa(str) {
+  return (Buffer.from ? Buffer.from(str) : new Buffer(str)).toString('base64');
+}
+
 function transformSource(content, filepath) {
   try {
-    return flowRemoveTypes(content);
+    return flowRemoveTypes(content, { all: all, pretty: pretty });
   } catch (error) {
     if (error.loc) {
       var line = error.loc.line - 1;

package/index.js

@@ -1,4 +1,5 @@
 var babylon = require('babylon');
+var vlq = require('vlq');
 
 /**
  * Given a string JavaScript source which contains Flow types, return a string
@@ -6,23 +7,57 @@ var babylon = require('babylon');
  *
  * Options:
  *
- *   - checkPragma: (default: true) looks for an @flow pragma before parsing.
+ *   - all: (default: false)
+ *     If true, bypasses looking for an @flow pragma comment before parsing.
+ *
+ *   - pretty: (default: false)
+ *     If true, removes types completely rather than replacing with spaces.
+ *     This may require using source maps.
+ *
+ * Returns an object with two methods:
+ *
+ *   - .toString()
+ *     Returns the transformed source code.
+ *
+ *   - .generateMap()
+ *     Returns a v3 source map.
  */
 module.exports = function flowRemoveTypes(source, options) {
+  // Options
+  var all = Boolean(options && options.all);
+  if (options && options.checkPragma) {
+    throw new Error(
+      'flow-remove-types: the "checkPragma" option has been replaced by "all".'
+    );
+  }
+
   // If there's no @flow or @noflow flag, then expect no annotation.
-  var pragmaStart = source.indexOf('@flow');
-  var pragmaEnd = pragmaStart + 5;
+  var pragmaStart = source.indexOf('@' + 'flow');
+  var pragmaSize = 5;
   if (pragmaStart === -1) {
-    pragmaStart = source.indexOf('@noflow');
-    pragmaEnd = pragmaStart + 7;
-    if (pragmaStart === -1 && !(options && options.checkPragma === false)) {
-      return source;
+    pragmaStart = source.indexOf('@' + 'noflow');
+    pragmaSize = 7;
+    if (pragmaStart === -1 && !all) {
+      return resultPrinter(options, source);
     }
   }
 
-  var removedNodes = pragmaStart === -1 ?
-    [] :
-    [ { start: pragmaStart, end: pragmaEnd } ];
+  var removedNodes = [];
+
+  // Remove the flow pragma.
+  if (pragmaStart !== -1) {
+    var prePragmaLines = source.slice(0, pragmaStart).split('\n');
+    var pragmaLine = prePragmaLines.length;
+    var pragmaCol = prePragmaLines[pragmaLine - 1].length;
+    removedNodes.push({
+      start: pragmaStart,
+      end: pragmaStart + pragmaSize,
+      loc: {
+        start: { line: pragmaLine, column: pragmaCol },
+        end: { line: pragmaLine, column: pragmaCol + pragmaSize }
+      },
+    })
+  }
 
   // Babylon is one of the sources of truth for Flow syntax. This parse
   // configuration is intended to be as permissive as possible.
@@ -34,33 +69,61 @@ module.exports = function flowRemoveTypes(source, options) {
     plugins: [ '*', 'jsx', 'flow' ],
   });
 
-  visit(ast, removedNodes, removeFlowVisitor);
+  var context = {
+    ast: ast,
+    source: source,
+    removedNodes: removedNodes,
+    pretty: Boolean(options && options.pretty)
+  };
 
-  if (removedNodes.length === 0) {
-    return source;
-  }
+  visit(ast, context, removeFlowVisitor);
 
-  var result = '';
-  var lastPos = 0;
+  return resultPrinter(options, source, removedNodes);
+}
 
-  // Step through the removed nodes, building up the resulting string.
-  for (var i = 0; i < removedNodes.length; i++) {
-    var node = removedNodes[i];
-    result += source.slice(lastPos, node.start);
-    var toReplace = source.slice(node.start, node.end);
-    lastPos = node.end;
-    if (!node.loc || node.loc.start.line === node.loc.end.line) {
-      result += space(toReplace.length);
-    } else {
-      var toReplaceLines = toReplace.split(LINE_RX);
-      result += space(toReplaceLines[0].length);
-      for (var j = 1; j < toReplaceLines.length; j += 2) {
-        result += toReplaceLines[j] + space(toReplaceLines[j + 1].length);
+function resultPrinter(options, source, removedNodes) {
+  // Options
+  var pretty = Boolean(options && options.pretty);
+
+  return {
+    toString: function () {
+      if (!removedNodes || removedNodes.length === 0) {
+        return source;
+      }
+
+      var result = '';
+      var lastPos = 0;
+
+      // Step through the removed nodes, building up the resulting string.
+      for (var i = 0; i < removedNodes.length; i++) {
+        var node = removedNodes[i];
+        result += source.slice(lastPos, node.start);
+        lastPos = node.end;
+        if (!pretty) {
+          var toReplace = source.slice(node.start, node.end);
+          if (!node.loc || node.loc.start.line === node.loc.end.line) {
+            result += space(toReplace.length);
+          } else {
+            var toReplaceLines = toReplace.split(LINE_RX);
+            result += space(toReplaceLines[0].length);
+            for (var j = 1; j < toReplaceLines.length; j += 2) {
+              result += toReplaceLines[j] + space(toReplaceLines[j + 1].length);
+            }
+          }
+        }
       }
+
+      return result += source.slice(lastPos);
+    },
+    generateMap: function () {
+      return {
+        version: 3,
+        sources: [ 'source.js' ],
+        names: [],
+        mappings: pretty ? generateSourceMappings(removedNodes) : ''
+      };
     }
   }
-
-  return result += source.slice(lastPos);
 }
 
 var LINE_RX = /(\r\n?|\n|\u2028|\u2029)/;
@@ -83,39 +146,56 @@ var removeFlowVisitor = {
   ClassDeclaration: removeImplementedInterfaces,
   ClassExpression: removeImplementedInterfaces,
 
-  Identifier: function (removedNodes, node, ast) {
+  Identifier: function (context, node, ast) {
     if (node.optional) {
       // Find the optional token.
       var idx = findTokenIndex(ast.tokens, node.start);
       do {
         idx++;
       } while (ast.tokens[idx].type.label !== '?');
-      removeNode(removedNodes, ast.tokens[idx]);
+      removeNode(context, ast.tokens[idx]);
     }
   },
 
-  ClassProperty: function (removedNodes, node) {
+  ClassProperty: function (context, node) {
     if (!node.value) {
-      return removeNode(removedNodes, node)
+      return removeNode(context, node)
     }
   },
 
-  ExportNamedDeclaration: function (removedNodes, node) {
-    if (node.exportKind === 'type') {
-      return removeNode(removedNodes, node);
+  ExportNamedDeclaration: function (context, node) {
+    if (node.exportKind === 'type' || node.exportKind === 'typeof') {
+      return removeNode(context, node);
     }
   },
 
-  ImportDeclaration: function (removedNodes, node) {
-    if (node.importKind === 'type') {
-      return removeNode(removedNodes, node);
+  ImportDeclaration: function (context, node) {
+    if (node.importKind === 'type' || node.importKind === 'typeof') {
+      return removeNode(context, node);
+    }
+  },
+
+  ImportSpecifier: function(context, node) {
+    if (node.importKind === 'type' || node.importKind === 'typeof') {
+      removeNode(context, node);
+
+      // Remove trailing comma
+      var ast = context.ast;
+      var idx = findTokenIndex(ast.tokens, node.end);
+      while (isComment(ast.tokens[idx])) {
+        idx++;
+      }
+      if (ast.tokens[idx].type.label === ',') {
+        removeNode(context, ast.tokens[idx]);
+      }
+      return false;
     }
   }
 };
 
 // If this class declaration or expression implements interfaces, remove
 // the associated tokens.
-function removeImplementedInterfaces(removedNodes, node, ast) {
+function removeImplementedInterfaces(context, node, ast) {
   if (node.implements && node.implements.length > 0) {
     var first = node.implements[0];
     var last = node.implements[node.implements.length - 1];
@@ -126,9 +206,8 @@ function removeImplementedInterfaces(removedNodes, node, ast) {
 
     var lastIdx = findTokenIndex(ast.tokens, last.start);
     do {
-      if (ast.tokens[idx].type !== 'CommentBlock' &&
-          ast.tokens[idx].type !== 'CommentLine') {
-        removeNode(removedNodes, ast.tokens[idx]);
+      if (!isComment(ast.tokens[idx])) {
+        removeNode(context, ast.tokens[idx]);
       }
     } while (idx++ !== lastIdx);
   }
@@ -136,17 +215,131 @@ function removeImplementedInterfaces(removedNodes, node, ast) {
 
 // Append node to the list of removed nodes, ensuring the order of the nodes
 // in the list.
-function removeNode(removedNodes, node) {
+function removeNode(context, node) {
+  var removedNodes = context.removedNodes;
   var length = removedNodes.length;
   var index = length;
+
+  // Check for line's leading and trailing space to be removed.
+  var spaceNode = context.pretty ? getLeadingSpaceNode(context, node) : null;
+  var lineNode = context.pretty ? getTrailingLineNode(context, node) : null;
+
   while (index > 0 && removedNodes[index - 1].end > node.start) {
     index--;
   }
+
   if (index === length) {
+    if (spaceNode) {
+      removedNodes.push(spaceNode);
+    }
     removedNodes.push(node);
+    if (lineNode) {
+      removedNodes.push(lineNode);
+    }
   } else {
-    removedNodes.splice(index, 0, node);
+    if (lineNode) {
+      if (spaceNode) {
+        removedNodes.splice(index, 0, spaceNode, node, lineNode);
+      } else {
+        removedNodes.splice(index, 0, node, lineNode);
+      }
+    } else if (spaceNode) {
+      removedNodes.splice(index, 0, spaceNode, node);
+    } else {
+      removedNodes.splice(index, 0, node);
+    }
+  }
+
+  return false;
+}
+
+function getLeadingSpaceNode(context, node) {
+  var source = context.source;
+  var end = node.start;
+  var start = end;
+  while (source[start - 1] === ' ' || source[start - 1] === '\t') {
+    start--;
+  }
+  if (start !== end) {
+    return {
+      start: start,
+      end: end,
+      loc: { start: node.loc.start, end: node.loc.start }
+    };
+  }
+}
+
+function getTrailingLineNode(context, node) {
+  var source = context.source;
+  var start = node.end;
+  var end = start;
+  while (source[end] === ' ' || source[end] === '\t') {
+    end++;
+  }
+
+  // Remove all space including the line break if this token was alone on the line.
+  if (source[end] === '\n' || source[end] === '\r') {
+    if (source[end] === '\r' && source[end + 1] === '\n') {
+      end++;
+    }
+    end++;
+
+    if (isLastNodeRemovedFromLine(context, node)) {
+      return {
+        start: start,
+        end: end,
+        loc: { start: node.loc.end, end: node.loc.end }
+      };
+    }
+  }
+}
+
+// Returns true if node is the last to be removed from a line.
+function isLastNodeRemovedFromLine(context, node) {
+  var tokens = context.ast.tokens;
+  var priorTokenIdx = findTokenIndex(tokens, node.start) - 1;
+  var token = tokens[priorTokenIdx];
+  var line = node.loc.end.line;
+
+  // Find previous token that was not removed on the same line.
+  while (priorTokenIdx >= 0 &&
+         token.loc.end.line === line &&
+         isRemovedToken(context, token)) {
+    token = tokens[--priorTokenIdx]
+  }
+
+  // If there's no prior token (start of file), or the prior token is on another
+  // line, this line must be fully removed.
+  return !token || token.loc.end.line !== line;
+}
+
+// Returns true if the provided token was previously marked as removed.
+function isRemovedToken(context, token) {
+  var removedNodes = context.removedNodes;
+  var nodeIdx = removedNodes.length - 1;
+
+  // Find the last removed node which could possibly contain this token.
+  while (nodeIdx >= 0 && removedNodes[nodeIdx].start > token.start) {
+    nodeIdx--;
+  }
+
+  var node = removedNodes[nodeIdx];
+
+  // This token couldn't be removed if not contained within the removed node.
+  if (nodeIdx === -1 || node.end < token.end) {
+    return false;
+  }
+
+  // Iterate through the tokens contained by the removed node to find a match.
+  var tokens = context.ast.tokens;
+  var tokenIdx = findTokenIndex(tokens, node.start);
+  while (tokens[tokenIdx].end <= node.end) {
+    if (token === tokens[tokenIdx]) {
+      return true;
+    }
+    tokenIdx++;
   }
+
   return false;
 }
 
@@ -204,6 +397,11 @@ function findTokenIndex(tokens, offset) {
   return ptr;
 }
 
+// True if the provided token is a comment.
+function isComment(token) {
+  return token.type === 'CommentBlock' || token.type === 'CommentLine';
+}
+
 // Produce a string full of space characters of a given size.
 function space(size) {
   var sp = ' '
@@ -221,3 +419,37 @@ function space(size) {
   }
   return result;
 }
+
+// Generate a source map when *removing* nodes rather than replacing them
+// with spaces.
+function generateSourceMappings(removedNodes) {
+  var mappings = '';
+  if (!removedNodes || removedNodes.length === '') {
+    return mappings;
+  }
+
+  var end = { line: 1, column: 0 };
+
+  for (var i = 0; i < removedNodes.length; i++) {
+    var start = removedNodes[i].loc.start;
+    var lineDiff = start.line - end.line;
+    var columnDiff = start.column - end.column;
+    if (lineDiff) {
+      for (var l = 0; l !== lineDiff; l++) {
+        mappings += ';';
+      }
+      mappings += vlq.encode([ start.column, 0, lineDiff, columnDiff ]);
+    } else if (columnDiff) {
+      if (i) {
+        mappings += ',';
+      }
+      mappings += vlq.encode([ columnDiff, 0, lineDiff, columnDiff ]);
+    }
+
+    end = removedNodes[i].loc.end;
+    mappings += ',';
+    mappings += vlq.encode([ 0, 0, end.line - start.line, end.column - start.column ]);
+  }
+
+  return mappings;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flow-remove-types",
-  "version": "1.0.5",
+  "version": "1.2.0",
   "description": "Removes Flow type annotations from JavaScript files with speed and simplicity.",
   "author": "Lee Byron <lee@leebyron.com> (http://leebyron.com/)",
   "license": "BSD-3-Clause",
@@ -9,17 +9,25 @@
     "flow-remove-types": "./flow-remove-types",
     "flow-node": "./flow-node"
   },
-  "homepage": "https://github.com/leebyron/flow-remove-types",
+  "files": [
+    "index.js",
+    "register.js",
+    "flow-remove-types",
+    "flow-node",
+    "LICENSE",
+    "PATENTS"
+  ],
+  "homepage": "https://github.com/flowtype/flow-remove-types",
   "bugs": {
-    "url": "https://github.com/leebyron/flow-remove-types/issues"
+    "url": "https://github.com/flowtype/flow-remove-types/issues"
   },
   "repository": {
     "type": "git",
-    "url": "http://github.com/leebyron/flow-remove-types.git"
+    "url": "http://github.com/flowtype/flow-remove-types.git"
   },
   "scripts": {
-    "test": "DIFF=$(./flow-remove-types test/source.js | diff test/expected.js -); if [ -n \"$DIFF\" ]; then echo \"$DIFF\"; exit 1; fi; RES=$(node -e 'require(\"./register\");require(\"./test/test-node-module.js\")'); if [ \"$RES\" != 42 ]; then echo 'Node register hook failed'; exit 1; fi; FLOW_NODE=$(./flow-node ./test/test-node-module.js); if [ \"$FLOW_NODE\" != 42 ]; then echo 'flow-node failed'; exit 1; fi;",
-    "test-update": "./flow-remove-types test/source.js > test/expected.js"
+    "test": "./test.sh",
+    "test-update": "./test-update.sh"
   },
   "keywords": [
     "flow",
@@ -30,6 +38,7 @@
     "es6"
   ],
   "dependencies": {
-    "babylon": "^6.8.4"
+    "babylon": "^6.15.0",
+    "vlq": "^0.2.1"
   }
 }

package/register.js

@@ -1,13 +1,66 @@
-var Module = require('module');
-var removeTypes = require('./index');
-
-// Rather than use require.extensions, swizzle Module#_compile. Not only does
-// this typically leverage the existing behavior of require.extensions['.js'],
-// but allows for use alongside other "require extension hook" if necessary.
-var super_compile = Module.prototype._compile;
-Module.prototype._compile = function _compile(source, filename) {
-  var transformedSource = filename.indexOf('node_modules/') === -1
-    ? removeTypes(source)
-    : source;
-  super_compile.call(this, transformedSource, filename);
-};
+var flowRemoveTypes = require('./index');
+
+// Supported options:
+//
+//   - all: Transform all files, not just those with a @flow comment.
+//   - includes: A Regexp/String to determine which files should be transformed.
+//               (alias: include)
+//   - excludes: A Regexp/String to determine which files should not be
+//               transformed, defaults to ignoring /node_modules/, provide null
+//               to exclude nothing. (alias: exclude)
+var options;
+module.exports = function setOptions(newOptions) {
+  options = newOptions;
+}
+
+// Swizzle Module#_compile on each applicable module instance.
+// NOTE: if using alongside Babel or another require-hook which simply
+// over-writes the require.extensions and does not continue execution, then
+// this require hook must come after it. Encourage those module authors to call
+// the prior loader in their require hooks.
+var jsLoader = require.extensions['.js'];
+var exts = [ '.js', '.jsx', '.flow', '.es6' ];
+exts.forEach(function (ext) {
+  var superLoader = require.extensions[ext] || jsLoader;
+  require.extensions[ext] = function (module, filename) {
+    if (shouldTransform(filename, options)) {
+      var super_compile = module._compile;
+      module._compile = function _compile(code, filename) {
+        super_compile.call(this, flowRemoveTypes(code, options).toString(), filename);
+      };
+    }
+    superLoader(module, filename);
+  };
+});
+
+function shouldTransform(filename, options) {
+  var includes = options && regexpPattern(options.includes || options.include);
+  var excludes =
+    options && 'excludes' in options ? regexpPattern(options.excludes) :
+    options && 'exclude' in options ? regexpPattern(options.exclude) :
+    /\/node_modules\//;
+  return (!includes || includes.test(filename)) && !(excludes && excludes.test(filename));
+}
+
+// Given a null | string | RegExp | any, returns null | Regexp or throws a
+// more helpful error.
+function regexpPattern(pattern) {
+  if (!pattern) {
+    return pattern;
+  }
+  // A very simplified glob transform which allows passing legible strings like
+  // "myPath/*.js" instead of a harder to read RegExp like /\/myPath\/.*\.js/.
+  if (typeof pattern === 'string') {
+    pattern = pattern.replace(/\./g, '\\.').replace(/\*/g, '.*');
+    if (pattern[0] !== '/') {
+      pattern = '/' + pattern;
+    }
+    return new RegExp(pattern);
+  }
+  if (typeof pattern.test === 'function') {
+    return pattern;
+  }
+  throw new Error(
+    'flow-remove-types: includes and excludes must be RegExp or path strings. Got: ' + pattern
+  );
+}

package/.npmignore

@@ -1,3 +0,0 @@
-.DS_Store
-npm-debug.log
-node_modules

package/.travis.yml

@@ -1,12 +0,0 @@
-language: node_js
-
-node_js:
-  - "6"
-  - "5"
-  - "4"
-  - "iojs"
-  - "0.12"
-  - "0.10"
-
-before_install:
-  - npm config set spin false --global

package/bow.js

@@ -1,4 +0,0 @@
-var temp, onNeck, purchaseBowtie = function(){ return 'tie' };
-
-var inBag = purchaseBowtie()
-(temp = onNeck, onNeck = inBag, inBag = temp)

package/test/expected.js

@@ -1,132 +0,0 @@
-/*       */
-
-// Regular import
-import { Something } from 'some-module';
-
-// Import types
-                                            
-
-// Typed function
-async function test(x      , y /*.*/   /*.*/ , z /*.*/   /*.*/                = 123)         {
-  // Typed expression
-  return await (x     );
-}
-
-// Interface
-               
-            
-
-                  
- 
-
-// Exported interface
-                         
-                 
- 
-
-// Interface extends
-                                
-                
- 
-
-// Implements interface
-class Bar extends Other            /*.*/                 {
-  // Class Property with default value
-  answer         = 42;
-
-  // Class Property
-            
-
-  method()        {
-    return;
-  }
-}
-
-// Class expression implements interface
-var SomeClass = class Baz                {
-            
-
-  method()        {
-    return;
-  }
-};
-
-// Parametric class
-class Wrapper    {
-  get()    {
-    return this.value;
-  }
-
-  map   ()             {
-    // do something
-  }
-}
-
-// Extends Parametric class
-class StringWrapper extends Wrapper         {
-  // ...
-}
-
-// Declare class
-                   
-                  
- 
-
-// Declare funtion
-                                  
-
-// Declare interface
-                              
-                 
- 
-
-// Declare module
-                     
-                                                   
- 
-
-// Declare type alias
-                         
-              
-             
-  
-
-// Declare variable
-                               
-
-// Type alias
-                
-
-// Export type
-                  
-
-// Regular export
-export { Wrapper };
-
-// Exported type alias
-                                  
-
-// Object with types within
-var someObj = {
-  objMethod()       {
-    // do nothing.
-  }
-}
-
-// Example from README
-import SomeClass from 'some-module'
-                                                
-
-export class MyClass    extends SomeClass                          {
-
-          
-
-  constructor(value   ) {
-    this.value = value
-  }
-
-  get()    {
-    return this.value
-  }
-
-}

package/test/source.js

@@ -1,132 +0,0 @@
-/* @flow */
-
-// Regular import
-import { Something } from 'some-module';
-
-// Import types
-import type { SomeType } from 'some-module';
-
-// Typed function
-async function test(x: Type, y /*.*/ ? /*.*/ , z /*.*/ ? /*.*/ : /*.*/ number = 123): string {
-  // Typed expression
-  return await (x: any);
-}
-
-// Interface
-interface Foo {
-  prop: any;
-
-  method(): mixed;
-}
-
-// Exported interface
-export interface IThing {
-  exported: true;
-}
-
-// Interface extends
-interface SillyFoo extends Foo {
-  silly: string;
-}
-
-// Implements interface
-class Bar extends Other implements /*.*/ Foo, ISomething {
-  // Class Property with default value
-  answer: number = 42;
-
-  // Class Property
-  prop: any;
-
-  method(): mixed {
-    return;
-  }
-}
-
-// Class expression implements interface
-var SomeClass = class Baz implements Foo {
-  prop: any;
-
-  method(): mixed {
-    return;
-  }
-};
-
-// Parametric class
-class Wrapper<T> {
-  get(): T {
-    return this.value;
-  }
-
-  map<M>(): Wrapper<M> {
-    // do something
-  }
-}
-
-// Extends Parametric class
-class StringWrapper extends Wrapper<string> {
-  // ...
-}
-
-// Declare class
-declare class Baz {
-  method(): mixed;
-}
-
-// Declare funtion
-declare function someFunc(): void;
-
-// Declare interface
-declare interface ISomething {
-  answer: number;
-}
-
-// Declare module
-declare module 'fs' {
-  declare function readThing(path: string): string;
-}
-
-// Declare type alias
-declare type Location = {
-  lat: number,
-  lon: number
-};
-
-// Declare variable
-declare var SOME_CONST: string;
-
-// Type alias
-type T = string;
-
-// Export type
-export type { T };
-
-// Regular export
-export { Wrapper };
-
-// Exported type alias
-export type ONE = { one: number };
-
-// Object with types within
-var someObj = {
-  objMethod(): void {
-    // do nothing.
-  }
-}
-
-// Example from README
-import SomeClass from 'some-module'
-import type { SomeInterface } from 'some-module'
-
-export class MyClass<T> extends SomeClass implements SomeInterface {
-
-  value: T
-
-  constructor(value: T) {
-    this.value = value
-  }
-
-  get(): T {
-    return this.value
-  }
-
-}

package/test/test-node-module.js

@@ -1,4 +0,0 @@
-// @flow
-
-var n: number = 42;
-console.log(n);