tor-browser

browser_dbg-sourcemapped-scopes.js (42668B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */

"use strict";

// This test can be really slow on debug platforms and should be split.
requestLongerTimeout(30);

// Tests loading sourcemapped sources for Babel's compile output.

/* eslint-disable no-inline-comments */

const ACTIVE_TARGETS = new Set([
 // "webpack3",
 "webpack3-babel6",
 // "webpack3-babel7",
 // "webpack4",
 // "webpack4-babel6",
 // "webpack4-babel7",
 "rollup",
 // "rollup-babel6",
 // "rollup-babel7",
 "parcel",
]);

const ACTIVE_FIXTURES = [
 testBabelBindingsWithFlow,
 testBabelFlowtypeBindings,
 testEvalMaps,
 testForOf,
 testShadowedVars,
 testLineStartBindingsES6,
 testThisArgumentsBindings,
 testClasses,
 testForLoops,
 testFunctions,
 testSwitches,
 testTryCatches,
 testLexAndNonlex,
 testTypescriptClasses,
 testTypeModule,
 testTypeScriptCJS,
 testOutOfOrderDeclarationsCJS,
 testModulesCJS,
 testWebpackLineMappings,
 testWebpackFunctions,
 testESModules,
 testESModulesCJS,
 testESModulesES6,
];

async function breakpointScopes(
 dbg,
 target,
 fixture,
 { line, column },
 scopes
) {
 if (!ACTIVE_TARGETS.has(target)) {
   return;
 }

 const extension = fixture == "typescript-classes" ? "ts" : "js";
 const url = `${target}://./${fixture}/input.${extension}`;
 const fnName = pairToFnName(target, fixture);

 await invokeWithBreakpoint(dbg, fnName, url, { line, column }, async () => {
   await assertScopes(dbg, scopes);
 });

 ok(true, `Ran tests for ${fixture} at line ${line} column ${column}`);
}

add_task(async function () {
 await pushPref("devtools.debugger.map-scopes-enabled", true);
 const dbg = await initDebugger("doc-sourcemapped.html");

 for (const fixture of ACTIVE_FIXTURES) {
   await fixture(dbg);
 }
});

function targetToFlags(target) {
 const isRollup = target.startsWith("rollup");
 const isWebpack = target.startsWith("webpack");
 const isParcel = target.startsWith("parcel");
 const isWebpack4 = target.startsWith("webpack4");

 // Rollup removes lots of things as dead code, so they are marked as optimized out.
 const rollupOptimized = isRollup ? "(optimized away)" : null;
 const webpackImportGetter = isWebpack ? "Getter" : null;
 const webpack4ImportGetter = isWebpack4 ? "Getter" : null;
 const maybeLineStart = col => col;
 const defaultExport = isWebpack4
   ? name => `${name}()`
   : name => [name, "(optimized away)"];

 return {
   isRollup,
   isWebpack,
   isParcel,
   rollupOptimized,
   webpackImportGetter,
   webpack4ImportGetter,
   maybeLineStart,
   defaultExport,
 };
}
function pairToFnName(target, fixture) {
 return `${target}-${fixture}`.replace(/-([a-z])/g, (s, c) => c.toUpperCase());
}

function runtimeFunctionName(target, fixture) {
 // Webpack 4 appears to output it's bundles in such a way that Spidermonkey
 if (target === "webpack4") {
   return "js";
 }

 return pairToFnName(target, fixture);
}

function webpackModule(target, fixture, optimizedOut) {
 return [
   runtimeFunctionName(target, fixture),
   ["__webpack_exports__", optimizedOut ? "(optimized away)" : "{\u2026}"],
   optimizedOut
     ? ["__webpack_require__", "(optimized away)"]
     : "__webpack_require__()",
   ["arguments", optimizedOut ? "(unavailable)" : "Arguments"],
 ];
}

async function testBabelBindingsWithFlow(dbg) {
 // Flow is not available on the non-babel builds.
 for (const target of [
   "parcel",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { webpackImportGetter } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "babel-bindings-with-flow",
     { line: 9, column: 3 },
     [
       "root",
       ["value", '"a-named"'],
       "Module",
       ["aNamed", webpackImportGetter || '"a-named"'],
       "root()",
     ]
   );
 }
}

async function testBabelFlowtypeBindings(dbg) {
 // Flow is not available on the non-babel builds.
 for (const target of [
   "parcel",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { webpackImportGetter } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "babel-flowtype-bindings",
     { line: 9, column: 3 },
     [
       "Module",
       ["aConst", '"a-const"'],
       ["Four", webpackImportGetter || '"one"'],
       "root()",
     ]
   );
 }
}

async function testEvalMaps(dbg) {
 // At times, this test has been a bit flakey due to the inlined source map
 // never loading. I'm not sure what causes that. If we observe flakiness in CI,
 // we should consider disabling this test for now.

 for (const target of ["webpack3", "webpack4"]) {
   const { defaultExport } = targetToFlags(target);

   await breakpointScopes(dbg, target, "eval-maps", { line: 14, column: 5 }, [
     "Block",
     ["<this>", "Window"],
     ["three", "5"],
     ["two", "4"],
     "Block",
     ["three", "3"],
     ["two", "2"],
     "Block",
     ["arguments", "Arguments"],
     ["one", "1"],
     ...webpackModule(target, "eval-maps", true /* optimized out */),
     ["module", "(optimized away)"],
     defaultExport("root"),
   ]);
 }

 for (const target of [
   "parcel",
   "rollup",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { defaultExport, rollupOptimized, maybeLineStart } =
     targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "eval-maps",
     { line: 14, column: maybeLineStart(5) },
     [
       "Block",
       ["three", "5"],
       ["two", "4"],
       "Function Body",
       ["three", rollupOptimized || "3"],
       ["two", rollupOptimized || "2"],
       "root",
       ["one", "1"],
       "Module",
       defaultExport("root"),
     ]
   );
 }
}

async function testForOf(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   const { defaultExport } = targetToFlags(target);

   await breakpointScopes(dbg, target, "for-of", { line: 5, column: 1 }, [
     "Block",
     ["<this>", "Window"],
     ["x", "1"],
     "Block",
     ["arguments", "Arguments"],
     "class doThing",
     "Block",
     "mod",
     ...webpackModule(target, "for-of", true /* optimizedOut */),
     defaultExport("forOf"),
     "module",
   ]);
 }

 for (const target of [
   "parcel",
   "rollup",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { defaultExport, maybeLineStart } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "for-of",
     { line: 5, column: maybeLineStart(5) },
     [
       "For",
       ["x", "1"],
       "forOf",
       "doThing(arg)",
       "Module",
       defaultExport("forOf"),
       "mod",
     ]
   );
 }
}

async function testShadowedVars(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   await breakpointScopes(
     dbg,
     target,
     "shadowed-vars",
     { line: 18, column: 1 },
     [
       "Block",
       ["<this>", "Window"],
       ["aConst", '"const3"'],
       ["aLet", '"let3"'],

       "Block",
       ["aConst", '"const2"'],
       ["aLet", '"let2"'],
       "class Outer",

       "Block",
       ["aConst", '"const1"'],
       ["aLet", '"let1"'],
       "class Outer",

       "Block",
       ["arguments", "Arguments"],
       ["aVar", '"var3"'],

       ...webpackModule(target, "shadowed-vars", true /* optimizedOut */),
       ["module", "(optimized away)"],
     ]
   );
 }

 for (const target of [
   "parcel",
   "rollup",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { isParcel, rollupOptimized, maybeLineStart } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "shadowed-vars",
     { line: 18, column: maybeLineStart(7) },
     [
       "Block",
       ["aConst", rollupOptimized || '"const3"'],
       ["aLet", rollupOptimized || '"let3"'],
       "Block",
       ["aConst", rollupOptimized || '"const2"'],
       ["aLet", rollupOptimized || '"let2"'],
       // eslint-disable-next-line no-nested-ternary
       isParcel
         ? "Outer()"
         : rollupOptimized
           ? ["Outer", rollupOptimized]
           : "Outer:_Outer()",
       "Function Body",
       ["aConst", rollupOptimized || '"const1"'],
       ["aLet", rollupOptimized || '"let1"'],
       // eslint-disable-next-line no-nested-ternary
       rollupOptimized
         ? ["Outer", rollupOptimized]
         : isParcel
           ? "class Outer"
           : "Outer()",
       "default",
       ["aVar", rollupOptimized || '"var3"'],
     ]
   );
 }
}

async function testLineStartBindingsES6(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   await breakpointScopes(
     dbg,
     target,
     "line-start-bindings-es6",
     { line: 19, column: 1 },
     [
       "Block",
       ["<this>", "{\u2026}"],
       ["one", "1"],
       ["two", "2"],
       "Block",
       ["arguments", "Arguments"],

       "Block",
       ["aFunc", "(optimized away)"],
       ["arguments", "(unavailable)"],

       ...webpackModule(
         target,
         "line-start-bindings-es6",
         true /* optimizedOut */
       ),
       ["module", "(optimized away)"],
       "root()",
     ]
   );
 }

 for (const target of [
   "parcel",
   "rollup",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { rollupOptimized, maybeLineStart } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "line-start-bindings-es6",
     { line: 19, column: maybeLineStart(5) },
     [
       "Function Body",
       ["<this>", "{\u2026}"],
       ["one", rollupOptimized || "1"],
       ["two", rollupOptimized || "2"],
       "root",
       ["aFunc", "(optimized away)"],
       "Module",
       "root()",
     ]
   );
 }
}

async function testThisArgumentsBindings(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   await breakpointScopes(
     dbg,
     target,
     "this-arguments-bindings",
     { line: 4, column: 1 },
     [
       "Block",
       ["<this>", '"this-value"'],
       ["arrow", "(uninitialized)"],
       "fn",
       ["arg", '"arg-value"'],
       ["arguments", "Arguments"],
       "root",
       ["arguments", "Arguments"],
       "fn()",
       ...webpackModule(
         target,
         "this-arguments-bindings",
         true /* optimizedOut */
       ),
       ["module", "(optimized away)"],
       "root()",
     ]
   );

   await breakpointScopes(
     dbg,
     target,
     "this-arguments-bindings",
     { line: 8, column: 1 },
     [
       "Block",
       ["<this>", '"this-value"'],
       ["argArrow", '"arrow-arg"'],
       ["arguments", "Arguments"],
       "Block",
       ["arrow", "(optimized away)"],
       "fn",
       ["arg", '"arg-value"'],
       ["arguments", "Arguments"],
       "root",
       ["arguments", "Arguments"],
       "fn()",
       ...webpackModule(
         target,
         "this-arguments-bindings",
         true /* optimizedOut */
       ),
       ["module", "(optimized away)"],
       "root()",
     ]
   );
 }

 for (const target of [
   "parcel",
   "rollup",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { isParcel, maybeLineStart } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "this-arguments-bindings",
     { line: 4, column: maybeLineStart(5) },
     [
       "Function Body",
       ["<this>", '"this-value"'],
       [
         "arrow",
         target === "rollup" || isParcel ? "(uninitialized)" : "undefined",
       ],
       "fn",
       ["arg", '"arg-value"'],
       ["arguments", "Arguments"],
       "root",
       "fn(arg)",
       "Module",
       "root()",
     ]
   );

   await breakpointScopes(
     dbg,
     target,
     "this-arguments-bindings",
     { line: 8, column: maybeLineStart(7) },
     [
       "arrow",
       ["<this>", '"this-value"'],
       ["argArrow", '"arrow-arg"'],
       "Function Body",
       target === "rollup" || isParcel
         ? ["arrow", "(optimized away)"]
         : "arrow(argArrow)",
       "fn",
       ["arg", '"arg-value"'],
       ["arguments", "Arguments"],
       "root",
       "fn(arg)",
       "Module",
       "root()",
     ]
   );
 }
}

async function testClasses(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   await breakpointScopes(dbg, target, "classes", { line: 6, column: 1 }, [
     "Block",
     ["<this>", "{}"],
     ["arguments", "Arguments"],
     "Block",
     ["Thing", "(optimized away)"],
     "Block",
     "Another()",
     ["one", "1"],
     "Thing()",
     "Block",
     ["arguments", "(unavailable)"],
     ...webpackModule(target, "classes", true /* optimizedOut */),
     ["module", "(optimized away)"],
     "root()",
   ]);

   await breakpointScopes(dbg, target, "classes", { line: 16, column: 1 }, [
     "Block",
     ["<this>", "{}"],
     ["three", "3"],
     ["two", "2"],
     "Block",
     ["arguments", "Arguments"],
     "Block",
     "Another()",
     "Block",
     "Another()",
     ["one", "1"],
     "Thing()",
     "Block",
     ["arguments", "(unavailable)"],
     ...webpackModule(target, "classes", true /* optimizedOut */),
     ["module", "(optimized away)"],
     "root()",
   ]);
 }

 for (const target of [
   "parcel",
   "rollup",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { isParcel, rollupOptimized, maybeLineStart } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "classes",
     { line: 6, column: maybeLineStart(7) },
     [
       "Class",
       target === "rollup" || isParcel
         ? ["Thing", "(optimized away)"]
         : "Thing()",
       "Function Body",
       target === "webpack3-babel6" ? "Another()" : "class Another",
       "one",
       target === "rollup" || isParcel
         ? ["Thing", "(optimized away)"]
         : "Thing()",
       "Module",
       "root()",
     ]
   );

   await breakpointScopes(
     dbg,
     target,
     "classes",
     { line: 16, column: maybeLineStart(7) },
     [
       "Function Body",
       ["three", rollupOptimized || "3"],
       ["two", rollupOptimized || "2"],
       "Class",
       target === "webpack3-babel6" ? "Another()" : "class Another",
       "Function Body",
       target === "webpack3-babel6" ? "Another()" : "class Another",
       ["one", "1"],
       target === "webpack3-babel6" ? "Thing()" : "class Thing",
       "Module",
       "root()",
     ]
   );
 }
}

async function testForLoops(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   await breakpointScopes(dbg, target, "for-loops", { line: 5, column: 1 }, [
     "Block",
     ["<this>", "Window"],
     ["i", "1"],
     "Block",
     ["i", "0"],
     "Block",
     ["arguments", "Arguments"],
     ...webpackModule(target, "for-loops", true /* optimizedOut */),
     ["module", "(optimized away)"],
     "root()",
   ]);
   await breakpointScopes(dbg, target, "for-loops", { line: 9, column: 1 }, [
     "Block",
     ["<this>", "Window"],
     ["i", '"2"'],
     "Block",
     ["i", "0"],
     "Block",
     ["arguments", "Arguments"],
     ...webpackModule(target, "for-loops", true /* optimizedOut */),
     ["module", "(optimized away)"],
     "root()",
   ]);
   await breakpointScopes(dbg, target, "for-loops", { line: 13, column: 1 }, [
     "Block",
     ["<this>", "Window"],
     ["i", "3"],
     "Block",
     ["i", "0"],
     "Block",
     ["arguments", "Arguments"],
     ...webpackModule(target, "for-loops", true /* optimizedOut */),
     ["module", "(optimized away)"],
     "root()",
   ]);
 }

 for (const target of [
   "parcel",
   "rollup",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { rollupOptimized, maybeLineStart } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "for-loops",
     { line: 5, column: maybeLineStart(5) },
     [
       "For",
       ["i", "1"],
       "Function Body",
       ["i", rollupOptimized || "0"],
       "Module",
       "root()",
     ]
   );
   await breakpointScopes(
     dbg,
     target,
     "for-loops",
     { line: 9, column: maybeLineStart(5) },
     [
       "For",
       ["i", '"2"'],
       "Function Body",
       ["i", rollupOptimized || "0"],
       "Module",
       "root()",
     ]
   );
   await breakpointScopes(
     dbg,
     target,
     "for-loops",
     { line: 13, column: maybeLineStart(5) },
     [
       "For",
       ["i", target === "rollup" ? "3" : rollupOptimized || "3"],
       "Function Body",
       ["i", rollupOptimized || "0"],
       "Module",
       "root()",
     ]
   );
 }
}

async function testFunctions(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   await breakpointScopes(dbg, target, "functions", { line: 6, column: 1 }, [
     "Block",
     ["<this>", "(optimized away)"],
     ["arguments", "Arguments"],
     ["p3", "undefined"],
     "Block",
     "arrow()",
     "inner",
     ["arguments", "Arguments"],
     ["p2", "undefined"],
     "Block",
     "inner(p2)",
     "Block",
     ["inner", "(optimized away)"],
     "decl",
     ["arguments", "Arguments"],
     ["p1", "undefined"],
     "root",
     ["arguments", "Arguments"],
     "decl()",
     ...webpackModule(target, "functions", true /* optimizedOut */),
     ["module", "(optimized away)"],
     "root()",
   ]);
 }

 for (const target of [
   "parcel",
   "rollup",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { isParcel, maybeLineStart } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "functions",
     { line: 6, column: maybeLineStart(9) },
     [
       "arrow",
       ["p3", "undefined"],
       "Function Body",
       "arrow(p3)",
       "inner",
       ["p2", "undefined"],
       "Function Expression",
       "inner(p2)",
       "Function Body",
       target === "rollup" || isParcel
         ? ["inner", "(optimized away)"]
         : "inner(p2)",
       "decl",
       ["p1", "undefined"],
       "root",
       "decl(p1)",
       "Module",
       "root()",
     ]
   );
 }
}

async function testSwitches(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   await breakpointScopes(dbg, target, "switches", { line: 7, column: 1 }, [
     "Block",
     ["<this>", "Window"],
     ["val", "2"],
     "Block",
     ["val", "1"],
     "Block",
     ["arguments", "Arguments"],
     ...webpackModule(target, "switches", true /* optimizedOut */),
     ["module", "(optimized away)"],
     "root()",
   ]);

   await breakpointScopes(dbg, target, "switches", { line: 10, column: 1 }, [
     "Block",
     ["<this>", "Window"],
     ["val", "3"],
     "Block",
     ["val", "2"],
     "Block",
     ["val", "1"],
     "Block",
     ["arguments", "Arguments"],
     ...webpackModule(target, "switches", true /* optimizedOut */),
     ["module", "(optimized away)"],
     "root()",
   ]);
 }

 for (const target of [
   "parcel",
   "rollup",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { rollupOptimized, maybeLineStart } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "switches",
     { line: 7, column: maybeLineStart(7) },
     [
       "Switch",
       ["val", rollupOptimized || "2"],
       "Function Body",
       ["val", rollupOptimized || "1"],
       "Module",
       "root()",
     ]
   );

   await breakpointScopes(
     dbg,
     target,
     "switches",
     { line: 10, column: maybeLineStart(7) },
     [
       "Block",
       ["val", rollupOptimized || "3"],
       "Switch",
       ["val", rollupOptimized || "2"],
       "Function Body",
       ["val", rollupOptimized || "1"],
       "Module",
       "root()",
     ]
   );
 }
}

async function testTryCatches(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   await breakpointScopes(dbg, target, "try-catches", { line: 8, column: 1 }, [
     "Block",
     ["<this>", "Window"],
     ["two", "2"],
     "Block",
     ["err", '"AnError"'],
     "Block",
     ["one", "1"],
     "Block",
     ["arguments", "Arguments"],
     ...webpackModule(target, "try-catches", true /* optimizedOut */),
     ["module", "(optimized away)"],
     "root()",
   ]);
 }

 for (const target of [
   "parcel",
   "rollup",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { rollupOptimized, maybeLineStart } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "try-catches",
     { line: 8, column: maybeLineStart(5) },
     [
       "Block",
       ["two", rollupOptimized || "2"],
       "Catch",
       ["err", '"AnError"'],
       "Function Body",
       ["one", rollupOptimized || "1"],
       "Module",
       "root()",
     ]
   );
 }
}

async function testLexAndNonlex(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   await breakpointScopes(
     dbg,
     target,
     "lex-and-nonlex",
     { line: 3, column: 1 },
     [
       "Block",
       ["<this>", "undefined"],
       ["arguments", "Arguments"],
       "Block",
       "class Thing",
       "Block",
       ["arguments", "(unavailable)"],
       ["someHelper", "(optimized away)"],
       ...webpackModule(target, "lex-and-nonlex", true /* optimizedOut */),
       ["module", "(optimized away)"],
       "root()",
     ]
   );
 }

 for (const target of [
   "parcel",
   "rollup",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { isParcel, maybeLineStart } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "lex-and-nonlex",
     { line: 3, column: maybeLineStart(5) },
     [
       "Function Body",
       target === "rollup" || target === "parcel" ? "class Thing" : "Thing()",
       "root",
       target === "rollup" || isParcel
         ? ["someHelper", "(optimized away)"]
         : "someHelper()",
       "Module",
       "root()",
     ]
   );
 }
}

async function testTypescriptClasses(dbg) {
 // Typescript is not available on the Babel builds.
 for (const target of ["parcel", "webpack3", "webpack4", "rollup"]) {
   const { isRollup, isParcel, rollupOptimized } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "typescript-classes",
     { line: 50, column: 3 },
     [
       "Module",
       "AnotherThing()",
       "AppComponent()",
       "decoratorFactory(opts)",
       rollupOptimized ? ["def", rollupOptimized] : "def()",
       rollupOptimized
         ? ["ExportedOther", rollupOptimized]
         : "ExportedOther()",
       rollupOptimized
         ? ["ExpressionClass", rollupOptimized]
         : "ExpressionClass:Foo()",
       "fn(arg)",
       // Rollup optimizes out the 'ns' reference here, but when it does, it leave a mapping
       // pointed at a location that is super weird, so it ends up being unmapped instead
       // be "(optimized out)".
       // Parcel converts the "ns;" mapping into a single full-line mapping, for some reason.
       // That may have to do with https://github.com/parcel-bundler/parcel/pull/1755#discussion_r205584159
       // though it's not 100% clear.
       ["ns", isRollup || isParcel ? "(unmapped)" : "{\u2026}"],
       "SubDecl()",
       "SubVar:SubExpr()",
     ]
   );
 }
}

async function testTypeModule(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   await breakpointScopes(dbg, target, "type-module", { line: 7, column: 1 }, [
     "Block",
     ["<this>", "Window"],
     ["arguments", "Arguments"],
     "Block",
     ["alsoModuleScoped", "2"],
     ...webpackModule(target, "type-module", true /* optimizedOut */),
     ["module", "(optimized away)"],
     ["moduleScoped", "1"],
     "thirdModuleScoped()",
   ]);
 }

 for (const target of [
   "parcel",
   "rollup",
   "rollup-babel6",
   "rollup-babel7",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { maybeLineStart } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "type-module",
     { line: 7, column: maybeLineStart(3) },
     [
       "Module",
       ["alsoModuleScoped", "2"],
       ["moduleScoped", "1"],
       "thirdModuleScoped()",
     ]
   );
 }
}

async function testTypeScriptCJS(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   await breakpointScopes(
     dbg,
     target,
     "type-script-cjs",
     { line: 7, column: 1 },
     [
       "Block",
       ["<this>", "Window"],
       ["arguments", "Arguments"],
       "Block",
       "alsoModuleScopes",

       runtimeFunctionName(target, "type-script-cjs"),
       ["arguments", "(unavailable)"],
       ["exports", "(optimized away)"],
       ["module", "(optimized away)"],
       "moduleScoped",
       "nonModules",
       "thirdModuleScoped",
     ]
   );
 }

 // CJS does not work on Rollup.
 for (const target of [
   "parcel",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   await breakpointScopes(
     dbg,
     target,
     "type-script-cjs",
     { line: 7, column: 3 },
     [
       "Module",
       "alsoModuleScopes",
       "moduleScoped",
       "nonModules",
       "thirdModuleScoped",
     ]
   );
 }
}

async function testOutOfOrderDeclarationsCJS(dbg) {
 // CJS does not work on Rollup.
 for (const target of [
   "parcel",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   await breakpointScopes(
     dbg,
     target,
     "out-of-order-declarations-cjs",
     { line: 8, column: 5 },
     [
       "callback",
       "fn(inner)",
       ["val", "undefined"],
       "root",
       ["callback", "(optimized away)"],
       ["fn", "(optimized away)"],
       ["val", "(optimized away)"],
       "Module",

       // This value is currently optimized away, which isn't 100% accurate.
       // Because import declarations is the last thing in the file, our current
       // logic doesn't cover _both_ 'var' statements that it generates,
       // making us use the first, optimized-out binding. Given that imports
       // are almost never the last thing in a file though, this is probably not
       // a huge deal for now.
       [
         "aDefault",
         target.match(/webpack(3|4)-babel7/)
           ? '"a-default"'
           : "(optimized away)",
       ],
       ["root", "(optimized away)"],
       ["val", "(optimized away)"],
     ]
   );
 }
}

async function testModulesCJS(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   await breakpointScopes(dbg, target, "modules-cjs", { line: 7, column: 1 }, [
     "Block",
     ["<this>", "Window"],
     ["arguments", "Arguments"],
     "Block",
     ["alsoModuleScoped", "2"],
     runtimeFunctionName(target, "modules-cjs"),
     ["arguments", "(unavailable)"],
     ["exports", "(optimized away)"],
     ["module", "(optimized away)"],
     ["moduleScoped", "1"],
     "thirdModuleScoped()",
   ]);
 }

 // CJS does not work on Rollup.
 for (const target of [
   "parcel",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   await breakpointScopes(dbg, target, "modules-cjs", { line: 7, column: 3 }, [
     "Module",
     ["alsoModuleScoped", "2"],
     ["moduleScoped", "1"],
     "thirdModuleScoped()",
   ]);
 }
}

async function testWebpackLineMappings(dbg) {
 await breakpointScopes(
   dbg,
   "webpack3",
   "webpack-line-mappings",
   { line: 11, column: 1 },
   [
     "Block",
     ["<this>", '"this-value"'],
     ["arg", '"arg-value"'],
     ["arguments", "Arguments"],
     ["inner", "undefined"],
     "Block",
     ["someName", "(optimized away)"],
     "Block",
     ["two", "2"],
     "Block",
     ["one", "1"],
     "root",
     ["arguments", "Arguments"],
     "fn:someName()",
     runtimeFunctionName("webpack3", "webpack-line-mappings"),
     ["__webpack_exports__", "(optimized away)"],
     ["__WEBPACK_IMPORTED_MODULE_0__src_mod1__", "{\u2026}"],
     ["__webpack_require__", "(optimized away)"],
     ["arguments", "(unavailable)"],
     ["module", "(optimized away)"],
     "root()",
   ]
 );

 await breakpointScopes(
   dbg,
   "webpack4",
   "webpack-line-mappings",
   { line: 11, column: 1 },
   [
     "Block",
     ["<this>", '"this-value"'],
     ["arg", '"arg-value"'],
     ["arguments", "Arguments"],
     ["inner", "undefined"],
     "Block",
     ["someName", "(optimized away)"],
     "Block",
     ["two", "2"],
     "Block",
     ["one", "1"],
     "root",
     ["arguments", "Arguments"],
     "fn:someName()",
     runtimeFunctionName("webpack4", "webpack-line-mappings"),
     ["__webpack_exports__", "(optimized away)"],
     ["__webpack_require__", "(optimized away)"],
     ["_src_mod1__WEBPACK_IMPORTED_MODULE_0__", "{\u2026}"],
     ["arguments", "(unavailable)"],
     ["module", "(optimized away)"],
     "root()",
   ]
 );
}

async function testWebpackFunctions(dbg) {
 for (const target of ["webpack3", "webpack4"]) {
   const { defaultExport } = targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "webpack-functions",
     { line: 4, column: 1 },
     [
       "Block",
       ["<this>", "{\u2026}"],
       ["arguments", "Arguments"],
       ["x", "4"],
       runtimeFunctionName(target, "webpack-functions"),
       ["__webpack_exports__", "(optimized away)"],
       ["__webpack_require__", "(optimized away)"],
       ["arguments", "(unavailable)"],
       ["module", "{\u2026}"],
       defaultExport("root"),
     ]
   );
 }
}

async function testESModules(dbg) {
 await breakpointScopes(
   dbg,
   "webpack3",
   "esmodules",
   { line: 20, column: 1 },
   [
     "Block",
     ["<this>", "Window"],
     ["arguments", "Arguments"],
     runtimeFunctionName("webpack3", "esmodules"),
     "__webpack_exports__",
     "__WEBPACK_IMPORTED_MODULE_0__src_mod1__",
     "__WEBPACK_IMPORTED_MODULE_1__src_mod2__",
     "__WEBPACK_IMPORTED_MODULE_10__src_optimized_out__",
     "__WEBPACK_IMPORTED_MODULE_2__src_mod3__",
     "__WEBPACK_IMPORTED_MODULE_3__src_mod4__",
     "__WEBPACK_IMPORTED_MODULE_4__src_mod5__",
     "__WEBPACK_IMPORTED_MODULE_5__src_mod6__",
     "__WEBPACK_IMPORTED_MODULE_6__src_mod7__",
     "__WEBPACK_IMPORTED_MODULE_7__src_mod9__",
     "__WEBPACK_IMPORTED_MODULE_8__src_mod10__",
     "__WEBPACK_IMPORTED_MODULE_9__src_mod11__",
     "__webpack_require__",
     "arguments",
     "example",
     "module",
     "root()",
   ]
 );

 await breakpointScopes(
   dbg,
   "webpack4",
   "esmodules",
   { line: 20, column: 1 },
   [
     "Block",
     ["<this>", "Window"],
     ["arguments", "Arguments"],
     runtimeFunctionName("webpack4", "esmodules"),
     "__webpack_exports__",
     "__webpack_require__",
     "_src_mod1__WEBPACK_IMPORTED_MODULE_0__",
     "_src_mod10__WEBPACK_IMPORTED_MODULE_8__",
     "_src_mod11__WEBPACK_IMPORTED_MODULE_9__",
     "_src_mod2__WEBPACK_IMPORTED_MODULE_1__",
     "_src_mod3__WEBPACK_IMPORTED_MODULE_2__",
     "_src_mod4__WEBPACK_IMPORTED_MODULE_3__",
     "_src_mod5__WEBPACK_IMPORTED_MODULE_4__",
     "_src_mod6__WEBPACK_IMPORTED_MODULE_5__",
     "_src_mod7__WEBPACK_IMPORTED_MODULE_6__",
     "_src_mod9__WEBPACK_IMPORTED_MODULE_7__",
     "_src_optimized_out__WEBPACK_IMPORTED_MODULE_10__",
     "arguments",
     "example()",
     "module",
     "root()",
   ]
 );

 for (const target of [
   "parcel",
   "rollup",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { defaultExport, webpackImportGetter, maybeLineStart } =
     targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "esmodules",
     { line: 20, column: maybeLineStart(3) },
     [
       "Module",
       ["aDefault", '"a-default"'],
       ["aDefault2", '"a-default2"'],
       ["aDefault3", '"a-default3"'],
       ["anAliased", webpackImportGetter || '"an-original"'],
       ["anAliased2", webpackImportGetter || '"an-original2"'],
       ["anAliased3", webpackImportGetter || '"an-original3"'],
       ["aNamed", webpackImportGetter || '"a-named"'],
       ["aNamed2", webpackImportGetter || '"a-named2"'],
       ["aNamed3", webpackImportGetter || '"a-named3"'],
       ["aNamespace", "{\u2026}"],
       ["anotherNamed", webpackImportGetter || '"a-named"'],
       ["anotherNamed2", webpackImportGetter || '"a-named2"'],
       ["anotherNamed3", webpackImportGetter || '"a-named3"'],
       defaultExport("example"),
       ["optimizedOut", "(optimized away)"],
       "root()",
     ]
   );
 }

 for (const target of ["rollup-babel6", "rollup-babel7"]) {
   // This test currently bails out because Babel does not map function calls
   // fully and includes the () of the call in the range of the identifier.
   // this means that Rollup, has to map locations for calls to imports,
   // it can fail. This will be addressed in Babel eventually.
   await breakpointScopes(dbg, target, "esmodules", { line: 20, column: 3 }, [
     "root",
     ["<this>", "Window"],
     ["arguments", "Arguments"],
     runtimeFunctionName(target, "esmodules"),
     ["aDefault", '"a-default"'],
     ["aDefault2", '"a-default2"'],
     ["aDefault3", '"a-default3"'],
     ["aNamed", '"a-named"'],
     ["aNamed$1", "(optimized away)"],
     ["aNamed2", '"a-named2"'],
     ["aNamed3", '"a-named3"'],
     ["aNamespace", "{\u2026}"],
     ["arguments", "(unavailable)"],
     ["mod4", "(optimized away)"],
     ["original", '"an-original"'],
     ["original$1", '"an-original2"'],
     ["original$2", '"an-original3"'],
     "root()",
   ]);
 }
}

async function testESModulesCJS(dbg) {
 await breakpointScopes(
   dbg,
   "webpack3",
   "esmodules-cjs",
   { line: 20, column: 1 },
   [
     "Block",
     ["<this>", "Window"],
     ["arguments", "Arguments"],
     runtimeFunctionName("webpack3", "esmodules-cjs"),
     "__webpack_exports__",
     "__WEBPACK_IMPORTED_MODULE_0__src_mod1__",
     "__WEBPACK_IMPORTED_MODULE_1__src_mod2__",
     "__WEBPACK_IMPORTED_MODULE_10__src_optimized_out__",
     "__WEBPACK_IMPORTED_MODULE_2__src_mod3__",
     "__WEBPACK_IMPORTED_MODULE_3__src_mod4__",
     "__WEBPACK_IMPORTED_MODULE_4__src_mod5__",
     "__WEBPACK_IMPORTED_MODULE_5__src_mod6__",
     "__WEBPACK_IMPORTED_MODULE_6__src_mod7__",
     "__WEBPACK_IMPORTED_MODULE_7__src_mod9__",
     "__WEBPACK_IMPORTED_MODULE_8__src_mod10__",
     "__WEBPACK_IMPORTED_MODULE_9__src_mod11__",
     "__webpack_require__",
     "arguments",
     "example",
     "module",
     "root()",
   ]
 );

 await breakpointScopes(
   dbg,
   "webpack4",
   "esmodules-cjs",
   { line: 20, column: 1 },
   [
     "Block",
     ["<this>", "Window"],
     ["arguments", "Arguments"],
     runtimeFunctionName("webpack4", "esmodules-cjs"),
     "__webpack_exports__",
     "__webpack_require__",
     "_src_mod1__WEBPACK_IMPORTED_MODULE_0__",
     "_src_mod10__WEBPACK_IMPORTED_MODULE_8__",
     "_src_mod11__WEBPACK_IMPORTED_MODULE_9__",
     "_src_mod2__WEBPACK_IMPORTED_MODULE_1__",
     "_src_mod3__WEBPACK_IMPORTED_MODULE_2__",
     "_src_mod4__WEBPACK_IMPORTED_MODULE_3__",
     "_src_mod5__WEBPACK_IMPORTED_MODULE_4__",
     "_src_mod6__WEBPACK_IMPORTED_MODULE_5__",
     "_src_mod7__WEBPACK_IMPORTED_MODULE_6__",
     "_src_mod9__WEBPACK_IMPORTED_MODULE_7__",
     "_src_optimized_out__WEBPACK_IMPORTED_MODULE_10__",
     "arguments",
     "example()",
     "module",
     "root()",
   ]
 );

 // CJS does not work on Rollup.
 for (const target of [
   "parcel",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   await breakpointScopes(
     dbg,
     target,
     "esmodules-cjs",
     { line: 20, column: 3 },
     [
       "Module",
       ["aDefault", '"a-default"'],
       ["aDefault2", '"a-default2"'],
       ["aDefault3", '"a-default3"'],
       ["anAliased", '"an-original"'],
       ["anAliased2", '"an-original2"'],
       ["anAliased3", '"an-original3"'],
       ["aNamed", '"a-named"'],
       ["aNamed2", '"a-named2"'],
       ["aNamed3", '"a-named3"'],
       ["aNamespace", "{\u2026}"],
       ["anotherNamed", '"a-named"'],
       ["anotherNamed2", '"a-named2"'],
       ["anotherNamed3", '"a-named3"'],
       ["example", "(optimized away)"],
       ["optimizedOut", "(optimized away)"],
       "root()",
     ]
   );
 }
}

async function testESModulesES6(dbg) {
 await breakpointScopes(
   dbg,
   "webpack3",
   "esmodules-es6",
   { line: 20, column: 1 },
   [
     "Block",
     ["<this>", "Window"],
     ["arguments", "Arguments"],
     runtimeFunctionName("webpack3", "esmodules-es6"),
     "__webpack_exports__",
     "__WEBPACK_IMPORTED_MODULE_0__src_mod1__",
     "__WEBPACK_IMPORTED_MODULE_1__src_mod2__",
     "__WEBPACK_IMPORTED_MODULE_10__src_optimized_out__",
     "__WEBPACK_IMPORTED_MODULE_2__src_mod3__",
     "__WEBPACK_IMPORTED_MODULE_3__src_mod4__",
     "__WEBPACK_IMPORTED_MODULE_4__src_mod5__",
     "__WEBPACK_IMPORTED_MODULE_5__src_mod6__",
     "__WEBPACK_IMPORTED_MODULE_6__src_mod7__",
     "__WEBPACK_IMPORTED_MODULE_7__src_mod9__",
     "__WEBPACK_IMPORTED_MODULE_8__src_mod10__",
     "__WEBPACK_IMPORTED_MODULE_9__src_mod11__",
     "__webpack_require__",
     "arguments",
     "example",
     "module",
     "root()",
   ]
 );

 await breakpointScopes(
   dbg,
   "webpack4",
   "esmodules-es6",
   { line: 20, column: 1 },
   [
     "Block",
     ["<this>", "Window"],
     ["arguments", "Arguments"],
     runtimeFunctionName("webpack4", "esmodules-es6"),
     "__webpack_exports__",
     "__webpack_require__",
     "_src_mod1__WEBPACK_IMPORTED_MODULE_0__",
     "_src_mod10__WEBPACK_IMPORTED_MODULE_8__",
     "_src_mod11__WEBPACK_IMPORTED_MODULE_9__",
     "_src_mod2__WEBPACK_IMPORTED_MODULE_1__",
     "_src_mod3__WEBPACK_IMPORTED_MODULE_2__",
     "_src_mod4__WEBPACK_IMPORTED_MODULE_3__",
     "_src_mod5__WEBPACK_IMPORTED_MODULE_4__",
     "_src_mod6__WEBPACK_IMPORTED_MODULE_5__",
     "_src_mod7__WEBPACK_IMPORTED_MODULE_6__",
     "_src_mod9__WEBPACK_IMPORTED_MODULE_7__",
     "_src_optimized_out__WEBPACK_IMPORTED_MODULE_10__",
     "arguments",
     "example()",
     "module",
     "root()",
   ]
 );

 for (const target of [
   "parcel",
   "rollup",
   "webpack3-babel6",
   "webpack3-babel7",
   "webpack4-babel6",
   "webpack4-babel7",
 ]) {
   const { defaultExport, webpack4ImportGetter, maybeLineStart } =
     targetToFlags(target);

   await breakpointScopes(
     dbg,
     target,
     "esmodules-es6",
     { line: 20, column: maybeLineStart(3) },
     [
       "Module",
       ["aDefault", '"a-default"'],
       ["aDefault2", '"a-default2"'],
       ["aDefault3", '"a-default3"'],
       ["anAliased", webpack4ImportGetter || '"an-original"'],
       ["anAliased2", webpack4ImportGetter || '"an-original2"'],
       ["anAliased3", webpack4ImportGetter || '"an-original3"'],
       ["aNamed", webpack4ImportGetter || '"a-named"'],
       ["aNamed2", webpack4ImportGetter || '"a-named2"'],
       ["aNamed3", webpack4ImportGetter || '"a-named3"'],
       ["aNamespace", "{\u2026}"],
       ["anotherNamed", webpack4ImportGetter || '"a-named"'],
       ["anotherNamed2", webpack4ImportGetter || '"a-named2"'],
       ["anotherNamed3", webpack4ImportGetter || '"a-named3"'],
       defaultExport("example"),
       ["optimizedOut", "(optimized away)"],
       "root()",
     ]
   );
 }

 for (const target of ["rollup-babel6", "rollup-babel7"]) {
   // This test currently bails out because Babel does not map function calls
   // fully and includes the () of the call in the range of the identifier.
   // this means that Rollup, has to map locations for calls to imports,
   // it can fail. This will be addressed in Babel eventually.
   await breakpointScopes(
     dbg,
     target,
     "esmodules-es6",
     { line: 20, column: 3 },
     [
       "root",
       ["<this>", "Window"],
       ["arguments", "Arguments"],

       "Block",
       ["aNamed", '"a-named"'],
       ["aNamed$1", "undefined"],
       ["aNamed2", '"a-named2"'],
       ["aNamed3", '"a-named3"'],
       ["original", '"an-original"'],
       ["original$1", '"an-original2"'],
       ["original$2", '"an-original3"'],

       runtimeFunctionName(target, "esmodules-es6"),
       ["aDefault", '"a-default"'],
       ["aDefault2", '"a-default2"'],
       ["aDefault3", '"a-default3"'],

       ["aNamespace", "{\u2026}"],
       ["arguments", "(unavailable)"],
       ["mod4", "(optimized away)"],
       "root()",
     ]
   );
 }
}