Allow inputSourceMap on .parse()

lib/parser.ts

@@ -12,7 +12,8 @@ import { Options } from "./options";
 export function parse(source: string, options?: Partial<Options>) {
   options = normalizeOptions(options);
 
-  const lines = fromString(source, options);
+  const map = options.inputSourceMap ? ({source, inputSourceMap: options.inputSourceMap}) : util.extractInlineSourceMaps(source);
+  const lines = fromString(map.source, options);
 
   const sourceWithoutTabs = lines.toString({
     tabWidth: options.tabWidth,
@@ -120,7 +121,17 @@ export function parse(source: string, options?: Partial<Options>) {
 
   // Return a copy of the original AST so that any changes made may be
   // compared to the original.
-  return new TreeCopier(lines, tokens).copy(file);
+  const copy = new TreeCopier(lines, tokens).copy(file);
+
+  // Attach inline sourcemap metadata when possible
+  Object.defineProperty(copy, "inputSourceMap", {
+    enumerable: false,
+    configurable: false,
+    writable: false,
+    value: map.inputSourceMap
+  });
+
+  return copy;
 }
 
 interface TreeCopierType {

lib/printer.ts

@@ -143,7 +143,7 @@ const Printer = (function Printer(this: PrinterType, config?: any) {
     return new PrintResult(
       lines.toString(config),
       util.composeSourceMaps(
-        config.inputSourceMap,
+        config.inputSourceMap || ast.inputSourceMap,
         lines.getSourceMap(config.sourceMapName, config.sourceRoot),
       ),
     );

lib/util.ts

@@ -348,3 +348,13 @@ export function isTrailingCommaEnabled(options: any, context: any) {
   }
   return !!trailingComma;
 }
+
+export function extractInlineSourceMaps(source: string) {
+  const re = /\s*\/\/(?:@|#) sourceMappingURL=data:application\/json;base64,(\S*)$/m;
+  const map = source.match(re);
+
+  return {
+    source: map ? source.replace(re, '') : source,
+    inputSourceMap: map ? (Buffer.from(map[1], 'base64')).toString() : undefined
+  };
+}

test/mapping.ts

@@ -169,6 +169,97 @@ describe("source maps", function () {
     });
   });
 
+  it("should extract inline sourcemap from source", function() {
+    function addUseStrict(ast: any) {
+      return recast.visit(ast, {
+        visitFunction: function(path) {
+          path.get("body", "body").unshift(
+            b.expressionStatement(b.literal("use strict"))
+          );
+          this.traverse(path);
+        }
+      });
+    }
+
+    function stripConsole(ast: any) {
+      return recast.visit(ast, {
+        visitCallExpression: function(path) {
+          const node = path.value;
+          if (n.MemberExpression.check(node.callee) &&
+            n.Identifier.check(node.callee.object) &&
+            node.callee.object.name === "console") {
+            n.ExpressionStatement.assert(path.parent.node);
+            path.parent.replace();
+            return false;
+          }
+
+          return;
+        }
+      });
+    }
+
+    const code = [
+      "function add(a, b) {",
+      "  var sum = a + b;",
+      "  console.log(a, b);",
+      "  return sum;",
+      "}"
+    ].join("\n");
+
+    const ast = parse(code, {
+      sourceFileName: "original.js"
+    });
+
+    const useStrictResult = new Printer({
+      sourceMapName: "useStrict.map.json"
+    }).print(addUseStrict(ast));
+
+    const useStrictResultCodeAndMap = [
+        useStrictResult.code,
+        "//# sourceMappingURL=data:application/json;base64,",
+        Buffer.from(JSON.stringify(useStrictResult.map)).toString('base64')
+      ].join('');
+
+    const useStrictAst = parse(useStrictResultCodeAndMap, {
+      sourceFileName: "useStrict.js"
+    });
+
+    const oneStepResult = new Printer({
+      sourceMapName: "oneStep.map.json"
+    }).print(stripConsole(ast));
+
+    const twoStepResult = new Printer({
+      sourceMapName: "twoStep.map.json"
+    }).print(stripConsole(useStrictAst));
+
+    assert.strictEqual(
+      oneStepResult.code,
+      twoStepResult.code
+    );
+
+    const smc1 = new sourceMap.SourceMapConsumer(oneStepResult.map);
+    const smc2 = new sourceMap.SourceMapConsumer(twoStepResult.map);
+
+    smc1.eachMapping(function(mapping) {
+      const pos = {
+        line: mapping.generatedLine,
+        column: mapping.generatedColumn
+      };
+
+      const orig1 = smc1.originalPositionFor(pos);
+      const orig2 = smc2.originalPositionFor(pos);
+
+      // The composition of the source maps generated separately from
+      // the two transforms should be equivalent to the source map
+      // generated from the composition of the two transforms.
+      assert.deepEqual(orig1, orig2);
+
+      // Make sure the two-step source map refers back to the original
+      // source instead of the intermediate source.
+      assert.strictEqual(orig2.source, "original.js");
+    });
+  });
+
   it("should work when a child node becomes null", function () {
     // https://github.com/facebook/regenerator/issues/103
     const code = ["for (var i = 0; false; i++)", "  log(i);"].join(eol);