Merge inbound to mozilla-central a=merge
authorarthur.iakab <aiakab@mozilla.com>
Tue, 03 Jul 2018 11:55:46 +0300
changeset 424798 a0e47ebc4c06e652b919dabee711fdbd6bfd31b5
parent 424750 f6e1ff7b57e6702bfcbcf9fc12014bf78921d6d3 (current diff)
parent 424797 f947d902ed915d6069314d07fa10cc9d5ac2a283 (diff)
child 424799 e06c40d73f8d1c0b616b57e4ff6355e62616c0d6
child 424862 232d577631d1380d171989820e6f730f2fa54d15
push id65850
push useraiakab@mozilla.com
push dateTue, 03 Jul 2018 08:57:33 +0000
treeherderautoland@e06c40d73f8d [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone63.0a1
first release with
nightly linux32
a0e47ebc4c06 / 63.0a1 / 20180703100028 / files
nightly linux64
a0e47ebc4c06 / 63.0a1 / 20180703100028 / files
nightly mac
a0e47ebc4c06 / 63.0a1 / 20180703100028 / files
nightly win32
a0e47ebc4c06 / 63.0a1 / 20180703100028 / files
nightly win64
a0e47ebc4c06 / 63.0a1 / 20180703100028 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge inbound to mozilla-central a=merge
browser/base/content/browser.js
browser/base/content/browser.xul
browser/base/content/tabbrowser.js
browser/base/content/test/tabs/browser.ini
devtools/client/debugger/new/test/mochitest/examples/wasm-sourcemaps/average.c
devtools/client/debugger/new/test/mochitest/examples/wasm-sourcemaps/average.js
devtools/client/debugger/new/test/mochitest/examples/wasm-sourcemaps/average.wasm
devtools/client/debugger/new/test/mochitest/examples/wasm-sourcemaps/average.wasm.map
dom/base/nsGlobalWindowInner.cpp
testing/web-platform/meta/MANIFEST.json
--- a/browser/base/content/browser.js
+++ b/browser/base/content/browser.js
@@ -7867,16 +7867,20 @@ var TabContextMenu = {
     menuItems = aPopupMenu.getElementsByAttribute("tbattr", "tabbrowser-multiple-visible");
     for (let menuItem of menuItems)
       menuItem.disabled = disabled;
 
     // Session store
     document.getElementById("context_undoCloseTab").disabled =
       SessionStore.getClosedTabCount(window) == 0;
 
+    // Only one of Reload_Tab/Reload_Selected_Tabs should be visible.
+    document.getElementById("context_reloadTab").hidden = multiselectionContext;
+    document.getElementById("context_reloadSelectedTabs").hidden = !multiselectionContext;
+
     // Only one of pin/unpin/multiselect-pin/multiselect-unpin should be visible
     let contextPinTab = document.getElementById("context_pinTab");
     contextPinTab.hidden = this.contextTab.pinned || multiselectionContext;
     let contextUnpinTab = document.getElementById("context_unpinTab");
     contextUnpinTab.hidden = !this.contextTab.pinned || multiselectionContext;
     let contextPinSelectedTabs = document.getElementById("context_pinSelectedTabs");
     contextPinSelectedTabs.hidden = this.contextTab.pinned || !multiselectionContext;
     let contextUnpinSelectedTabs = document.getElementById("context_unpinSelectedTabs");
--- a/browser/base/content/browser.xul
+++ b/browser/base/content/browser.xul
@@ -92,16 +92,19 @@
 #include browser-sets.inc
 
   <popupset id="mainPopupSet">
     <menupopup id="tabContextMenu"
                onpopupshowing="if (event.target == this) TabContextMenu.updateContextMenu(this);"
                onpopuphidden="if (event.target == this) TabContextMenu.contextTab = null;">
       <menuitem id="context_reloadTab" label="&reloadTab.label;" accesskey="&reloadTab.accesskey;"
                 oncommand="gBrowser.reloadTab(TabContextMenu.contextTab);"/>
+      <menuitem id="context_reloadSelectedTabs" label="&reloadSelectedTabs.label;" hidden="true"
+                accesskey="&reloadSelectedTabs.accesskey;"
+                oncommand="gBrowser.reloadMultiSelectedTabs();"/>
       <menuitem id="context_toggleMuteTab" oncommand="TabContextMenu.contextTab.toggleMuteAudio();"/>
       <menuitem id="context_toggleMuteSelectedTabs" hidden="true"
                 oncommand="gBrowser.toggleMuteAudioOnMultiSelectedTabs(TabContextMenu.contextTab);"/>
       <menuseparator/>
       <menuitem id="context_pinTab" label="&pinTab.label;"
                 accesskey="&pinTab.accesskey;"
                 oncommand="gBrowser.pinTab(TabContextMenu.contextTab);"/>
       <menuitem id="context_unpinTab" label="&unpinTab.label;" hidden="true"
--- a/browser/base/content/tabbrowser.js
+++ b/browser/base/content/tabbrowser.js
@@ -3263,21 +3263,27 @@ window._gBrowser = {
       delete aOtherBrowser.registeredOpenURI;
     }
     if (tmp) {
       aOtherBrowser.registeredOpenURI = tmp;
     }
   },
 
   reloadAllTabs() {
-    let tabs = this.visibleTabs;
-    let l = tabs.length;
-    for (var i = 0; i < l; i++) {
+    this.reloadTabs(this.visibleTabs);
+  },
+
+  reloadMultiSelectedTabs() {
+    this.reloadTabs(this.selectedTabs);
+  },
+
+  reloadTabs(tabs) {
+    for (let tab of tabs) {
       try {
-        this.getBrowserForTab(tabs[i]).reload();
+        this.getBrowserForTab(tab).reload();
       } catch (e) {
         // ignore failure to reload so others will be reloaded
       }
     }
   },
 
   reloadTab(aTab) {
     let browser = this.getBrowserForTab(aTab);
--- a/browser/base/content/test/tabs/browser.ini
+++ b/browser/base/content/test/tabs/browser.ini
@@ -20,16 +20,17 @@ support-files =
   test_bug1358314.html
 [browser_isLocalAboutURI.js]
 [browser_multiselect_tabs_active_tab_selected_by_default.js]
 [browser_multiselect_tabs_close_using_shortcuts.js]
 [browser_multiselect_tabs_close.js]
 [browser_multiselect_tabs_mute_unmute.js]
 [browser_multiselect_tabs_pin_unpin.js]
 [browser_multiselect_tabs_positional_attrs.js]
+[browser_multiselect_tabs_reload.js]
 [browser_multiselect_tabs_using_Ctrl.js]
 [browser_multiselect_tabs_using_Shift.js]
 [browser_multiselect_tabs_using_selectedTabs.js]
 [browser_navigatePinnedTab.js]
 [browser_new_file_whitelisted_http_tab.js]
 skip-if = !e10s # Test only relevant for e10s.
 [browser_new_tab_insert_position.js]
 skip-if = (debug && os == 'linux' && bits == 32) #Bug 1455882, disabled on Linux32 for almost permafailing
new file mode 100644
--- /dev/null
+++ b/browser/base/content/test/tabs/browser_multiselect_tabs_reload.js
@@ -0,0 +1,50 @@
+const PREF_MULTISELECT_TABS = "browser.tabs.multiselect";
+
+async function tabLoaded(tab) {
+    const browser = gBrowser.getBrowserForTab(tab);
+    await BrowserTestUtils.browserLoaded(browser);
+    return true;
+}
+
+add_task(async function setPref() {
+    await SpecialPowers.pushPrefEnv({
+        set: [[PREF_MULTISELECT_TABS, true]]
+    });
+});
+
+add_task(async function test() {
+    let tab1 = await addTab();
+    let tab2 = await addTab();
+    let tab3 = await addTab();
+
+    let menuItemReloadTab = document.getElementById("context_reloadTab");
+    let menuItemReloadSelectedTabs = document.getElementById("context_reloadSelectedTabs");
+
+    await BrowserTestUtils.switchTab(gBrowser, tab1);
+    await triggerClickOn(tab2, { ctrlKey: true });
+
+    ok(tab1.multiselected, "Tab1 is multi-selected");
+    ok(tab2.multiselected, "Tab2 is multi-selected");
+    ok(!tab3.multiselected, "Tab3 is not multi-selected");
+
+    updateTabContextMenu(tab3);
+    is(menuItemReloadTab.hidden, false, "Reload Tab is visible");
+    is(menuItemReloadSelectedTabs.hidden, true, "Reload Selected Tabs is hidden");
+
+    updateTabContextMenu(tab2);
+    is(menuItemReloadTab.hidden, true, "Reload Tab is hidden");
+    is(menuItemReloadSelectedTabs.hidden, false, "Reload Selected Tabs is visible");
+
+    let tab1Loaded = tabLoaded(tab1);
+    let tab2Loaded = tabLoaded(tab2);
+    menuItemReloadSelectedTabs.click();
+    await tab1Loaded;
+    await tab2Loaded;
+
+    // We got here because tab1 and tab2 are reloaded. Otherwise the test would have timed out and failed.
+    ok(true, "Tab1 and Tab2 are reloaded");
+
+    BrowserTestUtils.removeTab(tab1);
+    BrowserTestUtils.removeTab(tab2);
+    BrowserTestUtils.removeTab(tab3);
+});
--- a/browser/extensions/asan-reporter/bootstrap.js
+++ b/browser/extensions/asan-reporter/bootstrap.js
@@ -24,56 +24,52 @@ const PREF_LOG_LEVEL = "asanreporter.log
 
 // Setup logging
 const LOGGER_NAME = "extensions.asanreporter";
 let logger = Log.repository.getLogger(LOGGER_NAME);
 logger.addAppender(new Log.ConsoleAppender(new Log.BasicFormatter()));
 logger.addAppender(new Log.DumpAppender(new Log.BasicFormatter()));
 logger.level = Preferences.get(PREF_LOG_LEVEL, Log.Level.Info);
 
+// Determine the directory where ASan dumps will be located
+let profileDir = Services.dirsvc.get("ProfD", Ci.nsIFile);
+let asanDumpDir = OS.Path.join(profileDir.path, "asan");
+
 this.TabCrashObserver = {
   init() {
     if (this.initialized)
       return;
     this.initialized = true;
 
     Services.obs.addObserver(this, "ipc:content-shutdown");
   },
 
   observe(aSubject, aTopic, aData) {
     if (aTopic == "ipc:content-shutdown") {
         aSubject.QueryInterface(Ci.nsIPropertyBag2);
         if (!aSubject.get("abnormal")) {
           return;
         }
-        processDirectory("/tmp");
+        processDirectory(asanDumpDir);
     }
   },
 };
 
 function install(aData, aReason) {}
 
 function uninstall(aData, aReason) {}
 
 function startup(aData, aReason) {
   logger.info("Starting up...");
 
   // Install a handler to observe tab crashes, so we can report those right
   // after they happen instead of relying on the user to restart the browser.
   TabCrashObserver.init();
 
-  // We could use OS.Constants.Path.tmpDir here, but unfortunately there is
-  // no way in C++ to get the same value *prior* to xpcom initialization.
-  // Since ASan needs its options, including the "log_path" option already
-  // at early startup, there is no way to pass this on to ASan.
-  //
-  // Instead, we hardcode the /tmp directory here, which should be fine in
-  // most cases, as long as we are on Linux and Mac (the main targets for
-  // this addon at the time of writing).
-  processDirectory("/tmp");
+  processDirectory(asanDumpDir);
 }
 
 function shutdown(aData, aReason) {
   logger.info("Shutting down...");
 }
 
 function processDirectory(pathString) {
   let iterator = new OS.File.DirectoryIterator(pathString);
--- a/browser/extensions/asan-reporter/clone_asan_reporter.sh
+++ b/browser/extensions/asan-reporter/clone_asan_reporter.sh
@@ -1,11 +1,11 @@
 #!/bin/sh
 
 mkdir tmp/
 git clone --no-checkout --depth 1 https://github.com/choller/firefox-asan-reporter tmp/
-(cd tmp && git reset --hard d508c6e3f5df752a9a7a2d6f1e4e7261ec2290e7)
+(cd tmp && git reset --hard c42a0b9c131c90cec2a2e93efb77e02e1673316f)
 
 # Copy only whitelisted files
 cp tmp/bootstrap.js tmp/install.rdf.in tmp/moz.build tmp/README.md tmp/LICENSE .
 
 # Remove the temporary directory
 rm -Rf tmp/
--- a/browser/locales/en-US/chrome/browser/browser.dtd
+++ b/browser/locales/en-US/chrome/browser/browser.dtd
@@ -40,16 +40,20 @@ left instead of right. -->
 <!ENTITY  pinSelectedTabs.label              "Pin Tabs">
 <!-- Pin Tab and Pin Selected Tabs have the same accesskey
 but will never be visible at the same time. -->
 <!ENTITY  pinSelectedTabs.accesskey          "P">
 <!ENTITY  unpinSelectedTabs.label            "Unpin Tabs">
 <!-- Unpin Tab and Unpin Selected Tabs have the same accesskey
 but will never be visible at the same time. -->
 <!ENTITY  unpinSelectedTabs.accesskey        "b">
+<!-- Reload Tab and Reload Selected Tabs have the same accesskey
+but will never be visible at the same time. -->
+<!ENTITY  reloadSelectedTabs.label           "Reload Selected Tabs">
+<!ENTITY  reloadSelectedTabs.accesskey       "R">
 
 <!-- LOCALIZATION NOTE (pinTab.label, unpinTab.label): "Pin" is being
 used as a metaphor for expressing the fact that these tabs are "pinned" to the
 left edge of the tabstrip. Really we just want the string to express the idea
 that this is a lightweight and reversible action that keeps your tab where you
 can reach it easily. -->
 <!ENTITY  pinTab.label                       "Pin Tab">
 <!ENTITY  pinTab.accesskey                   "P">
--- a/devtools/client/debugger/new/README.mozilla
+++ b/devtools/client/debugger/new/README.mozilla
@@ -1,13 +1,13 @@
 This is the debugger.html project output.
 See https://github.com/devtools-html/debugger.html
 
-Version 64
+Version 66
 
-Comparison: https://github.com/devtools-html/debugger.html/compare/release-63...release-64
+Comparison: https://github.com/devtools-html/debugger.html/compare/release-65...release-66
 
 Packages:
 - babel-plugin-transform-es2015-modules-commonjs @6.26.2
 - babel-preset-react @6.24.1
 - react @16.2.0
 - react-dom @16.2.0
 - webpack @3.11.0
--- a/devtools/client/debugger/new/dist/debugger.css
+++ b/devtools/client/debugger/new/dist/debugger.css
@@ -242,16 +242,17 @@ body {
   border-radius: 8px;
   background: transparent;
 }
 
 ::-webkit-scrollbar-thumb {
   border-radius: 8px;
   background: rgba(113, 113, 113, 0.5);
 }
+
 /* 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/>. */
 
 menupopup {
   position: fixed;
   z-index: 10000;
   background: white;
@@ -2702,17 +2703,17 @@ html[dir="rtl"] .editor-mount {
 
 .theme-dark {
   --gutter-hover-background-color: #414141;
 }
 
 :not(.empty-line):not(.new-breakpoint) > .CodeMirror-gutter-wrapper:hover {
   width: 60px;
   height: 13px;
-  margin-left: -25px;
+  left: -55px !important;
   background-color: var(--gutter-hover-background-color) !important;
   mask: url("chrome://devtools/skin/images/debugger/breakpoint.svg") no-repeat;
   mask-size: 100%;
   mask-position: 0 1px;
 }
 
 :not(.empty-line):not(.new-breakpoint)
   > .CodeMirror-gutter-wrapper:hover
@@ -3109,18 +3110,18 @@ html[dir="rtl"] .breakpoints-list .break
 }
 
 .breakpoints-list .pause-indicator {
   flex: 0 1 content;
   order: 3;
 }
 
 .breakpoint .close-btn {
-  inset-inline-end: 15px;
-  inset-inline-start: auto;
+  offset-inline-end: 15px;
+  offset-inline-start: auto;
   position: absolute;
   top: 8px;
   display: none;
 }
 
 .breakpoint:hover .close-btn {
   display: flex;
 }
@@ -3259,17 +3260,17 @@ html[dir="rtl"] .breakpoints-list .break
 }
 
 .tree .tree-node:not(.focused):hover {
   background-color: transparent;
 }
 
 .expression-container__close-btn {
   position: absolute;
-  inset-inline-end: 0px;
+  offset-inline-end: 0px;
   top: 1px;
 }
 
 .expression-content {
   position: relative;
 }
 
 .expression-content .tree {
@@ -3943,18 +3944,18 @@ html[dir="rtl"] .object-node {
 
 .theme-dark .welcomebox {
   background-color: var(--theme-body-background);
 }
 
 .welcomebox .command-bar-button {
   position: absolute;
   top: auto;
-  inset-inline-end: 0;
-  inset-inline-start: auto;
+  offset-inline-end: 0;
+  offset-inline-start: auto;
   bottom: 0;
 }
 
 .alignlabel {
   display: flex;
   white-space: nowrap;
 }
 
--- a/devtools/client/debugger/new/dist/parser-worker.js
+++ b/devtools/client/debugger/new/dist/parser-worker.js
@@ -1668,17 +1668,18 @@ function extractSymbols(sourceId) {
     memberExpressions: [],
     objectProperties: [],
     comments: [],
     identifiers: [],
     classes: [],
     imports: [],
     literals: [],
     hasJsx: false,
-    hasTypes: false
+    hasTypes: false,
+    loading: false
   };
 
   const ast = (0, _ast.traverseAst)(sourceId, {
     enter(node, ancestors) {
       try {
         const path = (0, _simplePath2.default)(ancestors);
         if (path) {
           extractSymbol(path, symbols);
--- a/devtools/client/debugger/new/dist/vendors.js
+++ b/devtools/client/debugger/new/dist/vendors.js
@@ -1715,27 +1715,29 @@ module.exports = {
 const Menu = __webpack_require__(1464);
 const MenuItem = __webpack_require__(1466);
 const { PrefsHelper } = __webpack_require__(1467);
 const Services = __webpack_require__(22);
 const KeyShortcuts = __webpack_require__(1468);
 const { ZoomKeys } = __webpack_require__(1469);
 const EventEmitter = __webpack_require__(1382);
 const SourceUtils = __webpack_require__(3637);
+const Telemetry = __webpack_require__(3750);
 const { getUnicodeHostname, getUnicodeUrlPath, getUnicodeUrl } = __webpack_require__(3638);
 
 module.exports = {
   KeyShortcuts,
   Menu,
   MenuItem,
   PrefsHelper,
   Services,
   ZoomKeys,
   EventEmitter,
   SourceUtils,
+  Telemetry,
   getUnicodeHostname,
   getUnicodeUrlPath,
   getUnicodeUrl
 };
 
 /***/ }),
 
 /***/ 1382:
@@ -1911,17 +1913,17 @@ module.exports = isObjectLike;
 
 "use strict";
 
 
 /* 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/. */
 
-const { Menu, MenuItem } = __webpack_require__(1376);
+const { Menu, MenuItem } = __webpack_require__(1767);
 
 function inToolbox() {
   return window.parent.document.documentURI == "about:devtools-toolbox";
 }
 
 if (!inToolbox()) {
   __webpack_require__(1301);
 }
@@ -4353,16 +4355,148 @@ var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBP
 	} else {
 		window.classNames = classNames;
 	}
 }());
 
 
 /***/ }),
 
+/***/ 1759:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/* 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/. */
+
+var EventEmitter = function EventEmitter() {};
+module.exports = EventEmitter;
+
+const promise = __webpack_require__(1769);
+
+/**
+ * Decorate an object with event emitter functionality.
+ *
+ * @param Object aObjectToDecorate
+ *        Bind all public methods of EventEmitter to
+ *        the aObjectToDecorate object.
+ */
+EventEmitter.decorate = function EventEmitter_decorate(aObjectToDecorate) {
+  let emitter = new EventEmitter();
+  aObjectToDecorate.on = emitter.on.bind(emitter);
+  aObjectToDecorate.off = emitter.off.bind(emitter);
+  aObjectToDecorate.once = emitter.once.bind(emitter);
+  aObjectToDecorate.emit = emitter.emit.bind(emitter);
+};
+
+EventEmitter.prototype = {
+  /**
+   * Connect a listener.
+   *
+   * @param string aEvent
+   *        The event name to which we're connecting.
+   * @param function aListener
+   *        Called when the event is fired.
+   */
+  on: function EventEmitter_on(aEvent, aListener) {
+    if (!this._eventEmitterListeners) this._eventEmitterListeners = new Map();
+    if (!this._eventEmitterListeners.has(aEvent)) {
+      this._eventEmitterListeners.set(aEvent, []);
+    }
+    this._eventEmitterListeners.get(aEvent).push(aListener);
+  },
+
+  /**
+   * Listen for the next time an event is fired.
+   *
+   * @param string aEvent
+   *        The event name to which we're connecting.
+   * @param function aListener
+   *        (Optional) Called when the event is fired. Will be called at most
+   *        one time.
+   * @return promise
+   *        A promise which is resolved when the event next happens. The
+   *        resolution value of the promise is the first event argument. If
+   *        you need access to second or subsequent event arguments (it's rare
+   *        that this is needed) then use aListener
+   */
+  once: function EventEmitter_once(aEvent, aListener) {
+    let deferred = promise.defer();
+
+    let handler = (aEvent, aFirstArg, ...aRest) => {
+      this.off(aEvent, handler);
+      if (aListener) {
+        aListener.apply(null, [aEvent, aFirstArg, ...aRest]);
+      }
+      deferred.resolve(aFirstArg);
+    };
+
+    handler._originalListener = aListener;
+    this.on(aEvent, handler);
+
+    return deferred.promise;
+  },
+
+  /**
+   * Remove a previously-registered event listener.  Works for events
+   * registered with either on or once.
+   *
+   * @param string aEvent
+   *        The event name whose listener we're disconnecting.
+   * @param function aListener
+   *        The listener to remove.
+   */
+  off: function EventEmitter_off(aEvent, aListener) {
+    if (!this._eventEmitterListeners) return;
+    let listeners = this._eventEmitterListeners.get(aEvent);
+    if (listeners) {
+      this._eventEmitterListeners.set(aEvent, listeners.filter(l => {
+        return l !== aListener && l._originalListener !== aListener;
+      }));
+    }
+  },
+
+  /**
+   * Emit an event.  All arguments to this method will
+   * be sent to listener functions.
+   */
+  emit: function EventEmitter_emit(aEvent) {
+    if (!this._eventEmitterListeners || !this._eventEmitterListeners.has(aEvent)) {
+      return;
+    }
+
+    let originalListeners = this._eventEmitterListeners.get(aEvent);
+    for (let listener of this._eventEmitterListeners.get(aEvent)) {
+      // If the object was destroyed during event emission, stop
+      // emitting.
+      if (!this._eventEmitterListeners) {
+        break;
+      }
+
+      // If listeners were removed during emission, make sure the
+      // event handler we're going to fire wasn't removed.
+      if (originalListeners === this._eventEmitterListeners.get(aEvent) || this._eventEmitterListeners.get(aEvent).some(l => l === listener)) {
+        try {
+          listener.apply(null, arguments);
+        } catch (ex) {
+          // Prevent a bad listener from interfering with the others.
+          let msg = ex + ": " + ex.stack;
+          //console.error(msg);
+          console.log(msg);
+        }
+      }
+    }
+  }
+};
+
+/***/ }),
+
 /***/ 1763:
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -4452,16 +4586,813 @@ InlineSVG.defaultProps = {
 InlineSVG.propTypes = {
     src: _propTypes.string.isRequired,
     element: _propTypes.string,
     raw: _propTypes.bool
 };
 
 /***/ }),
 
+/***/ 1767:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/* 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/. */
+
+const Menu = __webpack_require__(1768);
+const MenuItem = __webpack_require__(1770);
+const { PrefsHelper } = __webpack_require__(1771);
+const Services = __webpack_require__(22);
+const KeyShortcuts = __webpack_require__(1772);
+const { ZoomKeys } = __webpack_require__(1773);
+const EventEmitter = __webpack_require__(1759);
+const SourceUtils = __webpack_require__(3752);
+const { getUnicodeHostname, getUnicodeUrlPath, getUnicodeUrl } = __webpack_require__(3753);
+
+module.exports = {
+  KeyShortcuts,
+  Menu,
+  MenuItem,
+  PrefsHelper,
+  Services,
+  ZoomKeys,
+  EventEmitter,
+  SourceUtils,
+  getUnicodeHostname,
+  getUnicodeUrlPath,
+  getUnicodeUrl
+};
+
+/***/ }),
+
+/***/ 1768:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/* 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/. */
+
+const EventEmitter = __webpack_require__(1759);
+
+function inToolbox() {
+  return window.parent.document.documentURI == "about:devtools-toolbox";
+}
+
+/**
+ * A partial implementation of the Menu API provided by electron:
+ * https://github.com/electron/electron/blob/master/docs/api/menu.md.
+ *
+ * Extra features:
+ *  - Emits an 'open' and 'close' event when the menu is opened/closed
+
+ * @param String id (non standard)
+ *        Needed so tests can confirm the XUL implementation is working
+ */
+function Menu({ id = null } = {}) {
+  this.menuitems = [];
+  this.id = id;
+
+  Object.defineProperty(this, "items", {
+    get() {
+      return this.menuitems;
+    }
+  });
+
+  EventEmitter.decorate(this);
+}
+
+/**
+ * Add an item to the end of the Menu
+ *
+ * @param {MenuItem} menuItem
+ */
+Menu.prototype.append = function (menuItem) {
+  this.menuitems.push(menuItem);
+};
+
+/**
+ * Add an item to a specified position in the menu
+ *
+ * @param {int} pos
+ * @param {MenuItem} menuItem
+ */
+Menu.prototype.insert = function (pos, menuItem) {
+  throw Error("Not implemented");
+};
+
+/**
+ * Show the Menu at a specified location on the screen
+ *
+ * Missing features:
+ *   - browserWindow - BrowserWindow (optional) - Default is null.
+ *   - positioningItem Number - (optional) OS X
+ *
+ * @param {int} screenX
+ * @param {int} screenY
+ * @param Toolbox toolbox (non standard)
+ *        Needed so we in which window to inject XUL
+ */
+Menu.prototype.popup = function (screenX, screenY, toolbox) {
+  let doc = toolbox.doc;
+  let popupset = doc.querySelector("popupset");
+  // See bug 1285229, on Windows, opening the same popup multiple times in a
+  // row ends up duplicating the popup. The newly inserted popup doesn't
+  // dismiss the old one. So remove any previously displayed popup before
+  // opening a new one.
+  let popup = popupset.querySelector("menupopup[menu-api=\"true\"]");
+  if (popup) {
+    popup.hidePopup();
+  }
+
+  popup = this.createPopup(doc);
+  popup.setAttribute("menu-api", "true");
+
+  if (this.id) {
+    popup.id = this.id;
+  }
+  this._createMenuItems(popup);
+
+  // Remove the menu from the DOM once it's hidden.
+  popup.addEventListener("popuphidden", e => {
+    if (e.target === popup) {
+      popup.remove();
+      this.emit("close", popup);
+    }
+  });
+
+  popup.addEventListener("popupshown", e => {
+    if (e.target === popup) {
+      this.emit("open", popup);
+    }
+  });
+
+  popupset.appendChild(popup);
+  popup.openPopupAtScreen(screenX, screenY, true);
+};
+
+Menu.prototype.createPopup = function (doc) {
+  return doc.createElement("menupopup");
+};
+
+Menu.prototype._createMenuItems = function (parent) {
+  let doc = parent.ownerDocument;
+  this.menuitems.forEach(item => {
+    if (!item.visible) {
+      return;
+    }
+
+    if (item.submenu) {
+      let menupopup = doc.createElement("menupopup");
+      item.submenu._createMenuItems(menupopup);
+
+      let menuitem = doc.createElement("menuitem");
+      menuitem.setAttribute("label", item.label);
+      if (!inToolbox()) {
+        menuitem.textContent = item.label;
+      }
+
+      let menu = doc.createElement("menu");
+      menu.appendChild(menuitem);
+      menu.appendChild(menupopup);
+      if (item.disabled) {
+        menu.setAttribute("disabled", "true");
+      }
+      if (item.accesskey) {
+        menu.setAttribute("accesskey", item.accesskey);
+      }
+      if (item.id) {
+        menu.id = item.id;
+      }
+      parent.appendChild(menu);
+    } else if (item.type === "separator") {
+      let menusep = doc.createElement("menuseparator");
+      parent.appendChild(menusep);
+    } else {
+      let menuitem = doc.createElement("menuitem");
+      menuitem.setAttribute("label", item.label);
+
+      if (!inToolbox()) {
+        menuitem.textContent = item.label;
+      }
+
+      menuitem.addEventListener("command", () => item.click());
+
+      if (item.type === "checkbox") {
+        menuitem.setAttribute("type", "checkbox");
+      }
+      if (item.type === "radio") {
+        menuitem.setAttribute("type", "radio");
+      }
+      if (item.disabled) {
+        menuitem.setAttribute("disabled", "true");
+      }
+      if (item.checked) {
+        menuitem.setAttribute("checked", "true");
+      }
+      if (item.accesskey) {
+        menuitem.setAttribute("accesskey", item.accesskey);
+      }
+      if (item.id) {
+        menuitem.id = item.id;
+      }
+
+      parent.appendChild(menuitem);
+    }
+  });
+};
+
+Menu.setApplicationMenu = () => {
+  throw Error("Not implemented");
+};
+
+Menu.sendActionToFirstResponder = () => {
+  throw Error("Not implemented");
+};
+
+Menu.buildFromTemplate = () => {
+  throw Error("Not implemented");
+};
+
+module.exports = Menu;
+
+/***/ }),
+
+/***/ 1769:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/* 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/. */
+
+/*
+ * A sham for https://dxr.mozilla.org/mozilla-central/source/toolkit/modules/Promise.jsm
+ */
+
+/**
+ * Promise.jsm is mostly the Promise web API with a `defer` method. Just drop this in here,
+ * and use the native web API (although building with webpack/babel, it may replace this
+ * with it's own version if we want to target environments that do not have `Promise`.
+ */
+
+let p = typeof window != "undefined" ? window.Promise : Promise;
+p.defer = function defer() {
+  var resolve, reject;
+  var promise = new Promise(function () {
+    resolve = arguments[0];
+    reject = arguments[1];
+  });
+  return {
+    resolve: resolve,
+    reject: reject,
+    promise: promise
+  };
+};
+
+module.exports = p;
+
+/***/ }),
+
+/***/ 1770:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/* 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/. */
+
+/**
+ * A partial implementation of the MenuItem API provided by electron:
+ * https://github.com/electron/electron/blob/master/docs/api/menu-item.md.
+ *
+ * Missing features:
+ *   - id String - Unique within a single menu. If defined then it can be used
+ *                 as a reference to this item by the position attribute.
+ *   - role String - Define the action of the menu item; when specified the
+ *                   click property will be ignored
+ *   - sublabel String
+ *   - accelerator Accelerator
+ *   - icon NativeImage
+ *   - position String - This field allows fine-grained definition of the
+ *                       specific location within a given menu.
+ *
+ * Implemented features:
+ *  @param Object options
+ *    Function click
+ *      Will be called with click(menuItem, browserWindow) when the menu item
+ *       is clicked
+ *    String type
+ *      Can be normal, separator, submenu, checkbox or radio
+ *    String label
+ *    Boolean enabled
+ *      If false, the menu item will be greyed out and unclickable.
+ *    Boolean checked
+ *      Should only be specified for checkbox or radio type menu items.
+ *    Menu submenu
+ *      Should be specified for submenu type menu items. If submenu is specified,
+ *      the type: 'submenu' can be omitted. If the value is not a Menu then it
+ *      will be automatically converted to one using Menu.buildFromTemplate.
+ *    Boolean visible
+ *      If false, the menu item will be entirely hidden.
+ */
+function MenuItem({
+  accesskey = null,
+  checked = false,
+  click = () => {},
+  disabled = false,
+  label = "",
+  id = null,
+  submenu = null,
+  type = "normal",
+  visible = true
+} = {}) {
+  this.accesskey = accesskey;
+  this.checked = checked;
+  this.click = click;
+  this.disabled = disabled;
+  this.id = id;
+  this.label = label;
+  this.submenu = submenu;
+  this.type = type;
+  this.visible = visible;
+}
+
+module.exports = MenuItem;
+
+/***/ }),
+
+/***/ 1771:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/* 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/. */
+
+const Services = __webpack_require__(22);
+const EventEmitter = __webpack_require__(1759);
+
+/**
+ * Shortcuts for lazily accessing and setting various preferences.
+ * Usage:
+ *   let prefs = new Prefs("root.path.to.branch", {
+ *     myIntPref: ["Int", "leaf.path.to.my-int-pref"],
+ *     myCharPref: ["Char", "leaf.path.to.my-char-pref"],
+ *     myJsonPref: ["Json", "leaf.path.to.my-json-pref"],
+ *     myFloatPref: ["Float", "leaf.path.to.my-float-pref"]
+ *     ...
+ *   });
+ *
+ * Get/set:
+ *   prefs.myCharPref = "foo";
+ *   let aux = prefs.myCharPref;
+ *
+ * Observe:
+ *   prefs.registerObserver();
+ *   prefs.on("pref-changed", (prefName, prefValue) => {
+ *     ...
+ *   });
+ *
+ * @param string prefsRoot
+ *        The root path to the required preferences branch.
+ * @param object prefsBlueprint
+ *        An object containing { accessorName: [prefType, prefName, prefDefault] } keys.
+ */
+function PrefsHelper(prefsRoot = "", prefsBlueprint = {}) {
+  EventEmitter.decorate(this);
+
+  let cache = new Map();
+
+  for (let accessorName in prefsBlueprint) {
+    let [prefType, prefName, prefDefault] = prefsBlueprint[accessorName];
+    map(this, cache, accessorName, prefType, prefsRoot, prefName, prefDefault);
+  }
+
+  let observer = makeObserver(this, cache, prefsRoot, prefsBlueprint);
+  this.registerObserver = () => observer.register();
+  this.unregisterObserver = () => observer.unregister();
+}
+
+/**
+ * Helper method for getting a pref value.
+ *
+ * @param Map cache
+ * @param string prefType
+ * @param string prefsRoot
+ * @param string prefName
+ * @return any
+ */
+function get(cache, prefType, prefsRoot, prefName) {
+  let cachedPref = cache.get(prefName);
+  if (cachedPref !== undefined) {
+    return cachedPref;
+  }
+  let value = Services.prefs["get" + prefType + "Pref"]([prefsRoot, prefName].join("."));
+  cache.set(prefName, value);
+  return value;
+}
+
+/**
+ * Helper method for setting a pref value.
+ *
+ * @param Map cache
+ * @param string prefType
+ * @param string prefsRoot
+ * @param string prefName
+ * @param any value
+ */
+function set(cache, prefType, prefsRoot, prefName, value) {
+  Services.prefs["set" + prefType + "Pref"]([prefsRoot, prefName].join("."), value);
+  cache.set(prefName, value);
+}
+
+/**
+ * Maps a property name to a pref, defining lazy getters and setters.
+ * Supported types are "Bool", "Char", "Int", "Float" (sugar around "Char"
+ * type and casting), and "Json" (which is basically just sugar for "Char"
+ * using the standard JSON serializer).
+ *
+ * @param PrefsHelper self
+ * @param Map cache
+ * @param string accessorName
+ * @param string prefType
+ * @param string prefsRoot
+ * @param string prefName
+ * @param string prefDefault
+ * @param array serializer [optional]
+ */
+function map(self, cache, accessorName, prefType, prefsRoot, prefName, prefDefault, serializer = { in: e => e, out: e => e }) {
+  if (prefName in self) {
+    throw new Error(`Can't use ${prefName} because it overrides a property` + "on the instance.");
+  }
+  if (prefType == "Json") {
+    map(self, cache, accessorName, "String", prefsRoot, prefName, prefDefault, {
+      in: JSON.parse,
+      out: JSON.stringify
+    });
+    return;
+  }
+  if (prefType == "Float") {
+    map(self, cache, accessorName, "Char", prefsRoot, prefName, prefDefault, {
+      in: Number.parseFloat,
+      out: n => n + ""
+    });
+    return;
+  }
+
+  Object.defineProperty(self, accessorName, {
+    get: () => {
+      try {
+        return serializer.in(get(cache, prefType, prefsRoot, prefName));
+      } catch (e) {
+        if (typeof prefDefault !== 'undefined') {
+          return prefDefault;
+        }
+        throw e;
+      }
+    },
+    set: e => set(cache, prefType, prefsRoot, prefName, serializer.out(e))
+  });
+}
+
+/**
+ * Finds the accessor for the provided pref, based on the blueprint object
+ * used in the constructor.
+ *
+ * @param PrefsHelper self
+ * @param object prefsBlueprint
+ * @return string
+ */
+function accessorNameForPref(somePrefName, prefsBlueprint) {
+  for (let accessorName in prefsBlueprint) {
+    let [, prefName] = prefsBlueprint[accessorName];
+    if (somePrefName == prefName) {
+      return accessorName;
+    }
+  }
+  return "";
+}
+
+/**
+ * Creates a pref observer for `self`.
+ *
+ * @param PrefsHelper self
+ * @param Map cache
+ * @param string prefsRoot
+ * @param object prefsBlueprint
+ * @return object
+ */
+function makeObserver(self, cache, prefsRoot, prefsBlueprint) {
+  return {
+    register: function () {
+      this._branch = Services.prefs.getBranch(prefsRoot + ".");
+      this._branch.addObserver("", this);
+    },
+    unregister: function () {
+      this._branch.removeObserver("", this);
+    },
+    observe: function (subject, topic, prefName) {
+      // If this particular pref isn't handled by the blueprint object,
+      // even though it's in the specified branch, ignore it.
+      let accessorName = accessorNameForPref(prefName, prefsBlueprint);
+      if (!(accessorName in self)) {
+        return;
+      }
+      cache.delete(prefName);
+      self.emit("pref-changed", accessorName, self[accessorName]);
+    }
+  };
+}
+
+exports.PrefsHelper = PrefsHelper;
+
+/***/ }),
+
+/***/ 1772:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/* 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/. */
+
+const { appinfo } = __webpack_require__(22);
+const EventEmitter = __webpack_require__(1759);
+const isOSX = appinfo.OS === "Darwin";
+
+// List of electron keys mapped to DOM API (DOM_VK_*) key code
+const ElectronKeysMapping = {
+  "F1": "DOM_VK_F1",
+  "F2": "DOM_VK_F2",
+  "F3": "DOM_VK_F3",
+  "F4": "DOM_VK_F4",
+  "F5": "DOM_VK_F5",
+  "F6": "DOM_VK_F6",
+  "F7": "DOM_VK_F7",
+  "F8": "DOM_VK_F8",
+  "F9": "DOM_VK_F9",
+  "F10": "DOM_VK_F10",
+  "F11": "DOM_VK_F11",
+  "F12": "DOM_VK_F12",
+  "F13": "DOM_VK_F13",
+  "F14": "DOM_VK_F14",
+  "F15": "DOM_VK_F15",
+  "F16": "DOM_VK_F16",
+  "F17": "DOM_VK_F17",
+  "F18": "DOM_VK_F18",
+  "F19": "DOM_VK_F19",
+  "F20": "DOM_VK_F20",
+  "F21": "DOM_VK_F21",
+  "F22": "DOM_VK_F22",
+  "F23": "DOM_VK_F23",
+  "F24": "DOM_VK_F24",
+  "Space": "DOM_VK_SPACE",
+  "Backspace": "DOM_VK_BACK_SPACE",
+  "Delete": "DOM_VK_DELETE",
+  "Insert": "DOM_VK_INSERT",
+  "Return": "DOM_VK_RETURN",
+  "Enter": "DOM_VK_RETURN",
+  "Up": "DOM_VK_UP",
+  "Down": "DOM_VK_DOWN",
+  "Left": "DOM_VK_LEFT",
+  "Right": "DOM_VK_RIGHT",
+  "Home": "DOM_VK_HOME",
+  "End": "DOM_VK_END",
+  "PageUp": "DOM_VK_PAGE_UP",
+  "PageDown": "DOM_VK_PAGE_DOWN",
+  "Escape": "DOM_VK_ESCAPE",
+  "Esc": "DOM_VK_ESCAPE",
+  "Tab": "DOM_VK_TAB",
+  "VolumeUp": "DOM_VK_VOLUME_UP",
+  "VolumeDown": "DOM_VK_VOLUME_DOWN",
+  "VolumeMute": "DOM_VK_VOLUME_MUTE",
+  "PrintScreen": "DOM_VK_PRINTSCREEN"
+};
+
+/**
+ * Helper to listen for keyboard events decribed in .properties file.
+ *
+ * let shortcuts = new KeyShortcuts({
+ *   window
+ * });
+ * shortcuts.on("Ctrl+F", event => {
+ *   // `event` is the KeyboardEvent which relates to the key shortcuts
+ * });
+ *
+ * @param DOMWindow window
+ *        The window object of the document to listen events from.
+ * @param DOMElement target
+ *        Optional DOM Element on which we should listen events from.
+ *        If omitted, we listen for all events fired on `window`.
+ */
+function KeyShortcuts({ window, target }) {
+  this.window = window;
+  this.target = target || window;
+  this.keys = new Map();
+  this.eventEmitter = new EventEmitter();
+  this.target.addEventListener("keydown", this);
+}
+
+/*
+ * Parse an electron-like key string and return a normalized object which
+ * allow efficient match on DOM key event. The normalized object matches DOM
+ * API.
+ *
+ * @param DOMWindow window
+ *        Any DOM Window object, just to fetch its `KeyboardEvent` object
+ * @param String str
+ *        The shortcut string to parse, following this document:
+ *        https://github.com/electron/electron/blob/master/docs/api/accelerator.md
+ */
+KeyShortcuts.parseElectronKey = function (window, str) {
+  let modifiers = str.split("+");
+  let key = modifiers.pop();
+
+  let shortcut = {
+    ctrl: false,
+    meta: false,
+    alt: false,
+    shift: false,
+    // Set for character keys
+    key: undefined,
+    // Set for non-character keys
+    keyCode: undefined
+  };
+  for (let mod of modifiers) {
+    if (mod === "Alt") {
+      shortcut.alt = true;
+    } else if (["Command", "Cmd"].includes(mod)) {
+      shortcut.meta = true;
+    } else if (["CommandOrControl", "CmdOrCtrl"].includes(mod)) {
+      if (isOSX) {
+        shortcut.meta = true;
+      } else {
+        shortcut.ctrl = true;
+      }
+    } else if (["Control", "Ctrl"].includes(mod)) {
+      shortcut.ctrl = true;
+    } else if (mod === "Shift") {
+      shortcut.shift = true;
+    } else {
+      console.error("Unsupported modifier:", mod, "from key:", str);
+      return null;
+    }
+  }
+
+  // Plus is a special case. It's a character key and shouldn't be matched
+  // against a keycode as it is only accessible via Shift/Capslock
+  if (key === "Plus") {
+    key = "+";
+  }
+
+  if (typeof key === "string" && key.length === 1) {
+    // Match any single character
+    shortcut.key = key.toLowerCase();
+  } else if (key in ElectronKeysMapping) {
+    // Maps the others manually to DOM API DOM_VK_*
+    key = ElectronKeysMapping[key];
+    shortcut.keyCode = window.KeyboardEvent[key];
+    // Used only to stringify the shortcut
+    shortcut.keyCodeString = key;
+    shortcut.key = key;
+  } else {
+    console.error("Unsupported key:", key);
+    return null;
+  }
+
+  return shortcut;
+};
+
+KeyShortcuts.stringify = function (shortcut) {
+  let list = [];
+  if (shortcut.alt) {
+    list.push("Alt");
+  }
+  if (shortcut.ctrl) {
+    list.push("Ctrl");
+  }
+  if (shortcut.meta) {
+    list.push("Cmd");
+  }
+  if (shortcut.shift) {
+    list.push("Shift");
+  }
+  let key;
+  if (shortcut.key) {
+    key = shortcut.key.toUpperCase();
+  } else {
+    key = shortcut.keyCodeString;
+  }
+  list.push(key);
+  return list.join("+");
+};
+
+KeyShortcuts.prototype = {
+  destroy() {
+    this.target.removeEventListener("keydown", this);
+    this.keys.clear();
+  },
+
+  doesEventMatchShortcut(event, shortcut) {
+    if (shortcut.meta != event.metaKey) {
+      return false;
+    }
+    if (shortcut.ctrl != event.ctrlKey) {
+      return false;
+    }
+    if (shortcut.alt != event.altKey) {
+      return false;
+    }
+    // Shift is a special modifier, it may implicitely be required if the
+    // expected key is a special character accessible via shift.
+    if (shortcut.shift != event.shiftKey && event.key && event.key.match(/[a-zA-Z]/)) {
+      return false;
+    }
+    if (shortcut.keyCode) {
+      return event.keyCode == shortcut.keyCode;
+    } else if (event.key in ElectronKeysMapping) {
+      return ElectronKeysMapping[event.key] === shortcut.key;
+    }
+
+    // get the key from the keyCode if key is not provided.
+    let key = event.key || String.fromCharCode(event.keyCode);
+
+    // For character keys, we match if the final character is the expected one.
+    // But for digits we also accept indirect match to please azerty keyboard,
+    // which requires Shift to be pressed to get digits.
+    return key.toLowerCase() == shortcut.key || shortcut.key.match(/^[0-9]$/) && event.keyCode == shortcut.key.charCodeAt(0);
+  },
+
+  handleEvent(event) {
+    for (let [key, shortcut] of this.keys) {
+      if (this.doesEventMatchShortcut(event, shortcut)) {
+        this.eventEmitter.emit(key, event);
+      }
+    }
+  },
+
+  on(key, listener) {
+    if (typeof listener !== "function") {
+      throw new Error("KeyShortcuts.on() expects a function as " + "second argument");
+    }
+    if (!this.keys.has(key)) {
+      let shortcut = KeyShortcuts.parseElectronKey(this.window, key);
+      // The key string is wrong and we were unable to compute the key shortcut
+      if (!shortcut) {
+        return;
+      }
+      this.keys.set(key, shortcut);
+    }
+    this.eventEmitter.on(key, listener);
+  },
+
+  off(key, listener) {
+    this.eventEmitter.off(key, listener);
+  }
+};
+module.exports = KeyShortcuts;
+
+/***/ }),
+
+/***/ 1773:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* 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/. */
+
+
+
+/**
+ * Empty shim for "devtools/client/shared/zoom-keys" module
+ *
+ * Based on nsIMarkupDocumentViewer.fullZoom API
+ * https://developer.mozilla.org/en-US/Firefox/Releases/3/Full_page_zoom
+ */
+
+exports.register = function (window) {};
+
+/***/ }),
+
 /***/ 1777:
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -7515,17 +8446,19 @@ class Tree extends Component {
       // Optional event handler called with the current focused node when the
       // Enter key is pressed. Can be useful to allow further keyboard actions
       // within the tree node.
       onActivate: _propTypes2.default.func,
       isExpandable: _propTypes2.default.func,
       // Additional classes to add to the root element.
       className: _propTypes2.default.string,
       // style object to be applied to the root element.
-      style: _propTypes2.default.object
+      style: _propTypes2.default.object,
+      // Prevents blur when Tree loses focus
+      preventBlur: _propTypes2.default.bool
     };
   }
 
   static get defaultProps() {
     return {
       autoExpandDepth: AUTO_EXPAND_DEPTH,
       autoExpandAll: true
     };
@@ -7766,17 +8699,19 @@ class Tree extends Component {
       }
     }
   }
 
   /**
    * Sets the state to have no focused item.
    */
   _onBlur() {
-    this._focus(undefined);
+    if (!this.props.preventBlur) {
+      this._focus(undefined);
+    }
   }
 
   /**
    * Handles key down events in the tree's container.
    *
    * @param {Event} e
    */
   _onKeyDown(e) {
@@ -7885,25 +8820,16 @@ class Tree extends Component {
    */
   _focusParentNode() {
     const parent = this.props.getParent(this.props.focused);
     if (!parent) {
       this._focusPrevNode(this.props.focused);
       return;
     }
 
-    const traversal = this._dfsFromRoots();
-    const length = traversal.length;
-    let parentIndex = 0;
-    for (; parentIndex < length; parentIndex++) {
-      if (traversal[parentIndex].item === parent) {
-        break;
-      }
-    }
-
     this._focus(parent, { alignTo: "top" });
   }
 
   _focusFirstNode() {
     const traversal = this._dfsFromRoots();
     this._focus(traversal[0].item, { alignTo: "top" });
   }
 
@@ -7974,22 +8900,22 @@ class Tree extends Component {
       onKeyDown: this._onKeyDown,
       onKeyPress: this._preventArrowKeyScrolling,
       onKeyUp: this._preventArrowKeyScrolling,
       onFocus: ({ nativeEvent }) => {
         if (focused || !nativeEvent || !this.treeRef) {
           return;
         }
 
-        const { relatedTarget } = nativeEvent;
+        const { explicitOriginalTarget } = nativeEvent;
 
         // Only set default focus to the first tree node if the focus came
         // from outside the tree (e.g. by tabbing to the tree from other
         // external elements).
-        if (relatedTarget !== this.treeRef && !this.treeRef.contains(relatedTarget)) {
+        if (explicitOriginalTarget !== this.treeRef && !this.treeRef.contains(explicitOriginalTarget)) {
           this._focus(traversal[0].item);
         }
       },
       onBlur: this._onBlur,
       "aria-label": this.props.label,
       "aria-labelledby": this.props.labelledby,
       "aria-activedescendant": focused && this.props.getKey(focused),
       style
@@ -8149,16 +9075,20 @@ var transition = _interopRequireWildcard
 var _reselect = __webpack_require__(993);
 
 var reselect = _interopRequireWildcard(_reselect);
 
 var _url = __webpack_require__(334);
 
 var url = _interopRequireWildcard(_url);
 
+var _lodashMove = __webpack_require__(3751);
+
+var lodashMove = _interopRequireWildcard(_lodashMove);
+
 var _classnames = __webpack_require__(175);
 
 var _classnames2 = _interopRequireDefault(_classnames);
 
 var _devtoolsSplitter = __webpack_require__(1440);
 
 var _devtoolsSplitter2 = _interopRequireDefault(_devtoolsSplitter);
 
@@ -8169,35 +9099,16 @@ var _Svg2 = _interopRequireDefault(_Svg)
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
 // We cannot directly export literals containing special characters
 // (eg. "my-module/Test") which is why they are nested in "vendored".
 // The keys of the vendored object should match the module names
 // !!! Should remain synchronized with .babel/transform-mc.js !!!
-const vendored = exports.vendored = {
-  classnames: _classnames2.default,
-  "devtools-components": devtoolsComponents,
-  "devtools-config": devtoolsConfig,
-  "devtools-contextmenu": devtoolsContextmenu,
-  "devtools-environment": devtoolsEnvironment,
-  "devtools-modules": devtoolsModules,
-  "devtools-splitter": _devtoolsSplitter2.default,
-  "devtools-utils": devtoolsUtils,
-  "fuzzaldrin-plus": fuzzaldrinPlus,
-  "react-transition-group/Transition": transition,
-  reselect,
-  // Svg is required via relative paths, so the key is not imported path.
-  // See .babel/transform-mc.js
-  Svg: _Svg2.default,
-  url
-};
-
-// Modules imported without destructuring
 /* 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/>. */
 
 /**
  * Vendors.js is a file used to bundle and expose all dependencies needed to run
  * the transpiled debugger modules when running in Firefox.
  *
@@ -8205,16 +9116,844 @@ const vendored = exports.vendored = {
  * same way:
  * - always with destructuring (import { a } from "modA";)
  * - always without destructuring (import modB from "modB")
  *
  * Both are fine, but cannot be mixed for the same module.
  */
 
 // Modules imported with destructuring
+const vendored = exports.vendored = {
+  classnames: _classnames2.default,
+  "devtools-components": devtoolsComponents,
+  "devtools-config": devtoolsConfig,
+  "devtools-contextmenu": devtoolsContextmenu,
+  "devtools-environment": devtoolsEnvironment,
+  "devtools-modules": devtoolsModules,
+  "devtools-splitter": _devtoolsSplitter2.default,
+  "devtools-utils": devtoolsUtils,
+  "fuzzaldrin-plus": fuzzaldrinPlus,
+  "lodash-move": lodashMove,
+  "react-transition-group/Transition": transition,
+  reselect,
+  // Svg is required via relative paths, so the key is not imported path.
+  // See .babel/transform-mc.js
+  Svg: _Svg2.default,
+  url
+};
+
+// Modules imported without destructuring
+
+/***/ }),
+
+/***/ 3750:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/* 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/>. */
+
+/**
+ * This is a stub of the DevTools telemetry module and will be replaced by the
+ * full version of the file by Webpack for running inside Firefox.
+ */
+
+class Telemetry {
+  /**
+   * Time since the system wide epoch. This is not a monotonic timer but
+   * can be used across process boundaries.
+   */
+  get msSystemNow() {
+    return 0;
+  }
+
+  /**
+   * Starts a timer associated with a telemetry histogram. The timer can be
+   * directly associated with a histogram, or with a pair of a histogram and
+   * an object.
+   *
+   * @param {String} histogramId
+   *        A string which must be a valid histogram name.
+   * @param {Object} obj
+   *        Optional parameter. If specified, the timer is associated with this
+   *        object, meaning that multiple timers for the same histogram may be
+   *        run concurrently, as long as they are associated with different
+   *        objects.
+   *
+   * @returns {Boolean}
+   *          True if the timer was successfully started, false otherwise. If a
+   *          timer already exists, it can't be started again, and the existing
+   *          one will be cleared in order to avoid measurements errors.
+   */
+  start(histogramId, obj) {
+    return true;
+  }
+
+  /**
+   * Starts a timer associated with a keyed telemetry histogram. The timer can
+   * be directly associated with a histogram and its key. Similarly to
+   * TelemetryStopwatch.start the histogram and its key can be associated
+   * with an object. Each key may have multiple associated objects and each
+   * object can be associated with multiple keys.
+   *
+   * @param {String} histogramId
+   *        A string which must be a valid histogram name.
+   * @param {String} key
+   *        A string which must be a valid histgram key.
+   * @param {Object} obj
+   *        Optional parameter. If specified, the timer is associated with this
+   *        object, meaning that multiple timers for the same histogram may be
+   *        run concurrently,as long as they are associated with different
+   *        objects.
+   *
+   * @returns {Boolean}
+   *          True if the timer was successfully started, false otherwise. If a
+   *          timer already exists, it can't be started again, and the existing
+   *          one will be cleared in order to avoid measurements errors.
+   */
+  startKeyed(histogramId, key, obj) {
+    return true;
+  }
+
+  /**
+   * Stops the timer associated with the given histogram (and object),
+   * calculates the time delta between start and finish, and adds the value
+   * to the histogram.
+   *
+   * @param {String} histogramId
+   *        A string which must be a valid histogram name.
+   * @param {Object} obj
+   *        Optional parameter which associates the histogram timer with the
+   *        given object.
+   * @param {Boolean} canceledOkay
+   *        Optional parameter which will suppress any warnings that normally
+   *        fire when a stopwatch is finished after being cancelled.
+   *        Defaults to false.
+   *
+   * @returns {Boolean}
+   *          True if the timer was succesfully stopped and the data was added
+   *          to the histogram, False otherwise.
+   */
+  finish(histogramId, obj, canceledOkay) {
+    return true;
+  }
+
+  /**
+   * Stops the timer associated with the given keyed histogram (and object),
+   * calculates the time delta between start and finish, and adds the value
+   * to the keyed histogram.
+   *
+   * @param {String} histogramId
+   *        A string which must be a valid histogram name.
+   * @param {String} key
+   *        A string which must be a valid histogram key.
+   * @param {Object} obj
+   *        Optional parameter which associates the histogram timer with the
+   *        given object.
+   * @param {Boolean} canceledOkay
+   *        Optional parameter which will suppress any warnings that normally
+   *        fire when a stopwatch is finished after being cancelled.
+   *        Defaults to false.
+   *
+   * @returns {Boolean}
+   *          True if the timer was succesfully stopped and the data was added
+   *          to the histogram, False otherwise.
+   */
+  finishKeyed(histogramId, key, obj, cancelledOkay) {
+    return true;
+  }
+
+  /**
+   * Log a value to a histogram.
+   *
+   * @param  {String} histogramId
+   *         Histogram in which the data is to be stored.
+   */
+  getHistogramById(histogramId) {
+    return {
+      add: () => {}
+    };
+  }
+
+  /**
+   * Get a keyed histogram.
+   *
+   * @param  {String} histogramId
+   *         Histogram in which the data is to be stored.
+   */
+  getKeyedHistogramById(histogramId) {
+    return {
+      add: () => {}
+    };
+  }
+
+  /**
+   * Log a value to a scalar.
+   *
+   * @param  {String} scalarId
+   *         Scalar in which the data is to be stored.
+   * @param  value
+   *         Value to store.
+   */
+  scalarSet(scalarId, value) {}
+
+  /**
+   * Log a value to a count scalar.
+   *
+   * @param  {String} scalarId
+   *         Scalar in which the data is to be stored.
+   * @param  value
+   *         Value to store.
+   */
+  scalarAdd(scalarId, value) {}
+
+  /**
+   * Log a value to a keyed count scalar.
+   *
+   * @param  {String} scalarId
+   *         Scalar in which the data is to be stored.
+   * @param  {String} key
+   *         The key within the  scalar.
+   * @param  value
+   *         Value to store.
+   */
+  keyedScalarAdd(scalarId, key, value) {}
+
+  /**
+   * Event telemetry is disabled by default. Use this method to enable it for
+   * a particular category.
+   *
+   * @param {String} category
+   *        The telemetry event category e.g. "devtools.main"
+   * @param {Boolean} enabled
+   *        Enabled: true or false.
+   */
+  setEventRecordingEnabled(category, enabled) {
+    return enabled;
+  }
+
+  /**
+   * Telemetry events often need to make use of a number of properties from
+   * completely different codepaths. To make this possible we create a
+   * "pending event" along with an array of property names that we need to wait
+   * for before sending the event.
+   *
+   * As each property is received via addEventProperty() we check if all
+   * properties have been received. Once they have all been received we send the
+   * telemetry event.
+   *
+   * @param {String} category
+   *        The telemetry event category (a group name for events and helps to
+   *        avoid name conflicts) e.g. "devtools.main"
+   * @param {String} method
+   *        The telemetry event method (describes the type of event that
+   *        occurred e.g. "open")
+   * @param {String} object
+   *        The telemetry event object name (the name of the object the event
+   *        occurred on) e.g. "tools" or "setting"
+   * @param {String|null} value
+   *        The telemetry event value (a user defined value, providing context
+   *        for the event) e.g. "console"
+   * @param {Array} expected
+   *        An array of the properties needed before sending the telemetry
+   *        event e.g.
+   *        [
+   *          "host",
+   *          "width"
+   *        ]
+   */
+  preparePendingEvent(category, method, object, value, expected = []) {}
+
+  /**
+   * Adds an expected property for either a current or future pending event.
+   * This means that if preparePendingEvent() is called before or after sending
+   * the event properties they will automatically added to the event.
+   *
+   * @param {String} category
+   *        The telemetry event category (a group name for events and helps to
+   *        avoid name conflicts) e.g. "devtools.main"
+   * @param {String} method
+   *        The telemetry event method (describes the type of event that
+   *        occurred e.g. "open")
+   * @param {String} object
+   *        The telemetry event object name (the name of the object the event
+   *        occurred on) e.g. "tools" or "setting"
+   * @param {String|null} value
+   *        The telemetry event value (a user defined value, providing context
+   *        for the event) e.g. "console"
+   * @param {String} pendingPropName
+   *        The pending property name
+   * @param {String} pendingPropValue
+   *        The pending property value
+   */
+  addEventProperty(category, method, object, value, pendingPropName, pendingPropValue) {}
+
+  /**
+   * Adds expected properties for either a current or future pending event.
+   * This means that if preparePendingEvent() is called before or after sending
+   * the event properties they will automatically added to the event.
+   *
+   * @param {String} category
+   *        The telemetry event category (a group name for events and helps to
+   *        avoid name conflicts) e.g. "devtools.main"
+   * @param {String} method
+   *        The telemetry event method (describes the type of event that
+   *        occurred e.g. "open")
+   * @param {String} object
+   *        The telemetry event object name (the name of the object the event
+   *        occurred on) e.g. "tools" or "setting"
+   * @param {String|null} value
+   *        The telemetry event value (a user defined value, providing context
+   *        for the event) e.g. "console"
+   * @param {String} pendingObject
+   *        An object containing key, value pairs that should be added to the
+   *        event as properties.
+   */
+  addEventProperties(category, method, object, value, pendingObject) {}
+
+  /**
+   * A private method that is not to be used externally. This method is used to
+   * prepare a pending telemetry event for sending and then send it via
+   * recordEvent().
+   *
+   * @param {String} category
+   *        The telemetry event category (a group name for events and helps to
+   *        avoid name conflicts) e.g. "devtools.main"
+   * @param {String} method
+   *        The telemetry event method (describes the type of event that
+   *        occurred e.g. "open")
+   * @param {String} object
+   *        The telemetry event object name (the name of the object the event
+   *        occurred on) e.g. "tools" or "setting"
+   * @param {String|null} value
+   *        The telemetry event value (a user defined value, providing context
+   *        for the event) e.g. "console"
+   */
+  _sendPendingEvent(category, method, object, value) {}
+
+  /**
+   * Send a telemetry event.
+   *
+   * @param {String} category
+   *        The telemetry event category (a group name for events and helps to
+   *        avoid name conflicts) e.g. "devtools.main"
+   * @param {String} method
+   *        The telemetry event method (describes the type of event that
+   *        occurred e.g. "open")
+   * @param {String} object
+   *        The telemetry event object name (the name of the object the event
+   *        occurred on) e.g. "tools" or "setting"
+   * @param {String|null} value
+   *        The telemetry event value (a user defined value, providing context
+   *        for the event) e.g. "console"
+   * @param {Object} extra
+   *        The telemetry event extra object containing the properties that will
+   *        be sent with the event e.g.
+   *        {
+   *          host: "bottom",
+   *          width: "1024"
+   *        }
+   */
+  recordEvent(category, method, object, value, extra) {}
+
+  /**
+   * Sends telemetry pings to indicate that a tool has been opened.
+   *
+   * @param {String} id
+   *        The ID of the tool opened.
+   */
+  toolOpened(id) {}
+
+  /**
+   * Sends telemetry pings to indicate that a tool has been closed.
+   *
+   * @param {String} id
+   *        The ID of the tool opened.
+   */
+  toolClosed(id) {}
+}
+
+module.exports = Telemetry;
+
+/***/ }),
+
+/***/ 3751:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = move;
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+function move(array, moveIndex, toIndex) {
+  /* #move - Moves an array item from one position in an array to another.
+      Note: This is a pure function so a new array will be returned, instead
+     of altering the array argument.
+     Arguments:
+    1. array     (String) : Array in which to move an item.         (required)
+    2. moveIndex (Object) : The index of the item to move.          (required)
+    3. toIndex   (Object) : The index to move item at moveIndex to. (required)
+  */
+  var item = array[moveIndex];
+  var length = array.length;
+  var diff = moveIndex - toIndex;
+
+  if (diff > 0) {
+    // move left
+    return [].concat(_toConsumableArray(array.slice(0, toIndex)), [item], _toConsumableArray(array.slice(toIndex, moveIndex)), _toConsumableArray(array.slice(moveIndex + 1, length)));
+  } else if (diff < 0) {
+    // move right
+    return [].concat(_toConsumableArray(array.slice(0, moveIndex)), _toConsumableArray(array.slice(moveIndex + 1, toIndex + 1)), [item], _toConsumableArray(array.slice(toIndex + 1, length)));
+  }
+  return array;
+}
+
+/***/ }),
+
+/***/ 3752:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/* 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/. */
+
+// TODO : Localize this (was l10n.getStr("frame.unknownSource"))
+const UNKNOWN_SOURCE_STRING = "(unknown)";
+
+// Character codes used in various parsing helper functions.
+const CHAR_CODE_A = "a".charCodeAt(0);
+const CHAR_CODE_B = "b".charCodeAt(0);
+const CHAR_CODE_C = "c".charCodeAt(0);
+const CHAR_CODE_D = "d".charCodeAt(0);
+const CHAR_CODE_E = "e".charCodeAt(0);
+const CHAR_CODE_F = "f".charCodeAt(0);
+const CHAR_CODE_H = "h".charCodeAt(0);
+const CHAR_CODE_I = "i".charCodeAt(0);
+const CHAR_CODE_J = "j".charCodeAt(0);
+const CHAR_CODE_L = "l".charCodeAt(0);
+const CHAR_CODE_M = "m".charCodeAt(0);
+const CHAR_CODE_N = "n".charCodeAt(0);
+const CHAR_CODE_O = "o".charCodeAt(0);
+const CHAR_CODE_P = "p".charCodeAt(0);
+const CHAR_CODE_R = "r".charCodeAt(0);
+const CHAR_CODE_S = "s".charCodeAt(0);
+const CHAR_CODE_T = "t".charCodeAt(0);
+const CHAR_CODE_U = "u".charCodeAt(0);
+const CHAR_CODE_W = "w".charCodeAt(0);
+const CHAR_CODE_COLON = ":".charCodeAt(0);
+const CHAR_CODE_DASH = "-".charCodeAt(0);
+const CHAR_CODE_L_SQUARE_BRACKET = "[".charCodeAt(0);
+const CHAR_CODE_SLASH = "/".charCodeAt(0);
+const CHAR_CODE_CAP_S = "S".charCodeAt(0);
+
+// The cache used in the `parseURL` function.
+const gURLStore = new Map();
+// The cache used in the `getSourceNames` function.
+const gSourceNamesStore = new Map();
+
+/**
+* Takes a string and returns an object containing all the properties
+* available on an URL instance, with additional properties (fileName),
+* Leverages caching.
+*
+* @param {String} location
+* @return {Object?} An object containing most properties available
+*                   in https://developer.mozilla.org/en-US/docs/Web/API/URL
+*/
+
+function parseURL(location) {
+  let url = gURLStore.get(location);
+
+  if (url !== void 0) {
+    return url;
+  }
+
+  try {
+    url = new URL(location);
+    // The callers were generally written to expect a URL from
+    // sdk/url, which is subtly different.  So, work around some
+    // important differences here.
+    url = {
+      href: url.href,
+      protocol: url.protocol,
+      host: url.host,
+      hostname: url.hostname,
+      port: url.port || null,
+      pathname: url.pathname,
+      search: url.search,
+      hash: url.hash,
+      username: url.username,
+      password: url.password,
+      origin: url.origin
+    };
+
+    // Definitions:
+    // Example: https://foo.com:8888/file.js
+    // `hostname`: "foo.com"
+    // `host`: "foo.com:8888"
+    let isChrome = isChromeScheme(location);
+
+    url.fileName = url.pathname ? url.pathname.slice(url.pathname.lastIndexOf("/") + 1) || "/" : "/";
+
+    if (isChrome) {
+      url.hostname = null;
+      url.host = null;
+    }
+
+    gURLStore.set(location, url);
+    return url;
+  } catch (e) {
+    gURLStore.set(location, null);
+    return null;
+  }
+}
+
+/**
+* Parse a source into a short and long name as well as a host name.
+*
+* @param {String} source
+*        The source to parse. Can be a URI or names like "(eval)" or
+*        "self-hosted".
+* @return {Object}
+*         An object with the following properties:
+*           - {String} short: A short name for the source.
+*             - "http://page.com/test.js#go?q=query" -> "test.js"
+*           - {String} long: The full, long name for the source, with
+              hash/query stripped.
+*             - "http://page.com/test.js#go?q=query" -> "http://page.com/test.js"
+*           - {String?} host: If available, the host name for the source.
+*             - "http://page.com/test.js#go?q=query" -> "page.com"
+*/
+function getSourceNames(source) {
+  let data = gSourceNamesStore.get(source);
+
+  if (data) {
+    return data;
+  }
+
+  let short, long, host;
+  const sourceStr = source ? String(source) : "";
+
+  // If `data:...` uri
+  if (isDataScheme(sourceStr)) {
+    let commaIndex = sourceStr.indexOf(",");
+    if (commaIndex > -1) {
+      // The `short` name for a data URI becomes `data:` followed by the actual
+      // encoded content, omitting the MIME type, and charset.
+      short = `data:${sourceStr.substring(commaIndex + 1)}`.slice(0, 100);
+      let result = { short, long: sourceStr };
+      gSourceNamesStore.set(source, result);
+      return result;
+    }
+  }
+
+  // If Scratchpad URI, like "Scratchpad/1"; no modifications,
+  // and short/long are the same.
+  if (isScratchpadScheme(sourceStr)) {
+    let result = { short: sourceStr, long: sourceStr };
+    gSourceNamesStore.set(source, result);
+    return result;
+  }
+
+  const parsedUrl = parseURL(sourceStr);
+
+  if (!parsedUrl) {
+    // Malformed URI.
+    long = sourceStr;
+    short = sourceStr.slice(0, 100);
+  } else {
+    host = parsedUrl.host;
+
+    long = parsedUrl.href;
+    if (parsedUrl.hash) {
+      long = long.replace(parsedUrl.hash, "");
+    }
+    if (parsedUrl.search) {
+      long = long.replace(parsedUrl.search, "");
+    }
+
+    short = parsedUrl.fileName;
+    // If `short` is just a slash, and we actually have a path,
+    // strip the slash and parse again to get a more useful short name.
+    // e.g. "http://foo.com/bar/" -> "bar", rather than "/"
+    if (short === "/" && parsedUrl.pathname !== "/") {
+      short = parseURL(long.replace(/\/$/, "")).fileName;
+    }
+  }
+
+  if (!short) {
+    if (!long) {
+      long = UNKNOWN_SOURCE_STRING;
+    }
+    short = long.slice(0, 100);
+  }
+
+  let result = { short, long, host };
+  gSourceNamesStore.set(source, result);
+  return result;
+}
+
+// For the functions below, we assume that we will never access the location
+// argument out of bounds, which is indeed the vast majority of cases.
+//
+// They are written this way because they are hot. Each frame is checked for
+// being content or chrome when processing the profile.
+
+function isColonSlashSlash(location, i = 0) {
+  return location.charCodeAt(++i) === CHAR_CODE_COLON && location.charCodeAt(++i) === CHAR_CODE_SLASH && location.charCodeAt(++i) === CHAR_CODE_SLASH;
+}
+
+/**
+* Checks for a Scratchpad URI, like "Scratchpad/1"
+*/
+function isScratchpadScheme(location, i = 0) {
+  return location.charCodeAt(i) === CHAR_CODE_CAP_S && location.charCodeAt(++i) === CHAR_CODE_C && location.charCodeAt(++i) === CHAR_CODE_R && location.charCodeAt(++i) === CHAR_CODE_A && location.charCodeAt(++i) === CHAR_CODE_T && location.charCodeAt(++i) === CHAR_CODE_C && location.charCodeAt(++i) === CHAR_CODE_H && location.charCodeAt(++i) === CHAR_CODE_P && location.charCodeAt(++i) === CHAR_CODE_A && location.charCodeAt(++i) === CHAR_CODE_D && location.charCodeAt(++i) === CHAR_CODE_SLASH;
+}
+
+function isDataScheme(location, i = 0) {
+  return location.charCodeAt(i) === CHAR_CODE_D && location.charCodeAt(++i) === CHAR_CODE_A && location.charCodeAt(++i) === CHAR_CODE_T && location.charCodeAt(++i) === CHAR_CODE_A && location.charCodeAt(++i) === CHAR_CODE_COLON;
+}
+
+function isContentScheme(location, i = 0) {
+  let firstChar = location.charCodeAt(i);
+
+  switch (firstChar) {
+    // "http://" or "https://"
+    case CHAR_CODE_H:
+      if (location.charCodeAt(++i) === CHAR_CODE_T && location.charCodeAt(++i) === CHAR_CODE_T && location.charCodeAt(++i) === CHAR_CODE_P) {
+        if (location.charCodeAt(i + 1) === CHAR_CODE_S) {
+          ++i;
+        }
+        return isColonSlashSlash(location, i);
+      }
+      return false;
+
+    // "file://"
+    case CHAR_CODE_F:
+      if (location.charCodeAt(++i) === CHAR_CODE_I && location.charCodeAt(++i) === CHAR_CODE_L && location.charCodeAt(++i) === CHAR_CODE_E) {
+        return isColonSlashSlash(location, i);
+      }
+      return false;
+
+    // "app://"
+    case CHAR_CODE_A:
+      if (location.charCodeAt(++i) == CHAR_CODE_P && location.charCodeAt(++i) == CHAR_CODE_P) {
+        return isColonSlashSlash(location, i);
+      }
+      return false;
+
+    // "blob:"
+    case CHAR_CODE_B:
+      if (location.charCodeAt(++i) == CHAR_CODE_L && location.charCodeAt(++i) == CHAR_CODE_O && location.charCodeAt(++i) == CHAR_CODE_B && location.charCodeAt(++i) == CHAR_CODE_COLON) {
+        return isContentScheme(location, i + 1);
+      }
+      return false;
+
+    default:
+      return false;
+  }
+}
+
+function isChromeScheme(location, i = 0) {
+  let firstChar = location.charCodeAt(i);
+
+  switch (firstChar) {
+    // "chrome://"
+    case CHAR_CODE_C:
+      if (location.charCodeAt(++i) === CHAR_CODE_H && location.charCodeAt(++i) === CHAR_CODE_R && location.charCodeAt(++i) === CHAR_CODE_O && location.charCodeAt(++i) === CHAR_CODE_M && location.charCodeAt(++i) === CHAR_CODE_E) {
+        return isColonSlashSlash(location, i);
+      }
+      return false;
+
+    // "resource://"
+    case CHAR_CODE_R:
+      if (location.charCodeAt(++i) === CHAR_CODE_E && location.charCodeAt(++i) === CHAR_CODE_S && location.charCodeAt(++i) === CHAR_CODE_O && location.charCodeAt(++i) === CHAR_CODE_U && location.charCodeAt(++i) === CHAR_CODE_R && location.charCodeAt(++i) === CHAR_CODE_C && location.charCodeAt(++i) === CHAR_CODE_E) {
+        return isColonSlashSlash(location, i);
+      }
+      return false;
+
+    // "jar:file://"
+    case CHAR_CODE_J:
+      if (location.charCodeAt(++i) === CHAR_CODE_A && location.charCodeAt(++i) === CHAR_CODE_R && location.charCodeAt(++i) === CHAR_CODE_COLON && location.charCodeAt(++i) === CHAR_CODE_F && location.charCodeAt(++i) === CHAR_CODE_I && location.charCodeAt(++i) === CHAR_CODE_L && location.charCodeAt(++i) === CHAR_CODE_E) {
+        return isColonSlashSlash(location, i);
+      }
+      return false;
+
+    default:
+      return false;
+  }
+}
+
+function isWASM(location, i = 0) {
+  return (
+    // "wasm-function["
+    location.charCodeAt(i) === CHAR_CODE_W && location.charCodeAt(++i) === CHAR_CODE_A && location.charCodeAt(++i) === CHAR_CODE_S && location.charCodeAt(++i) === CHAR_CODE_M && location.charCodeAt(++i) === CHAR_CODE_DASH && location.charCodeAt(++i) === CHAR_CODE_F && location.charCodeAt(++i) === CHAR_CODE_U && location.charCodeAt(++i) === CHAR_CODE_N && location.charCodeAt(++i) === CHAR_CODE_C && location.charCodeAt(++i) === CHAR_CODE_T && location.charCodeAt(++i) === CHAR_CODE_I && location.charCodeAt(++i) === CHAR_CODE_O && location.charCodeAt(++i) === CHAR_CODE_N && location.charCodeAt(++i) === CHAR_CODE_L_SQUARE_BRACKET
+  );
+}
+
+/**
+* A utility method to get the file name from a sourcemapped location
+* The sourcemap location can be in any form. This method returns a
+* formatted file name for different cases like Windows or OSX.
+* @param source
+* @returns String
+*/
+function getSourceMappedFile(source) {
+  // If sourcemapped source is a OSX path, return
+  // the characters after last "/".
+  // If sourcemapped source is a Windowss path, return
+  // the characters after last "\\".
+  if (source.lastIndexOf("/") >= 0) {
+    source = source.slice(source.lastIndexOf("/") + 1);
+  } else if (source.lastIndexOf("\\") >= 0) {
+    source = source.slice(source.lastIndexOf("\\") + 1);
+  }
+  return source;
+}
+
+module.exports = {
+  parseURL,
+  getSourceNames,
+  isScratchpadScheme,
+  isChromeScheme,
+  isContentScheme,
+  isWASM,
+  isDataScheme,
+  getSourceMappedFile
+};
+
+/***/ }),
+
+/***/ 3753:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* 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/. */
+
+// This file is a chrome-API-free version of the module
+// devtools/client/shared/unicode-url.js in the mozilla-central repository, so
+// that it can be used in Chrome-API-free applications, such as the Launchpad.
+// But because of this, it cannot take advantage of utilizing chrome APIs and
+// should implement the similar functionalities on its own.
+//
+// Please keep in mind that if the feature in this file has changed, don't
+// forget to also change that accordingly in
+// devtools/client/shared/unicode-url.js in the mozilla-central repository.
+
+
+
+const punycode = __webpack_require__(3641);
+
+/**
+ * Gets a readble Unicode hostname from a hostname.
+ *
+ * If the `hostname` is a readable ASCII hostname, such as example.org, then
+ * this function will simply return the original `hostname`.
+ *
+ * If the `hostname` is a Punycode hostname representing a Unicode domain name,
+ * such as xn--g6w.xn--8pv, then this function will return the readable Unicode
+ * domain name by decoding the Punycode hostname.
+ *
+ * @param {string}  hostname
+ *                  the hostname from which the Unicode hostname will be
+ *                  parsed, such as example.org, xn--g6w.xn--8pv.
+ * @return {string} The Unicode hostname. It may be the same as the `hostname`
+ *                  passed to this function if the `hostname` itself is
+ *                  a readable ASCII hostname or a Unicode hostname.
+ */
+function getUnicodeHostname(hostname) {
+  try {
+    return punycode.toUnicode(hostname);
+  } catch (err) {}
+  return hostname;
+}
+
+/**
+ * Gets a readble Unicode URL pathname from a URL pathname.
+ *
+ * If the `urlPath` is a readable ASCII URL pathname, such as /a/b/c.js, then
+ * this function will simply return the original `urlPath`.
+ *
+ * If the `urlPath` is a URI-encoded pathname, such as %E8%A9%A6/%E6%B8%AC.js,
+ * then this function will return the readable Unicode pathname.
+ *
+ * If the `urlPath` is a malformed URL pathname, then this function will simply
+ * return the original `urlPath`.
+ *
+ * @param {string}  urlPath
+ *                  the URL path from which the Unicode URL path will be parsed,
+ *                  such as /a/b/c.js, %E8%A9%A6/%E6%B8%AC.js.
+ * @return {string} The Unicode URL Path. It may be the same as the `urlPath`
+ *                  passed to this function if the `urlPath` itself is a readable
+ *                  ASCII url or a Unicode url.
+ */
+function getUnicodeUrlPath(urlPath) {
+  try {
+    return decodeURIComponent(urlPath);
+  } catch (err) {}
+  return urlPath;
+}
+
+/**
+ * Gets a readable Unicode URL from a URL.
+ *
+ * If the `url` is a readable ASCII URL, such as http://example.org/a/b/c.js,
+ * then this function will simply return the original `url`.
+ *
+ * If the `url` includes either an unreadable Punycode domain name or an
+ * unreadable URI-encoded pathname, such as
+ * http://xn--g6w.xn--8pv/%E8%A9%A6/%E6%B8%AC.js, then this function will return
+ * the readable URL by decoding all its unreadable URL components to Unicode
+ * characters.
+ *
+ * If the `url` is a malformed URL, then this function will return the original
+ * `url`.
+ *
+ * If the `url` is a data: URI, then this function will return the original
+ * `url`.
+ *
+ * @param {string}  url
+ *                  the full URL, or a data: URI. from which the readable URL
+ *                  will be parsed, such as, http://example.org/a/b/c.js,
+ *                  http://xn--g6w.xn--8pv/%E8%A9%A6/%E6%B8%AC.js
+ * @return {string} The readable URL. It may be the same as the `url` passed to
+ *                  this function if the `url` itself is readable.
+ */
+function getUnicodeUrl(url) {
+  try {
+    const { protocol, hostname } = new URL(url);
+    if (protocol === "data:") {
+      // Never convert a data: URI.
+      return url;
+    }
+    const readableHostname = getUnicodeHostname(hostname);
+    url = decodeURIComponent(url);
+    return url.replace(hostname, readableHostname);
+  } catch (err) {}
+  return url;
+}
+
+module.exports = {
+  getUnicodeHostname,
+  getUnicodeUrlPath,
+  getUnicodeUrl
+};
 
 /***/ }),
 
 /***/ 4:
 /***/ (function(module, exports) {
 
 module.exports = __WEBPACK_EXTERNAL_MODULE_4__;
 
--- a/devtools/client/debugger/new/src/actions/ast.js
+++ b/devtools/client/debugger/new/src/actions/ast.js
@@ -17,27 +17,29 @@ var _setInScopeLines = require("./ast/se
 var _parser = require("../workers/parser/index");
 
 var _promise = require("./utils/middleware/promise");
 
 var _devtoolsSourceMap = require("devtools/client/shared/source-map/index.js");
 
 var _prefs = require("../utils/prefs");
 
+var _source = require("../utils/source");
+
 /* 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/>. */
 function setSourceMetaData(sourceId) {
   return async ({
     dispatch,
     getState
   }) => {
     const source = (0, _selectors.getSource)(getState(), sourceId);
 
-    if (!source || !source.text || source.isWasm) {
+    if (!source || !(0, _source.isLoaded)(source) || source.isWasm) {
       return;
     }
 
     const framework = await (0, _parser.getFramework)(source.id);
     dispatch({
       type: "SET_SOURCE_METADATA",
       sourceId: source.id,
       sourceMetaData: {
@@ -47,19 +49,19 @@ function setSourceMetaData(sourceId) {
   };
 }
 
 function setSymbols(sourceId) {
   return async ({
     dispatch,
     getState
   }) => {
-    const source = (0, _selectors.getSource)(getState(), sourceId);
+    const source = (0, _selectors.getSourceFromId)(getState(), sourceId);
 
-    if (!source || !source.text || source.isWasm || (0, _selectors.hasSymbols)(getState(), source)) {
+    if (source.isWasm || (0, _selectors.hasSymbols)(getState(), source)) {
       return;
     }
 
     await dispatch({
       type: "SET_SYMBOLS",
       sourceId,
       [_promise.PROMISE]: (0, _parser.getSymbols)(sourceId)
     });
@@ -80,21 +82,21 @@ function setOutOfScopeLocations() {
     getState
   }) => {
     const location = (0, _selectors.getSelectedLocation)(getState());
 
     if (!location) {
       return;
     }
 
-    const source = (0, _selectors.getSource)(getState(), location.sourceId);
+    const source = (0, _selectors.getSourceFromId)(getState(), location.sourceId);
     let locations = null;
 
     if (location.line && source && (0, _selectors.isPaused)(getState())) {
-      locations = await (0, _parser.findOutOfScopeLocations)(source.get("id"), location);
+      locations = await (0, _parser.findOutOfScopeLocations)(source.id, location);
     }
 
     dispatch({
       type: "OUT_OF_SCOPE_LOCATIONS",
       locations
     });
     dispatch((0, _setInScopeLines.setInScopeLines)());
   };
@@ -116,29 +118,29 @@ function compressPausePoints(pausePoints
 }
 
 function setPausePoints(sourceId) {
   return async ({
     dispatch,
     getState,
     client
   }) => {
-    const source = (0, _selectors.getSource)(getState(), sourceId);
+    const source = (0, _selectors.getSourceFromId)(getState(), sourceId);
 
     if (!_prefs.features.pausePoints || !source || !source.text || source.isWasm) {
       return;
     }
 
     const pausePoints = await (0, _parser.getPausePoints)(sourceId);
     const compressed = compressPausePoints(pausePoints);
 
     if ((0, _devtoolsSourceMap.isGeneratedId)(sourceId)) {
       await client.setPausePoints(sourceId, compressed);
     }
 
     dispatch({
       type: "SET_PAUSE_POINTS",
-      sourceText: source.text,
+      sourceText: source.text || "",
       sourceId,
       pausePoints
     });
   };
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/actions/ast/setInScopeLines.js
+++ b/devtools/client/debugger/new/src/actions/ast/setInScopeLines.js
@@ -22,25 +22,25 @@ function getOutOfScopeLines(outOfScopeLo
   return (0, _lodash.uniq)((0, _lodash.flatMap)(outOfScopeLocations, location => (0, _lodash.range)(location.start.line, location.end.line)));
 }
 
 function setInScopeLines() {
   return ({
     dispatch,
     getState
   }) => {
-    const sourceRecord = (0, _selectors.getSelectedSource)(getState());
+    const source = (0, _selectors.getSelectedSource)(getState());
     const outOfScopeLocations = (0, _selectors.getOutOfScopeLocations)(getState());
 
-    if (!sourceRecord || !sourceRecord.text) {
+    if (!source || !source.text) {
       return;
     }
 
     const linesOutOfScope = getOutOfScopeLines(outOfScopeLocations);
-    const sourceNumLines = (0, _source.getSourceLineCount)(sourceRecord);
+    const sourceNumLines = (0, _source.getSourceLineCount)(source);
     const sourceLines = (0, _lodash.range)(1, sourceNumLines + 1);
     const inScopeLines = !linesOutOfScope ? sourceLines : (0, _lodash.without)(sourceLines, ...linesOutOfScope);
     dispatch({
       type: "IN_SCOPE_LINES",
       lines: inScopeLines
     });
   };
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/actions/breakpoints.js
+++ b/devtools/client/debugger/new/src/actions/breakpoints.js
@@ -402,22 +402,23 @@ function setBreakpointCondition(location
 
 function toggleBreakpoint(line, column) {
   return ({
     dispatch,
     getState,
     client,
     sourceMaps
   }) => {
-    if (!line) {
+    const state = getState();
+    const selectedSource = (0, _selectors.getSelectedSource)(state);
+
+    if (!line || !selectedSource) {
       return;
     }
 
-    const state = getState();
-    const selectedSource = (0, _selectors.getSelectedSource)(state);
     const bp = (0, _selectors.getBreakpointAtLocation)(state, {
       line,
       column
     });
     const isEmptyLine = (0, _ast.isEmptyLineInSource)(state, line, selectedSource.id);
 
     if (!bp && isEmptyLine || bp && bp.loading) {
       return;
@@ -444,38 +445,39 @@ function toggleBreakpoint(line, column) 
 
 function addOrToggleDisabledBreakpoint(line, column) {
   return ({
     dispatch,
     getState,
     client,
     sourceMaps
   }) => {
-    if (!line) {
+    const selectedSource = (0, _selectors.getSelectedSource)(getState());
+
+    if (!line || !selectedSource) {
       return;
     }
 
-    const selectedSource = (0, _selectors.getSelectedSource)(getState());
     const bp = (0, _selectors.getBreakpointAtLocation)(getState(), {
       line,
       column
     });
 
     if (bp && bp.loading) {
       return;
     }
 
     if (bp) {
       // NOTE: it's possible the breakpoint has slid to a column
       return dispatch(toggleDisabledBreakpoint(line, column || bp.location.column));
     }
 
     return dispatch(addBreakpoint({
-      sourceId: selectedSource.get("id"),
-      sourceUrl: selectedSource.get("url"),
+      sourceId: selectedSource.id,
+      sourceUrl: selectedSource.url,
       line: line,
       column: column
     }));
   };
 }
 
 function toggleDisabledBreakpoint(line, column) {
   return ({
--- a/devtools/client/debugger/new/src/actions/breakpoints/syncBreakpoint.js
+++ b/devtools/client/debugger/new/src/actions/breakpoints/syncBreakpoint.js
@@ -51,19 +51,19 @@ function createSyncData(id, pendingBreak
     previousLocation
   };
 } // we have three forms of syncing: disabled syncing, existing server syncing
 // and adding a new breakpoint
 
 
 async function syncClientBreakpoint(getState, client, sourceMaps, sourceId, pendingBreakpoint) {
   (0, _breakpoint.assertPendingBreakpoint)(pendingBreakpoint);
-  const source = (0, _selectors.getSource)(getState(), sourceId);
+  const source = (0, _selectors.getSourceFromId)(getState(), sourceId);
   const generatedSourceId = sourceMaps.isOriginalId(sourceId) ? (0, _devtoolsSourceMap.originalToGeneratedId)(sourceId) : sourceId;
-  const generatedSource = (0, _selectors.getSource)(getState(), generatedSourceId);
+  const generatedSource = (0, _selectors.getSourceFromId)(getState(), generatedSourceId);
   const {
     location,
     astLocation
   } = pendingBreakpoint;
 
   const previousLocation = _objectSpread({}, location, {
     sourceId
   });
--- a/devtools/client/debugger/new/src/actions/event-listeners.js
+++ b/devtools/client/debugger/new/src/actions/event-listeners.js
@@ -98,17 +98,17 @@ function fetchEventListeners() {
   };
 }
 
 function formatListeners(state, listeners) {
   return listeners.map(l => {
     return {
       selector: l.node.selector,
       type: l.type,
-      sourceId: (0, _selectors.getSourceByURL)(state, l.function.location.url).get("id"),
+      sourceId: (0, _selectors.getSourceByURL)(state, l.function.location.url).id,
       line: l.function.location.line
     };
   });
 }
 
 async function _getEventListeners(threadClient) {
   const response = await threadClient.eventListeners(); // Make sure all the listeners are sorted by the event type, since
   // they"re not guaranteed to be clustered together.
--- a/devtools/client/debugger/new/src/actions/expressions.js
+++ b/devtools/client/debugger/new/src/actions/expressions.js
@@ -1,15 +1,16 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.addExpression = addExpression;
 exports.autocomplete = autocomplete;
+exports.clearAutocomplete = clearAutocomplete;
 exports.clearExpressionError = clearExpressionError;
 exports.updateExpression = updateExpression;
 exports.deleteExpression = deleteExpression;
 exports.evaluateExpressions = evaluateExpressions;
 exports.getMappedExpression = getMappedExpression;
 
 var _selectors = require("../selectors/index");
 
@@ -81,16 +82,22 @@ function autocomplete(input, cursor) {
     await dispatch({
       type: "AUTOCOMPLETE",
       input,
       result
     });
   };
 }
 
+function clearAutocomplete() {
+  return {
+    type: "CLEAR_AUTOCOMPLETE"
+  };
+}
+
 function clearExpressionError() {
   return {
     type: "CLEAR_EXPRESSION_ERROR"
   };
 }
 
 function updateExpression(input, expression) {
   return async ({
@@ -172,21 +179,21 @@ function evaluateExpression(expression) 
 
     let input = expression.input;
     const frame = (0, _selectors.getSelectedFrame)(getState());
 
     if (frame) {
       const {
         location
       } = frame;
-      const source = (0, _selectors.getSource)(getState(), location.sourceId);
-      const sourceId = source.get("id");
+      const source = (0, _selectors.getSourceFromId)(getState(), location.sourceId);
+      const sourceId = source.id;
       const selectedSource = (0, _selectors.getSelectedSource)(getState());
 
-      if (selectedSource && !(0, _devtoolsSourceMap.isGeneratedId)(sourceId) && !(0, _devtoolsSourceMap.isGeneratedId)(selectedSource.get("id"))) {
+      if (selectedSource && !(0, _devtoolsSourceMap.isGeneratedId)(sourceId) && !(0, _devtoolsSourceMap.isGeneratedId)(selectedSource.id)) {
         input = await dispatch(getMappedExpression(input));
       }
     }
 
     const frameId = (0, _selectors.getSelectedFrameId)(getState());
     return dispatch({
       type: "EVALUATE_EXPRESSION",
       input: expression.input,
--- a/devtools/client/debugger/new/src/actions/navigation.js
+++ b/devtools/client/debugger/new/src/actions/navigation.js
@@ -89,14 +89,14 @@ function connect(url, canRewind) {
 function navigated() {
   return async function ({
     dispatch,
     getState,
     client
   }) {
     await (0, _utils.waitForMs)(100);
 
-    if ((0, _sources.getSources)(getState()).size == 0) {
+    if (Object.keys((0, _sources.getSources)(getState())).length == 0) {
       const sources = await client.fetchSources();
       dispatch((0, _sources2.newSources)(sources));
     }
   };
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/actions/pause/continueToHere.js
+++ b/devtools/client/debugger/new/src/actions/pause/continueToHere.js
@@ -15,22 +15,22 @@ var _commands = require("./commands");
  * 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/>. */
 function continueToHere(line) {
   return async function ({
     dispatch,
     getState
   }) {
     const selectedSource = (0, _selectors.getSelectedSource)(getState());
+    const selectedFrame = (0, _selectors.getSelectedFrame)(getState());
 
-    if (!(0, _selectors.isPaused)(getState()) || !selectedSource) {
+    if (!selectedFrame || !selectedSource) {
       return;
     }
 
-    const selectedFrame = (0, _selectors.getSelectedFrame)(getState());
     const debugLine = selectedFrame.location.line;
 
     if (debugLine == line) {
       return;
     }
 
     const action = (0, _selectors.getCanRewind)(getState()) && line < debugLine ? _commands.rewind : _commands.resume;
     await dispatch((0, _breakpoints.addHiddenBreakpoint)({
--- a/devtools/client/debugger/new/src/actions/pause/extra.js
+++ b/devtools/client/debugger/new/src/actions/pause/extra.js
@@ -68,16 +68,21 @@ async function getExtraProps(getState, e
 }
 
 function fetchExtra() {
   return async function ({
     dispatch,
     getState
   }) {
     const frame = (0, _selectors.getSelectedFrame)(getState());
+
+    if (!frame) {
+      return;
+    }
+
     const extra = await dispatch(getExtra("this;", frame.this));
     dispatch({
       type: "ADD_EXTRA",
       extra: extra
     });
   };
 }
 
--- a/devtools/client/debugger/new/src/actions/pause/mapFrames.js
+++ b/devtools/client/debugger/new/src/actions/pause/mapFrames.js
@@ -27,17 +27,17 @@ function updateFrameLocations(frames, so
     return Promise.resolve(frames);
   }
 
   return Promise.all(frames.map(frame => updateFrameLocation(frame, sourceMaps)));
 }
 
 function mapDisplayNames(frames, getState) {
   return frames.map(frame => {
-    const source = (0, _selectors.getSource)(getState(), frame.location.sourceId);
+    const source = (0, _selectors.getSourceFromId)(getState(), frame.location.sourceId);
     const symbols = (0, _selectors.getSymbols)(getState(), source);
 
     if (!symbols || !symbols.functions) {
       return frame;
     }
 
     const originalFunction = (0, _ast.findClosestFunction)(symbols, frame.location);
 
--- a/devtools/client/debugger/new/src/actions/pause/mapScopes.js
+++ b/devtools/client/debugger/new/src/actions/pause/mapScopes.js
@@ -24,31 +24,31 @@ var _mapScopes = require("../../utils/pa
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 function mapScopes(scopes, frame) {
   return async function ({
     dispatch,
     getState,
     client,
     sourceMaps
   }) {
-    const generatedSourceRecord = (0, _selectors.getSource)(getState(), frame.generatedLocation.sourceId);
-    const sourceRecord = (0, _selectors.getSource)(getState(), frame.location.sourceId);
-    const shouldMapScopes = _prefs.features.mapScopes && !generatedSourceRecord.isWasm && !sourceRecord.isPrettyPrinted && !(0, _devtoolsSourceMap.isGeneratedId)(frame.location.sourceId);
+    const generatedSource = (0, _selectors.getSourceFromId)(getState(), frame.generatedLocation.sourceId);
+    const source = (0, _selectors.getSourceFromId)(getState(), frame.location.sourceId);
+    const shouldMapScopes = _prefs.features.mapScopes && !generatedSource.isWasm && !source.isPrettyPrinted && !(0, _devtoolsSourceMap.isGeneratedId)(frame.location.sourceId);
     await dispatch({
       type: "MAP_SCOPES",
       frame,
       [_promise.PROMISE]: async function () {
         if (!shouldMapScopes) {
           return null;
         }
 
-        await dispatch((0, _loadSourceText.loadSourceText)(sourceRecord));
+        await dispatch((0, _loadSourceText.loadSourceText)(source));
 
         try {
-          return await (0, _mapScopes.buildMappedScopes)(sourceRecord.toJS(), frame, (await scopes), sourceMaps, client);
+          return await (0, _mapScopes.buildMappedScopes)(source, frame, (await scopes), sourceMaps, client);
         } catch (e) {
           (0, _log.log)(e);
           return null;
         }
       }()
     });
   };
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/actions/pause/paused.js
+++ b/devtools/client/debugger/new/src/actions/pause/paused.js
@@ -28,17 +28,17 @@ var _pause = require("../../utils/pause/
 var _mapFrames = require("./mapFrames");
 
 var _fetchScopes = require("./fetchScopes");
 
 /* 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/>. */
 async function getOriginalSourceForFrame(state, frame) {
-  return (0, _selectors.getSources)(state).get(frame.location.sourceId);
+  return (0, _selectors.getSources)(state)[frame.location.sourceId];
 }
 /**
  * Debugger has just paused
  *
  * @param {object} pauseInfo
  * @memberof actions/pause
  * @static
  */
@@ -83,17 +83,17 @@ function paused(pauseInfo) {
       dispatch((0, _breakpoints.removeBreakpoint)(hiddenBreakpointLocation));
     }
 
     await dispatch((0, _.mapFrames)());
     const selectedFrame = (0, _selectors.getSelectedFrame)(getState());
 
     if (selectedFrame) {
       const visibleFrame = (0, _selectors.getVisibleSelectedFrame)(getState());
-      const location = (0, _devtoolsSourceMap.isGeneratedId)(visibleFrame.location.sourceId) ? selectedFrame.generatedLocation : selectedFrame.location;
+      const location = visibleFrame && (0, _devtoolsSourceMap.isGeneratedId)(visibleFrame.location.sourceId) ? selectedFrame.generatedLocation : selectedFrame.location;
       await dispatch((0, _sources.selectLocation)(location));
     }
 
     dispatch((0, _ui.togglePaneCollapse)("end", false));
     await dispatch((0, _fetchScopes.fetchScopes)()); // Run after fetching scoping data so that it may make use of the sourcemap
     // expression mappings for local variables.
 
     const atException = why.type == "exception";
--- a/devtools/client/debugger/new/src/actions/pause/skipPausing.js
+++ b/devtools/client/debugger/new/src/actions/pause/skipPausing.js
@@ -17,17 +17,16 @@ var _selectors = require("../../selector
  */
 function toggleSkipPausing() {
   return async ({
     dispatch,
     client,
     getState,
     sourceMaps
   }) => {
-    const skipPausing = !(0, _selectors.getSkipPausing)(getState()); // NOTE: enable this when we land the endpoint in m-c
-    // await client.setSkipPausing(skipPausing);
-
+    const skipPausing = !(0, _selectors.getSkipPausing)(getState());
+    await client.setSkipPausing(skipPausing);
     dispatch({
       type: "TOGGLE_SKIP_PAUSING",
       skipPausing
     });
   };
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/actions/preview.js
+++ b/devtools/client/debugger/new/src/actions/preview.js
@@ -23,16 +23,21 @@ var _expressions = require("./expression
 
 var _pause = require("./pause/index");
 
 /* 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/>. */
 function findExpressionMatch(state, codeMirror, tokenPos) {
   const source = (0, _selectors.getSelectedSource)(state);
+
+  if (!source) {
+    return;
+  }
+
   const symbols = (0, _selectors.getSymbols)(state, source);
   let match;
 
   if (!symbols || symbols.loading) {
     match = (0, _getExpression.getExpressionFromCoords)(codeMirror, tokenPos);
   } else {
     match = (0, _ast.findBestMatchExpression)(symbols, tokenPos);
   }
@@ -78,16 +83,21 @@ function setPreview(expression, location
     getState,
     client,
     sourceMaps
   }) => {
     await dispatch({
       type: "SET_PREVIEW",
       [_promise.PROMISE]: async function () {
         const source = (0, _selectors.getSelectedSource)(getState());
+
+        if (!source) {
+          return;
+        }
+
         const sourceId = source.id;
         const selectedFrame = (0, _selectors.getSelectedFrame)(getState());
 
         if (location && !(0, _devtoolsSourceMap.isGeneratedId)(sourceId)) {
           expression = await dispatch((0, _expressions.getMappedExpression)(expression));
         }
 
         if (!selectedFrame) {
--- a/devtools/client/debugger/new/src/actions/project-text-search.js
+++ b/devtools/client/debugger/new/src/actions/project-text-search.js
@@ -83,40 +83,39 @@ function closeProjectSearch() {
 function searchSources(query) {
   return async ({
     dispatch,
     getState
   }) => {
     await dispatch(clearSearchResults());
     await dispatch(addSearchQuery(query));
     dispatch(updateSearchStatus(_projectTextSearch.statusType.fetching));
-    const sources = (0, _selectors.getSources)(getState());
-    const validSources = sources.valueSeq().filter(source => !(0, _selectors.hasPrettySource)(getState(), source.id) && !(0, _source.isThirdParty)(source));
+    const validSources = (0, _selectors.getSourceList)(getState()).filter(source => !(0, _selectors.hasPrettySource)(getState(), source.id) && !(0, _source.isThirdParty)(source));
 
     for (const source of validSources) {
       await dispatch((0, _loadSourceText.loadSourceText)(source));
       await dispatch(searchSource(source.id, query));
     }
 
     dispatch(updateSearchStatus(_projectTextSearch.statusType.done));
   };
 }
 
 function searchSource(sourceId, query) {
   return async ({
     dispatch,
     getState
   }) => {
-    const sourceRecord = (0, _selectors.getSource)(getState(), sourceId);
+    const source = (0, _selectors.getSource)(getState(), sourceId);
 
-    if (!sourceRecord) {
+    if (!source) {
       return;
     }
 
-    const matches = await (0, _search.findSourceMatches)(sourceRecord.toJS(), query);
+    const matches = await (0, _search.findSourceMatches)(source, query);
 
     if (!matches.length) {
       return;
     }
 
-    dispatch(addSearchResult(sourceRecord.id, sourceRecord.url, matches));
+    dispatch(addSearchResult(source.id, source.url, matches));
   };
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/actions/sources/loadSourceText.js
+++ b/devtools/client/debugger/new/src/actions/sources/loadSourceText.js
@@ -12,44 +12,46 @@ var _promise = require("../utils/middlew
 var _selectors = require("../../selectors/index");
 
 var _parser = require("../../workers/parser/index");
 
 var parser = _interopRequireWildcard(_parser);
 
 var _source = require("../../utils/source");
 
+var _devtoolsModules = require("devtools/client/debugger/new/dist/vendors").vendored["devtools-modules"];
+
 var _defer = require("../../utils/defer");
 
 var _defer2 = _interopRequireDefault(_defer);
 
-var _devtoolsModules = require("devtools/client/debugger/new/dist/vendors").vendored["devtools-modules"];
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
 
 /* 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/>. */
-const requests = new Map();
+const requests = new Map(); // Measures the time it takes for a source to load
 
-const loadSourceHistogram = _devtoolsModules.Services.telemetry.getHistogramById("DEVTOOLS_DEBUGGER_LOAD_SOURCE_MS");
+const loadSourceHistogram = "DEVTOOLS_DEBUGGER_LOAD_SOURCE_MS";
+const telemetry = new _devtoolsModules.Telemetry();
 
 async function loadSource(source, {
   sourceMaps,
   client
 }) {
-  const id = source.get("id");
+  const id = source.id;
 
   if ((0, _devtoolsSourceMap.isOriginalId)(id)) {
-    return sourceMaps.getOriginalSourceText(source.toJS());
+    return sourceMaps.getOriginalSourceText(source);
   }
 
   const response = await client.sourceContents(id);
+  telemetry.finish(loadSourceHistogram, source);
   return {
     id,
     text: response.source,
     contentType: response.contentType || "text/javascript"
   };
 }
 /**
  * @memberof actions/sources
@@ -59,56 +61,54 @@ async function loadSource(source, {
 
 function loadSourceText(source) {
   return async ({
     dispatch,
     getState,
     client,
     sourceMaps
   }) => {
-    const id = source.get("id"); // Fetch the source text only once.
+    const id = source.id; // Fetch the source text only once.
 
     if (requests.has(id)) {
       return requests.get(id);
     }
 
     if ((0, _source.isLoaded)(source)) {
       return Promise.resolve();
     }
 
-    const telemetryStart = performance.now();
     const deferred = (0, _defer2.default)();
     requests.set(id, deferred.promise);
+    telemetry.start(loadSourceHistogram, source);
 
     try {
       await dispatch({
         type: "LOAD_SOURCE_TEXT",
         sourceId: id,
         [_promise.PROMISE]: loadSource(source, {
           sourceMaps,
           client
         })
       });
     } catch (e) {
       deferred.resolve();
       requests.delete(id);
       return;
     }
 
-    const newSource = (0, _selectors.getSource)(getState(), source.get("id")).toJS();
+    const newSource = (0, _selectors.getSourceFromId)(getState(), source.id);
 
     if ((0, _devtoolsSourceMap.isOriginalId)(newSource.id) && !newSource.isWasm) {
       const generatedSource = (0, _selectors.getGeneratedSource)(getState(), source);
       await dispatch(loadSourceText(generatedSource));
     }
 
     if (!newSource.isWasm) {
       await parser.setSource(newSource);
     } // signal that the action is finished
 
 
     deferred.resolve();
     requests.delete(id);
-    const telemetryEnd = performance.now();
-    const duration = telemetryEnd - telemetryStart;
-    loadSourceHistogram.add(duration);
+    return source;
   };
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/actions/sources/newSources.js
+++ b/devtools/client/debugger/new/src/actions/sources/newSources.js
@@ -59,19 +59,19 @@ function loadSourceMaps(sources) {
 
 
 function loadSourceMap(sourceId) {
   return async function ({
     dispatch,
     getState,
     sourceMaps
   }) {
-    const source = (0, _selectors.getSource)(getState(), sourceId).toJS();
+    const source = (0, _selectors.getSource)(getState(), sourceId);
 
-    if (!sourceMaps || !(0, _devtoolsSourceMap.isGeneratedId)(sourceId) || !source.sourceMapURL) {
+    if (!source || !(0, _devtoolsSourceMap.isGeneratedId)(sourceId) || !source.sourceMapURL) {
       return;
     }
 
     let urls = null;
 
     try {
       urls = await sourceMaps.getOriginalURLs(source);
     } catch (e) {
@@ -95,17 +95,17 @@ function loadSourceMap(sourceId) {
 // select it.
 
 
 function checkSelectedSource(sourceId) {
   return async ({
     dispatch,
     getState
   }) => {
-    const source = (0, _selectors.getSource)(getState(), sourceId);
+    const source = (0, _selectors.getSourceFromId)(getState(), sourceId);
     const pendingLocation = (0, _selectors.getPendingSelectedLocation)(getState());
 
     if (!pendingLocation || !pendingLocation.url || !source.url) {
       return;
     }
 
     const pendingUrl = pendingLocation.url;
     const rawPendingUrl = (0, _source.getRawSourceURL)(pendingUrl);
@@ -123,18 +123,18 @@ function checkSelectedSource(sourceId) {
 }
 
 function checkPendingBreakpoints(sourceId) {
   return async ({
     dispatch,
     getState
   }) => {
     // source may have been modified by selectLocation
-    const source = (0, _selectors.getSource)(getState(), sourceId);
-    const pendingBreakpoints = (0, _selectors.getPendingBreakpointsForSource)(getState(), source.get("url"));
+    const source = (0, _selectors.getSourceFromId)(getState(), sourceId);
+    const pendingBreakpoints = (0, _selectors.getPendingBreakpointsForSource)(getState(), source.url);
 
     if (!pendingBreakpoints.size) {
       return;
     } // load the source text if there is a pending breakpoint for it
 
 
     await dispatch((0, _loadSourceText.loadSourceText)(source));
     const pendingBreakpointsArray = pendingBreakpoints.valueSeq().toJS();
--- a/devtools/client/debugger/new/src/actions/sources/prettyPrint.js
+++ b/devtools/client/debugger/new/src/actions/sources/prettyPrint.js
@@ -35,17 +35,17 @@ function _objectSpread(target) { for (va
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 function createPrettySource(sourceId) {
   return async ({
     dispatch,
     getState,
     sourceMaps
   }) => {
-    const source = (0, _selectors.getSource)(getState(), sourceId);
+    const source = (0, _selectors.getSourceFromId)(getState(), sourceId);
     const url = (0, _source.getPrettySourceURL)(source.url);
     const id = await sourceMaps.generatedToOriginalId(sourceId, url);
     const prettySource = {
       url,
       id,
       isBlackBoxed: false,
       isPrettyPrinted: true,
       isWasm: false,
@@ -115,18 +115,17 @@ function togglePrettyPrint(sourceId) {
     const prettySource = (0, _selectors.getSourceByURL)(getState(), url);
     const options = {};
 
     if (selectedLocation) {
       options.location = await sourceMaps.getOriginalLocation(selectedLocation);
     }
 
     if (prettySource) {
-      const _sourceId = prettySource.get("id");
-
+      const _sourceId = prettySource.id;
       return dispatch((0, _sources.selectLocation)(_objectSpread({}, options.location, {
         sourceId: _sourceId
       })));
     }
 
     const newPrettySource = await dispatch(createPrettySource(sourceId));
     await dispatch((0, _breakpoints.remapBreakpoints)(sourceId));
     await dispatch((0, _pause.mapFrames)());
--- a/devtools/client/debugger/new/src/actions/sources/select.js
+++ b/devtools/client/debugger/new/src/actions/sources/select.js
@@ -111,47 +111,45 @@ function selectLocation(location) {
     client
   }) => {
     if (!client) {
       // No connection, do nothing. This happens when the debugger is
       // shut down too fast and it tries to display a default source.
       return;
     }
 
-    const sourceRecord = (0, _selectors.getSource)(getState(), location.sourceId);
+    const source = (0, _selectors.getSource)(getState(), location.sourceId);
 
-    if (!sourceRecord) {
+    if (!source) {
       // If there is no source we deselect the current selected source
       return dispatch(clearSelectedLocation());
     }
 
     const activeSearch = (0, _selectors.getActiveSearch)(getState());
 
     if (activeSearch !== "file") {
       dispatch((0, _ui.closeActiveSearch)());
     }
 
-    const source = sourceRecord.toJS();
     dispatch((0, _tabs.addTab)(source.url, 0));
     dispatch(setSelectedLocation(source, location));
-    await dispatch((0, _loadSourceText.loadSourceText)(sourceRecord));
-    const selectedSource = (0, _selectors.getSelectedSource)(getState());
+    await dispatch((0, _loadSourceText.loadSourceText)(source));
+    const loadedSource = (0, _selectors.getSource)(getState(), source.id);
 
-    if (!selectedSource) {
+    if (!loadedSource) {
+      // If there was a navigation while we were loading the loadedSource
       return;
     }
 
-    const sourceId = selectedSource.id;
-
-    if (_prefs.prefs.autoPrettyPrint && !(0, _selectors.getPrettySource)(getState(), sourceId) && (0, _source.shouldPrettyPrint)(selectedSource) && (0, _source.isMinified)(selectedSource)) {
-      await dispatch((0, _prettyPrint.togglePrettyPrint)(sourceId));
-      dispatch((0, _tabs.closeTab)(source.url));
+    if (_prefs.prefs.autoPrettyPrint && !(0, _selectors.getPrettySource)(getState(), loadedSource.id) && (0, _source.shouldPrettyPrint)(loadedSource) && (0, _source.isMinified)(loadedSource)) {
+      await dispatch((0, _prettyPrint.togglePrettyPrint)(loadedSource.id));
+      dispatch((0, _tabs.closeTab)(loadedSource.url));
     }
 
-    dispatch((0, _ast.setSymbols)(sourceId));
+    dispatch((0, _ast.setSymbols)(loadedSource.id));
     dispatch((0, _ast.setOutOfScopeLocations)());
   };
 }
 /**
  * @memberof actions/sources
  * @static
  */
 
@@ -163,40 +161,39 @@ function selectSpecificLocation(location
     client
   }) => {
     if (!client) {
       // No connection, do nothing. This happens when the debugger is
       // shut down too fast and it tries to display a default source.
       return;
     }
 
-    const sourceRecord = (0, _selectors.getSource)(getState(), location.sourceId);
+    const source = (0, _selectors.getSource)(getState(), location.sourceId);
 
-    if (!sourceRecord) {
+    if (!source) {
       // If there is no source we deselect the current selected source
       return dispatch(clearSelectedLocation());
     }
 
     const activeSearch = (0, _selectors.getActiveSearch)(getState());
 
     if (activeSearch !== "file") {
       dispatch((0, _ui.closeActiveSearch)());
     }
 
-    const source = sourceRecord.toJS();
-    dispatch((0, _tabs.addTab)(source, 0));
+    dispatch((0, _tabs.addTab)(source.url, 0));
     dispatch(setSelectedLocation(source, location));
-    await dispatch((0, _loadSourceText.loadSourceText)(sourceRecord));
-    const selectedSource = (0, _selectors.getSelectedSource)(getState());
+    await dispatch((0, _loadSourceText.loadSourceText)(source));
+    const loadedSource = (0, _selectors.getSource)(getState(), source.id);
 
-    if (!selectedSource) {
+    if (!loadedSource) {
       return;
     }
 
-    const sourceId = selectedSource.id;
+    const sourceId = loadedSource.id;
     dispatch((0, _ast.setSymbols)(sourceId));
     dispatch((0, _ast.setOutOfScopeLocations)());
   };
 }
 /**
  * @memberof actions/sources
  * @static
  */
@@ -230,24 +227,29 @@ function jumpToMappedLocation(location) 
     }
 
     const source = (0, _selectors.getSource)(getState(), location.sourceId);
     let pairedLocation;
 
     if ((0, _devtoolsSourceMap.isOriginalId)(location.sourceId)) {
       pairedLocation = await (0, _sourceMaps.getGeneratedLocation)(getState(), source, location, sourceMaps);
     } else {
-      pairedLocation = await sourceMaps.getOriginalLocation(location, source.toJS());
+      pairedLocation = await sourceMaps.getOriginalLocation(location, source);
     }
 
     return dispatch(selectLocation(_objectSpread({}, pairedLocation)));
   };
 }
 
 function jumpToMappedSelectedLocation() {
   return async function ({
     dispatch,
     getState
   }) {
     const location = (0, _selectors.getSelectedLocation)(getState());
+
+    if (!location) {
+      return;
+    }
+
     await dispatch(jumpToMappedLocation(location));
   };
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/actions/sources/tabs.js
+++ b/devtools/client/debugger/new/src/actions/sources/tabs.js
@@ -71,17 +71,17 @@ function closeTabs(urls) {
     dispatch,
     getState,
     client
   }) => {
     urls.forEach(url => {
       const source = (0, _selectors.getSourceByURL)(getState(), url);
 
       if (source) {
-        (0, _editor.removeDocument)(source.get("id"));
+        (0, _editor.removeDocument)(source.id);
       }
     });
     const tabs = (0, _selectors.removeSourcesFromTabList)((0, _selectors.getSourceTabs)(getState()), urls);
     dispatch({
       type: "CLOSE_TABS",
       urls,
       tabs
     });
--- a/devtools/client/debugger/new/src/actions/ui.js
+++ b/devtools/client/debugger/new/src/actions/ui.js
@@ -94,32 +94,36 @@ function toggleFrameworkGrouping(toggleV
 
 function showSource(sourceId) {
   return ({
     dispatch,
     getState
   }) => {
     const source = (0, _selectors.getSource)(getState(), sourceId);
 
+    if (!source) {
+      return;
+    }
+
     if ((0, _selectors.getPaneCollapse)(getState(), "start")) {
       dispatch({
         type: "TOGGLE_PANE",
         position: "start",
         paneCollapsed: false
       });
     }
 
     dispatch(setPrimaryPaneTab("sources"));
     dispatch({
       type: "SHOW_SOURCE",
       sourceUrl: ""
     });
     dispatch({
       type: "SHOW_SOURCE",
-      sourceUrl: (0, _source.getRawSourceURL)(source.get("url"))
+      sourceUrl: (0, _source.getRawSourceURL)(source.url)
     });
   };
 }
 
 function togglePaneCollapse(position, paneCollapsed) {
   return ({
     dispatch,
     getState
--- a/devtools/client/debugger/new/src/client/firefox/commands.js
+++ b/devtools/client/debugger/new/src/client/firefox/commands.js
@@ -316,17 +316,17 @@ async function setPausePoints(sourceId, 
     pausePoints
   });
 }
 
 async function setSkipPausing(shouldSkip) {
   return threadClient.request({
     skip: shouldSkip,
     to: threadClient.actor,
-    type: "skipPausing"
+    type: "skipBreakpoints"
   });
 }
 
 function interrupt() {
   return threadClient.interrupt();
 }
 
 function eventListeners() {
--- a/devtools/client/debugger/new/src/components/Editor/Breakpoints.js
+++ b/devtools/client/debugger/new/src/components/Editor/Breakpoints.js
@@ -36,17 +36,17 @@ class Breakpoints extends _react.Compone
 
   render() {
     const {
       breakpoints,
       selectedSource,
       editor
     } = this.props;
 
-    if (!selectedSource || !breakpoints || selectedSource.get("isBlackBoxed")) {
+    if (!selectedSource || !breakpoints || selectedSource.isBlackBoxed) {
       return null;
     }
 
     return _react2.default.createElement("div", null, breakpoints.valueSeq().map(bp => {
       return _react2.default.createElement(_Breakpoint2.default, {
         key: (0, _breakpoint.makeLocationId)(bp.location),
         breakpoint: bp,
         selectedSource: selectedSource,
--- a/devtools/client/debugger/new/src/components/Editor/CallSite.js
+++ b/devtools/client/debugger/new/src/components/Editor/CallSite.js
@@ -18,17 +18,17 @@ class CallSite extends _react.Component 
     this.addCallSite = nextProps => {
       const {
         editor,
         callSite,
         breakpoint,
         source
       } = nextProps || this.props;
       const className = !breakpoint ? "call-site" : "call-site-bp";
-      const sourceId = source.get("id");
+      const sourceId = source.id;
       const editorRange = (0, _editor.toEditorRange)(sourceId, callSite.location);
       this.marker = (0, _editor.markText)(editor, className, editorRange);
     };
 
     this.clearCallSite = () => {
       if (this.marker) {
         this.marker.clear();
         this.marker = null;
--- a/devtools/client/debugger/new/src/components/Editor/CallSites.js
+++ b/devtools/client/debugger/new/src/components/Editor/CallSites.js
@@ -141,17 +141,17 @@ class CallSites extends _react.Component
       removeBreakpoint({
         sourceId: sourceId,
         line: line,
         column
       });
     } else {
       addBreakpoint({
         sourceId: sourceId,
-        sourceUrl: selectedSource.get("url"),
+        sourceUrl: selectedSource.url,
         line: line,
         column: column
       });
     }
   }
 
   render() {
     const {
--- a/devtools/client/debugger/new/src/components/Editor/EditorMenu.js
+++ b/devtools/client/debugger/new/src/components/Editor/EditorMenu.js
@@ -43,17 +43,17 @@ function getMenuItems(event, {
   jumpToMappedLocation,
   onGutterContextMenu,
   selectedLocation,
   selectedSource,
   showSource,
   toggleBlackBox
 }) {
   // variables
-  const hasSourceMap = !!selectedSource.get("sourceMapURL");
+  const hasSourceMap = !!selectedSource.sourceMapURL;
   const isOriginal = (0, _devtoolsSourceMap.isOriginalId)(selectedLocation.sourceId);
   const isPrettyPrinted = (0, _source.isPretty)(selectedSource);
   const isPrettified = isPrettyPrinted || hasPrettyPrint;
   const isMapped = isOriginal || hasSourceMap;
   const {
     line
   } = editor.codeMirror.coordsChar({
     left: event.clientX,
@@ -99,17 +99,17 @@ function getMenuItems(event, {
   };
   const copySourceUri2Item = {
     id: "node-menu-copy-source-url",
     label: copySourceUri2Label,
     accesskey: copySourceUri2Key,
     disabled: false,
     click: () => (0, _clipboard.copyToTheClipboard)((0, _source.getRawSourceURL)(selectedSource.url))
   };
-  const sourceId = selectedSource.get("id");
+  const sourceId = selectedSource.id;
   const sourceLine = (0, _editor.toSourceLine)(sourceId, line);
   const functionText = getFunctionText(sourceLine);
   const copyFunctionItem = {
     id: "node-menu-copy-function",
     label: copyFunctionLabel,
     accesskey: copyFunctionKey,
     disabled: !functionText,
     click: () => {
@@ -141,17 +141,17 @@ function getMenuItems(event, {
     disabled: false,
     click: () => showSource(sourceId)
   };
   const blackBoxMenuItem = {
     id: "node-menu-blackbox",
     label: toggleBlackBoxLabel,
     accesskey: blackboxKey,
     disabled: isOriginal || isPrettyPrinted || hasSourceMap,
-    click: () => toggleBlackBox(selectedSource.toJS())
+    click: () => toggleBlackBox(selectedSource)
   };
   const watchExpressionItem = {
     id: "node-menu-add-watch-expression",
     label: watchExpressionLabel,
     accesskey: watchExpressionKey,
     click: () => addExpression(editor.codeMirror.getSelection())
   };
   const evaluateInConsoleItem = {
--- a/devtools/client/debugger/new/src/components/Editor/EmptyLines.js
+++ b/devtools/client/debugger/new/src/components/Editor/EmptyLines.js
@@ -32,17 +32,17 @@ class EmptyLines extends _react.Componen
     } = this.props;
 
     if (!emptyLines) {
       return;
     }
 
     editor.codeMirror.operation(() => {
       emptyLines.forEach(emptyLine => {
-        const line = (0, _editor.toEditorLine)(selectedSource.get("id"), emptyLine);
+        const line = (0, _editor.toEditorLine)(selectedSource.id, emptyLine);
         editor.codeMirror.removeLineClass(line, "line", "empty-line");
       });
     });
   }
 
   disableEmptyLines() {
     const {
       emptyLines,
@@ -51,17 +51,17 @@ class EmptyLines extends _react.Componen
     } = this.props;
 
     if (!emptyLines) {
       return;
     }
 
     editor.codeMirror.operation(() => {
       emptyLines.forEach(emptyLine => {
-        const line = (0, _editor.toEditorLine)(selectedSource.get("id"), emptyLine);
+        const line = (0, _editor.toEditorLine)(selectedSource.id, emptyLine);
         editor.codeMirror.addLineClass(line, "line", "empty-line");
       });
     });
   }
 
   render() {
     return null;
   }
--- a/devtools/client/debugger/new/src/components/Editor/Footer.js
+++ b/devtools/client/debugger/new/src/components/Editor/Footer.js
@@ -45,17 +45,17 @@ class SourceFooter extends _react.PureCo
 
     if (!(0, _editor.shouldShowPrettyPrint)(selectedSource)) {
       return;
     }
 
     const tooltip = L10N.getStr("sourceTabs.prettyPrint");
     const type = "prettyPrint";
     return _react2.default.createElement("button", {
-      onClick: () => togglePrettyPrint(selectedSource.get("id")),
+      onClick: () => togglePrettyPrint(selectedSource.id),
       className: (0, _classnames2.default)("action", type, {
         active: sourceLoaded,
         pretty: (0, _source.isPretty)(selectedSource)
       }),
       key: type,
       title: tooltip,
       "aria-label": tooltip
     }, _react2.default.createElement("img", {
@@ -73,17 +73,17 @@ class SourceFooter extends _react.PureCo
     if (!sourceLoaded) {
       return;
     }
 
     const blackboxed = selectedSource.isBlackBoxed;
     const tooltip = L10N.getStr("sourceFooter.blackbox");
     const type = "black-box";
     return _react2.default.createElement("button", {
-      onClick: () => toggleBlackBox(selectedSource.toJS()),
+      onClick: () => toggleBlackBox(selectedSource),
       className: (0, _classnames2.default)("action", type, {
         active: sourceLoaded,
         blackboxed: blackboxed
       }),
       key: type,
       title: tooltip,
       "aria-label": tooltip
     }, _react2.default.createElement("img", {
@@ -148,17 +148,17 @@ class SourceFooter extends _react.PureCo
       selectedSource
     } = this.props;
 
     if (mappedSource) {
       const filename = (0, _source.getFilename)(mappedSource);
       const tooltip = L10N.getFormatStr("sourceFooter.mappedSourceTooltip", filename);
       const title = L10N.getFormatStr("sourceFooter.mappedSource", filename);
       const mappedSourceLocation = {
-        sourceId: selectedSource.get("id"),
+        sourceId: selectedSource.id,
         line: 1,
         column: 1
       };
       return _react2.default.createElement("button", {
         className: "mapped-source",
         onClick: () => jumpToMappedLocation(mappedSourceLocation),
         title: tooltip
       }, _react2.default.createElement("span", null, title));
--- a/devtools/client/debugger/new/src/components/Editor/GutterMenu.js
+++ b/devtools/client/debugger/new/src/components/Editor/GutterMenu.js
@@ -134,17 +134,17 @@ class GutterContextMenuComponent extends
     const {
       contextMenu
     } = nextProps,
           props = _objectWithoutProperties(nextProps, ["contextMenu"]);
 
     const {
       event
     } = contextMenu;
-    const sourceId = props.selectedSource ? props.selectedSource.get("id") : "";
+    const sourceId = props.selectedSource ? props.selectedSource.id : "";
     const line = (0, _editor.lineAtHeight)(props.editor, sourceId, event);
     const breakpoint = nextProps.breakpoints.find(bp => bp.location.line === line);
 
     if (props.emptyLines && props.emptyLines.includes(line)) {
       return;
     }
 
     gutterMenu(_objectSpread({
--- a/devtools/client/debugger/new/src/components/Editor/Preview/Popup.js
+++ b/devtools/client/debugger/new/src/components/Editor/Preview/Popup.js
@@ -59,17 +59,17 @@ const {
 } = ObjectInspectorUtils.node;
 const {
   loadItemProperties
 } = ObjectInspectorUtils.loadProperties;
 
 function inPreview(event) {
   const relatedTarget = event.relatedTarget;
 
-  if (!relatedTarget || relatedTarget.classList.contains("preview-expression")) {
+  if (!relatedTarget || relatedTarget.classList && relatedTarget.classList.contains("preview-expression")) {
     return true;
   } // $FlowIgnore
 
 
   const inPreviewSelection = document.elementsFromPoint(event.clientX, event.clientY).some(el => el.classList.contains("preview-selection"));
   return inPreviewSelection;
 }
 
--- a/devtools/client/debugger/new/src/components/Editor/Preview/index.js
+++ b/devtools/client/debugger/new/src/components/Editor/Preview/index.js
@@ -164,17 +164,17 @@ class Preview extends _react.PureCompone
       extra
     } = preview;
     const value = result;
 
     if (typeof value == "undefined" || value.optimizedOut) {
       return null;
     }
 
-    const editorRange = (0, _editor.toEditorRange)(selectedSource.get("id"), location);
+    const editorRange = (0, _editor.toEditorRange)(selectedSource.id, location);
     return _react2.default.createElement(_Popup2.default, {
       value: value,
       editor: this.props.editor,
       editorRef: this.props.editorRef,
       range: editorRange,
       expression: expression,
       popoverPos: cursorPos,
       extra: extra,
--- a/devtools/client/debugger/new/src/components/Editor/SearchBar.js
+++ b/devtools/client/debugger/new/src/components/Editor/SearchBar.js
@@ -128,17 +128,17 @@ class SearchBar extends _react.Component
       }
     };
 
     this.doSearch = query => {
       const {
         selectedSource
       } = this.props;
 
-      if (!selectedSource || !selectedSource.get("text")) {
+      if (!selectedSource || !selectedSource.text) {
         return;
       }
 
       this.props.doSearch(query, this.props.editor);
     };
 
     this.updateSearchResults = (characterIndex, line, matches) => {
       const matchIndex = matches.findIndex(elm => elm.line === line && elm.ch === characterIndex);
--- a/devtools/client/debugger/new/src/components/Editor/Tab.js
+++ b/devtools/client/debugger/new/src/components/Editor/Tab.js
@@ -58,60 +58,60 @@ class Tab extends _react.PureComponent {
     const {
       closeTab,
       closeTabs,
       tabSources,
       showSource,
       togglePrettyPrint,
       selectedSource
     } = this.props;
-    const otherTabs = tabSources.filter(t => t.get("id") !== tab);
-    const sourceTab = tabSources.find(t => t.get("id") == tab);
-    const tabURLs = tabSources.map(t => t.get("url"));
-    const otherTabURLs = otherTabs.map(t => t.get("url"));
+    const otherTabs = tabSources.filter(t => t.id !== tab);
+    const sourceTab = tabSources.find(t => t.id == tab);
+    const tabURLs = tabSources.map(t => t.url);
+    const otherTabURLs = otherTabs.map(t => t.url);
 
     if (!sourceTab) {
       return;
     }
 
     const isPrettySource = (0, _source.isPretty)(sourceTab);
     const tabMenuItems = (0, _tabs.getTabMenuItems)();
     const items = [{
       item: _objectSpread({}, tabMenuItems.closeTab, {
-        click: () => closeTab(sourceTab.get("url"))
+        click: () => closeTab(sourceTab.url)
       })
     }, {
       item: _objectSpread({}, tabMenuItems.closeOtherTabs, {
         click: () => closeTabs(otherTabURLs)
       }),
       hidden: () => tabSources.size === 1
     }, {
       item: _objectSpread({}, tabMenuItems.closeTabsToEnd, {
         click: () => {
-          const tabIndex = tabSources.findIndex(t => t.get("id") == tab);
+          const tabIndex = tabSources.findIndex(t => t.id == tab);
           closeTabs(tabURLs.filter((t, i) => i > tabIndex));
         }
       }),
       hidden: () => tabSources.size === 1 || tabSources.some((t, i) => t === tab && tabSources.size - 1 === i)
     }, {
       item: _objectSpread({}, tabMenuItems.closeAllTabs, {
         click: () => closeTabs(tabURLs)
       })
     }, {
       item: {
         type: "separator"
       }
     }, {
       item: _objectSpread({}, tabMenuItems.copyToClipboard, {
-        disabled: selectedSource.get("id") !== tab,
+        disabled: selectedSource.id !== tab,
         click: () => (0, _clipboard.copyToTheClipboard)(sourceTab.text)
       })
     }, {
       item: _objectSpread({}, tabMenuItems.copySourceUri2, {
-        click: () => (0, _clipboard.copyToTheClipboard)((0, _source.getRawSourceURL)(sourceTab.get("url")))
+        click: () => (0, _clipboard.copyToTheClipboard)((0, _source.getRawSourceURL)(sourceTab.url))
       })
     }];
     items.push({
       item: _objectSpread({}, tabMenuItems.showSource, {
         click: () => showSource(tab)
       })
     });
 
@@ -138,17 +138,17 @@ class Tab extends _react.PureComponent {
     const {
       selectedSource,
       selectSpecificSource,
       closeTab,
       source
     } = this.props;
     const filename = (0, _source.getFilename)(source);
     const sourceId = source.id;
-    const active = selectedSource && sourceId == selectedSource.get("id") && !this.isProjectSearchEnabled() && !this.isSourceSearchEnabled();
+    const active = selectedSource && sourceId == selectedSource.id && !this.isProjectSearchEnabled() && !this.isSourceSearchEnabled();
     const isPrettyCode = (0, _source.isPretty)(source);
 
     function onClickClose(e) {
       e.stopPropagation();
       closeTab(source.url);
     }
 
     function handleTabClick(e) {
--- a/devtools/client/debugger/new/src/components/Editor/Tabs.js
+++ b/devtools/client/debugger/new/src/components/Editor/Tabs.js
@@ -5,20 +5,16 @@ Object.defineProperty(exports, "__esModu
 });
 
 var _react = require("devtools/client/shared/vendor/react");
 
 var _react2 = _interopRequireDefault(_react);
 
 var _reactRedux = require("devtools/client/shared/vendor/react-redux");
 
-var _immutable = require("devtools/client/shared/vendor/immutable");
-
-var I = _interopRequireWildcard(_immutable);
-
 var _selectors = require("../../selectors/index");
 
 var _ui = require("../../utils/ui");
 
 var _tabs = require("../../utils/tabs");
 
 var _source = require("../../utils/source");
 
@@ -33,18 +29,16 @@ var _Tab = require("./Tab");
 var _Tab2 = _interopRequireDefault(_Tab);
 
 var _Button = require("../shared/Button/index");
 
 var _Dropdown = require("../shared/Dropdown");
 
 var _Dropdown2 = _interopRequireDefault(_Dropdown);
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /* 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/>. */
 class Tabs extends _react.PureComponent {
   constructor(props) {
     super(props);
@@ -57,44 +51,44 @@ class Tabs extends _react.PureComponent 
       const {
         selectedSource,
         tabSources,
         moveTab
       } = this.props;
       const sourceTabEls = this.refs.sourceTabs.children;
       const hiddenTabs = (0, _tabs.getHiddenTabs)(tabSources, sourceTabEls);
 
-      if ((0, _ui.isVisible)() && hiddenTabs.indexOf(selectedSource) !== -1) {
+      if ((0, _ui.isVisible)() && hiddenTabs.find(tab => tab.id == selectedSource.id)) {
         return moveTab(selectedSource.url, 0);
       }
 
       this.setState({
         hiddenTabs
       });
     };
 
-    this.renderDropdownSource = sourceRecord => {
+    this.renderDropdownSource = source => {
       const {
         selectSpecificSource
       } = this.props;
-      const filename = (0, _source.getFilename)(sourceRecord);
+      const filename = (0, _source.getFilename)(source);
 
-      const onClick = () => selectSpecificSource(sourceRecord.id);
+      const onClick = () => selectSpecificSource(source.id);
 
       return _react2.default.createElement("li", {
-        key: sourceRecord.id,
+        key: source.id,
         onClick: onClick
       }, _react2.default.createElement("img", {
-        className: `dropdown-icon ${this.getIconClass(sourceRecord)}`
+        className: `dropdown-icon ${this.getIconClass(source)}`
       }), filename);
     };
 
     this.state = {
       dropdownShown: false,
-      hiddenTabs: I.List()
+      hiddenTabs: []
     };
     this.onResize = (0, _lodash.debounce)(() => {
       this.updateHiddenTabs();
     });
   }
 
   componentDidUpdate(prevProps) {
     if (!(prevProps === this.props)) {
@@ -117,22 +111,22 @@ class Tabs extends _react.PureComponent 
 
 
   toggleSourcesDropdown(e) {
     this.setState(prevState => ({
       dropdownShown: !prevState.dropdownShown
     }));
   }
 
-  getIconClass(sourceRecord) {
-    if ((0, _source.isPretty)(sourceRecord)) {
+  getIconClass(source) {
+    if ((0, _source.isPretty)(source)) {
       return "prettyPrint";
     }
 
-    if (sourceRecord.isBlackBoxed) {
+    if (source.isBlackBoxed) {
       return "blackBox";
     }
 
     return "file";
   }
 
   renderTabs() {
     const {
@@ -150,17 +144,17 @@ class Tabs extends _react.PureComponent 
       key: index,
       source: source
     })));
   }
 
   renderDropdown() {
     const hiddenTabs = this.state.hiddenTabs;
 
-    if (!hiddenTabs || hiddenTabs.size == 0) {
+    if (!hiddenTabs || hiddenTabs.length == 0) {
       return null;
     }
 
     const Panel = _react2.default.createElement("ul", null, hiddenTabs.map(this.renderDropdownSource));
 
     const icon = _react2.default.createElement("img", {
       className: "moreTabs"
     });
--- a/devtools/client/debugger/new/src/components/Editor/index.js
+++ b/devtools/client/debugger/new/src/components/Editor/index.js
@@ -175,17 +175,17 @@ class Editor extends _react.PureComponen
       if (conditionalPanelLine) {
         return closeConditionalPanel();
       }
 
       if (gutter === "CodeMirror-foldgutter") {
         return;
       }
 
-      const sourceLine = (0, _editor.toSourceLine)(selectedSource.get("id"), line);
+      const sourceLine = (0, _editor.toSourceLine)(selectedSource.id, line);
 
       if (ev.altKey) {
         return continueToHere(sourceLine);
       }
 
       if (ev.shiftKey) {
         return addOrToggleDisabledBreakpoint(sourceLine);
       }
@@ -339,17 +339,17 @@ class Editor extends _react.PureComponen
   getCurrentLine() {
     const {
       codeMirror
     } = this.state.editor;
     const {
       selectedSource
     } = this.props;
     const line = (0, _editor.getCursorLine)(codeMirror);
-    return (0, _editor.toSourceLine)(selectedSource.get("id"), line);
+    return (0, _editor.toSourceLine)(selectedSource.id, line);
   }
 
   onKeyDown(e) {
     const {
       codeMirror
     } = this.state.editor;
     const {
       key,
@@ -434,18 +434,18 @@ class Editor extends _react.PureComponen
     } = this.state;
 
     if (this.shouldScrollToLocation(nextProps)) {
       let {
         line,
         column
       } = (0, _editor.toEditorPosition)(nextProps.selectedLocation);
 
-      if ((0, _editor.hasDocument)(nextProps.selectedSource.get("id"))) {
-        const doc = (0, _editor.getDocument)(nextProps.selectedSource.get("id"));
+      if ((0, _editor.hasDocument)(nextProps.selectedSource.id)) {
+        const doc = (0, _editor.getDocument)(nextProps.selectedSource.id);
         const lineText = doc.getLine(line);
         column = Math.max(column, (0, _indentation.getIndentation)(lineText));
       }
 
       (0, _editor.scrollToColumn)(editor.codeMirror, line, column);
     }
   }
 
@@ -473,22 +473,22 @@ class Editor extends _react.PureComponen
     if (!selectedSource) {
       return this.clearEditor();
     }
 
     if (!(0, _source.isLoaded)(selectedSource)) {
       return (0, _editor.showLoading)(this.state.editor);
     }
 
-    if (selectedSource.get("error")) {
-      return this.showErrorMessage(selectedSource.get("error"));
+    if (selectedSource.error) {
+      return this.showErrorMessage(selectedSource.error);
     }
 
     if (selectedSource) {
-      return (0, _editor.showSourceText)(this.state.editor, selectedSource.toJS(), symbols);
+      return (0, _editor.showSourceText)(this.state.editor, selectedSource, symbols);
     }
   }
 
   clearEditor() {
     const {
       editor
     } = this.state;
 
@@ -618,17 +618,17 @@ class Editor extends _react.PureComponen
 }
 
 Editor.contextTypes = {
   shortcuts: _propTypes2.default.object
 };
 
 const mapStateToProps = state => {
   const selectedSource = (0, _selectors.getSelectedSource)(state);
-  const sourceId = selectedSource ? selectedSource.get("id") : "";
+  const sourceId = selectedSource ? selectedSource.id : "";
   return {
     selectedLocation: (0, _selectors.getSelectedLocation)(state),
     selectedSource,
     searchOn: (0, _selectors.getActiveSearch)(state) === "file",
     hitCount: (0, _selectors.getHitCountForSource)(state, sourceId),
     coverageOn: (0, _selectors.getCoverageEnabled)(state),
     conditionalPanelLine: (0, _selectors.getConditionalPanelLine)(state),
     symbols: (0, _selectors.getSymbols)(state, selectedSource)
--- a/devtools/client/debugger/new/src/components/PrimaryPanes/Outline.js
+++ b/devtools/client/debugger/new/src/components/PrimaryPanes/Outline.js
@@ -40,17 +40,17 @@ class Outline extends _react.Component {
       selectedSource,
       selectLocation
     } = this.props;
 
     if (!selectedSource) {
       return;
     }
 
-    const selectedSourceId = selectedSource.get("id");
+    const selectedSourceId = selectedSource.id;
     const startLine = location.start.line;
     selectLocation({
       sourceId: selectedSourceId,
       line: startLine
     });
   }
 
   onContextMenu(event, func) {
--- a/devtools/client/debugger/new/src/components/PrimaryPanes/SourcesTree.js
+++ b/devtools/client/debugger/new/src/components/PrimaryPanes/SourcesTree.js
@@ -80,17 +80,17 @@ class SourcesTree extends _react.Compone
       shownSource,
       selectedSource
     } = this.props;
     const {
       uncollapsedTree,
       sourceTree
     } = this.state;
 
-    if (projectRoot != nextProps.projectRoot || debuggeeUrl != nextProps.debuggeeUrl || nextProps.sources.size === 0) {
+    if (projectRoot != nextProps.projectRoot || debuggeeUrl != nextProps.debuggeeUrl || nextProps.sourceCount === 0) {
       // early recreate tree because of changes
       // to project root, debugee url or lack of sources
       return this.setState((0, _sourcesTree.createTree)({
         sources: nextProps.sources,
         debuggeeUrl: nextProps.debuggeeUrl,
         projectRoot: nextProps.projectRoot
       }));
     }
@@ -103,18 +103,18 @@ class SourcesTree extends _react.Compone
       }
 
       return this.setState({
         listItems
       });
     }
 
     if (nextProps.selectedSource && nextProps.selectedSource != selectedSource) {
-      const highlightItems = (0, _sourcesTree.getDirectories)((0, _source.getRawSourceURL)(nextProps.selectedSource.get("url")), sourceTree);
-      return this.setState({
+      const highlightItems = (0, _sourcesTree.getDirectories)((0, _source.getRawSourceURL)(nextProps.selectedSource.url), sourceTree);
+      this.setState({
         highlightItems
       });
     } // NOTE: do not run this every time a source is clicked,
     // only when a new source is added
 
 
     if (nextProps.sources != this.props.sources) {
       this.setState((0, _sourcesTree.updateTree)({
@@ -125,33 +125,46 @@ class SourcesTree extends _react.Compone
         uncollapsedTree,
         sourceTree
       }));
     }
   }
 
   // NOTE: we get the source from sources because item.contents is cached
   getSource(item) {
-    return this.props.sources.get(item.contents.id);
+    const source = (0, _sourcesTree.getSourceFromNode)(item);
+
+    if (source) {
+      return this.props.sources[source.id];
+    }
+
+    return null;
   }
 
   isEmpty() {
     const {
       sourceTree
     } = this.state;
     return sourceTree.contents.length === 0;
   }
 
   renderItemName(name) {
-    const hosts = {
-      "ng://": "Angular",
-      "webpack://": "Webpack",
-      "moz-extension://": L10N.getStr("extensionsText")
-    };
-    return hosts[name] || name;
+    switch (name) {
+      case "ng://":
+        return "Angular";
+
+      case "webpack://":
+        return "Webpack";
+
+      case "moz-extension://":
+        return L10N.getStr("extensionsText");
+
+      default:
+        return name;
+    }
   }
 
   renderEmptyElement(message) {
     return _react2.default.createElement("div", {
       key: "empty",
       className: "no-sources-message"
     }, message);
   }
@@ -202,17 +215,18 @@ class SourcesTree extends _react.Compone
       getRoots: this.getRoots,
       highlightItems,
       itemHeight: 21,
       key: this.isEmpty() ? "empty" : "full",
       listItems,
       onCollapse: this.onCollapse,
       onExpand: this.onExpand,
       onFocus: this.focusItem,
-      renderItem: this.renderItem
+      renderItem: this.renderItem,
+      preventBlur: true
     };
     return _react2.default.createElement(_ManagedTree2.default, treeProps);
   }
 
   renderPane(...children) {
     const {
       projectRoot
     } = this.props;
@@ -249,30 +263,32 @@ class SourcesTree extends _react.Compone
 var _initialiseProps = function () {
   this.focusItem = item => {
     this.setState({
       focusedItem: item
     });
   };
 
   this.selectItem = item => {
-    if (!(0, _sourcesTree.isDirectory)(item)) {
+    if (!(0, _sourcesTree.isDirectory)(item) && // This second check isn't strictly necessary, but it ensures that Flow
+    // knows that we are doing the correct thing.
+    !Array.isArray(item.contents)) {
       this.props.selectSource(item.contents.id);
     }
   };
 
   this.getPath = item => {
     const path = `${item.path}/${item.name}`;
 
     if ((0, _sourcesTree.isDirectory)(item)) {
       return path;
     }
 
     const source = this.getSource(item);
-    const blackBoxedPart = source.isBlackBoxed ? ":blackboxed" : "";
+    const blackBoxedPart = source && source.isBlackBoxed ? ":blackboxed" : "";
     return `${path}${blackBoxedPart}`;
   };
 
   this.getIcon = (sources, item, depth) => {
     const {
       debuggeeUrl,
       projectRoot
     } = this.props;
@@ -301,40 +317,52 @@ var _initialiseProps = function () {
 
     if ((0, _sourcesTree.isDirectory)(item)) {
       return _react2.default.createElement("img", {
         className: "folder"
       });
     }
 
     const source = this.getSource(item);
-    return _react2.default.createElement(_SourceIcon2.default, {
-      source: source
-    });
+
+    if (source) {
+      return _react2.default.createElement(_SourceIcon2.default, {
+        source: source
+      });
+    }
+
+    return null;
   };
 
   this.onContextMenu = (event, item) => {
     const copySourceUri2Label = L10N.getStr("copySourceUri2");
     const copySourceUri2Key = L10N.getStr("copySourceUri2.accesskey");
     const setDirectoryRootLabel = L10N.getStr("setDirectoryRoot.label");
     const setDirectoryRootKey = L10N.getStr("setDirectoryRoot.accesskey");
     const removeDirectoryRootLabel = L10N.getStr("removeDirectoryRoot.label");
     event.stopPropagation();
     event.preventDefault();
     const menuOptions = [];
 
     if (!(0, _sourcesTree.isDirectory)(item)) {
-      const copySourceUri2 = {
-        id: "node-menu-copy-source",
-        label: copySourceUri2Label,
-        accesskey: copySourceUri2Key,
-        disabled: false,
-        click: () => (0, _clipboard.copyToTheClipboard)(item.contents.url)
-      };
-      menuOptions.push(copySourceUri2);
+      // Flow requires some extra handling to ensure the value of contents.
+      const {
+        contents
+      } = item;
+
+      if (!Array.isArray(contents)) {
+        const copySourceUri2 = {
+          id: "node-menu-copy-source",
+          label: copySourceUri2Label,
+          accesskey: copySourceUri2Key,
+          disabled: false,
+          click: () => (0, _clipboard.copyToTheClipboard)(contents.url)
+        };
+        menuOptions.push(copySourceUri2);
+      }
     }
 
     if ((0, _sourcesTree.isDirectory)(item) && _prefs.features.root) {
       const {
         path
       } = item;
       const {
         projectRoot
@@ -377,17 +405,17 @@ var _initialiseProps = function () {
     if (e.keyCode === 13 && focusedItem) {
       this.selectItem(focusedItem);
     }
   };
 
   this.renderItem = (item, depth, focused, _, expanded, {
     setExpanded
   }) => {
-    const arrow = (0, _sourcesTree.nodeHasChildren)(item) ? _react2.default.createElement("img", {
+    const arrow = (0, _sourcesTree.isDirectory)(item) ? _react2.default.createElement("img", {
       className: (0, _classnames2.default)("arrow", {
         expanded: expanded
       })
     }) : _react2.default.createElement("i", {
       className: "no-arrow"
     });
     const {
       sources
@@ -438,17 +466,18 @@ var _initialiseProps = function () {
 
 const mapStateToProps = state => {
   return {
     shownSource: (0, _selectors.getShownSource)(state),
     selectedSource: (0, _selectors.getSelectedSource)(state),
     debuggeeUrl: (0, _selectors.getDebuggeeUrl)(state),
     expanded: (0, _selectors.getExpandedState)(state),
     projectRoot: (0, _selectors.getProjectDirectoryRoot)(state),
-    sources: (0, _selectors.getRelativeSources)(state)
+    sources: (0, _selectors.getRelativeSources)(state),
+    sourceCount: (0, _selectors.getSourceCount)(state)
   };
 };
 
 const actionCreators = {
   setExpandedState: _sourceTree.setExpandedState,
   selectSource: _sources.selectSource,
   setProjectDirectoryRoot: _ui.setProjectDirectoryRoot,
   clearProjectDirectoryRoot: _ui.clearProjectDirectoryRoot
--- a/devtools/client/debugger/new/src/components/QuickOpenModal.js
+++ b/devtools/client/debugger/new/src/components/QuickOpenModal.js
@@ -196,28 +196,27 @@ class QuickOpenModal extends _react.Comp
 
       if (!this.isSymbolSearch() || selectedSource == null) {
         return;
       }
 
       if (this.isVariableQuery()) {
         const line = item.location && item.location.start ? item.location.start.line : 0;
         return selectLocation({
-          sourceId: selectedSource.get("id"),
-          line,
-          column: null
+          sourceId: selectedSource.id,
+          line
         });
       }
 
       if (this.isFunctionQuery()) {
         return highlightLineRange(_objectSpread({}, item.location != null ? {
           start: item.location.start.line,
           end: item.location.end.line
         } : {}, {
-          sourceId: selectedSource.get("id")
+          sourceId: selectedSource.id
         }));
       }
     };
 
     this.traverseResults = e => {
       const direction = e.key === "ArrowUp" ? -1 : 1;
       const {
         selectedIndex,
@@ -235,36 +234,36 @@ class QuickOpenModal extends _react.Comp
       }
     };
 
     this.gotoLocation = location => {
       const {
         selectLocation,
         selectedSource
       } = this.props;
-      const selectedSourceId = selectedSource ? selectedSource.get("id") : "";
+      const selectedSourceId = selectedSource ? selectedSource.id : "";
 
       if (location != null) {
         const sourceId = location.sourceId ? location.sourceId : selectedSourceId;
         selectLocation({
           sourceId,
           line: location.line,
-          column: location.column || null
+          column: location.column
         });
         this.closeModal();
       }
     };
 
     this.onChange = e => {
       const {
         selectedSource,
         setQuickOpenQuery
       } = this.props;
       setQuickOpenQuery(e.target.value);
-      const noSource = !selectedSource || !selectedSource.get("text");
+      const noSource = !selectedSource || !selectedSource.text;
 
       if (this.isSymbolSearch() && noSource || this.isGotoQuery()) {
         return;
       }
 
       this.updateResults(e.target.value);
     };
 
@@ -319,45 +318,32 @@ class QuickOpenModal extends _react.Comp
     this.isGotoSourceQuery = () => this.props.searchType === "gotoSource";
 
     this.isShortcutQuery = () => this.props.searchType === "shortcuts";
 
     this.isSourcesQuery = () => this.props.searchType === "sources";
 
     this.isSourceSearch = () => this.isSourcesQuery() || this.isGotoSourceQuery();
 
-    this.renderHighlight = (candidateString, query, name) => {
-      const options = {
-        wrap: {
-          tagOpen: '<mark class="highlight">',
-          tagClose: "</mark>"
-        }
-      };
-
-      const html = _fuzzaldrinPlus2.default.wrap(candidateString, query, options);
-
-      return _react2.default.createElement("div", {
-        dangerouslySetInnerHTML: {
-          __html: html
-        }
-      });
-    };
-
     this.highlightMatching = (query, results) => {
       let newQuery = query;
 
       if (newQuery === "") {
         return results;
       }
 
       newQuery = query.replace(/[@:#?]/gi, " ");
       return results.map(result => {
-        return _objectSpread({}, result, {
-          title: this.renderHighlight(result.title, (0, _path.basename)(newQuery), "title")
-        });
+        if (typeof result.title == "string") {
+          return _objectSpread({}, result, {
+            title: this.renderHighlight(result.title, (0, _path.basename)(newQuery), "title")
+          });
+        }
+
+        return result;
       });
     };
 
     this.state = {
       results: null,
       selectedIndex: 0
     };
   }
@@ -383,16 +369,34 @@ class QuickOpenModal extends _react.Comp
       (0, _resultList.scrollList)(this.refs.resultList.refs, this.state.selectedIndex, nowEnabled || !queryChanged);
     }
 
     if (nowEnabled || queryChanged) {
       this.updateResults(this.props.query);
     }
   }
 
+  /* eslint-disable react/no-danger */
+  renderHighlight(candidateString, query, name) {
+    const options = {
+      wrap: {
+        tagOpen: '<mark class="highlight">',
+        tagClose: "</mark>"
+      }
+    };
+
+    const html = _fuzzaldrinPlus2.default.wrap(candidateString, query, options);
+
+    return _react2.default.createElement("div", {
+      dangerouslySetInnerHTML: {
+        __html: html
+      }
+    });
+  }
+
   shouldShowErrorEmoji() {
     const {
       query
     } = this.props;
 
     if (this.isGotoQuery()) {
       return !/^:\d*$/.test(query);
     }
@@ -463,21 +467,21 @@ class QuickOpenModal extends _react.Comp
 
 exports.QuickOpenModal = QuickOpenModal;
 /* istanbul ignore next: ignoring testing of redux connection stuff */
 
 function mapStateToProps(state) {
   const selectedSource = (0, _selectors.getSelectedSource)(state);
   return {
     enabled: (0, _selectors.getQuickOpenEnabled)(state),
-    sources: (0, _quickOpen.formatSources)((0, _selectors.getRelativeSources)(state), (0, _selectors.getTabs)(state).toArray()),
+    sources: (0, _quickOpen.formatSources)((0, _selectors.getRelativeSources)(state), (0, _selectors.getTabs)(state)),
     selectedSource,
     symbols: (0, _quickOpen.formatSymbols)((0, _selectors.getSymbols)(state, selectedSource)),
     symbolsLoading: (0, _selectors.isSymbolsLoading)(state, selectedSource),
     query: (0, _selectors.getQuickOpenQuery)(state),
     searchType: (0, _selectors.getQuickOpenType)(state),
-    tabs: (0, _selectors.getTabs)(state).toArray()
+    tabs: (0, _selectors.getTabs)(state)
   };
 }
 /* istanbul ignore next: ignoring testing of redux connection stuff */
 
 
 exports.default = (0, _reactRedux.connect)(mapStateToProps, _actions2.default)(QuickOpenModal);
\ No newline at end of file
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/Breakpoint.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/Breakpoint.js
@@ -186,13 +186,14 @@ class Breakpoint extends _react.PureComp
       handleClick: e => this.removeBreakpoint(e),
       tooltip: L10N.getStr("breakpoints.removeBreakpointTooltip")
     })));
   }
 
 }
 
 const mapStateToProps = state => ({
+  breakpoints: (0, _selectors.getBreakpoints)(state),
   frame: (0, _selectors.getTopFrame)(state),
   selectedSource: (0, _selectors.getSelectedSource)(state)
 });
 
 exports.default = (0, _reactRedux.connect)(mapStateToProps, _actions2.default)(Breakpoint);
\ No newline at end of file
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/index.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/index.js
@@ -72,17 +72,17 @@ class Breakpoints extends _react.Compone
     const {
       breakpointSources
     } = this.props;
     return [...breakpointSources.map(({
       source,
       breakpoints
     }) => [_react2.default.createElement("div", {
       className: "breakpoint-heading",
-      title: source.url,
+      title: (0, _source.getRawSourceURL)(source.url),
       key: source.url,
       onClick: () => this.props.selectSource(source.id)
     }, _react2.default.createElement(_SourceIcon2.default, {
       source: source,
       shouldHide: icon => ["file", "javascript"].includes(icon)
     }), (0, _source.getFilename)(source)), ...breakpoints.map(breakpoint => _react2.default.createElement(_Breakpoint2.default, {
       breakpoint: breakpoint,
       source: source,
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/CommandBar.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/CommandBar.js
@@ -253,17 +253,17 @@ class CommandBar extends _react.Componen
       toggleSkipPausing
     } = this.props;
 
     if (!_prefs.features.skipPausing) {
       return null;
     }
 
     return _react2.default.createElement("button", {
-      className: (0, _classnames2.default)("command-bar-button", {
+      className: (0, _classnames2.default)("command-bar-button", "command-bar-skip-pausing", {
         active: skipPausing
       }),
       title: L10N.getStr("skipPausingTooltip"),
       onClick: toggleSkipPausing
     }, _react2.default.createElement("img", {
       className: "skipPausing"
     }));
   }
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/EventListeners.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/EventListeners.js
@@ -97,18 +97,17 @@ class EventListeners extends _react.Comp
 
 }
 
 const mapStateToProps = state => {
   const listeners = (0, _selectors.getEventListeners)(state).map(listener => {
     return _objectSpread({}, listener, {
       breakpoint: (0, _selectors.getBreakpoint)(state, {
         sourceId: listener.sourceId,
-        line: listener.line,
-        column: null
+        line: listener.line
       })
     });
   });
   return {
     listeners
   };
 };
 
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Expressions.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Expressions.js
@@ -9,56 +9,72 @@ var _react = require("devtools/client/sh
 var _react2 = _interopRequireDefault(_react);
 
 var _reactRedux = require("devtools/client/shared/vendor/react-redux");
 
 var _classnames = require("devtools/client/debugger/new/dist/vendors").vendored["classnames"];
 
 var _classnames2 = _interopRequireDefault(_classnames);
 
+var _prefs = require("../../utils/prefs");
+
 var _devtoolsReps = require("devtools/client/shared/components/reps/reps.js");
 
 var _actions = require("../../actions/index");
 
 var _actions2 = _interopRequireDefault(_actions);
 
 var _selectors = require("../../selectors/index");
 
 var _expressions = require("../../utils/expressions");
 
 var _firefox = require("../../client/firefox");
 
 var _Button = require("../shared/Button/index");
 
+var _lodash = require("devtools/client/shared/vendor/lodash");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-/* 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/>. */
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
 class Expressions extends _react.Component {
   constructor(props) {
     super(props);
 
     this.clear = () => {
       this.setState(() => {
         this.props.clearExpressionError();
         return {
           editing: false,
           editIndex: -1,
           inputValue: ""
         };
       });
     };
 
     this.handleChange = e => {
+      const target = e.target;
+
+      if (_prefs.features.autocompleteExpression) {
+        this.findAutocompleteMatches(target.value, target.selectionStart);
+      }
+
       this.setState({
-        inputValue: e.target.value
+        inputValue: target.value
       });
     };
 
+    this.findAutocompleteMatches = (0, _lodash.debounce)((value, selectionStart) => {
+      const {
+        autocomplete
+      } = this.props;
+      autocomplete(value, selectionStart);
+    }, 250);
+
     this.handleKeyDown = e => {
       if (e.key === "Escape") {
         this.clear();
       }
     };
 
     this.hideInput = () => {
       this.setState({
@@ -92,16 +108,18 @@ class Expressions extends _react.Compone
         editing: false,
         editIndex: -1,
         inputValue: this.props.expressionError ? inputValue : ""
       });
 
       if (!this.props.expressionError) {
         this.hideInput();
       }
+
+      this.props.clearAutocomplete();
     };
 
     this.renderExpression = (expression, index) => {
       const {
         expressionError,
         openLink
       } = this.props;
       const {
@@ -182,19 +200,20 @@ class Expressions extends _react.Compone
     const {
       editing,
       inputValue,
       focused
     } = this.state;
     const {
       expressions,
       expressionError,
-      showInput
+      showInput,
+      autocompleteMatches
     } = this.props;
-    return expressions !== nextProps.expressions || expressionError !== nextProps.expressionError || editing !== nextState.editing || inputValue !== nextState.inputValue || nextProps.showInput !== showInput || focused !== nextState.focused;
+    return autocompleteMatches !== nextProps.autocompleteMatches || expressions !== nextProps.expressions || expressionError !== nextProps.expressionError || editing !== nextState.editing || inputValue !== nextState.inputValue || nextProps.showInput !== showInput || focused !== nextState.focused;
   }
 
   componentDidUpdate(prevProps, prevState) {
     const input = this._input;
 
     if (!input) {
       return;
     }
@@ -223,16 +242,41 @@ class Expressions extends _react.Compone
     deleteExpression(expression);
   }
 
   onBlur() {
     this.clear();
     this.hideInput();
   }
 
+  renderAutoCompleteMatches() {
+    if (!_prefs.features.autocompleteExpression) {
+      return null;
+    }
+
+    const {
+      autocompleteMatches
+    } = this.props;
+
+    if (autocompleteMatches) {
+      return _react2.default.createElement("datalist", {
+        id: "autocomplete-matches"
+      }, autocompleteMatches.map((match, index) => {
+        return _react2.default.createElement("option", {
+          key: index,
+          value: match
+        });
+      }));
+    }
+
+    return _react2.default.createElement("datalist", {
+      id: "autocomplete-matches"
+    });
+  }
+
   renderNewExpressionInput() {
     const {
       expressionError,
       showInput
     } = this.props;
     const {
       editing,
       inputValue,
@@ -243,28 +287,30 @@ class Expressions extends _react.Compone
     return _react2.default.createElement("li", {
       className: (0, _classnames2.default)("expression-input-container", {
         focused,
         error
       })
     }, _react2.default.createElement("form", {
       className: "expression-input-form",
       onSubmit: this.handleNewSubmit
-    }, _react2.default.createElement("input", {
+    }, _react2.default.createElement("input", _extends({
       className: "input-expression",
       type: "text",
       placeholder: placeholder,
       onChange: this.handleChange,
       onBlur: this.hideInput,
       onKeyDown: this.handleKeyDown,
       onFocus: this.onFocus,
       autoFocus: showInput,
       value: !editing ? inputValue : "",
       ref: c => this._input = c
-    }), _react2.default.createElement("input", {
+    }, _prefs.features.autocompleteExpression && {
+      list: "autocomplete-matches"
+    })), this.renderAutoCompleteMatches(), _react2.default.createElement("input", {
       type: "submit",
       style: {
         display: "none"
       }
     })));
   }
 
   renderExpressionEditInput(expression) {
@@ -281,28 +327,30 @@ class Expressions extends _react.Compone
       className: (0, _classnames2.default)("expression-input-container", {
         focused,
         error
       }),
       key: expression.input
     }, _react2.default.createElement("form", {
       className: "expression-input-form",
       onSubmit: e => this.handleExistingSubmit(e, expression)
-    }, _react2.default.createElement("input", {
+    }, _react2.default.createElement("input", _extends({
       className: (0, _classnames2.default)("input-expression", {
         error
       }),
       type: "text",
       onChange: this.handleChange,
       onBlur: this.clear,
       onKeyDown: this.handleKeyDown,
       onFocus: this.onFocus,
       value: editing ? inputValue : expression.input,
       ref: c => this._input = c
-    }), _react2.default.createElement("input", {
+    }, _prefs.features.autocompleteExpression && {
+      list: "autocomplete-matches"
+    })), this.renderAutoCompleteMatches(), _react2.default.createElement("input", {
       type: "submit",
       style: {
         display: "none"
       }
     })));
   }
 
   render() {
@@ -312,14 +360,17 @@ class Expressions extends _react.Compone
     } = this.props;
     return _react2.default.createElement("ul", {
       className: "pane expressions-list"
     }, expressions.map(this.renderExpression), (showInput || !expressions.size) && this.renderNewExpressionInput());
   }
 
 }
 
-const mapStateToProps = state => ({
-  expressions: (0, _selectors.getExpressions)(state),
-  expressionError: (0, _selectors.getExpressionError)(state)
-});
+const mapStateToProps = state => {
+  return {
+    autocompleteMatches: (0, _selectors.getAutocompleteMatchset)(state),
+    expressions: (0, _selectors.getExpressions)(state),
+    expressionError: (0, _selectors.getExpressionError)(state)
+  };
+};
 
 exports.default = (0, _reactRedux.connect)(mapStateToProps, _actions2.default)(Expressions);
\ No newline at end of file
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Frames/Frame.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Frames/Frame.js
@@ -75,17 +75,17 @@ class FrameComponent extends _react.Comp
     (0, _FrameMenu2.default)(frame, frameworkGroupingOn, {
       copyStackTrace,
       toggleFrameworkGrouping,
       toggleBlackBox
     }, event);
   }
 
   onMouseDown(e, frame, selectedFrame) {
-    if (e.nativeEvent.which == 3) {
+    if (e.which == 3) {
       return;
     }
 
     this.props.selectFrame(frame);
   }
 
   onKeyUp(event, frame, selectedFrame) {
     if (event.key != "Enter") {
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Scopes.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Scopes.js
@@ -121,17 +121,17 @@ class Scopes extends _react.PureComponen
 }
 
 const mapStateToProps = state => {
   const selectedFrame = (0, _selectors.getSelectedFrame)(state);
   const selectedSource = (0, _selectors.getSelectedSource)(state);
   const {
     scope: originalFrameScopes,
     pending: originalPending
-  } = (0, _selectors.getOriginalFrameScope)(state, selectedSource && selectedSource.get("id"), selectedFrame && selectedFrame.id) || {
+  } = (0, _selectors.getOriginalFrameScope)(state, selectedSource && selectedSource.id, selectedFrame && selectedFrame.id) || {
     scope: null,
     pending: false
   };
   const {
     scope: generatedFrameScopes,
     pending: generatedPending
   } = (0, _selectors.getGeneratedFrameScope)(state, selectedFrame && selectedFrame.id) || {
     scope: null,
--- a/devtools/client/debugger/new/src/components/shared/ManagedTree.js
+++ b/devtools/client/debugger/new/src/components/shared/ManagedTree.js
@@ -120,18 +120,21 @@ class ManagedTree extends _react.Compone
       expanded
     } = this.state; // This file is visible, so we highlight it.
 
     if (expanded.has(this.props.getPath(highlightItems[0]))) {
       this.focusItem(highlightItems[0]);
     } else {
       // Look at folders starting from the top-level until finds a
       // closed folder and highlights this folder
-      const index = highlightItems.reverse().findIndex(item => !expanded.has(this.props.getPath(item)));
-      this.focusItem(highlightItems[index]);
+      const index = highlightItems.reverse().findIndex(item => !expanded.has(this.props.getPath(item)) && item.name !== "root");
+
+      if (highlightItems[index]) {
+        this.focusItem(highlightItems[index]);
+      }
     }
   }
 
   render() {
     const {
       expanded,
       focusedItem
     } = this.state;
--- a/devtools/client/debugger/new/src/components/shared/Popover.js
+++ b/devtools/client/debugger/new/src/components/shared/Popover.js
@@ -166,21 +166,22 @@ class Popover extends _react.Component {
   getTooltipCoords() {
     if (this.$tooltip && this.props.editorRef) {
       const tooltip = this.$tooltip;
       const editor = this.props.editorRef;
       const tooltipRect = tooltip.getBoundingClientRect();
       const editorRect = editor.getBoundingClientRect();
       const targetRect = this.props.targetPosition;
       const left = this.calculateLeft(targetRect, editorRect, tooltipRect);
-      const top = targetRect.top - tooltipRect.height;
+      const enoughRoomForTooltipAbove = targetRect.top - editorRect.top > tooltipRect.height;
+      const top = enoughRoomForTooltipAbove ? targetRect.top - tooltipRect.height : targetRect.bottom;
       return {
         left,
         top,
-        orientation: "up",
+        orientation: enoughRoomForTooltipAbove ? "up" : "down",
         targetMid: {
           x: 0,
           y: 0
         }
       };
     }
 
     return {
--- a/devtools/client/debugger/new/src/components/shared/PreviewFunction.js
+++ b/devtools/client/debugger/new/src/components/shared/PreviewFunction.js
@@ -36,17 +36,18 @@ class PreviewFunction extends _react.Com
     } = func;
     const params = parameterNames.filter(i => i).map(param => _react2.default.createElement("span", {
       className: "param",
       key: param
     }, param));
     const commas = (0, _lodash.times)(params.length - 1).map((_, i) => _react2.default.createElement("span", {
       className: "delimiter",
       key: i
-    }, ", "));
+    }, ", ")); // $FlowIgnore
+
     return (0, _lodash.flatten)((0, _lodash.zip)(params, commas));
   }
 
   render() {
     return _react2.default.createElement("span", {
       className: "function-signature"
     }, this.renderFunctionName(this.props.func), _react2.default.createElement("span", {
       className: "paren"
--- a/devtools/client/debugger/new/src/components/shared/SearchInput.js
+++ b/devtools/client/debugger/new/src/components/shared/SearchInput.js
@@ -103,17 +103,17 @@ class SearchInput extends _react.Compone
     });
   }
 
   renderArrowButtons() {
     const {
       handleNext,
       handlePrev
     } = this.props;
-    return [arrowBtn(handleNext, "arrow-down", (0, _classnames2.default)("nav-btn", "next"), L10N.getFormatStr("editor.searchResults.nextResult")), arrowBtn(handlePrev, "arrow-up", (0, _classnames2.default)("nav-btn", "prev"), L10N.getFormatStr("editor.searchResults.prevResult"))];
+    return [arrowBtn(handlePrev, "arrow-up", (0, _classnames2.default)("nav-btn", "prev"), L10N.getFormatStr("editor.searchResults.prevResult")), arrowBtn(handleNext, "arrow-down", (0, _classnames2.default)("nav-btn", "next"), L10N.getFormatStr("editor.searchResults.nextResult"))];
   }
 
   renderSummaryMsg() {
     const {
       summaryMsg
     } = this.props;
 
     if (!summaryMsg) {
--- a/devtools/client/debugger/new/src/reducers/ast.js
+++ b/devtools/client/debugger/new/src/reducers/ast.js
@@ -149,27 +149,27 @@ function getSymbols(state, source) {
 
 function hasSymbols(state, source) {
   const symbols = getSymbols(state, source);
 
   if (!symbols) {
     return false;
   }
 
-  return !symbols.hasOwnProperty("loading");
+  return !symbols.loading;
 }
 
 function isSymbolsLoading(state, source) {
   const symbols = getSymbols(state, source);
 
   if (!symbols) {
     return false;
   }
 
-  return symbols.hasOwnProperty("loading");
+  return symbols.loading;
 }
 
 function isEmptyLineInSource(state, line, selectedSourceId) {
   const emptyLines = getEmptyLines(state, selectedSourceId);
   return emptyLines && emptyLines.includes(line);
 }
 
 function getEmptyLines(state, sourceId) {
--- a/devtools/client/debugger/new/src/reducers/debuggee.js
+++ b/devtools/client/debugger/new/src/reducers/debuggee.js
@@ -2,18 +2,16 @@
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getWorkers = exports.createDebuggeeState = undefined;
 exports.default = debuggee;
 exports.getWorker = getWorker;
 
-var _reselect = require("devtools/client/debugger/new/dist/vendors").vendored["reselect"];
-
 var _immutable = require("devtools/client/shared/vendor/immutable");
 
 var _makeRecord = require("../utils/makeRecord");
 
 var _makeRecord2 = _interopRequireDefault(_makeRecord);
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -34,15 +32,13 @@ function debuggee(state = createDebuggee
     case "SET_WORKERS":
       return state.set("workers", (0, _immutable.List)(action.workers));
 
     default:
       return state;
   }
 }
 
-const getDebuggeeWrapper = state => state.debuggee;
-
-const getWorkers = exports.getWorkers = (0, _reselect.createSelector)(getDebuggeeWrapper, debuggeeState => debuggeeState.get("workers"));
+const getWorkers = exports.getWorkers = state => state.debuggee.workers;
 
 function getWorker(state, url) {
   return getWorkers(state).find(value => url);
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/reducers/expressions.js
+++ b/devtools/client/debugger/new/src/reducers/expressions.js
@@ -27,17 +27,18 @@ function _interopRequireDefault(obj) { r
 
 /**
  * Expressions reducer
  * @module reducers/expressions
  */
 const createExpressionState = exports.createExpressionState = (0, _makeRecord2.default)({
   expressions: (0, _immutable.List)(restoreExpressions()),
   expressionError: false,
-  autocompleteMatches: (0, _immutable.Map)({})
+  autocompleteMatches: (0, _immutable.Map)({}),
+  currentAutocompleteInput: null
 });
 
 function update(state = createExpressionState(), action) {
   switch (action.type) {
     case "ADD_EXPRESSION":
       if (action.expressionError) {
         return state.set("expressionError", !!action.expressionError);
       }
@@ -84,17 +85,20 @@ function update(state = createExpression
     case "TRAVEL_TO":
       return travelTo(state, action);
 
     case "AUTOCOMPLETE":
       const {
         matchProp,
         matches
       } = action.result;
-      return state.updateIn(["autocompleteMatches", matchProp], list => matches);
+      return state.updateIn(["autocompleteMatches", matchProp], list => matches).set("currentAutocompleteInput", matchProp);
+
+    case "CLEAR_AUTOCOMPLETE":
+      return state.updateIn(["autocompleteMatches", ""], list => []).set("currentAutocompleteInput", "");
   }
 
   return state;
 }
 
 function travelTo(state, action) {
   const {
     expressions
@@ -158,14 +162,15 @@ const getExpressionsWrapper = state => s
 
 const getExpressions = exports.getExpressions = (0, _reselect.createSelector)(getExpressionsWrapper, expressions => expressions.expressions);
 const getAutocompleteMatches = exports.getAutocompleteMatches = (0, _reselect.createSelector)(getExpressionsWrapper, expressions => expressions.autocompleteMatches);
 
 function getExpression(state, input) {
   return getExpressions(state).find(exp => exp.input == input);
 }
 
-function getAutocompleteMatchset(state, input) {
+function getAutocompleteMatchset(state) {
+  const input = state.expressions.get("currentAutocompleteInput");
   return getAutocompleteMatches(state).get(input);
 }
 
 const getExpressionError = exports.getExpressionError = (0, _reselect.createSelector)(getExpressionsWrapper, expressions => expressions.expressionError);
 exports.default = update;
\ No newline at end of file
--- a/devtools/client/debugger/new/src/reducers/pause.js
+++ b/devtools/client/debugger/new/src/reducers/pause.js
@@ -376,17 +376,17 @@ function getFrameScope(state, sourceId, 
   return getOriginalFrameScope(state, sourceId, frameId) || getGeneratedFrameScope(state, frameId);
 }
 
 function getSelectedScope(state) {
   const sourceRecord = (0, _sources.getSelectedSource)(state);
   const frameId = getSelectedFrameId(state);
   const {
     scope
-  } = getFrameScope(state, sourceRecord && sourceRecord.get("id"), frameId) || {};
+  } = getFrameScope(state, sourceRecord && sourceRecord.id, frameId) || {};
   return scope || null;
 }
 
 function getSelectedScopeMappings(state) {
   const frameId = getSelectedFrameId(state);
 
   if (!frameId) {
     return null;
--- a/devtools/client/debugger/new/src/reducers/replay.js
+++ b/devtools/client/debugger/new/src/reducers/replay.js
@@ -69,33 +69,36 @@ function update(state = initialState(), 
   }
 
   return state;
 }
 
 function addScopes(state, action) {
   const {
     frame,
-    status,
-    value
+    status
   } = action;
   const selectedFrameId = frame.id;
   const instance = state.history[state.position];
 
   if (!instance) {
     return state;
   }
 
   const pausedInst = instance.paused;
+  const scopeValue = status === "done" ? {
+    pending: false,
+    scope: action.value
+  } : {
+    pending: true,
+    scope: null
+  };
 
   const generated = _objectSpread({}, pausedInst.frameScopes.generated, {
-    [selectedFrameId]: {
-      pending: status !== "done",
-      scope: value
-    }
+    [selectedFrameId]: scopeValue
   });
 
   const newPaused = _objectSpread({}, pausedInst, {
     frameScopes: _objectSpread({}, pausedInst.frameScopes, {
       generated
     })
   });
 
--- a/devtools/client/debugger/new/src/reducers/sources.js
+++ b/devtools/client/debugger/new/src/reducers/sources.js
@@ -1,81 +1,72 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getSelectedSourceText = exports.getSelectedSource = exports.getSelectedLocation = exports.getSourcesForTabs = exports.getSourceTabs = exports.getTabs = exports.getSources = exports.RelativeSourceRecordClass = exports.SourceRecordClass = undefined;
+exports.getSelectedSource = exports.getSelectedLocation = exports.getSourcesForTabs = exports.getSourceTabs = exports.getTabs = undefined;
 exports.initialSourcesState = initialSourcesState;
-exports.createSourceRecord = createSourceRecord;
+exports.createSource = createSource;
 exports.removeSourceFromTabList = removeSourceFromTabList;
 exports.removeSourcesFromTabList = removeSourcesFromTabList;
 exports.getBlackBoxList = getBlackBoxList;
 exports.getNewSelectedSourceId = getNewSelectedSourceId;
 exports.getSource = getSource;
+exports.getSourceFromId = getSourceFromId;
 exports.getSourceByURL = getSourceByURL;
 exports.getGeneratedSource = getGeneratedSource;
 exports.getPendingSelectedLocation = getPendingSelectedLocation;
 exports.getPrettySource = getPrettySource;
 exports.hasPrettySource = hasPrettySource;
 exports.getSourceInSources = getSourceInSources;
-
-var _immutable = require("devtools/client/shared/vendor/immutable");
-
-var I = _interopRequireWildcard(_immutable);
+exports.getSources = getSources;
+exports.getSourceList = getSourceList;
+exports.getSourceCount = getSourceCount;
 
 var _reselect = require("devtools/client/debugger/new/dist/vendors").vendored["reselect"];
 
-var _makeRecord = require("../utils/makeRecord");
-
-var _makeRecord2 = _interopRequireDefault(_makeRecord);
+var _lodashMove = require("devtools/client/debugger/new/dist/vendors").vendored["lodash-move"];
 
 var _source = require("../utils/source");
 
 var _devtoolsSourceMap = require("devtools/client/shared/source-map/index.js");
 
-var _prefs = require("../utils/prefs");
+var _devtoolsEnvironment = require("devtools/client/debugger/new/dist/vendors").vendored["devtools-environment"];
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _lodash = require("devtools/client/shared/vendor/lodash");
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+var _prefs = require("../utils/prefs");
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 function initialSourcesState() {
-  return (0, _makeRecord2.default)({
-    sources: I.Map(),
+  return {
+    sources: {},
     selectedLocation: undefined,
     pendingSelectedLocation: _prefs.prefs.pendingSelectedLocation,
-    sourcesText: I.Map(),
-    tabs: I.List(restoreTabs())
-  })();
+    tabs: restoreTabs()
+  };
 }
 
-const sourceRecordProperties = {
-  id: undefined,
-  url: undefined,
-  sourceMapURL: undefined,
-  isBlackBoxed: false,
-  isPrettyPrinted: false,
-  isWasm: false,
-  text: undefined,
-  contentType: "",
-  error: undefined,
-  loadedState: "unloaded"
-};
-const SourceRecordClass = exports.SourceRecordClass = new I.Record(sourceRecordProperties);
-const RelativeSourceRecordClass = exports.RelativeSourceRecordClass = new I.Record(_objectSpread({}, sourceRecordProperties, {
-  relativeUrl: undefined
-}));
-
-function createSourceRecord(source) {
-  return new SourceRecordClass(source);
+function createSource(source) {
+  return _objectSpread({
+    id: undefined,
+    url: undefined,
+    sourceMapURL: undefined,
+    isBlackBoxed: false,
+    isPrettyPrinted: false,
+    isWasm: false,
+    text: undefined,
+    contentType: "",
+    error: undefined,
+    loadedState: "unloaded"
+  }, source);
 }
 
 function update(state = initialSourcesState(), action) {
   let location = null;
 
   switch (action.type) {
     case "UPDATE_SOURCE":
       {
@@ -94,99 +85,104 @@ function update(state = initialSourcesSt
         return action.sources.reduce((newState, source) => updateSource(newState, source), state);
       }
 
     case "SET_SELECTED_LOCATION":
       location = _objectSpread({}, action.location, {
         url: action.source.url
       });
       _prefs.prefs.pendingSelectedLocation = location;
-      return state.set("selectedLocation", _objectSpread({
-        sourceId: action.source.id
-      }, action.location)).set("pendingSelectedLocation", location);
+      return _objectSpread({}, state, {
+        selectedLocation: _objectSpread({
+          sourceId: action.source.id
+        }, action.location),
+        pendingSelectedLocation: location
+      });
 
     case "CLEAR_SELECTED_LOCATION":
       location = {
         url: ""
       };
       _prefs.prefs.pendingSelectedLocation = location;
-      return state.set("selectedLocation", {
-        sourceId: ""
-      }).set("pendingSelectedLocation", location);
+      return _objectSpread({}, state, {
+        selectedLocation: null,
+        pendingSelectedLocation: location
+      });
 
     case "SET_PENDING_SELECTED_LOCATION":
       location = {
         url: action.url,
         line: action.line
       };
       _prefs.prefs.pendingSelectedLocation = location;
-      return state.set("pendingSelectedLocation", location);
+      return _objectSpread({}, state, {
+        pendingSelectedLocation: location
+      });
 
     case "ADD_TAB":
-      return state.merge({
-        tabs: updateTabList({
-          sources: state
-        }, action.url)
+      return _objectSpread({}, state, {
+        tabs: updateTabList(state.tabs, action.url)
       });
 
     case "MOVE_TAB":
-      return state.merge({
-        tabs: updateTabList({
-          sources: state
-        }, action.url, action.tabIndex)
+      return _objectSpread({}, state, {
+        tabs: updateTabList(state.tabs, action.url, action.tabIndex)
       });
 
     case "CLOSE_TAB":
       _prefs.prefs.tabs = action.tabs;
-      return state.merge({
+      return _objectSpread({}, state, {
         tabs: action.tabs
       });
 
     case "CLOSE_TABS":
       _prefs.prefs.tabs = action.tabs;
-      return state.merge({
+      return _objectSpread({}, state, {
         tabs: action.tabs
       });
 
     case "LOAD_SOURCE_TEXT":
       return setSourceTextProps(state, action);
 
     case "BLACKBOX":
       if (action.status === "done") {
-        const url = action.source.url;
+        const {
+          id,
+          url
+        } = action.source;
         const {
           isBlackBoxed
         } = action.value;
         updateBlackBoxList(url, isBlackBoxed);
-        return state.setIn(["sources", action.source.id, "isBlackBoxed"], isBlackBoxed);
+        return updateSource(state, {
+          id,
+          isBlackBoxed
+        });
       }
 
       break;
 
     case "NAVIGATE":
-      const source = getSelectedSource({
-        sources: state
-      });
+      const source = state.selectedLocation && state.sources[state.selectedLocation.sourceId];
       const url = source && source.url;
 
       if (!url) {
         return initialSourcesState();
       }
 
-      return initialSourcesState().set("pendingSelectedLocation", {
+      return _objectSpread({}, initialSourcesState(), {
         url
       });
   }
 
   return state;
 }
 
 function getTextPropsFromAction(action) {
   const {
-    value,
     sourceId
   } = action;
 
   if (action.status === "start") {
     return {
       id: sourceId,
       loadedState: "loading"
     };
@@ -194,19 +190,19 @@ function getTextPropsFromAction(action) 
     return {
       id: sourceId,
       error: action.error,
       loadedState: "loaded"
     };
   }
 
   return {
-    text: value.text,
+    text: action.value.text,
     id: sourceId,
-    contentType: value.contentType,
+    contentType: action.value.contentType,
     loadedState: "loaded"
   };
 } // TODO: Action is coerced to `any` unfortunately because how we type
 // asynchronous actions is wrong. The `value` may be null for the
 // "start" and "error" states but we don't type it like that. We need
 // to rethink how we type async actions.
 
 
@@ -215,64 +211,54 @@ function setSourceTextProps(state, actio
   return updateSource(state, text);
 }
 
 function updateSource(state, source) {
   if (!source.id) {
     return state;
   }
 
-  const existingSource = state.sources.get(source.id);
-
-  if (existingSource) {
-    const updatedSource = existingSource.merge(source);
-    return state.setIn(["sources", source.id], updatedSource);
-  }
-
-  return state.setIn(["sources", source.id], createSourceRecord(source));
+  const existingSource = state.sources[source.id];
+  const updatedSource = existingSource ? _objectSpread({}, existingSource, source) : createSource(source);
+  return _objectSpread({}, state, {
+    sources: _objectSpread({}, state.sources, {
+      [source.id]: updatedSource
+    })
+  });
 }
 
 function removeSourceFromTabList(tabs, url) {
-  return tabs.filter(tab => tab != url);
+  return tabs.filter(tab => tab !== url);
 }
 
 function removeSourcesFromTabList(tabs, urls) {
   return urls.reduce((t, url) => removeSourceFromTabList(t, url), tabs);
 }
 
 function restoreTabs() {
   const prefsTabs = _prefs.prefs.tabs || [];
-
-  if (prefsTabs.length == 0) {
-    return;
-  }
-
   return prefsTabs;
 }
 /**
  * Adds the new source to the tab list if it is not already there
  * @memberof reducers/sources
  * @static
  */
 
 
-function updateTabList(state, url, tabIndex) {
-  let tabs = state.sources.tabs;
-  const urlIndex = tabs.indexOf(url);
-  const includesUrl = !!tabs.find(tab => tab == url);
+function updateTabList(tabs, url, newIndex) {
+  const currentIndex = tabs.indexOf(url);
 
-  if (includesUrl) {
-    if (tabIndex != undefined) {
-      tabs = tabs.delete(urlIndex).insert(tabIndex, url);
-    }
-  } else {
-    tabs = tabs.insert(0, url);
+  if (currentIndex === -1) {
+    tabs = [url, ...tabs];
+  } else if (newIndex !== undefined) {
+    tabs = (0, _lodashMove.move)(tabs, currentIndex, newIndex);
   }
 
-  _prefs.prefs.tabs = tabs.toJS();
+  _prefs.prefs.tabs = tabs;
   return tabs;
 }
 
 function updateBlackBoxList(url, isBlackBoxed) {
   const tabs = getBlackBoxList();
   const i = tabs.indexOf(url);
 
   if (i >= 0) {
@@ -302,40 +288,43 @@ function getBlackBoxList() {
 
 function getNewSelectedSourceId(state, availableTabs) {
   const selectedLocation = state.sources.selectedLocation;
 
   if (!selectedLocation) {
     return "";
   }
 
-  const selectedTab = state.sources.sources.get(selectedLocation.sourceId);
-  const selectedTabUrl = selectedTab ? selectedTab.url : "";
+  const selectedTab = getSource(state, selectedLocation.sourceId);
 
-  if (availableTabs.includes(selectedTabUrl)) {
+  if (!selectedTab) {
+    return "";
+  }
+
+  if (availableTabs.includes(selectedTab.url)) {
     const sources = state.sources.sources;
 
     if (!sources) {
       return "";
     }
 
-    const selectedSource = sources.find(source => source.url == selectedTabUrl);
+    const selectedSource = getSourceByURL(state, selectedTab.url);
 
     if (selectedSource) {
       return selectedSource.id;
     }
 
     return "";
   }
 
   const tabUrls = state.sources.tabs;
-  const leftNeighborIndex = Math.max(tabUrls.indexOf(selectedTabUrl) - 1, 0);
-  const lastAvailbleTabIndex = availableTabs.size - 1;
+  const leftNeighborIndex = Math.max(tabUrls.indexOf(selectedTab.url) - 1, 0);
+  const lastAvailbleTabIndex = availableTabs.length - 1;
   const newSelectedTabIndex = Math.min(leftNeighborIndex, lastAvailbleTabIndex);
-  const availableTab = availableTabs.get(newSelectedTabIndex);
+  const availableTab = availableTabs[newSelectedTabIndex];
   const tabSource = getSourceByUrlInSources(state.sources.sources, availableTab);
 
   if (tabSource) {
     return tabSource.id;
   }
 
   return "";
 } // Selectors
@@ -349,26 +338,30 @@ function getNewSelectedSourceId(state, a
 
 
 const getSourcesState = state => state.sources;
 
 function getSource(state, id) {
   return getSourceInSources(getSources(state), id);
 }
 
+function getSourceFromId(state, id) {
+  return getSourcesState(state).sources[id];
+}
+
 function getSourceByURL(state, url) {
   return getSourceByUrlInSources(state.sources.sources, url);
 }
 
-function getGeneratedSource(state, sourceRecord) {
-  if (!sourceRecord || !(0, _devtoolsSourceMap.isOriginalId)(sourceRecord.id)) {
-    return null;
+function getGeneratedSource(state, source) {
+  if (!(0, _devtoolsSourceMap.isOriginalId)(source.id)) {
+    return source;
   }
 
-  return getSource(state, (0, _devtoolsSourceMap.originalToGeneratedId)(sourceRecord.id));
+  return getSourceFromId(state, (0, _devtoolsSourceMap.originalToGeneratedId)(source.id));
 }
 
 function getPendingSelectedLocation(state) {
   return state.sources.pendingSelectedLocation;
 }
 
 function getPrettySource(state, id) {
   const source = getSource(state, id);
@@ -384,34 +377,51 @@ function hasPrettySource(state, id) {
   return !!getPrettySource(state, id);
 }
 
 function getSourceByUrlInSources(sources, url) {
   if (!url) {
     return null;
   }
 
-  return sources.find(source => source.url === url);
+  return (0, _lodash.find)(sources, source => source.url === url);
 }
 
 function getSourceInSources(sources, id) {
-  return sources.get(id);
+  return sources[id];
+}
+
+function getSources(state) {
+  return state.sources.sources;
 }
 
-const getSources = exports.getSources = (0, _reselect.createSelector)(getSourcesState, sources => sources.sources);
+function getSourceList(state) {
+  return Object.values(getSources(state));
+}
+
+function getSourceCount(state) {
+  return Object.keys(getSources(state)).length;
+}
+
 const getTabs = exports.getTabs = (0, _reselect.createSelector)(getSourcesState, sources => sources.tabs);
 const getSourceTabs = exports.getSourceTabs = (0, _reselect.createSelector)(getTabs, getSources, (tabs, sources) => tabs.filter(tab => getSourceByUrlInSources(sources, tab)));
 const getSourcesForTabs = exports.getSourcesForTabs = (0, _reselect.createSelector)(getSourceTabs, getSources, (tabs, sources) => {
   return tabs.map(tab => getSourceByUrlInSources(sources, tab)).filter(source => source);
 });
 const getSelectedLocation = exports.getSelectedLocation = (0, _reselect.createSelector)(getSourcesState, sources => sources.selectedLocation);
 const getSelectedSource = exports.getSelectedSource = (0, _reselect.createSelector)(getSelectedLocation, getSources, (selectedLocation, sources) => {
   if (!selectedLocation) {
     return;
   }
 
-  return sources.get(selectedLocation.sourceId);
-});
-const getSelectedSourceText = exports.getSelectedSourceText = (0, _reselect.createSelector)(getSelectedSource, getSourcesState, (selectedSource, sources) => {
-  const id = selectedSource.id;
-  return id ? sources.sourcesText.get(id) : null;
+  const source = sources[selectedLocation.sourceId]; // TODO: remove this when the immutable refactor lands in m-c
+
+  if (_devtoolsEnvironment.isTesting) {
+    const testSource = _objectSpread({}, source, {
+      get: field => source[field]
+    });
+
+    return testSource;
+  }
+
+  return source;
 });
 exports.default = update;
\ No newline at end of file
--- a/devtools/client/debugger/new/src/selectors/breakpointAtLocation.js
+++ b/devtools/client/debugger/new/src/selectors/breakpointAtLocation.js
@@ -10,18 +10,17 @@ var _sources = require("../reducers/sour
 var _breakpoints = require("../reducers/breakpoints");
 
 var _devtoolsSourceMap = require("devtools/client/shared/source-map/index.js");
 
 /* 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/>. */
 function isGenerated(selectedSource) {
-  const sourceId = selectedSource.get("id");
-  return (0, _devtoolsSourceMap.isGeneratedId)(sourceId);
+  return (0, _devtoolsSourceMap.isGeneratedId)(selectedSource.id);
 }
 
 function getColumn(column, selectedSource) {
   if (column) {
     return column;
   }
 
   return isGenerated(selectedSource) ? undefined : 0;
@@ -30,17 +29,17 @@ function getColumn(column, selectedSourc
 function getLocation(bp, selectedSource) {
   return isGenerated(selectedSource) ? bp.generatedLocation || bp.location : bp.location;
 }
 
 function getBreakpointsForSource(state, selectedSource) {
   const breakpoints = (0, _breakpoints.getBreakpoints)(state);
   return breakpoints.filter(bp => {
     const location = getLocation(bp, selectedSource);
-    return location.sourceId === selectedSource.get("id");
+    return location.sourceId === selectedSource.id;
   });
 }
 
 function findBreakpointAtLocation(breakpoints, selectedSource, {
   line,
   column
 }) {
   return breakpoints.find(breakpoint => {
--- a/devtools/client/debugger/new/src/selectors/breakpointSources.js
+++ b/devtools/client/debugger/new/src/selectors/breakpointSources.js
@@ -12,26 +12,27 @@ var _reselect = require("devtools/client
 var _selectors = require("../selectors/index");
 
 var _source = require("../utils/source");
 
 /* 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/>. */
 function getBreakpointsForSource(source, breakpoints) {
-  return breakpoints.valueSeq().filter(bp => bp.location.sourceId == source.id && !bp.hidden && (bp.text || bp.condition)).sortBy(bp => bp.location.line).toJS();
+  const bpList = breakpoints.valueSeq();
+  return bpList.filter(bp => bp.location.sourceId == source.id && !bp.hidden && (bp.text || bp.condition)).sortBy(bp => bp.location.line).toJS();
 }
 
 function findBreakpointSources(sources, breakpoints) {
   const sourceIds = (0, _lodash.uniq)(breakpoints.valueSeq().filter(bp => !bp.hidden).map(bp => bp.location.sourceId).toJS());
-  const breakpointSources = sourceIds.map(id => (0, _selectors.getSourceInSources)(sources, id)).filter(source => source && !source.isBlackBoxed);
+  const breakpointSources = sourceIds.map(id => sources[id]).filter(source => source && !source.isBlackBoxed);
   return (0, _lodash.sortBy)(breakpointSources, source => (0, _source.getFilenameFromURL)(source.url));
 }
 
-function _getBreakpointSources(breakpoints, sources, selectedSource) {
+function _getBreakpointSources(breakpoints, sources) {
   const breakpointSources = findBreakpointSources(sources, breakpoints);
   return breakpointSources.map(source => ({
     source,
     breakpoints: getBreakpointsForSource(source, breakpoints)
   }));
 }
 
 const getBreakpointSources = exports.getBreakpointSources = (0, _reselect.createSelector)(_selectors.getBreakpoints, _selectors.getSources, _getBreakpointSources);
\ No newline at end of file
--- a/devtools/client/debugger/new/src/selectors/getCallStackFrames.js
+++ b/devtools/client/debugger/new/src/selectors/getCallStackFrames.js
@@ -27,20 +27,20 @@ function getLocation(frame, isGeneratedS
 }
 
 function getSourceForFrame(sources, frame, isGeneratedSource) {
   const sourceId = getLocation(frame, isGeneratedSource).sourceId;
   return (0, _sources.getSourceInSources)(sources, sourceId);
 }
 
 function appendSource(sources, frame, selectedSource) {
-  const isGeneratedSource = selectedSource && !(0, _devtoolsSourceMap.isOriginalId)(selectedSource.get("id"));
+  const isGeneratedSource = selectedSource && !(0, _devtoolsSourceMap.isOriginalId)(selectedSource.id);
   return _objectSpread({}, frame, {
     location: getLocation(frame, isGeneratedSource),
-    source: getSourceForFrame(sources, frame, isGeneratedSource).toJS()
+    source: getSourceForFrame(sources, frame, isGeneratedSource)
   });
 }
 
 function formatCallStackFrames(frames, sources, selectedSource) {
   if (!frames) {
     return null;
   }
 
--- a/devtools/client/debugger/new/src/selectors/getRelativeSources.js
+++ b/devtools/client/debugger/new/src/selectors/getRelativeSources.js
@@ -2,37 +2,45 @@
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getRelativeSources = undefined;
 
 var _selectors = require("../selectors/index");
 
-var _sources = require("../reducers/sources");
+var _lodash = require("devtools/client/shared/vendor/lodash");
 
 var _source = require("../utils/source");
 
 var _reselect = require("devtools/client/debugger/new/dist/vendors").vendored["reselect"];
 
-/* 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/>. */
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 function getRelativeUrl(url, root) {
   if (!root) {
     return (0, _source.getSourcePath)(url);
   } // + 1 removes the leading "/"
 
 
   return url.slice(url.indexOf(root) + root.length + 1);
 }
 
 function formatSource(source, root) {
-  return new _sources.RelativeSourceRecordClass(source).set("relativeUrl", getRelativeUrl(source.url, root));
+  return _objectSpread({}, source, {
+    relativeUrl: getRelativeUrl(source.url, root)
+  });
+}
+
+function underRoot(source, root) {
+  return source.url && source.url.includes(root);
 }
 /*
  * Gets the sources that are below a project root
  */
 
 
 const getRelativeSources = exports.getRelativeSources = (0, _reselect.createSelector)(_selectors.getSources, _selectors.getProjectDirectoryRoot, (sources, root) => {
-  return sources.filter(source => source.url && source.url.includes(root)).map(source => formatSource(source, root));
+  const relativeSources = (0, _lodash.chain)(sources).pickBy(source => underRoot(source, root)).mapValues(source => formatSource(source, root)).value();
+  return relativeSources;
 });
\ No newline at end of file
--- a/devtools/client/debugger/new/src/selectors/inComponent.js
+++ b/devtools/client/debugger/new/src/selectors/inComponent.js
@@ -11,17 +11,27 @@ var _ast = require("../utils/ast");
 
 var _ast2 = require("../reducers/ast");
 
 /* 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/>. */
 function inComponent(state) {
   const selectedFrame = (0, _.getSelectedFrame)(state);
+
+  if (!selectedFrame) {
+    return;
+  }
+
   const source = (0, _.getSource)(state, selectedFrame.location.sourceId);
+
+  if (!source) {
+    return;
+  }
+
   const symbols = (0, _.getSymbols)(state, source);
 
   if (!symbols) {
     return;
   }
 
   const closestClass = (0, _ast.findClosestClass)(symbols, selectedFrame.location);
 
--- a/devtools/client/debugger/new/src/selectors/visibleBreakpoints.js
+++ b/devtools/client/debugger/new/src/selectors/visibleBreakpoints.js
@@ -20,38 +20,36 @@ function getLocation(breakpoint, isGener
 
 function formatBreakpoint(breakpoint, selectedSource) {
   const {
     condition,
     loading,
     disabled,
     hidden
   } = breakpoint;
-  const sourceId = selectedSource.get("id");
+  const sourceId = selectedSource.id;
   const isGeneratedSource = (0, _devtoolsSourceMap.isGeneratedId)(sourceId);
   return {
     location: getLocation(breakpoint, isGeneratedSource),
     condition,
     loading,
     disabled,
     hidden
   };
 }
 
 function isVisible(breakpoint, selectedSource) {
-  const sourceId = selectedSource.get("id");
+  const sourceId = selectedSource.id;
   const isGeneratedSource = (0, _devtoolsSourceMap.isGeneratedId)(sourceId);
   const location = getLocation(breakpoint, isGeneratedSource);
   return location.sourceId === sourceId;
 }
 /*
  * Finds the breakpoints, which appear in the selected source.
- *
- * This
- */
+  */
 
 
 function getVisibleBreakpoints(state) {
   const selectedSource = (0, _sources.getSelectedSource)(state);
 
   if (!selectedSource) {
     return null;
   }
--- a/devtools/client/debugger/new/src/utils/dbg.js
+++ b/devtools/client/debugger/new/src/utils/dbg.js
@@ -18,23 +18,23 @@ var _pausePoints = require("./pause/paus
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 function findSource(dbg, url) {
   const sources = dbg.selectors.getSources();
-  const source = sources.find(s => (s.get("url") || "").includes(url));
+  const source = sources.find(s => (s.url || "").includes(url));
 
   if (!source) {
     return;
   }
 
-  return source.toJS();
+  return source;
 }
 
 function sendPacket(dbg, packet, callback) {
   dbg.client.sendPacket(packet, callback || console.log);
 }
 
 function sendPacketToThread(dbg, packet, callback) {
   sendPacket(dbg, _objectSpread({
--- a/devtools/client/debugger/new/src/utils/editor/index.js
+++ b/devtools/client/debugger/new/src/utils/editor/index.js
@@ -119,17 +119,17 @@ function shouldShowFooter(selectedSource
   if (!horizontal) {
     return true;
   }
 
   if (!selectedSource) {
     return false;
   }
 
-  return shouldShowPrettyPrint(selectedSource) || (0, _devtoolsSourceMap.isOriginalId)(selectedSource.get("id"));
+  return shouldShowPrettyPrint(selectedSource) || (0, _devtoolsSourceMap.isOriginalId)(selectedSource.id);
 }
 
 function traverseResults(e, ctx, query, dir, modifiers) {
   e.stopPropagation();
   e.preventDefault();
 
   if (dir == "prev") {
     (0, _sourceSearch.findPrev)(ctx, query, true, modifiers);
--- a/devtools/client/debugger/new/src/utils/editor/source-documents.js
+++ b/devtools/client/debugger/new/src/utils/editor/source-documents.js
@@ -71,17 +71,17 @@ function updateLineNumberFormat(editor, 
   (0, _ui.resizeToggleButton)(cm);
 }
 
 function updateDocument(editor, source) {
   if (!source) {
     return;
   }
 
-  const sourceId = source.get("id");
+  const sourceId = source.id;
   const doc = getDocument(sourceId) || editor.createDocument();
   editor.replaceDocument(doc);
   updateLineNumberFormat(editor, sourceId);
 }
 
 function clearEditor(editor) {
   const doc = editor.createDocument();
   editor.replaceDocument(doc);
--- a/devtools/client/debugger/new/src/utils/isMinified.js
+++ b/devtools/client/debugger/new/src/utils/isMinified.js
@@ -15,17 +15,17 @@ const CHARACTER_LIMIT = 250;
 
 const _minifiedCache = new Map();
 
 function isMinified(source) {
   if (_minifiedCache.has(source.id)) {
     return _minifiedCache.get(source.id);
   }
 
-  let text = source.get("text");
+  let text = source.text;
 
   if (!text) {
     return false;
   }
 
   let lineEndIndex = 0;
   let lineStartIndex = 0;
   let lines = 0;
--- a/devtools/client/debugger/new/src/utils/pause/frames/annotateFrames.js
+++ b/devtools/client/debugger/new/src/utils/pause/frames/annotateFrames.js
@@ -64,12 +64,13 @@ function getBabelFrameIndexes(frames) {
     return accumulator;
   }, []);
 
   if (startIndexes.length != endIndexes.length || startIndexes.length === 0) {
     return frames;
   } // Receives an array of start and end index tuples and returns
   // an array of async call stack index ranges.
   // e.g. [[1,3], [5,7]] => [[1,2,3], [5,6,7]]
+  // $FlowIgnore
 
 
   return (0, _lodash.flatMap)((0, _lodash.zip)(startIndexes, endIndexes), ([startIndex, endIndex]) => (0, _lodash.range)(startIndex, endIndex + 1));
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/utils/pause/frames/getLibraryFromUrl.js
+++ b/devtools/client/debugger/new/src/utils/pause/frames/getLibraryFromUrl.js
@@ -1,17 +1,15 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getLibraryFromUrl = getLibraryFromUrl;
 
-var _lodash = require("devtools/client/shared/vendor/lodash");
-
 var _getFrameUrl = require("./getFrameUrl");
 
 /* 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/>. */
 const libraryMap = [{
   label: "Backbone",
   pattern: /backbone/i
@@ -85,11 +83,16 @@ const libraryMap = [{
   label: "NextJS",
   pattern: /[\._]next/i
 }];
 
 function getLibraryFromUrl(frame) {
   // @TODO each of these fns calls getFrameUrl, just call it once
   // (assuming there's not more complex logic to identify a lib)
   const frameUrl = (0, _getFrameUrl.getFrameUrl)(frame);
-  const match = (0, _lodash.find)(libraryMap, o => frameUrl.match(o.pattern));
-  return match && match.label;
+  const matches = libraryMap.filter(o => frameUrl.match(o.pattern));
+
+  if (matches.length == 0) {
+    return null;
+  }
+
+  return matches[0].label;
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/utils/pause/mapScopes/index.js
+++ b/devtools/client/debugger/new/src/utils/pause/mapScopes/index.js
@@ -181,17 +181,16 @@ function generateClientScope(scopes, ori
       // The 'this' binding data we have is handled independently, so
       // the binding data is not included here.
       // eslint-disable-next-line no-unused-vars
       this: _this
     } = _orig$generatedBindin,
           variables = _objectWithoutProperties(_orig$generatedBindin, ["this"]);
 
     return _objectSpread({
-      // Flow doesn't like casting 'parent'.
       parent: acc,
       actor: `originalActor${i}`,
       type: orig.type,
       bindings: {
         arguments: [],
         variables
       }
     }, orig.type === "function" ? {
--- a/devtools/client/debugger/new/src/utils/pause/mapScopes/rangeMetadata.js
+++ b/devtools/client/debugger/new/src/utils/pause/mapScopes/rangeMetadata.js
@@ -33,17 +33,22 @@ async function loadRangeMetadata(source,
   return originalRanges.map(range => {
     const bindings = [];
 
     while (i < sortedOriginalAstBindings.length && (sortedOriginalAstBindings[i].start.line < range.line || sortedOriginalAstBindings[i].start.line === range.line && (0, _locColumn.locColumn)(sortedOriginalAstBindings[i].start) < range.columnStart)) {
       i++;
     }
 
     while (i < sortedOriginalAstBindings.length && sortedOriginalAstBindings[i].start.line === range.line && (0, _locColumn.locColumn)(sortedOriginalAstBindings[i].start) >= range.columnStart && (0, _locColumn.locColumn)(sortedOriginalAstBindings[i].start) < range.columnEnd) {
-      bindings.push(sortedOriginalAstBindings[i]);
+      const lastBinding = bindings[bindings.length - 1]; // Only add bindings when they're in new positions
+
+      if (!lastBinding || (0, _positionCmp.positionCmp)(lastBinding.start, sortedOriginalAstBindings[i].start) !== 0) {
+        bindings.push(sortedOriginalAstBindings[i]);
+      }
+
       i++;
     }
 
     let type = "empty";
     let singleDeclaration = true;
 
     if (bindings.length === 1) {
       const binding = bindings[0];
--- a/devtools/client/debugger/new/src/utils/prefs.js
+++ b/devtools/client/debugger/new/src/utils/prefs.js
@@ -57,18 +57,20 @@ if (isDevelopment()) {
   pref("devtools.debugger.features.remove-command-bar-options", true);
   pref("devtools.debugger.features.code-coverage", false);
   pref("devtools.debugger.features.event-listeners", false);
   pref("devtools.debugger.features.code-folding", false);
   pref("devtools.debugger.features.outline", true);
   pref("devtools.debugger.features.column-breakpoints", true);
   pref("devtools.debugger.features.replay", true);
   pref("devtools.debugger.features.pause-points", true);
-  pref("devtools.debugger.features.component-stack", true);
   pref("devtools.debugger.features.skip-pausing", false);
+  pref("devtools.debugger.features.component-pane", false);
+  pref("devtools.debugger.features.skip-pausing", true);
+  pref("devtools.debugger.features.autocomplete-expressions", false);
 }
 
 const prefs = exports.prefs = new PrefsHelper("devtools", {
   alphabetizeOutline: ["Bool", "debugger.alphabetize-outline"],
   autoPrettyPrint: ["Bool", "debugger.auto-pretty-print"],
   clientSourceMapsEnabled: ["Bool", "source-map.client-service.enabled"],
   pauseOnExceptions: ["Bool", "debugger.pause-on-exceptions"],
   pauseOnCaughtExceptions: ["Bool", "debugger.pause-on-caught-exceptions"],
@@ -105,17 +107,18 @@ const features = exports.features = new 
   removeCommandBarOptions: ["Bool", "remove-command-bar-options"],
   workers: ["Bool", "workers"],
   codeCoverage: ["Bool", "code-coverage"],
   eventListeners: ["Bool", "event-listeners"],
   outline: ["Bool", "outline"],
   codeFolding: ["Bool", "code-folding"],
   replay: ["Bool", "replay"],
   pausePoints: ["Bool", "pause-points"],
-  componentStack: ["Bool", "component-stack"],
-  skipPausing: ["Bool", "skip-pausing"]
+  skipPausing: ["Bool", "skip-pausing"],
+  componentPane: ["Bool", "component-pane"],
+  autocompleteExpression: ["Bool", "autocomplete-expressions"]
 });
 
 if (prefs.debuggerPrefsSchemaVersion !== prefsSchemaVersion) {
   // clear pending Breakpoints
   prefs.pendingBreakpoints = {};
   prefs.debuggerPrefsSchemaVersion = prefsSchemaVersion;
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/utils/quick-open.js
+++ b/devtools/client/debugger/new/src/utils/quick-open.js
@@ -118,12 +118,13 @@ function formatShortcutResults() {
   }, {
     value: L10N.getStr("gotoLineModal.title"),
     title: `: ${L10N.getStr("gotoLineModal.placeholder")}`,
     id: ":"
   }];
 }
 
 function formatSources(sources, tabs) {
-  return sources.valueSeq().toArray().filter(source => !(0, _source.isPretty)(source)).filter(({
+  const sourceList = Object.values(sources);
+  return sourceList.filter(source => !(0, _source.isPretty)(source)).filter(({
     relativeUrl
   }) => !!relativeUrl).map(source => formatSourcesForList(source, tabs));
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/utils/source-maps.js
+++ b/devtools/client/debugger/new/src/utils/source-maps.js
@@ -14,17 +14,17 @@ async function getGeneratedLocation(stat
   if (!sourceMaps.isOriginalId(location.sourceId)) {
     return location;
   }
 
   const {
     line,
     sourceId,
     column
-  } = await sourceMaps.getGeneratedLocation(location, source.toJS());
+  } = await sourceMaps.getGeneratedLocation(location, source);
   const generatedSource = (0, _selectors.getSource)(state, sourceId);
 
   if (!generatedSource) {
     return location;
   }
 
   return {
     line,
--- a/devtools/client/debugger/new/src/utils/source.js
+++ b/devtools/client/debugger/new/src/utils/source.js
@@ -71,17 +71,17 @@ function shouldPrettyPrint(source) {
     return false;
   }
 
   const _isPretty = isPretty(source);
 
   const _isJavaScript = isJavaScript(source);
 
   const isOriginal = (0, _devtoolsSourceMap.isOriginalId)(source.id);
-  const hasSourceMap = source.get("sourceMapURL");
+  const hasSourceMap = source.sourceMapURL;
 
   if (_isPretty || isOriginal || hasSourceMap || !_isJavaScript) {
     return false;
   }
 
   return true;
 }
 /**
@@ -416,21 +416,21 @@ function getMode(source, symbols) {
   }
 
   return {
     name: "text"
   };
 }
 
 function isLoaded(source) {
-  return source.get("loadedState") === "loaded";
+  return source.loadedState === "loaded";
 }
 
 function isLoading(source) {
-  return source.get("loadedState") === "loading";
+  return source.loadedState === "loading";
 }
 
 function getTextAtPosition(source, location) {
   if (!source || !source.text || source.isWasm) {
     return "";
   }
 
   const line = location.line;
--- a/devtools/client/debugger/new/src/utils/sources-tree/addToTree.js
+++ b/devtools/client/debugger/new/src/utils/sources-tree/addToTree.js
@@ -10,17 +10,17 @@ var _utils = require("./utils");
 var _treeOrder = require("./treeOrder");
 
 var _getURL = require("./getURL");
 
 /* 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/>. */
 function createNodeInTree(part, path, tree, index) {
-  const node = (0, _utils.createNode)(part, path, []); // we are modifying the tree
+  const node = (0, _utils.createDirectoryNode)(part, path, []); // we are modifying the tree
 
   const contents = tree.contents.slice(0);
   contents.splice(index, 0, node);
   tree.contents = contents;
   return node;
 }
 /*
  * Look for the child directory
@@ -41,70 +41,80 @@ function findOrCreateNode(parts, subTree
     return createNodeInTree(part, path, subTree, childIndex);
   } // we found a path with the same name as the part. We need to determine
   // if this is the correct child, or if we have a naming conflict
 
 
   const child = subTree.contents[childIndex];
   const childIsFile = !(0, _utils.nodeHasChildren)(child); // if we have a naming conflict, we'll create a new node
 
-  if (childIsFile && !addedPartIsFile || !childIsFile && addedPartIsFile) {
+  if (child.type === "source" || !childIsFile && addedPartIsFile) {
     return createNodeInTree(part, path, subTree, childIndex);
   } // if there is no naming conflict, we can traverse into the child
 
 
   return child;
 }
 /*
  * walk the source tree to the final node for a given url,
  * adding new nodes along the way
  */
 
 
 function traverseTree(url, tree, debuggeeHost) {
-  url.path = decodeURIComponent(url.path);
   const parts = url.path.split("/").filter(p => p !== "");
   parts.unshift(url.group);
   let path = "";
   return parts.reduce((subTree, part, index) => {
     path = path ? `${path}/${part}` : part;
     const debuggeeHostIfRoot = index === 0 ? debuggeeHost : null;
     return findOrCreateNode(parts, subTree, path, part, index, url, debuggeeHostIfRoot);
   }, tree);
 }
 /*
  * Add a source file to a directory node in the tree
  */
 
 
 function addSourceToNode(node, url, source) {
-  const isFile = !(0, _utils.isDirectory)(url); // if we have a file, and the subtree has no elements, overwrite the
+  const isFile = !(0, _utils.isPathDirectory)(url.path);
+
+  if (node.type == "source") {
+    throw new Error(`wtf ${node.name}`);
+  } // if we have a file, and the subtree has no elements, overwrite the
   // subtree contents with the source
 
+
   if (isFile) {
+    // $FlowIgnore
+    node.type = "source";
     return source;
   }
 
   const {
     filename
   } = url;
   const {
     found: childFound,
     index: childIndex
   } = (0, _treeOrder.findNodeInContents)(node, (0, _treeOrder.createTreeNodeMatcher)(filename, false, null)); // if we are readding an existing file in the node, overwrite the existing
   // file and return the node's contents
 
   if (childFound) {
     const existingNode = node.contents[childIndex];
-    existingNode.contents = source;
+
+    if (existingNode.type === "source") {
+      existingNode.contents = source;
+    }
+
     return node.contents;
   } // if this is a new file, add the new file;
 
 
-  const newNode = (0, _utils.createNode)(filename, source.get("url"), source);
+  const newNode = (0, _utils.createSourceNode)(filename, source.url, source);
   const contents = node.contents.slice(0);
   contents.splice(childIndex, 0, newNode);
   return contents;
 }
 /**
  * @memberof utils/sources-tree
  * @static
  */
@@ -113,11 +123,12 @@ function addSourceToNode(node, url, sour
 function addToTree(tree, source, debuggeeUrl, projectRoot) {
   const url = (0, _getURL.getURL)(source.url, debuggeeUrl);
   const debuggeeHost = (0, _treeOrder.getDomain)(debuggeeUrl);
 
   if ((0, _utils.isInvalidUrl)(url, source)) {
     return;
   }
 
-  const finalNode = traverseTree(url, tree, debuggeeHost);
+  const finalNode = traverseTree(url, tree, debuggeeHost); // $FlowIgnore
+
   finalNode.contents = addSourceToNode(finalNode, url, source);
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/utils/sources-tree/collapseTree.js
+++ b/devtools/client/debugger/new/src/utils/sources-tree/collapseTree.js
@@ -9,27 +9,43 @@ var _utils = require("./utils");
 
 /* 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/>. */
 
 /**
  * Take an existing source tree, and return a new one with collapsed nodes.
  */
-function collapseTree(node, depth = 0) {
+function _collapseTree(node, depth) {
   // Node is a folder.
-  if (Array.isArray(node.contents)) {
-    // Node is not a root/domain node, and only contains 1 item.
+  if (node.type === "directory") {
+    if (!Array.isArray(node.contents)) {
+      console.log(`WTF: ${node.path}`);
+    } // Node is not a root/domain node, and only contains 1 item.
+
+
     if (depth > 1 && node.contents.length === 1) {
       const next = node.contents[0]; // Do not collapse if the next node is a leaf node.
 
-      if ((0, _utils.nodeHasChildren)(next)) {
-        return collapseTree((0, _utils.createNode)(`${node.name}/${next.name}`, next.path, next.contents), depth + 1);
+      if (next.type === "directory") {
+        if (!Array.isArray(next.contents)) {
+          console.log(`WTF: ${next.name} -- ${node.name} -- ${JSON.stringify(next.contents)}`);
+        }
+
+        const name = `${node.name}/${next.name}`;
+        const nextNode = (0, _utils.createDirectoryNode)(name, next.path, next.contents);
+        return _collapseTree(nextNode, depth + 1);
       }
     } // Map the contents.
 
 
-    return (0, _utils.createNode)(node.name, node.path, node.contents.map(next => collapseTree(next, depth + 1)));
+    return (0, _utils.createDirectoryNode)(node.name, node.path, node.contents.map(next => _collapseTree(next, depth + 1)));
   } // Node is a leaf, not a folder, do not modify it.
 
 
   return node;
+}
+
+function collapseTree(node) {
+  const tree = _collapseTree(node, 0);
+
+  return tree;
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/utils/sources-tree/createTree.js
+++ b/devtools/client/debugger/new/src/utils/sources-tree/createTree.js
@@ -14,19 +14,20 @@ var _utils = require("./utils");
 /* 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/>. */
 function createTree({
   sources,
   debuggeeUrl,
   projectRoot
 }) {
-  const uncollapsedTree = (0, _utils.createNode)("root", "", []);
+  const uncollapsedTree = (0, _utils.createDirectoryNode)("root", "", []);
 
-  for (const source of sources.valueSeq()) {
+  for (const sourceId in sources) {
+    const source = sources[sourceId];
     (0, _addToTree.addToTree)(uncollapsedTree, source, debuggeeUrl, projectRoot);
   }
 
   const sourceTree = (0, _collapseTree.collapseTree)(uncollapsedTree);
   return {
     uncollapsedTree,
     sourceTree,
     parentMap: (0, _utils.createParentMap)(sourceTree),
--- a/devtools/client/debugger/new/src/utils/sources-tree/formatTree.js
+++ b/devtools/client/debugger/new/src/utils/sources-tree/formatTree.js
@@ -6,20 +6,20 @@ Object.defineProperty(exports, "__esModu
 exports.formatTree = formatTree;
 
 /* 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/>. */
 function formatTree(tree, depth = 0, str = "") {
   const whitespace = new Array(depth * 2).join(" ");
 
-  if (Array.isArray(tree.contents)) {
+  if (tree.type === "directory") {
     str += `${whitespace} - ${tree.name} path=${tree.path} \n`;
     tree.contents.forEach(t => {
       str = formatTree(t, depth + 1, str);
     });
   } else {
-    const id = tree.contents.get("id");
+    const id = tree.contents.id;
     str += `${whitespace} - ${tree.name} path=${tree.path} source_id=${id} \n`;
   }
 
   return str;
 }
\ No newline at end of file
--- a/devtools/client/debugger/new/src/utils/sources-tree/getDirectories.js
+++ b/devtools/client/debugger/new/src/utils/sources-tree/getDirectories.js
@@ -11,29 +11,29 @@ var _getURL = require("./getURL");
 
 /* 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/>. */
 function findSource(sourceTree, sourceUrl) {
   let returnTarget = null;
 
   function _traverse(subtree) {
-    if ((0, _utils.nodeHasChildren)(subtree)) {
+    if (subtree.type === "directory") {
       for (const child of subtree.contents) {
         _traverse(child);
       }
     } else if (!returnTarget) {
       if (subtree.path.replace(/http(s)?:\//, "") == sourceUrl) {
         returnTarget = subtree;
         return;
       }
     }
   }
 
-  sourceTree.contents.forEach(_traverse);
+  sourceTree.contents.forEach(node => _traverse(node));
 
   if (!returnTarget) {
     return sourceTree;
   }
 
   return returnTarget;
 }
 
--- a/devtools/client/debugger/new/src/utils/sources-tree/index.js
+++ b/devtools/client/debugger/new/src/utils/sources-tree/index.js
@@ -85,56 +85,17 @@ Object.defineProperty(exports, "updateTr
   enumerable: true,
   get: function () {
     return _updateTree.updateTree;
   }
 });
 
 var _utils = require("./utils");
 
-Object.defineProperty(exports, "createNode", {
-  enumerable: true,
-  get: function () {
-    return _utils.createNode;
-  }
-});
-Object.defineProperty(exports, "createParentMap", {
-  enumerable: true,
-  get: function () {
-    return _utils.createParentMap;
-  }
-});
-Object.defineProperty(exports, "getFileExtension", {
-  enumerable: true,
-  get: function () {
-    return _utils.getFileExtension;
-  }
-});
-Object.defineProperty(exports, "getRelativePath", {
-  enumerable: true,
-  get: function () {
-    return _utils.getRelativePath;
-  }
-});
-Object.defineProperty(exports, "isDirectory", {
-  enumerable: true,
-  get: function () {
-    return _utils.isDirectory;
-  }
-});
-Object.defineProperty(exports, "isExactUrlMatch", {
-  enumerable: true,
-  get: function () {
-    return _utils.isExactUrlMatch;
-  }
-});
-Object.defineProperty(exports, "isNotJavaScript", {
-  enumerable: true,
-  get: function () {
-    return _utils.isNotJavaScript;
-  }
-});
-Object.defineProperty(exports, "nodeHasChildren", {
-  enumerable: true,
-  get: function () {
-    return _utils.nodeHasChildren;
-  }
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
 });
\ No newline at end of file
--- a/devtools/client/debugger/new/src/utils/sources-tree/treeOrder.js
+++ b/devtools/client/debugger/new/src/utils/sources-tree/treeOrder.js
@@ -53,41 +53,37 @@ function isExactDomainMatch(part, debugg
 /*
  * Performs a binary search to insert a node into contents. Returns positive
  * number, index of the found child, or negative number, which can be used
  * to calculate a position where a new node can be inserted (`-index - 1`).
  * The matcher is a function that returns result of comparision of a node with
  * lookup value.
  */
 function findNodeInContents(tree, matcher) {
-  const {
-    contents
-  } = tree;
-
-  if (contents.length === 0) {
+  if (tree.type === "source" || tree.contents.length === 0) {
     return {
       found: false,
       index: 0
     };
   }
 
   let left = 0;
-  let right = contents.length - 1;
+  let right = tree.contents.length - 1;
 
   while (left < right) {
     const middle = Math.floor((left + right) / 2);
 
-    if (matcher(contents[middle]) < 0) {
+    if (matcher(tree.contents[middle]) < 0) {
       left = middle + 1;
     } else {
       right = middle;
     }
   }
 
-  const result = matcher(contents[left]);
+  const result = matcher(tree.contents[left]);
 
   if (result === 0) {
     return {
       found: true,
       index: left
     };
   }
 
--- a/devtools/client/debugger/new/src/utils/sources-tree/updateTree.js
+++ b/devtools/client/debugger/new/src/utils/sources-tree/updateTree.js
@@ -6,23 +6,25 @@ Object.defineProperty(exports, "__esModu
 exports.updateTree = updateTree;
 
 var _addToTree = require("./addToTree");
 
 var _collapseTree = require("./collapseTree");
 
 var _utils = require("./utils");
 
+var _lodash = require("devtools/client/shared/vendor/lodash");
+
 /* 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/>. */
 function newSourcesSet(newSources, prevSources) {
-  const next = newSources.toSet();
-  const prev = prevSources.toSet();
-  return next.subtract(prev);
+  const newSourceIds = (0, _lodash.difference)(Object.keys(newSources), Object.keys(prevSources));
+  const uniqSources = newSourceIds.map(id => newSources[id]);
+  return uniqSources;
 }
 
 function updateTree({
   newSources,
   prevSources,
   debuggeeUrl,
   projectRoot,
   uncollapsedTree,
--- a/devtools/client/debugger/new/src/utils/sources-tree/utils.js
+++ b/devtools/client/debugger/new/src/utils/sources-tree/utils.js
@@ -1,55 +1,77 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.nodeHasChildren = nodeHasChildren;
 exports.isExactUrlMatch = isExactUrlMatch;
+exports.isPathDirectory = isPathDirectory;
 exports.isDirectory = isDirectory;
+exports.getSourceFromNode = getSourceFromNode;
+exports.isSource = isSource;
 exports.getFileExtension = getFileExtension;
 exports.isNotJavaScript = isNotJavaScript;
 exports.isInvalidUrl = isInvalidUrl;
 exports.partIsFile = partIsFile;
-exports.createNode = createNode;
+exports.createDirectoryNode = createDirectoryNode;
+exports.createSourceNode = createSourceNode;
 exports.createParentMap = createParentMap;
 exports.getRelativePath = getRelativePath;
 
 var _url = require("devtools/client/debugger/new/dist/vendors").vendored["url"];
 
 var _source = require("../source");
 
 /* 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/>. */
 const IGNORED_URLS = ["debugger eval code", "XStringBundle"];
 
 function nodeHasChildren(item) {
-  return Array.isArray(item.contents);
+  return Array.isArray(item.contents) && item.type === "directory";
 }
 
 function isExactUrlMatch(pathPart, debuggeeUrl) {
   // compare to hostname with an optional 'www.' prefix
   const {
     host
   } = (0, _url.parse)(debuggeeUrl);
 
   if (!host) {
     return false;
   }
 
   return host.replace(/^www\./, "") === pathPart.replace(/^www\./, "");
 }
 
-function isDirectory(url) {
-  const parts = url.path.split("/").filter(p => p !== ""); // Assume that all urls point to files except when they end with '/'
+function isPathDirectory(path) {
+  // Assume that all urls point to files except when they end with '/'
   // Or directory node has children
+  const parts = path.split("/").filter(p => p !== "");
+  return parts.length === 0 || path.slice(-1) === "/";
+}
 
-  return (parts.length === 0 || url.path.slice(-1) === "/" || nodeHasChildren(url)) && url.name != "(index)";
+function isDirectory(item) {
+  return (isPathDirectory(item.path) || item.type === "directory") && item.name != "(index)";
+}
+
+function getSourceFromNode(item) {
+  const {
+    contents
+  } = item;
+
+  if (!isDirectory(item) && !Array.isArray(contents)) {
+    return contents;
+  }
+}
+
+function isSource(item) {
+  return item.type === "source";
 }
 
 function getFileExtension(url = "") {
   const parsedUrl = (0, _url.parse)(url).pathname;
 
   if (!parsedUrl) {
     return "";
   }
@@ -65,40 +87,53 @@ function isInvalidUrl(url, source) {
   return IGNORED_URLS.indexOf(url) != -1 || !source.url || !url.group || (0, _source.isPretty)(source) || isNotJavaScript(source);
 }
 
 function partIsFile(index, parts, url) {
   const isLastPart = index === parts.length - 1;
   return !isDirectory(url) && isLastPart;
 }
 
-function createNode(name, path, contents) {
+function createDirectoryNode(name, path, contents) {
   return {
+    type: "directory",
+    name,
+    path,
+    contents
+  };
+}
+
+function createSourceNode(name, path, contents) {
+  return {
+    type: "source",
     name,
     path,
     contents
   };
 }
 
 function createParentMap(tree) {
   const map = new WeakMap();
 
   function _traverse(subtree) {
-    if (nodeHasChildren(subtree)) {
+    if (subtree.type === "directory") {
       for (const child of subtree.contents) {
         map.set(child, subtree);
 
         _traverse(child);
       }
     }
-  } // Don't link each top-level path to the "root" node because the
-  // user never sees the root
+  }
 
+  if (tree.type === "directory") {
+    // Don't link each top-level path to the "root" node because the
+    // user never sees the root
+    tree.contents.forEach(_traverse);
+  }
 
-  tree.contents.forEach(_traverse);
   return map;
 }
 
 function getRelativePath(url) {
   const {
     pathname
   } = (0, _url.parse)(url);
 
--- a/devtools/client/debugger/new/src/workers/parser/getSymbols.js
+++ b/devtools/client/debugger/new/src/workers/parser/getSymbols.js
@@ -277,17 +277,18 @@ function extractSymbols(sourceId) {
     memberExpressions: [],
     objectProperties: [],
     comments: [],
     identifiers: [],
     classes: [],
     imports: [],
     literals: [],
     hasJsx: false,
-    hasTypes: false
+    hasTypes: false,
+    loading: false
   };
   const ast = (0, _ast.traverseAst)(sourceId, {
     enter(node, ancestors) {
       try {
         const path = (0, _simplePath2.default)(ancestors);
 
         if (path) {
           extractSymbol(path, symbols);
--- a/devtools/client/debugger/new/src/workers/parser/utils/formatSymbols.js
+++ b/devtools/client/debugger/new/src/workers/parser/utils/formatSymbols.js
@@ -36,23 +36,25 @@ function summarize(symbol) {
   const expression = symbol.expression || "";
   const klass = symbol.klass || "";
   const name = symbol.name == undefined ? "" : symbol.name;
   const names = symbol.specifiers ? symbol.specifiers.join(", ") : "";
   const values = symbol.values ? symbol.values.join(", ") : "";
   return `${loc} ${expression} ${name}${params} ${klass} ${names} ${values}`.trim(); // eslint-disable-line max-len
 }
 
+const bools = ["hasJsx", "hasTypes", "loading"];
+
+function formatBool(name, symbols) {
+  return `${name}: ${symbols[name] ? "true" : "false"}`;
+}
+
 function formatKey(name, symbols) {
-  if (name == "hasJsx") {
-    return `hasJsx: ${symbols.hasJsx ? "true" : "false"}`;
-  }
-
-  if (name == "hasTypes") {
-    return `hasTypes: ${symbols.hasTypes ? "true" : "false"}`;
+  if (bools.includes(name)) {
+    return formatBool(name, symbols);
   }
 
   return `${name}:\n${symbols[name].map(summarize).join("\n")}`;
 }
 
 function formatSymbols(source) {
   (0, _sources.setSource)(source);
   const symbols = (0, _getSymbols.getSymbols)(source.id);
--- a/devtools/client/debugger/new/test/mochitest/browser.ini
+++ b/devtools/client/debugger/new/test/mochitest/browser.ini
@@ -84,20 +84,19 @@ support-files =
   examples/sourcemaps-reload/v1.bundle.js
   examples/sourcemaps-reload/v1.bundle.js.map
   examples/sourcemaps-reload/v2.bundle.js
   examples/sourcemaps-reload/v2.bundle.js.map
   examples/sourcemaps-reload/v3.bundle.js
   examples/sourcemaps-reload/v3.bundle.js.map
   examples/sourcemaps-reload/doc-sourcemaps-reload.html
   examples/sourcemaps-reload/sjs_code_reload.sjs
-  examples/wasm-sourcemaps/average.js
-  examples/wasm-sourcemaps/average.wasm
-  examples/wasm-sourcemaps/average.wasm.map
-  examples/wasm-sourcemaps/average.c
+  examples/wasm-sourcemaps/fib.c
+  examples/wasm-sourcemaps/fib.wasm
+  examples/wasm-sourcemaps/fib.wasm.map
   examples/wasm-sourcemaps/utils.js
   examples/sum/sum.js
   examples/sum/sum.min.js
   examples/sum/sum.min.js.map
   examples/big-sourcemap_files/bundle.js
   examples/big-sourcemap_files/bundle.js.map
   examples/reload/code_reload_1.js
   examples/reload/code_reload_2.js
@@ -157,20 +156,22 @@ skip-if = (os == "win" && ccov) # Bug 14
 [browser_dbg-sourcemapped-scopes.js]
 skip-if = ccov || (verify && debug && (os == 'linux')) # Bug 1441545
 [browser_dbg-sourcemapped-stepping.js]
 [browser_dbg-sourcemapped-preview.js]
 skip-if = os == "win" # Bug 1448523, Bug 1448450
 [browser_dbg-breaking.js]
 [browser_dbg-breaking-from-console.js]
 [browser_dbg-breakpoints.js]
-[browser_dbg-breakpoints-reloading.js]
+[browser_dbg-breakpoints-actions.js]
 [browser_dbg-breakpoints-cond.js]
 [browser_dbg-browser-content-toolbox.js]
 skip-if = !e10s || verify # This test is only valid in e10s
+[browser_dbg-breakpoints-reloading.js]
+[browser_dbg-breakpoint-skipping.js]
 [browser_dbg-call-stack.js]
 [browser_dbg-scopes.js]
 [browser_dbg-chrome-create.js]
 skip-if = (verify && !debug && (os == 'linux'))
 [browser_dbg-chrome-debugging.js]
 [browser_dbg-console.js]
 [browser_dbg-console-link.js]
 [browser_dbg-content-script-sources.js]
--- a/devtools/client/debugger/new/test/mochitest/browser_dbg-breaking-from-console.js
+++ b/devtools/client/debugger/new/test/mochitest/browser_dbg-breaking-from-console.js
@@ -26,11 +26,10 @@ add_task(async function() {
   const {
     selectors: { getSelectedSource },
     getState
   } = dbg;
 
   // Make sure the thread is paused in the right source and location
   await waitForPaused(dbg);
   is(getCM(dbg).getValue(), "debugger");
-  const source = getSelectedSource(getState()).toJS();
   assertPausedLocation(dbg);
 });
--- a/devtools/client/debugger/new/test/mochitest/browser_dbg-breaking.js
+++ b/devtools/client/debugger/new/test/mochitest/browser_dbg-breaking.js
@@ -22,16 +22,16 @@ add_task(async function() {
   assertPausedLocation(dbg);
   await resume(dbg);
 
   // Create an eval script that pauses itself.
   invokeInTab("doEval");
   await waitForPaused(dbg);
 
   await resume(dbg);
-  const source = getSelectedSource(getState()).toJS();
+  const source = getSelectedSource(getState())
   ok(!source.url, "It is an eval source");
 
   await addBreakpoint(dbg, source, 5);
   invokeInTab("evaledFunc");
   await waitForPaused(dbg);
   assertPausedLocation(dbg);
 });
new file mode 100644
--- /dev/null
+++ b/devtools/client/debugger/new/test/mochitest/browser_dbg-breakpoint-skipping.js
@@ -0,0 +1,16 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function skipPausing(dbg) {
+  clickElementWithSelector(dbg, ".command-bar-skip-pausing");
+  return waitForState(dbg, state => dbg.selectors.getSkipPausing(state))
+}
+
+add_task(async function() {
+  let dbg = await initDebugger("doc-scripts.html");
+  await addBreakpoint(dbg, "simple3", 2);
+
+  await skipPausing(dbg);
+  const res = await invokeInTab("simple")
+  is(res, 3, "simple() successfully completed")
+});
new file mode 100644
--- /dev/null
+++ b/devtools/client/debugger/new/test/mochitest/browser_dbg-breakpoints-actions.js
@@ -0,0 +1,21 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+async function removeBreakpoint(dbg) {
+  rightClickElement(dbg, "breakpointItem", 3)
+  selectMenuItem(dbg, 1);
+}
+
+
+// Tests to see if we can trigger a breakpoint action via the context menu
+add_task(async function() {
+  const dbg = await initDebugger("doc-scripts.html");
+  await selectSource(dbg, "simple2");
+  await waitForSelectedSource(dbg, "simple2");
+
+  await addBreakpoint(dbg, "simple2", 3);
+  await removeBreakpoint(dbg);
+
+  await waitForState(dbg, state => dbg.selectors.getBreakpoints(state).size == 0)
+  ok("successfully removed the breakpoint")
+});
--- a/devtools/client/debugger/new/test/mochitest/browser_dbg-editor-highlight.js
+++ b/devtools/client/debugger/new/test/mochitest/browser_dbg-editor-highlight.js
@@ -35,14 +35,14 @@ add_task(async function() {
   // Test jumping to a line in a source that exists but hasn't been
   // loaded yet.
   log(`Select an unloaded source`);
   selectSource(dbg, "simple1.js", 6);
 
   // Make sure the source is in the loading state, wait for it to be
   // fully loaded, and check the highlighted line.
   const simple1 = findSource(dbg, "simple1.js");
-  is(getSource(getState(), simple1.id).get("loadedState"), "loading");
+  is(getSource(getState(), simple1.id).loadedState, "loading");
 
   await waitForSelectedSource(dbg, "simple1.js");
   ok(getSource(getState(), simple1.id).text);
   assertHighlightLocation(dbg, "simple1.js", 6);
 });
--- a/devtools/client/debugger/new/test/mochitest/browser_dbg-navigation.js
+++ b/devtools/client/debugger/new/test/mochitest/browser_dbg-navigation.js
@@ -1,14 +1,14 @@
-/* Any copyright is dedicated to the Public Domain.
- * http://creativecommons.org/publicdomain/zero/1.0/ */
+/* 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/>. */
 
 function countSources(dbg) {
-  const sources = dbg.selectors.getSources(dbg.getState());
-  return sources.size;
+  return dbg.selectors.getSourceCount(dbg.getState());
 }
 
 const sources = [
   "simple1.js",
   "simple2.js",
   "simple3.js",
   "long.js",
   "scripts.html"
--- a/devtools/client/debugger/new/test/mochitest/browser_dbg-sourcemapped-scopes.js
+++ b/devtools/client/debugger/new/test/mochitest/browser_dbg-sourcemapped-scopes.js
@@ -152,17 +152,28 @@ add_task(async function() {
     ["anotherNamed", '"a-named"'],
     ["anotherNamed2", '"a-named2"'],
     ["anotherNamed3", '"a-named3"'],
     ["example", "(optimized away)"],
     ["optimizedOut", "(optimized away)"],
     "root()"
   ]);
 
-  await breakpointScopes(dbg, "babel-classes", { line: 12, column: 6 }, [
+  await breakpointScopes(dbg, "babel-classes", { line: 6, column: 6 }, [
+    "Class",
+    "Thing()",
+    "Function Body",
+    "Another()",
+    "one",
+    "Thing()",
+    "Module",
+    "root()"
+  ]);
+
+  await breakpointScopes(dbg, "babel-classes", { line: 16, column: 6 }, [
     "Function Body",
     ["three", "3"],
     ["two", "2"],
     "Class",
     "Another()",
     "Function Body",
     "Another()",
     ["one", "1"],
--- a/devtools/client/debugger/new/test/mochitest/browser_dbg-sourcemaps-bogus.js
+++ b/devtools/client/debugger/new/test/mochitest/browser_dbg-sourcemaps-bogus.js
@@ -4,25 +4,25 @@
 // Test that an error while loading a sourcemap does not break
 // debugging.
 requestLongerTimeout(2);
 
 add_task(async function() {
   // NOTE: the CORS call makes the test run times inconsistent
   const dbg = await initDebugger("doc-sourcemap-bogus.html");
   const {
-    selectors: { getSources },
+    selectors: { getSourceCount },
     getState
   } = dbg;
 
   await selectSource(dbg, "bogus-map.js");
 
   // We should still be able to set breakpoints and pause in the
   // generated source.
   await addBreakpoint(dbg, "bogus-map.js", 4);
   invokeInTab("runCode");
   await waitForPaused(dbg);
   assertPausedLocation(dbg);
 
   // Make sure that only the single generated source exists. The
   // sourcemap failed to download.
-  is(getSources(getState()).size, 1, "Only 1 source exists");
+  is(getSourceCount(getState()), 1, "Only 1 source exists");
 });
--- a/devtools/client/debugger/new/test/mochitest/browser_dbg-wasm-sourcemaps.js
+++ b/devtools/client/debugger/new/test/mochitest/browser_dbg-wasm-sourcemaps.js
@@ -1,10 +1,11 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/ */
+ requestLongerTimeout(2);
 
 /**
  * Test WebAssembly source maps
  */
 add_task(async function() {
   const dbg = await initDebugger("doc-wasm-sourcemaps.html");
 
   // NOTE: wait for page load -- attempt to fight the intermittent failure:
@@ -13,27 +14,30 @@ add_task(async function() {
 
   await waitForLoadedSources(dbg);
   await reload(dbg);
   await waitForPaused(dbg);
 
   await waitForLoadedSource(dbg, "doc-wasm-sourcemaps");
   assertPausedLocation(dbg);
 
-  await waitForSource(dbg, "wasm-sourcemaps/average.c");
-  await addBreakpoint(dbg, "wasm-sourcemaps/average.c", 12);
+  await waitForSource(dbg, "fib.c");
+
+  ok(true, "Original sources exist");
+  const mainSrc = findSource(dbg, "fib.c");
 
-  clickElement(dbg, "resume");
+  await selectSource(dbg, mainSrc);
+  await addBreakpoint(dbg, "fib.c", 10);
 
-  await waitForPaused(dbg);
-  await waitForSelectedSource(dbg, "average.c");
-  assertPausedLocation(dbg);
+  resume(dbg);
+
+  await waitForPaused(dbg, "fib.c");
 
   const frames = findAllElements(dbg, "frames");
   const firstFrameTitle = frames[0].querySelector(".title").textContent;
   is(firstFrameTitle, "(wasmcall)", "It shall be a wasm call");
   const firstFrameLocation = frames[0].querySelector(".location").textContent;
   is(
-    firstFrameLocation.includes("average.c"),
+    firstFrameLocation.includes("fib.c"),
     true,
-    "It shall be to avarage.c source"
+    "It shall be to fib.c source"
   );
 });
--- a/devtools/client/debugger/new/test/mochitest/examples/doc-wasm-sourcemaps.html
+++ b/devtools/client/debugger/new/test/mochitest/examples/doc-wasm-sourcemaps.html
@@ -5,54 +5,32 @@
 <html>
   <head>
     <meta charset="utf-8"/>
     <title>Wasm+sourcemaps</title>
     <script src="wasm-sourcemaps/utils.js"></script>
     <script>
 
     function test() {
-      // Create memory and populate int32 array with some data.
-      var buf = Module._malloc(16);
-      var arr = new Int32Array(Module['buffer'], buf, 4);
-      arr.set(new Int32Array([1, 2, 3, 4]));
-
-      var average = Module.ccall(
-        'average',
-        'i32',
-        ['*', 'u32'],
-        [buf, arr.length]
-      );
-      console.log(average);
+      const result = wasmInstance.exports.fib(5);
+      console.log(result);
     }
 
-    // WebAssembly module is part of the emscripten generated one,
-    // loading emscripten module via script tag.
-    var Module = {
-      wasmBinary: null,
-      postRun: [],
-    };
-    function loadWasm(emscriptenWrapper, wasmUrl, sourceMapUrl) {
+    var wasmInstance = null;
+    function loadWasm(wasmUrl, sourceMapUrl) {
       return fetch(wasmUrl).then(res => res.arrayBuffer()).then(buffer => {
         if (!sourceMapUrl) return buffer;
         return updateSourceMappingURLSection(buffer, sourceMapUrl);
-      }).then(buffer => {
-        return new Promise(resolve => {
-          Module.wasmBinary = buffer;
-          Module.postRun.push(resolve);
-          let script = document.createElement('script');
-          script.src = emscriptenWrapper;
-          document.head.appendChild(script);
-        });
+      }).then(buffer => WebAssembly.instantiate(buffer)).then(({instance}) => {
+        wasmInstance = instance;
       });
     }
 
-    loadWasm('wasm-sourcemaps/average.js',
-              'wasm-sourcemaps/average.wasm',
-              new URL('wasm-sourcemaps/average.wasm.map', document.location).href).then(() => {
+    loadWasm('wasm-sourcemaps/fib.wasm',
+              new URL('wasm-sourcemaps/fib.wasm.map', document.location).href).then(() => {
       debugger;
 
       test();
     });
   </script>
   </head>
 
   <body>
--- a/devtools/client/debugger/new/test/mochitest/examples/sourcemapped/fixtures/babel-classes/input.js
+++ b/devtools/client/debugger/new/test/mochitest/examples/sourcemapped/fixtures/babel-classes/input.js
@@ -1,17 +1,22 @@
 export default function root() {
   let one = 1;
 
-  class Thing {}
+  class Thing {
+    one() {
+      console.log("pause here");
+    }
+  }
 
   class Another {
     method() {
       let two = 2;
 
       const three = 3;
 
       console.log("pause here", Another, one, Thing, root);
     }
   }
 
   new Another().method();
+  new Thing().one();
 }
--- a/devtools/client/debugger/new/test/mochitest/examples/sourcemapped/fixtures/babel-classes/output.js
+++ b/devtools/client/debugger/new/test/mochitest/examples/sourcemapped/fixtures/babel-classes/output.js
@@ -73,19 +73,30 @@ Object.defineProperty(__webpack_exports_
 /* harmony export (immutable) */ __webpack_exports__["default"] = root;
 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function root() {
   var one = 1;
 
-  var Thing = function Thing() {
-    _classCallCheck(this, Thing);
-  };
+  var Thing = function () {
+    function Thing() {
+      _classCallCheck(this, Thing);
+    }
+
+    _createClass(Thing, [{
+      key: "one",
+      value: function one() {
+        console.log("pause here");
+      }
+    }]);
+
+    return Thing;
+  }();
 
   var Another = function () {
     function Another() {
       _classCallCheck(this, Another);
     }
 
     _createClass(Another, [{
       key: "method",
@@ -97,13 +108,14 @@ function root() {
         console.log("pause here", Another, one, Thing, root);
       }
     }]);
 
     return Another;
   }();
 
   new Another().method();
+  new Thing().one();
 }
 
 /***/ })
 /******/ ])["default"];
 //# sourceMappingURL=output.js.map
\ No newline at end of file
--- a/devtools/client/debugger/new/test/mochitest/examples/sourcemapped/fixtures/babel-classes/output.js.map
+++ b/devtools/client/debugger/new/test/mochitest/examples/sourcemapped/fixtures/babel-classes/output.js.map
@@ -1,1 +1,1 @@
-{"version":3,"sources":["webpack:///webpack/bootstrap 506487d51ad6252294dd","webpack:///./fixtures/babel-classes/input.js"],"names":["root","one","Thing","Another","two","three","console","log","method"],"mappings":";;AAAA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAK;AACL;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;AAEA;AACA;;;;;;;;;;;;;;AC7De,SAASA,IAAT,GAAgB;AAC7B,MAAIC,MAAM,CAAV;;AAD6B,MAGvBC,KAHuB;AAAA;AAAA;;AAAA,MAKvBC,OALuB;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,+BAMlB;AACP,YAAIC,MAAM,CAAV;;AAEA,YAAMC,QAAQ,CAAd;;AAEAC,gBAAQC,GAAR,CAAY,YAAZ,EAA0BJ,OAA1B,EAAmCF,GAAnC,EAAwCC,KAAxC,EAA+CF,IAA/C;AACD;AAZ0B;;AAAA;AAAA;;AAe7B,MAAIG,OAAJ,GAAcK,MAAd;AACD,C","file":"fixtures/babel-classes/output.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 506487d51ad6252294dd","export default function root() {\n  let one = 1;\n\n  class Thing {}\n\n  class Another {\n    method() {\n      let two = 2;\n\n      const three = 3;\n\n      console.log(\"pause here\", Another, one, Thing, root);\n    }\n  }\n\n  new Another().method();\n}\n\n\n\n// WEBPACK FOOTER //\n// ./fixtures/babel-classes/input.js"],"sourceRoot":""}
\ No newline at end of file
+{"version":3,"sources":["webpack:///webpack/bootstrap f822bade65c0f7424528","webpack:///./fixtures/babel-classes/input.js"],"names":["root","one","Thing","console","log","Another","two","three","method"],"mappings":";;AAAA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAK;AACL;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;AAEA;AACA;;;;;;;;;;;;;;AC7De,SAASA,IAAT,GAAgB;AAC7B,MAAIC,MAAM,CAAV;;AAD6B,MAGvBC,KAHuB;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,4BAIrB;AACJC,gBAAQC,GAAR,CAAY,YAAZ;AACD;AAN0B;;AAAA;AAAA;;AAAA,MASvBC,OATuB;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,+BAUlB;AACP,YAAIC,MAAM,CAAV;;AAEA,YAAMC,QAAQ,CAAd;;AAEAJ,gBAAQC,GAAR,CAAY,YAAZ,EAA0BC,OAA1B,EAAmCJ,GAAnC,EAAwCC,KAAxC,EAA+CF,IAA/C;AACD;AAhB0B;;AAAA;AAAA;;AAmB7B,MAAIK,OAAJ,GAAcG,MAAd;AACA,MAAIN,KAAJ,GAAYD,GAAZ;AACD,C","file":"fixtures/babel-classes/output.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap f822bade65c0f7424528","export default function root() {\n  let one = 1;\n\n  class Thing {\n    one() {\n      console.log(\"pause here\");\n    }\n  }\n\n  class Another {\n    method() {\n      let two = 2;\n\n      const three = 3;\n\n      console.log(\"pause here\", Another, one, Thing, root);\n    }\n  }\n\n  new Another().method();\n  new Thing().one();\n}\n\n\n\n// WEBPACK FOOTER //\n// ./fixtures/babel-classes/input.js"],"sourceRoot":""}
\ No newline at end of file
--- a/devtools/client/debugger/new/test/mochitest/examples/sourcemapped/fixtures/typescript-classes/output.js.map
+++ b/devtools/client/debugger/new/test/mochitest/examples/sourcemapped/fixtures/typescript-classes/output.js.map
@@ -1,1 +1,1 @@
-{"version":3,"sources":["webpack:///webpack/bootstrap 8a81270f7a42e5d76341","webpack:///./fixtures/typescript-classes/src/mod.ts","webpack:///./fixtures/typescript-classes/input.ts"],"names":[],"mappings":";;AAAA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAK;AACL;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;AAEA;AACA;;;;;;;;;;AC5DA,0BAAiC,IAA0B;IACzD,OAAO,mBAAmB,MAAM;QAC9B,OAAY,MAAM,CAAC;IACrB,CAAC,CAAC;AACJ,CAAC;AAJD,4CAIC;AAED,iBAA+B,CAAC;AAAhC,yBAAgC;;;;;;;;;ACPhC,gFAAgF;AAChF,qCAAqC;;;;;;;;;;;;;;;;;;AAErC,sCAAqD;AAErD,gCAAmC;AAKnC;IAHA;QAIE,UAAK,GAAG,KAAK,CAAC;IAChB,CAAC;IAFY,YAAY;QAHxB,yBAAgB,CAAC;YAChB,QAAQ,EAAE,UAAU;SACrB,CAAC;OACW,YAAY,CAExB;IAAD,mBAAC;CAAA;AAFY,oCAAY;AAIzB,IAAM,EAAE,GAAG,aAAG;IACZ,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AACtB,CAAC,CAAC;AACF,EAAE,CAAC,KAAK,CAAC,CAAC;AAEV,mEAAmE;AACnE,8DAA8D;AAC9D;IAAA;QACE,UAAK,GAAG,KAAK,CAAC;IAChB,CAAC;IAAD,oBAAC;AAAD,CAAC;AAFY,sCAAa;AAI1B;IAAA;QACE,SAAI,GAAG,CAAC,CAAC;IACX,CAAC;IAAD,mBAAC;AAAD,CAAC;AAED,IAAM,eAAe;IAAG;QACtB,SAAI,GAAG,CAAC,CAAC;IACX,CAAC;IAAD,UAAC;AAAD,CAAC,IAAC;AAEF;IAAsB,2BAAY;IAAlC;QAAA,qEAEC;QADC,UAAI,GAAG,CAAC,CAAC;;IACX,CAAC;IAAD,cAAC;AAAD,CAAC,CAFqB,YAAY,GAEjC;AAED,IAAI,MAAM;IAAyB,2BAAY;IAAlC;QAAA,qEAEZ;QADC,UAAI,GAAG,CAAC,CAAC;;IACX,CAAC;IAAD,cAAC;AAAD,CAAC,CAFkC,YAAY,EAE9C,CAAC;AAEF,EAAE,CAAC;AAEH;IACE,2EAA2E;IAC3E,0EAA0E;IAC1E,kEAAkE;IAClE,IAAI,CAAC,EAAE,CAAC,CAAC;IAET,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;AAC5B,CAAC;AAPD,+BAOC","file":"fixtures/typescript-classes/output.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 1);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 8a81270f7a42e5d76341","\nexport function decoratorFactory(opts: { selector: string }) {\n  return function decorator(target) {\n    return <any>target;\n  };\n}\n\nexport default function def() {}\n\n\n\n// WEBPACK FOOTER //\n// ./fixtures/typescript-classes/src/mod.ts","// This file essentially reproduces an example Angular component to map testing,\n// among other typescript edge cases.\n\nimport def, { decoratorFactory } from './src/mod.ts';\n\nimport * as ns from './src/mod.ts';\n\n@decoratorFactory({\n  selector: 'app-root',\n})\nexport class AppComponent {\n  title = 'app';\n}\n\nconst fn = arg => {\n  console.log(\"here\");\n};\nfn(\"arg\");\n\n// Un-decorated exported classes present a mapping challege because\n// the class name is mapped to an unhelpful export assignment.\nexport class ExportedOther {\n  title = 'app';\n}\n\nclass AnotherThing {\n  prop = 4;\n}\n\nconst ExpressionClass = class Foo {\n  prop = 4;\n};\n\nclass SubDecl extends AnotherThing {\n  prop = 4;\n}\n\nlet SubVar = class SubExpr extends AnotherThing {\n  prop = 4;\n};\n\nns;\n\nexport default function(){\n  // This file is specifically for testing the mappings of classes and things\n  // above, which means we don't want to include _other_ references to then.\n  // To avoid having them be optimized out, we include a no-op eval.\n  eval(\"\");\n\n  console.log(\"pause here\");\n}\n\n\n\n// WEBPACK FOOTER //\n// ./fixtures/typescript-classes/input.ts"],"sourceRoot":""}
\ No newline at end of file
+{"version":3,"sources":["webpack:///webpack/bootstrap 0112384f4b82e20507d8","webpack:///./fixtures/typescript-classes/src/mod.ts","webpack:///./fixtures/typescript-classes/input.ts"],"names":[],"mappings":";;AAAA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAK;AACL;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;AAEA;AACA;;;;;;;;;;AC5DA,0BAAiC,IAA0B;IACzD,OAAO,mBAAmB,MAAM;QAC9B,OAAY,MAAM,CAAC;IACrB,CAAC,CAAC;AACJ,CAAC;AAJD,4CAIC;AAED,iBAA+B,CAAC;AAAhC,yBAAgC;;;;;;;;;ACPhC,gFAAgF;AAChF,qCAAqC;;;;;;;;;;;;;;;;;;AAErC,sCAAqD;AAErD,gCAAmC;AAKnC;IAHA;QAIE,UAAK,GAAG,KAAK,CAAC;IAChB,CAAC;IAFY,YAAY;QAHxB,yBAAgB,CAAC;YAChB,QAAQ,EAAE,UAAU;SACrB,CAAC;OACW,YAAY,CAExB;IAAD,mBAAC;CAAA;AAFY,oCAAY;AAIzB,IAAM,EAAE,GAAG,aAAG;IACZ,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AACtB,CAAC,CAAC;AACF,EAAE,CAAC,KAAK,CAAC,CAAC;AAEV,mEAAmE;AACnE,8DAA8D;AAC9D;IAAA;QACE,UAAK,GAAG,KAAK,CAAC;IAChB,CAAC;IAAD,oBAAC;AAAD,CAAC;AAFY,sCAAa;AAI1B;IAAA;QACE,SAAI,GAAG,CAAC,CAAC;IACX,CAAC;IAAD,mBAAC;AAAD,CAAC;AAED,IAAM,eAAe;IAAG;QACtB,SAAI,GAAG,CAAC,CAAC;IACX,CAAC;IAAD,UAAC;AAAD,CAAC,IAAC;AAEF;IAAsB,2BAAY;IAAlC;QAAA,qEAEC;QADC,UAAI,GAAG,CAAC,CAAC;;IACX,CAAC;IAAD,cAAC;AAAD,CAAC,CAFqB,YAAY,GAEjC;AAED,IAAI,MAAM;IAAyB,2BAAY;IAAlC;QAAA,qEAEZ;QADC,UAAI,GAAG,CAAC,CAAC;;IACX,CAAC;IAAD,cAAC;AAAD,CAAC,CAFkC,YAAY,EAE9C,CAAC;AAEF,EAAE,CAAC;AAEH;IACE,2EAA2E;IAC3E,0EAA0E;IAC1E,kEAAkE;IAClE,IAAI,CAAC,EAAE,CAAC,CAAC;IAET,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;AAC5B,CAAC;AAPD,+BAOC","file":"fixtures/typescript-classes/output.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 1);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 0112384f4b82e20507d8","\nexport function decoratorFactory(opts: { selector: string }) {\n  return function decorator(target) {\n    return <any>target;\n  };\n}\n\nexport default function def() {}\n\n\n\n// WEBPACK FOOTER //\n// ./fixtures/typescript-classes/src/mod.ts","// This file essentially reproduces an example Angular component to map testing,\n// among other typescript edge cases.\n\nimport def, { decoratorFactory } from './src/mod.ts';\n\nimport * as ns from './src/mod.ts';\n\n@decoratorFactory({\n  selector: 'app-root',\n})\nexport class AppComponent {\n  title = 'app';\n}\n\nconst fn = arg => {\n  console.log(\"here\");\n};\nfn(\"arg\");\n\n// Un-decorated exported classes present a mapping challege because\n// the class name is mapped to an unhelpful export assignment.\nexport class ExportedOther {\n  title = 'app';\n}\n\nclass AnotherThing {\n  prop = 4;\n}\n\nconst ExpressionClass = class Foo {\n  prop = 4;\n};\n\nclass SubDecl extends AnotherThing {\n  prop = 4;\n}\n\nlet SubVar = class SubExpr extends AnotherThing {\n  prop = 4;\n};\n\nns;\n\nexport default function(){\n  // This file is specifically for testing the mappings of classes and things\n  // above, which means we don't want to include _other_ references to then.\n  // To avoid having them be optimized out, we include a no-op eval.\n  eval(\"\");\n\n  console.log(\"pause here\");\n}\n\n\n\n// WEBPACK FOOTER //\n// ./fixtures/typescript-classes/input.ts"],"sourceRoot":""}
\ No newline at end of file
--- a/devtools/client/debugger/new/test/mochitest/examples/sourcemapped/polyfill-bundle.js
+++ b/devtools/client/debugger/new/test/mochitest/examples/sourcemapped/polyfill-bundle.js
@@ -63,20 +63,20 @@
 /******/ 	return __webpack_require__(__webpack_require__.s = 125);
 /******/ })
 /************************************************************************/
 /******/ ([
 /* 0 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var global = __webpack_require__(2);
-var core = __webpack_require__(21);
+var core = __webpack_require__(18);
 var hide = __webpack_require__(11);
 var redefine = __webpack_require__(12);
-var ctx = __webpack_require__(18);
+var ctx = __webpack_require__(19);
 var PROTOTYPE = 'prototype';
 
 var $export = function (type, name, source) {
   var IS_FORCED = type & $export.F;
   var IS_GLOBAL = type & $export.G;
   var IS_STATIC = type & $export.S;
   var IS_PROTO = type & $export.P;
   var IS_BIND = type & $export.B;
@@ -157,17 +157,17 @@ module.exports = function (it) {
 };
 
 
 /***/ }),
 /* 5 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var store = __webpack_require__(49)('wks');
-var uid = __webpack_require__(32);
+var uid = __webpack_require__(33);
 var Symbol = __webpack_require__(2).Symbol;
 var USE_SYMBOL = typeof Symbol == 'function';
 
 var $exports = module.exports = function (name) {
   return store[name] || (store[name] =
     USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
 };
 
@@ -239,38 +239,38 @@ module.exports = function (it) {
 };
 
 
 /***/ }),
 /* 11 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var dP = __webpack_require__(7);
-var createDesc = __webpack_require__(31);
+var createDesc = __webpack_require__(32);
 module.exports = __webpack_require__(6) ? function (object, key, value) {
   return dP.f(object, key, createDesc(1, value));
 } : function (object, key, value) {
   object[key] = value;
   return object;
 };
 
 
 /***/ }),
 /* 12 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var global = __webpack_require__(2);
 var hide = __webpack_require__(11);
 var has = __webpack_require__(14);
-var SRC = __webpack_require__(32)('src');
+var SRC = __webpack_require__(33)('src');
 var TO_STRING = 'toString';
 var $toString = Function[TO_STRING];
 var TPL = ('' + $toString).split(TO_STRING);
 
-__webpack_require__(21).inspectSource = function (it) {
+__webpack_require__(18).inspectSource = function (it) {
   return $toString.call(it);
 };
 
 (module.exports = function (O, key, val, safe) {
   var isFunction = typeof val == 'function';
   if (isFunction) has(val, 'name') || hide(val, 'name', key);
   if (O[key] === val) return;
   if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
@@ -337,17 +337,17 @@ module.exports = function (it) {
 };
 
 
 /***/ }),
 /* 16 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var pIE = __webpack_require__(47);
-var createDesc = __webpack_require__(31);
+var createDesc = __webpack_require__(32);
 var toIObject = __webpack_require__(15);
 var toPrimitive = __webpack_require__(22);
 var has = __webpack_require__(14);
 var IE8_DOM_DEFINE = __webpack_require__(91);
 var gOPD = Object.getOwnPropertyDescriptor;
 
 exports.f = __webpack_require__(6) ? gOPD : function getOwnPropertyDescriptor(O, P) {
   O = toIObject(O);
@@ -361,30 +361,38 @@ exports.f = __webpack_require__(6) ? gOP
 
 /***/ }),
 /* 17 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
 var has = __webpack_require__(14);
 var toObject = __webpack_require__(9);
-var IE_PROTO = __webpack_require__(65)('IE_PROTO');
+var IE_PROTO = __webpack_require__(66)('IE_PROTO');
 var ObjectProto = Object.prototype;
 
 module.exports = Object.getPrototypeOf || function (O) {
   O = toObject(O);
   if (has(O, IE_PROTO)) return O[IE_PROTO];
   if (typeof O.constructor == 'function' && O instanceof O.constructor) {
     return O.constructor.prototype;
   } return O instanceof Object ? ObjectProto : null;
 };
 
 
 /***/ }),
 /* 18 */
+/***/ (function(module, exports) {
+
+var core = module.exports = { version: '2.5.7' };
+if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
+
+
+/***/ }),
+/* 19 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // optional / simple context binding
 var aFunction = __webpack_require__(10);
 module.exports = function (fn, that, length) {
   aFunction(fn);
   if (that === undefined) return fn;
   switch (length) {
@@ -400,51 +408,43 @@ module.exports = function (fn, that, len
   }
   return function (/* ...args */) {
     return fn.apply(that, arguments);
   };
 };
 
 
 /***/ }),
-/* 19 */
+/* 20 */
 /***/ (function(module, exports) {
 
 var toString = {}.toString;
 
 module.exports = function (it) {
   return toString.call(it).slice(8, -1);
 };
 
 
 /***/ }),
-/* 20 */
+/* 21 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var fails = __webpack_require__(3);
 
 module.exports = function (method, arg) {
   return !!method && fails(function () {
     // eslint-disable-next-line no-useless-call
     arg ? method.call(null, function () { /* empty */ }, 1) : method.call(null);
   });
 };
 
 
 /***/ }),
-/* 21 */
-/***/ (function(module, exports) {
-
-var core = module.exports = { version: '2.5.5' };
-if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
-
-
-/***/ }),
 /* 22 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 7.1.1 ToPrimitive(input [, PreferredType])
 var isObject = __webpack_require__(4);
 // instead of the ES6 spec version, we didn't implement @@toPrimitive case
 // and the second argument - flag - preferred type is a string
 module.exports = function (it, S) {
@@ -481,17 +481,17 @@ module.exports = function (it) {
 
 
 /***/ }),
 /* 25 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // most Object methods by ES6 should accept primitives
 var $export = __webpack_require__(0);
-var core = __webpack_require__(21);
+var core = __webpack_require__(18);
 var fails = __webpack_require__(3);
 module.exports = function (KEY, exec) {
   var fn = (core.Object || {})[KEY] || Object[KEY];
   var exp = {};
   exp[KEY] = exec(fn);
   $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp);
 };
 
@@ -502,21 +502,21 @@ module.exports = function (KEY, exec) {
 
 // 0 -> Array#forEach
 // 1 -> Array#map
 // 2 -> Array#filter
 // 3 -> Array#some
 // 4 -> Array#every
 // 5 -> Array#find
 // 6 -> Array#findIndex
-var ctx = __webpack_require__(18);
+var ctx = __webpack_require__(19);
 var IObject = __webpack_require__(46);
 var toObject = __webpack_require__(9);
 var toLength = __webpack_require__(8);
-var asc = __webpack_require__(82);
+var asc = __webpack_require__(83);
 module.exports = function (TYPE, $create) {
   var IS_MAP = TYPE == 1;
   var IS_FILTER = TYPE == 2;
   var IS_SOME = TYPE == 3;
   var IS_EVERY = TYPE == 4;
   var IS_FIND_INDEX = TYPE == 6;
   var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
   var create = $create || asc;
@@ -548,51 +548,51 @@ module.exports = function (TYPE, $create
 
 /***/ }),
 /* 27 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 if (__webpack_require__(6)) {
-  var LIBRARY = __webpack_require__(33);
+  var LIBRARY = __webpack_require__(30);
   var global = __webpack_require__(2);
   var fails = __webpack_require__(3);
   var $export = __webpack_require__(0);
-  var $typed = __webpack_require__(59);
-  var $buffer = __webpack_require__(88);
-  var ctx = __webpack_require__(18);
+  var $typed = __webpack_require__(60);
+  var $buffer = __webpack_require__(89);
+  var ctx = __webpack_require__(19);
   var anInstance = __webpack_require__(39);
-  var propertyDesc = __webpack_require__(31);
+  var propertyDesc = __webpack_require__(32);
   var hide = __webpack_require__(11);
   var redefineAll = __webpack_require__(41);
   var toInteger = __webpack_require__(24);
   var toLength = __webpack_require__(8);
   var toIndex = __webpack_require__(117);
   var toAbsoluteIndex = __webpack_require__(35);
   var toPrimitive = __webpack_require__(22);
   var has = __webpack_require__(14);
   var classof = __webpack_require__(48);
   var isObject = __webpack_require__(4);
   var toObject = __webpack_require__(9);
-  var isArrayIter = __webpack_require__(79);
+  var isArrayIter = __webpack_require__(80);
   var create = __webpack_require__(36);
   var getPrototypeOf = __webpack_require__(17);
   var gOPN = __webpack_require__(37).f;
-  var getIterFn = __webpack_require__(81);
-  var uid = __webpack_require__(32);
+  var getIterFn = __webpack_require__(82);
+  var uid = __webpack_require__(33);
   var wks = __webpack_require__(5);
   var createArrayMethod = __webpack_require__(26);
   var createArrayIncludes = __webpack_require__(50);
   var speciesConstructor = __webpack_require__(57);
-  var ArrayIterators = __webpack_require__(84);
+  var ArrayIterators = __webpack_require__(85);
   var Iterators = __webpack_require__(44);
   var $iterDetect = __webpack_require__(54);
   var setSpecies = __webpack_require__(38);
-  var arrayFill = __webpack_require__(83);
+  var arrayFill = __webpack_require__(84);
   var arrayCopyWithin = __webpack_require__(107);
   var $DP = __webpack_require__(7);
   var $GOPD = __webpack_require__(16);
   var dP = $DP.f;
   var gOPD = $GOPD.f;
   var RangeError = global.RangeError;
   var TypeError = global.TypeError;
   var Uint8Array = global.Uint8Array;
@@ -1089,17 +1089,17 @@ module.exports = {
   exp: exp
 };
 
 
 /***/ }),
 /* 29 */
 /***/ (function(module, exports, __webpack_require__) {
 
-var META = __webpack_require__(32)('meta');
+var META = __webpack_require__(33)('meta');
 var isObject = __webpack_require__(4);
 var has = __webpack_require__(14);
 var setDesc = __webpack_require__(7).f;
 var id = 0;
 var isExtensible = Object.isExtensible || function () {
   return true;
 };
 var FREEZE = !__webpack_require__(3)(function () {
@@ -1146,66 +1146,66 @@ var meta = module.exports = {
   fastKey: fastKey,
   getWeak: getWeak,
   onFreeze: onFreeze
 };
 
 
 /***/ }),
 /* 30 */
+/***/ (function(module, exports) {
+
+module.exports = false;
+
+
+/***/ }),
+/* 31 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 22.1.3.31 Array.prototype[@@unscopables]
 var UNSCOPABLES = __webpack_require__(5)('unscopables');
 var ArrayProto = Array.prototype;
 if (ArrayProto[UNSCOPABLES] == undefined) __webpack_require__(11)(ArrayProto, UNSCOPABLES, {});
 module.exports = function (key) {
   ArrayProto[UNSCOPABLES][key] = true;
 };
 
 
 /***/ }),
-/* 31 */
+/* 32 */
 /***/ (function(module, exports) {
 
 module.exports = function (bitmap, value) {
   return {
     enumerable: !(bitmap & 1),
     configurable: !(bitmap & 2),
     writable: !(bitmap & 4),
     value: value
   };
 };
 
 
 /***/ }),
-/* 32 */
+/* 33 */
 /***/ (function(module, exports) {
 
 var id = 0;
 var px = Math.random();
 module.exports = function (key) {
   return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
 };
 
 
 /***/ }),
-/* 33 */
-/***/ (function(module, exports) {
-
-module.exports = false;
-
-
-/***/ }),
 /* 34 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 19.1.2.14 / 15.2.3.14 Object.keys(O)
 var $keys = __webpack_require__(93);
-var enumBugKeys = __webpack_require__(66);
+var enumBugKeys = __webpack_require__(67);
 
 module.exports = Object.keys || function keys(O) {
   return $keys(O, enumBugKeys);
 };
 
 
 /***/ }),
 /* 35 */
@@ -1222,31 +1222,31 @@ module.exports = function (index, length
 
 /***/ }),
 /* 36 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
 var anObject = __webpack_require__(1);
 var dPs = __webpack_require__(94);
-var enumBugKeys = __webpack_require__(66);
-var IE_PROTO = __webpack_require__(65)('IE_PROTO');
+var enumBugKeys = __webpack_require__(67);
+var IE_PROTO = __webpack_require__(66)('IE_PROTO');
 var Empty = function () { /* empty */ };
 var PROTOTYPE = 'prototype';
 
 // Create object with fake `null` prototype: use iframe Object with cleared prototype
 var createDict = function () {
   // Thrash, waste and sodomy: IE GC bug
-  var iframe = __webpack_require__(63)('iframe');
+  var iframe = __webpack_require__(64)('iframe');
   var i = enumBugKeys.length;
   var lt = '<';
   var gt = '>';
   var iframeDocument;
   iframe.style.display = 'none';
-  __webpack_require__(67).appendChild(iframe);
+  __webpack_require__(68).appendChild(iframe);
   iframe.src = 'javascript:'; // eslint-disable-line no-script-url
   // createDict = iframe.contentWindow.Object;
   // html.removeChild(iframe);
   iframeDocument = iframe.contentWindow.document;
   iframeDocument.open();
   iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
   iframeDocument.close();
   createDict = iframeDocument.F;
@@ -1268,17 +1268,17 @@ module.exports = Object.create || functi
 
 
 /***/ }),
 /* 37 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
 var $keys = __webpack_require__(93);
-var hiddenKeys = __webpack_require__(66).concat('length', 'prototype');
+var hiddenKeys = __webpack_require__(67).concat('length', 'prototype');
 
 exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
   return $keys(O, hiddenKeys);
 };
 
 
 /***/ }),
 /* 38 */
@@ -1310,22 +1310,22 @@ module.exports = function (it, Construct
   } return it;
 };
 
 
 /***/ }),
 /* 40 */
 /***/ (function(module, exports, __webpack_require__) {
 
-var ctx = __webpack_require__(18);
+var ctx = __webpack_require__(19);
 var call = __webpack_require__(105);
-var isArrayIter = __webpack_require__(79);
+var isArrayIter = __webpack_require__(80);
 var anObject = __webpack_require__(1);
 var toLength = __webpack_require__(8);
-var getIterFn = __webpack_require__(81);
+var getIterFn = __webpack_require__(82);
 var BREAK = {};
 var RETURN = {};
 var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
   var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable);
   var f = ctx(fn, that, entries ? 2 : 1);
   var index = 0;
   var length, step, iterator, result;
   if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
@@ -1368,17 +1368,17 @@ module.exports = function (it, tag, stat
 
 /***/ }),
 /* 43 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var $export = __webpack_require__(0);
 var defined = __webpack_require__(23);
 var fails = __webpack_require__(3);
-var spaces = __webpack_require__(69);
+var spaces = __webpack_require__(70);
 var space = '[' + spaces + ']';
 var non = '\u200b\u0085';
 var ltrim = RegExp('^' + space + space + '*');
 var rtrim = RegExp(space + space + '*$');
 
 var exporter = function (KEY, exec, ALIAS) {
   var exp = {};
   var FORCE = fails(function () {
@@ -1420,17 +1420,17 @@ module.exports = function (it, TYPE) {
 };
 
 
 /***/ }),
 /* 46 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // fallback for non-array-like ES3 and non-enumerable old V8 strings
-var cof = __webpack_require__(19);
+var cof = __webpack_require__(20);
 // eslint-disable-next-line no-prototype-builtins
 module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
   return cof(it) == 'String' ? it.split('') : Object(it);
 };
 
 
 /***/ }),
 /* 47 */
@@ -1439,17 +1439,17 @@ module.exports = Object('z').propertyIsE
 exports.f = {}.propertyIsEnumerable;
 
 
 /***/ }),
 /* 48 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // getting tag from 19.1.3.6 Object.prototype.toString()
-var cof = __webpack_require__(19);
+var cof = __webpack_require__(20);
 var TAG = __webpack_require__(5)('toStringTag');
 // ES3 wrong here
 var ARG = cof(function () { return arguments; }()) == 'Arguments';
 
 // fallback for IE11 Script Access Denied error
 var tryGet = function (it, key) {
   try {
     return it[key];
@@ -1467,22 +1467,28 @@ module.exports = function (it) {
     : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
 };
 
 
 /***/ }),
 /* 49 */
 /***/ (function(module, exports, __webpack_require__) {
 
+var core = __webpack_require__(18);
 var global = __webpack_require__(2);
 var SHARED = '__core-js_shared__';
 var store = global[SHARED] || (global[SHARED] = {});
-module.exports = function (key) {
-  return store[key] || (store[key] = {});
-};
+
+(module.exports = function (key, value) {
+  return store[key] || (store[key] = value !== undefined ? value : {});
+})('versions', []).push({
+  version: core.version,
+  mode: __webpack_require__(30) ? 'pure' : 'global',
+  copyright: '© 2018 Denis Pushkarev (zloirock.ru)'
+});
 
 
 /***/ }),
 /* 50 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // false -> Array#indexOf
 // true  -> Array#includes
@@ -1516,29 +1522,29 @@ module.exports = function (IS_INCLUDES) 
 exports.f = Object.getOwnPropertySymbols;
 
 
 /***/ }),
 /* 52 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 7.2.2 IsArray(argument)
-var cof = __webpack_require__(19);
+var cof = __webpack_require__(20);
 module.exports = Array.isArray || function isArray(arg) {
   return cof(arg) == 'Array';
 };
 
 
 /***/ }),
 /* 53 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 7.2.8 IsRegExp(argument)
 var isObject = __webpack_require__(4);
-var cof = __webpack_require__(19);
+var cof = __webpack_require__(20);
 var MATCH = __webpack_require__(5)('match');
 module.exports = function (it) {
   var isRegExp;
   return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp');
 };
 
 
 /***/ }),
@@ -1638,30 +1644,40 @@ module.exports = function (O, D) {
   return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
 };
 
 
 /***/ }),
 /* 58 */
 /***/ (function(module, exports, __webpack_require__) {
 
+var global = __webpack_require__(2);
+var navigator = global.navigator;
+
+module.exports = navigator && navigator.userAgent || '';
+
+
+/***/ }),
+/* 59 */
+/***/ (function(module, exports, __webpack_require__) {
+
 "use strict";
 
 var global = __webpack_require__(2);
 var $export = __webpack_require__(0);
 var redefine = __webpack_require__(12);
 var redefineAll = __webpack_require__(41);
 var meta = __webpack_require__(29);
 var forOf = __webpack_require__(40);
 var anInstance = __webpack_require__(39);
 var isObject = __webpack_require__(4);
 var fails = __webpack_require__(3);
 var $iterDetect = __webpack_require__(54);
 var setToStringTag = __webpack_require__(42);
-var inheritIfRequired = __webpack_require__(70);
+var inheritIfRequired = __webpack_require__(71);
 
 module.exports = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {
   var Base = global[NAME];
   var C = Base;
   var ADDER = IS_MAP ? 'set' : 'add';
   var proto = C && C.prototype;
   var O = {};
   var fixMethod = function (KEY) {
@@ -1727,22 +1743,22 @@ module.exports = function (NAME, wrapper
 
   if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);
 
   return C;
 };
 
 
 /***/ }),
-/* 59 */
+/* 60 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var global = __webpack_require__(2);
 var hide = __webpack_require__(11);
-var uid = __webpack_require__(32);
+var uid = __webpack_require__(33);
 var TYPED = uid('typed_array');
 var VIEW = uid('view');
 var ABV = !!(global.ArrayBuffer && global.DataView);
 var CONSTR = ABV;
 var i = 0;
 var l = 9;
 var Typed;
 
@@ -1761,33 +1777,33 @@ module.exports = {
   ABV: ABV,
   CONSTR: CONSTR,
   TYPED: TYPED,
   VIEW: VIEW
 };
 
 
 /***/ }),
-/* 60 */
+/* 61 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 // Forced replacement prototype accessors methods
-module.exports = __webpack_require__(33) || !__webpack_require__(3)(function () {
+module.exports = __webpack_require__(30) || !__webpack_require__(3)(function () {
   var K = Math.random();
   // In FF throws only define methods
   // eslint-disable-next-line no-undef, no-useless-call
   __defineSetter__.call(null, K, function () { /* empty */ });
   delete __webpack_require__(2)[K];
 });
 
 
 /***/ }),
-/* 61 */
+/* 62 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 // https://tc39.github.io/proposal-setmap-offrom/
 var $export = __webpack_require__(0);
 
 module.exports = function (COLLECTION) {
@@ -1796,25 +1812,25 @@ module.exports = function (COLLECTION) {
     var A = new Array(length);
     while (length--) A[length] = arguments[length];
     return new this(A);
   } });
 };
 
 
 /***/ }),
-/* 62 */
+/* 63 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 // https://tc39.github.io/proposal-setmap-offrom/
 var $export = __webpack_require__(0);
 var aFunction = __webpack_require__(10);
-var ctx = __webpack_require__(18);
+var ctx = __webpack_require__(19);
 var forOf = __webpack_require__(40);
 
 module.exports = function (COLLECTION) {
   $export($export.S, COLLECTION, { from: function from(source /* , mapFn, thisArg */) {
     var mapFn = arguments[1];
     var mapping, A, n, cb;
     aFunction(this);
     mapping = mapFn !== undefined;
@@ -1831,128 +1847,128 @@ module.exports = function (COLLECTION) {
       forOf(source, false, A.push, A);
     }
     return new this(A);
   } });
 };
 
 
 /***/ }),
-/* 63 */
+/* 64 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var isObject = __webpack_require__(4);
 var document = __webpack_require__(2).document;
 // typeof document.createElement is 'object' in old IE
 var is = isObject(document) && isObject(document.createElement);
 module.exports = function (it) {
   return is ? document.createElement(it) : {};
 };
 
 
 /***/ }),
-/* 64 */
+/* 65 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var global = __webpack_require__(2);
-var core = __webpack_require__(21);
-var LIBRARY = __webpack_require__(33);
+var core = __webpack_require__(18);
+var LIBRARY = __webpack_require__(30);
 var wksExt = __webpack_require__(92);
 var defineProperty = __webpack_require__(7).f;
 module.exports = function (name) {
   var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});
   if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: wksExt.f(name) });
 };
 
 
 /***/ }),
-/* 65 */
+/* 66 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var shared = __webpack_require__(49)('keys');
-var uid = __webpack_require__(32);
+var uid = __webpack_require__(33);
 module.exports = function (key) {
   return shared[key] || (shared[key] = uid(key));
 };
 
 
 /***/ }),
-/* 66 */
+/* 67 */
 /***/ (function(module, exports) {
 
 // IE 8- don't enum bug keys
 module.exports = (
   'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
 ).split(',');
 
 
 /***/ }),
-/* 67 */
+/* 68 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var document = __webpack_require__(2).document;
 module.exports = document && document.documentElement;
 
 
 /***/ }),
-/* 68 */
+/* 69 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // Works with __proto__ only. Old v8 can't work with null proto objects.
 /* eslint-disable no-proto */
 var isObject = __webpack_require__(4);
 var anObject = __webpack_require__(1);
 var check = function (O, proto) {
   anObject(O);
   if (!isObject(proto) && proto !== null) throw TypeError(proto + ": can't set as prototype!");
 };
 module.exports = {
   set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
     function (test, buggy, set) {
       try {
-        set = __webpack_require__(18)(Function.call, __webpack_require__(16).f(Object.prototype, '__proto__').set, 2);
+        set = __webpack_require__(19)(Function.call, __webpack_require__(16).f(Object.prototype, '__proto__').set, 2);
         set(test, []);
         buggy = !(test instanceof Array);
       } catch (e) { buggy = true; }
       return function setPrototypeOf(O, proto) {
         check(O, proto);
         if (buggy) O.__proto__ = proto;
         else set(O, proto);
         return O;
       };
     }({}, false) : undefined),
   check: check
 };
 
 
 /***/ }),
-/* 69 */
+/* 70 */
 /***/ (function(module, exports) {
 
 module.exports = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' +
   '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
 
 
 /***/ }),
-/* 70 */
+/* 71 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var isObject = __webpack_require__(4);
-var setPrototypeOf = __webpack_require__(68).set;
+var setPrototypeOf = __webpack_require__(69).set;
 module.exports = function (that, target, C) {
   var S = target.constructor;
   var P;
   if (S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && setPrototypeOf) {
     setPrototypeOf(that, P);
   } return that;
 };
 
 
 /***/ }),
-/* 71 */
+/* 72 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var toInteger = __webpack_require__(24);
 var defined = __webpack_require__(23);
 
 module.exports = function repeat(count) {
@@ -1961,44 +1977,44 @@ module.exports = function repeat(count) 
   var n = toInteger(count);
   if (n < 0 || n == Infinity) throw RangeError("Count can't be negative");
   for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) res += str;
   return res;
 };
 
 
 /***/ }),
-/* 72 */
+/* 73 */
 /***/ (function(module, exports) {
 
 // 20.2.2.28 Math.sign(x)
 module.exports = Math.sign || function sign(x) {
   // eslint-disable-next-line no-self-compare
   return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1;
 };
 
 
 /***/ }),
-/* 73 */
+/* 74 */
 /***/ (function(module, exports) {
 
 // 20.2.2.14 Math.expm1(x)
 var $expm1 = Math.expm1;
 module.exports = (!$expm1
   // Old FF bug
   || $expm1(10) > 22025.465794806719 || $expm1(10) < 22025.4657948067165168
   // Tor Browser bug
   || $expm1(-2e-17) != -2e-17
 ) ? function expm1(x) {
   return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : Math.exp(x) - 1;
 } : $expm1;
 
 
 /***/ }),
-/* 74 */
+/* 75 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var toInteger = __webpack_require__(24);
 var defined = __webpack_require__(23);
 // true  -> String#at
 // false -> String#codePointAt
 module.exports = function (TO_STRING) {
   return function (that, pos) {
@@ -2011,27 +2027,27 @@ module.exports = function (TO_STRING) {
     return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
       ? TO_STRING ? s.charAt(i) : a
       : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
   };
 };
 
 
 /***/ }),
-/* 75 */
+/* 76 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
-var LIBRARY = __webpack_require__(33);
+var LIBRARY = __webpack_require__(30);
 var $export = __webpack_require__(0);
 var redefine = __webpack_require__(12);
 var hide = __webpack_require__(11);
 var Iterators = __webpack_require__(44);
-var $iterCreate = __webpack_require__(76);
+var $iterCreate = __webpack_require__(77);
 var setToStringTag = __webpack_require__(42);
 var getPrototypeOf = __webpack_require__(17);
 var ITERATOR = __webpack_require__(5)('iterator');
 var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`
 var FF_ITERATOR = '@@iterator';
 var KEYS = 'keys';
 var VALUES = 'values';
 
@@ -2087,51 +2103,51 @@ module.exports = function (Base, NAME, C
       if (!(key in proto)) redefine(proto, key, methods[key]);
     } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
   }
   return methods;
 };
 
 
 /***/ }),
-/* 76 */
+/* 77 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var create = __webpack_require__(36);
-var descriptor = __webpack_require__(31);
+var descriptor = __webpack_require__(32);
 var setToStringTag = __webpack_require__(42);
 var IteratorPrototype = {};
 
 // 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
 __webpack_require__(11)(IteratorPrototype, __webpack_require__(5)('iterator'), function () { return this; });
 
 module.exports = function (Constructor, NAME, next) {
   Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });
   setToStringTag(Constructor, NAME + ' Iterator');
 };
 
 
 /***/ }),
-/* 77 */
+/* 78 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // helper for String#{startsWith, endsWith, includes}
 var isRegExp = __webpack_require__(53);
 var defined = __webpack_require__(23);
 
 module.exports = function (that, searchString, NAME) {
   if (isRegExp(searchString)) throw TypeError('String#' + NAME + " doesn't accept regex!");
   return String(defined(that));
 };
 
 
 /***/ }),
-/* 78 */
+/* 79 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var MATCH = __webpack_require__(5)('match');
 module.exports = function (KEY) {
   var re = /./;
   try {
     '/./'[KEY](re);
   } catch (e) {
@@ -2139,72 +2155,72 @@ module.exports = function (KEY) {
       re[MATCH] = false;
       return !'/./'[KEY](re);
     } catch (f) { /* empty */ }
   } return true;
 };
 
 
 /***/ }),
-/* 79 */
+/* 80 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // check on default Array iterator
 var Iterators = __webpack_require__(44);
 var ITERATOR = __webpack_require__(5)('iterator');
 var ArrayProto = Array.prototype;
 
 module.exports = function (it) {
   return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
 };
 
 
 /***/ }),
-/* 80 */
+/* 81 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $defineProperty = __webpack_require__(7);
-var createDesc = __webpack_require__(31);
+var createDesc = __webpack_require__(32);
 
 module.exports = function (object, index, value) {
   if (index in object) $defineProperty.f(object, index, createDesc(0, value));
   else object[index] = value;
 };
 
 
 /***/ }),
-/* 81 */
+/* 82 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var classof = __webpack_require__(48);
 var ITERATOR = __webpack_require__(5)('iterator');
 var Iterators = __webpack_require__(44);
-module.exports = __webpack_require__(21).getIteratorMethod = function (it) {
+module.exports = __webpack_require__(18).getIteratorMethod = function (it) {
   if (it != undefined) return it[ITERATOR]
     || it['@@iterator']
     || Iterators[classof(it)];
 };
 
 
 /***/ }),
-/* 82 */
+/* 83 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 9.4.2.3 ArraySpeciesCreate(originalArray, length)
 var speciesConstructor = __webpack_require__(217);
 
 module.exports = function (original, length) {
   return new (speciesConstructor(original))(length);
 };
 
 
 /***/ }),
-/* 83 */
+/* 84 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 // 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)
 
 var toObject = __webpack_require__(9);
 var toAbsoluteIndex = __webpack_require__(35);
 var toLength = __webpack_require__(8);
@@ -2216,31 +2232,31 @@ module.exports = function fill(value /* 
   var end = aLen > 2 ? arguments[2] : undefined;
   var endPos = end === undefined ? length : toAbsoluteIndex(end, length);
   while (endPos > index) O[index++] = value;
   return O;
 };
 
 
 /***/ }),
-/* 84 */
+/* 85 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
-var addToUnscopables = __webpack_require__(30);
+var addToUnscopables = __webpack_require__(31);
 var step = __webpack_require__(108);
 var Iterators = __webpack_require__(44);
 var toIObject = __webpack_require__(15);
 
 // 22.1.3.4 Array.prototype.entries()
 // 22.1.3.13 Array.prototype.keys()
 // 22.1.3.29 Array.prototype.values()
 // 22.1.3.30 Array.prototype[@@iterator]()
-module.exports = __webpack_require__(75)(Array, 'Array', function (iterated, kind) {
+module.exports = __webpack_require__(76)(Array, 'Array', function (iterated, kind) {
   this._t = toIObject(iterated); // target
   this._i = 0;                   // next index
   this._k = kind;                // kind
 // 22.1.5.2.1 %ArrayIteratorPrototype%.next()
 }, function () {
   var O = this._t;
   var kind = this._k;
   var index = this._i++;
@@ -2257,23 +2273,23 @@ module.exports = __webpack_require__(75)
 Iterators.Arguments = Iterators.Array;
 
 addToUnscopables('keys');
 addToUnscopables('values');
 addToUnscopables('entries');
 
 
 /***/ }),
-/* 85 */
-/***/ (function(module, exports, __webpack_require__) {
-
-var ctx = __webpack_require__(18);
+/* 86 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var ctx = __webpack_require__(19);
 var invoke = __webpack_require__(98);
-var html = __webpack_require__(67);
-var cel = __webpack_require__(63);
+var html = __webpack_require__(68);
+var cel = __webpack_require__(64);
 var global = __webpack_require__(2);
 var process = global.process;
 var setTask = global.setImmediate;
 var clearTask = global.clearImmediate;
 var MessageChannel = global.MessageChannel;
 var Dispatch = global.Dispatch;
 var counter = 0;
 var queue = {};
@@ -2303,17 +2319,17 @@ if (!setTask || !clearTask) {
     };
     defer(counter);
     return counter;
   };
   clearTask = function clearImmediate(id) {
     delete queue[id];
   };
   // Node.js 0.8-
-  if (__webpack_require__(19)(process) == 'process') {
+  if (__webpack_require__(20)(process) == 'process') {
     defer = function (id) {
       process.nextTick(ctx(run, id, 1));
     };
   // Sphere (JS game engine) Dispatch API
   } else if (Dispatch && Dispatch.now) {
     defer = function (id) {
       Dispatch.now(ctx(run, id, 1));
     };
@@ -2347,25 +2363,25 @@ if (!setTask || !clearTask) {
 }
 module.exports = {
   set: setTask,
   clear: clearTask
 };
 
 
 /***/ }),
-/* 86 */
+/* 87 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var global = __webpack_require__(2);
-var macrotask = __webpack_require__(85).set;
+var macrotask = __webpack_require__(86).set;
 var Observer = global.MutationObserver || global.WebKitMutationObserver;
 var process = global.process;
 var Promise = global.Promise;
-var isNode = __webpack_require__(19)(process) == 'process';
+var isNode = __webpack_require__(20)(process) == 'process';
 
 module.exports = function () {
   var head, last, notify;
 
   var flush = function () {
     var parent, fn;
     if (isNode && (parent = process.domain)) parent.exit();
     while (head) {
@@ -2392,17 +2408,18 @@ module.exports = function () {
     var toggle = true;
     var node = document.createTextNode('');
     new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new
     notify = function () {
       node.data = toggle = !toggle;
     };
   // environments with maybe non-completely correct, but existent Promise
   } else if (Promise && Promise.resolve) {
-    var promise = Promise.resolve();
+    // Promise.resolve without an argument throws an error in LG WebOS 2
+    var promise = Promise.resolve(undefined);
     notify = function () {
       promise.then(flush);
     };
   // for other environments - macrotask based on:
   // - setImmediate
   // - MessageChannel
   // - window.postMessag
   // - onreadystatechange
@@ -2421,17 +2438,17 @@ module.exports = function () {
       head = task;
       notify();
     } last = task;
   };
 };
 
 
 /***/ }),
-/* 87 */
+/* 88 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 // 25.4.1.5 NewPromiseCapability(C)
 var aFunction = __webpack_require__(10);
 
 function PromiseCapability(C) {
@@ -2446,35 +2463,35 @@ function PromiseCapability(C) {
 }
 
 module.exports.f = function (C) {
   return new PromiseCapability(C);
 };
 
 
 /***/ }),
-/* 88 */
+/* 89 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var global = __webpack_require__(2);
 var DESCRIPTORS = __webpack_require__(6);
-var LIBRARY = __webpack_require__(33);
-var $typed = __webpack_require__(59);
+var LIBRARY = __webpack_require__(30);
+var $typed = __webpack_require__(60);
 var hide = __webpack_require__(11);
 var redefineAll = __webpack_require__(41);
 var fails = __webpack_require__(3);
 var anInstance = __webpack_require__(39);
 var toInteger = __webpack_require__(24);
 var toLength = __webpack_require__(8);
 var toIndex = __webpack_require__(117);
 var gOPN = __webpack_require__(37).f;
 var dP = __webpack_require__(7).f;
-var arrayFill = __webpack_require__(83);
+var arrayFill = __webpack_require__(84);
 var setToStringTag = __webpack_require__(42);
 var ARRAY_BUFFER = 'ArrayBuffer';
 var DATA_VIEW = 'DataView';
 var PROTOTYPE = 'prototype';
 var WRONG_LENGTH = 'Wrong length!';
 var WRONG_INDEX = 'Wrong index!';
 var $ArrayBuffer = global[ARRAY_BUFFER];
 var $DataView = global[DATA_VIEW];
@@ -2729,26 +2746,16 @@ if (!$typed.ABV) {
 setToStringTag($ArrayBuffer, ARRAY_BUFFER);
 setToStringTag($DataView, DATA_VIEW);
 hide($DataView[PROTOTYPE], $typed.VIEW, true);
 exports[ARRAY_BUFFER] = $ArrayBuffer;
 exports[DATA_VIEW] = $DataView;
 
 
 /***/ }),
-/* 89 */
-/***/ (function(module, exports, __webpack_require__) {
-
-var global = __webpack_require__(2);
-var navigator = global.navigator;
-
-module.exports = navigator && navigator.userAgent || '';
-
-
-/***/ }),
 /* 90 */
 /***/ (function(module, exports) {
 
 var g;
 
 // This works in non-strict mode
 g = (function() {
 	return this;
@@ -2770,17 +2777,17 @@ try {
 module.exports = g;
 
 
 /***/ }),
 /* 91 */
 /***/ (function(module, exports, __webpack_require__) {
 
 module.exports = !__webpack_require__(6) && !__webpack_require__(3)(function () {
-  return Object.defineProperty(__webpack_require__(63)('div'), 'a', { get: function () { return 7; } }).a != 7;
+  return Object.defineProperty(__webpack_require__(64)('div'), 'a', { get: function () { return 7; } }).a != 7;
 });
 
 
 /***/ }),
 /* 92 */
 /***/ (function(module, exports, __webpack_require__) {
 
 exports.f = __webpack_require__(5);
@@ -2788,17 +2795,17 @@ exports.f = __webpack_require__(5);
 
 /***/ }),
 /* 93 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var has = __webpack_require__(14);
 var toIObject = __webpack_require__(15);
 var arrayIndexOf = __webpack_require__(50)(false);
-var IE_PROTO = __webpack_require__(65)('IE_PROTO');
+var IE_PROTO = __webpack_require__(66)('IE_PROTO');
 
 module.exports = function (object, names) {
   var O = toIObject(object);
   var i = 0;
   var result = [];
   var key;
   for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);
   // Don't enum bug & hidden keys
@@ -2949,44 +2956,44 @@ module.exports = function (fn, args, tha
 
 
 /***/ }),
 /* 99 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var $parseInt = __webpack_require__(2).parseInt;
 var $trim = __webpack_require__(43).trim;
-var ws = __webpack_require__(69);
+var ws = __webpack_require__(70);
 var hex = /^[-+]?0[xX]/;
 
 module.exports = $parseInt(ws + '08') !== 8 || $parseInt(ws + '0x16') !== 22 ? function parseInt(str, radix) {
   var string = $trim(String(str), 3);
   return $parseInt(string, (radix >>> 0) || (hex.test(string) ? 16 : 10));
 } : $parseInt;
 
 
 /***/ }),
 /* 100 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var $parseFloat = __webpack_require__(2).parseFloat;
 var $trim = __webpack_require__(43).trim;
 
-module.exports = 1 / $parseFloat(__webpack_require__(69) + '-0') !== -Infinity ? function parseFloat(str) {
+module.exports = 1 / $parseFloat(__webpack_require__(70) + '-0') !== -Infinity ? function parseFloat(str) {
   var string = $trim(String(str), 3);
   var result = $parseFloat(string);
   return result === 0 && string.charAt(0) == '-' ? -0 : result;
 } : $parseFloat;
 
 
 /***/ }),
 /* 101 */
 /***/ (function(module, exports, __webpack_require__) {
 
-var cof = __webpack_require__(19);
+var cof = __webpack_require__(20);
 module.exports = function (it, msg) {
   if (typeof it != 'number' && cof(it) != 'Number') throw TypeError(msg);
   return +it;
 };
 
 
 /***/ }),
 /* 102 */
@@ -3010,17 +3017,17 @@ module.exports = Math.log1p || function 
 };
 
 
 /***/ }),
 /* 104 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 20.2.2.16 Math.fround(x)
-var sign = __webpack_require__(72);
+var sign = __webpack_require__(73);
 var pow = Math.pow;
 var EPSILON = pow(2, -52);
 var EPSILON32 = pow(2, -23);
 var MAX32 = pow(2, 127) * (2 - EPSILON32);
 var MIN32 = pow(2, -126);
 
 var roundTiesToEven = function (n) {
   return n + 1 / EPSILON - 1 / EPSILON;
@@ -3158,17 +3165,17 @@ module.exports = function (exec) {
 
 
 /***/ }),
 /* 111 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var anObject = __webpack_require__(1);
 var isObject = __webpack_require__(4);
-var newPromiseCapability = __webpack_require__(87);
+var newPromiseCapability = __webpack_require__(88);
 
 module.exports = function (C, x) {
   anObject(C);
   if (isObject(x) && x.constructor === C) return x;
   var promiseCapability = newPromiseCapability.f(C);
   var resolve = promiseCapability.resolve;
   resolve(x);
   return promiseCapability.promise;
@@ -3181,17 +3188,17 @@ module.exports = function (C, x) {
 
 "use strict";
 
 var strong = __webpack_require__(113);
 var validate = __webpack_require__(45);
 var MAP = 'Map';
 
 // 23.1 Map Objects
-module.exports = __webpack_require__(58)(MAP, function (get) {
+module.exports = __webpack_require__(59)(MAP, function (get) {
   return function Map() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
 }, {
   // 23.1.3.6 Map.prototype.get(key)
   get: function get(key) {
     var entry = strong.getEntry(validate(this, MAP), key);
     return entry && entry.v;
   },
   // 23.1.3.9 Map.prototype.set(key, value)
@@ -3205,20 +3212,20 @@ module.exports = __webpack_require__(58)
 /* 113 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var dP = __webpack_require__(7).f;
 var create = __webpack_require__(36);
 var redefineAll = __webpack_require__(41);
-var ctx = __webpack_require__(18);
+var ctx = __webpack_require__(19);
 var anInstance = __webpack_require__(39);
 var forOf = __webpack_require__(40);
-var $iterDefine = __webpack_require__(75);
+var $iterDefine = __webpack_require__(76);
 var step = __webpack_require__(108);
 var setSpecies = __webpack_require__(38);
 var DESCRIPTORS = __webpack_require__(6);
 var fastKey = __webpack_require__(29).fastKey;
 var validate = __webpack_require__(45);
 var SIZE = DESCRIPTORS ? '_s' : 'size';
 
 var getEntry = function (that, key) {
@@ -3358,17 +3365,17 @@ module.exports = {
 
 "use strict";
 
 var strong = __webpack_require__(113);
 var validate = __webpack_require__(45);
 var SET = 'Set';
 
 // 23.2 Set Objects
-module.exports = __webpack_require__(58)(SET, function (get) {
+module.exports = __webpack_require__(59)(SET, function (get) {
   return function Set() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
 }, {
   // 23.2.3.1 Set.prototype.add(value)
   add: function add(value) {
     return strong.def(validate(this, SET), value = value === 0 ? 0 : value, value);
   }
 }, strong);
 
@@ -3411,17 +3418,17 @@ var methods = {
   },
   // 23.3.3.5 WeakMap.prototype.set(key, value)
   set: function set(key, value) {
     return weak.def(validate(this, WEAK_MAP), key, value);
   }
 };
 
 // 23.3 WeakMap Objects
-var $WeakMap = module.exports = __webpack_require__(58)(WEAK_MAP, wrapper, methods, weak, true, true);
+var $WeakMap = module.exports = __webpack_require__(59)(WEAK_MAP, wrapper, methods, weak, true, true);
 
 // IE11 WeakMap frozen keys fix
 if (fails(function () { return new $WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7; })) {
   InternalMap = weak.getConstructor(wrapper, WEAK_MAP);
   assign(InternalMap.prototype, methods);
   meta.NEED = true;
   each(['delete', 'has', 'get', 'set'], function (key) {
     var proto = $WeakMap.prototype;
@@ -3568,17 +3575,17 @@ module.exports = Reflect && Reflect.ownK
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 // https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray
 var isArray = __webpack_require__(52);
 var isObject = __webpack_require__(4);
 var toLength = __webpack_require__(8);
-var ctx = __webpack_require__(18);
+var ctx = __webpack_require__(19);
 var IS_CONCAT_SPREADABLE = __webpack_require__(5)('isConcatSpreadable');
 
 function flattenIntoArray(target, original, source, sourceLen, start, depth, mapper, thisArg) {
   var targetIndex = start;
   var sourceIndex = 0;
   var mapFn = mapper ? ctx(mapper, thisArg, 3) : false;
   var element, spreadable;
 
@@ -3610,17 +3617,17 @@ module.exports = flattenIntoArray;
 
 
 /***/ }),
 /* 120 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://github.com/tc39/proposal-string-pad-start-end
 var toLength = __webpack_require__(8);
-var repeat = __webpack_require__(71);
+var repeat = __webpack_require__(72);
 var defined = __webpack_require__(23);
 
 module.exports = function (that, maxLength, fillString, left) {
   var S = String(defined(that));
   var stringLength = S.length;
   var fillStr = fillString === undefined ? ' ' : String(fillString);
   var intMaxLength = toLength(maxLength);
   if (intMaxLength <= stringLength || fillStr == '') return S;
@@ -3838,17 +3845,17 @@ define(String.prototype, "padRight", "".
 __webpack_require__(223);
 __webpack_require__(224);
 __webpack_require__(225);
 __webpack_require__(226);
 __webpack_require__(227);
 __webpack_require__(228);
 __webpack_require__(229);
 __webpack_require__(230);
-__webpack_require__(84);
+__webpack_require__(85);
 __webpack_require__(231);
 __webpack_require__(232);
 __webpack_require__(109);
 __webpack_require__(233);
 __webpack_require__(234);
 __webpack_require__(235);
 __webpack_require__(236);
 __webpack_require__(237);
@@ -3935,17 +3942,17 @@ define(String.prototype, "padRight", "".
 __webpack_require__(315);
 __webpack_require__(316);
 __webpack_require__(317);
 __webpack_require__(318);
 __webpack_require__(319);
 __webpack_require__(320);
 __webpack_require__(321);
 __webpack_require__(322);
-module.exports = __webpack_require__(21);
+module.exports = __webpack_require__(18);
 
 
 /***/ }),
 /* 127 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
@@ -3954,27 +3961,27 @@ var global = __webpack_require__(2);
 var has = __webpack_require__(14);
 var DESCRIPTORS = __webpack_require__(6);
 var $export = __webpack_require__(0);
 var redefine = __webpack_require__(12);
 var META = __webpack_require__(29).KEY;
 var $fails = __webpack_require__(3);
 var shared = __webpack_require__(49);
 var setToStringTag = __webpack_require__(42);
-var uid = __webpack_require__(32);
+var uid = __webpack_require__(33);
 var wks = __webpack_require__(5);
 var wksExt = __webpack_require__(92);
-var wksDefine = __webpack_require__(64);
+var wksDefine = __webpack_require__(65);
 var enumKeys = __webpack_require__(128);
 var isArray = __webpack_require__(52);
 var anObject = __webpack_require__(1);
 var isObject = __webpack_require__(4);
 var toIObject = __webpack_require__(15);
 var toPrimitive = __webpack_require__(22);
-var createDesc = __webpack_require__(31);
+var createDesc = __webpack_require__(32);
 var _create = __webpack_require__(36);
 var gOPNExt = __webpack_require__(95);
 var $GOPD = __webpack_require__(16);
 var $DP = __webpack_require__(7);
 var $keys = __webpack_require__(34);
 var gOPD = $GOPD.f;
 var dP = $DP.f;
 var gOPN = gOPNExt.f;
@@ -4096,17 +4103,17 @@ if (!USE_NATIVE) {
   });
 
   $GOPD.f = $getOwnPropertyDescriptor;
   $DP.f = $defineProperty;
   __webpack_require__(37).f = gOPNExt.f = $getOwnPropertyNames;
   __webpack_require__(47).f = $propertyIsEnumerable;
   __webpack_require__(51).f = $getOwnPropertySymbols;
 
-  if (DESCRIPTORS && !__webpack_require__(33)) {
+  if (DESCRIPTORS && !__webpack_require__(30)) {
     redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
   }
 
   wksExt.f = function (name) {
     return wrap(wks(name));
   };
 }
 
@@ -4405,17 +4412,17 @@ module.exports = Object.is || function i
 
 
 /***/ }),
 /* 145 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 19.1.3.19 Object.setPrototypeOf(O, proto)
 var $export = __webpack_require__(0);
-$export($export.S, 'Object', { setPrototypeOf: __webpack_require__(68).set });
+$export($export.S, 'Object', { setPrototypeOf: __webpack_require__(69).set });
 
 
 /***/ }),
 /* 146 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
@@ -4505,18 +4512,18 @@ var $parseFloat = __webpack_require__(10
 /***/ }),
 /* 152 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var global = __webpack_require__(2);
 var has = __webpack_require__(14);
-var cof = __webpack_require__(19);
-var inheritIfRequired = __webpack_require__(70);
+var cof = __webpack_require__(20);
+var inheritIfRequired = __webpack_require__(71);
 var toPrimitive = __webpack_require__(22);
 var fails = __webpack_require__(3);
 var gOPN = __webpack_require__(37).f;
 var gOPD = __webpack_require__(16).f;
 var dP = __webpack_require__(7).f;
 var $trim = __webpack_require__(43).trim;
 var NUMBER = 'Number';
 var $Number = global[NUMBER];
@@ -4582,17 +4589,17 @@ if (!$Number(' 0o1') || !$Number('0b1') 
 /* 153 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $export = __webpack_require__(0);
 var toInteger = __webpack_require__(24);
 var aNumberValue = __webpack_require__(101);
-var repeat = __webpack_require__(71);
+var repeat = __webpack_require__(72);
 var $toFixed = 1.0.toFixed;
 var floor = Math.floor;
 var data = [0, 0, 0, 0, 0, 0];
 var ERROR = 'Number.toFixed: incorrect invocation!';
 var ZERO = '0';
 
 var multiply = function (n, c) {
   var i = -1;
@@ -4887,17 +4894,17 @@ var $atanh = Math.atanh;
 
 
 /***/ }),
 /* 167 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 20.2.2.9 Math.cbrt(x)
 var $export = __webpack_require__(0);
-var sign = __webpack_require__(72);
+var sign = __webpack_require__(73);
 
 $export($export.S, 'Math', {
   cbrt: function cbrt(x) {
     return sign(x = +x) * Math.pow(Math.abs(x), 1 / 3);
   }
 });
 
 
@@ -4931,17 +4938,17 @@ var exp = Math.exp;
 
 
 /***/ }),
 /* 170 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 20.2.2.14 Math.expm1(x)
 var $export = __webpack_require__(0);
-var $expm1 = __webpack_require__(73);
+var $expm1 = __webpack_require__(74);
 
 $export($export.S + $export.F * ($expm1 != Math.expm1), 'Math', { expm1: $expm1 });
 
 
 /***/ }),
 /* 171 */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -5045,26 +5052,26 @@ var $export = __webpack_require__(0);
 
 /***/ }),
 /* 177 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 20.2.2.28 Math.sign(x)
 var $export = __webpack_require__(0);
 
-$export($export.S, 'Math', { sign: __webpack_require__(72) });
+$export($export.S, 'Math', { sign: __webpack_require__(73) });
 
 
 /***/ }),
 /* 178 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 20.2.2.30 Math.sinh(x)
 var $export = __webpack_require__(0);
-var expm1 = __webpack_require__(73);
+var expm1 = __webpack_require__(74);
 var exp = Math.exp;
 
 // V8 near Chromium 38 has a problem with very small numbers
 $export($export.S + $export.F * __webpack_require__(3)(function () {
   return !Math.sinh(-2e-17) != -2e-17;
 }), 'Math', {
   sinh: function sinh(x) {
     return Math.abs(x = +x) < 1
@@ -5075,17 +5082,17 @@ var exp = Math.exp;
 
 
 /***/ }),
 /* 179 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 20.2.2.33 Math.tanh(x)
 var $export = __webpack_require__(0);
-var expm1 = __webpack_require__(73);
+var expm1 = __webpack_require__(74);
 var exp = Math.exp;
 
 $export($export.S, 'Math', {
   tanh: function tanh(x) {
     var a = expm1(x = +x);
     var b = expm1(-x);
     return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x));
   }
@@ -5174,20 +5181,20 @@ var toLength = __webpack_require__(8);
 
 
 /***/ }),
 /* 184 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
-var $at = __webpack_require__(74)(true);
+var $at = __webpack_require__(75)(true);
 
 // 21.1.3.27 String.prototype[@@iterator]()
-__webpack_require__(75)(String, 'String', function (iterated) {
+__webpack_require__(76)(String, 'String', function (iterated) {
   this._t = String(iterated); // target
   this._i = 0;                // next index
 // 21.1.5.2.1 %StringIteratorPrototype%.next()
 }, function () {
   var O = this._t;
   var index = this._i;
   var point;
   if (index >= O.length) return { value: undefined, done: true };
@@ -5199,17 +5206,17 @@ var $at = __webpack_require__(74)(true);
 
 /***/ }),
 /* 185 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $export = __webpack_require__(0);
-var $at = __webpack_require__(74)(false);
+var $at = __webpack_require__(75)(false);
 $export($export.P, 'String', {
   // 21.1.3.3 String.prototype.codePointAt(pos)
   codePointAt: function codePointAt(pos) {
     return $at(this, pos);
   }
 });
 
 
@@ -5217,21 +5224,21 @@ var $at = __webpack_require__(74)(false)
 /* 186 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 // 21.1.3.6 String.prototype.endsWith(searchString [, endPosition])
 
 var $export = __webpack_require__(0);
 var toLength = __webpack_require__(8);
-var context = __webpack_require__(77);
+var context = __webpack_require__(78);
 var ENDS_WITH = 'endsWith';
 var $endsWith = ''[ENDS_WITH];
 
-$export($export.P + $export.F * __webpack_require__(78)(ENDS_WITH), 'String', {
+$export($export.P + $export.F * __webpack_require__(79)(ENDS_WITH), 'String', {
   endsWith: function endsWith(searchString /* , endPosition = @length */) {
     var that = context(this, searchString, ENDS_WITH);
     var endPosition = arguments.length > 1 ? arguments[1] : undefined;
     var len = toLength(that.length);
     var end = endPosition === undefined ? len : Math.min(toLength(endPosition), len);
     var search = String(searchString);
     return $endsWith
       ? $endsWith.call(that, search, end)
@@ -5243,53 +5250,53 @@ var $endsWith = ''[ENDS_WITH];
 /***/ }),
 /* 187 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 // 21.1.3.7 String.prototype.includes(searchString, position = 0)
 
 var $export = __webpack_require__(0);
-var context = __webpack_require__(77);
+var context = __webpack_require__(78);
 var INCLUDES = 'includes';
 
-$export($export.P + $export.F * __webpack_require__(78)(INCLUDES), 'String', {
+$export($export.P + $export.F * __webpack_require__(79)(INCLUDES), 'String', {
   includes: function includes(searchString /* , position = 0 */) {
     return !!~context(this, searchString, INCLUDES)
       .indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined);
   }
 });
 
 
 /***/ }),
 /* 188 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var $export = __webpack_require__(0);
 
 $export($export.P, 'String', {
   // 21.1.3.13 String.prototype.repeat(count)
-  repeat: __webpack_require__(71)
+  repeat: __webpack_require__(72)
 });
 
 
 /***/ }),
 /* 189 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 // 21.1.3.18 String.prototype.startsWith(searchString [, position ])
 
 var $export = __webpack_require__(0);
 var toLength = __webpack_require__(8);
-var context = __webpack_require__(77);
+var context = __webpack_require__(78);
 var STARTS_WITH = 'startsWith';
 var $startsWith = ''[STARTS_WITH];
 
-$export($export.P + $export.F * __webpack_require__(78)(STARTS_WITH), 'String', {
+$export($export.P + $export.F * __webpack_require__(79)(STARTS_WITH), 'String', {
   startsWith: function startsWith(searchString /* , position = 0 */) {
     var that = context(this, searchString, STARTS_WITH);
     var index = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length));
     var search = String(searchString);
     return $startsWith
       ? $startsWith.call(that, search, index)
       : that.slice(index, index + search.length) === search;
   }
@@ -5613,24 +5620,24 @@ var $export = __webpack_require__(0);
 
 
 /***/ }),
 /* 211 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
-var ctx = __webpack_require__(18);
+var ctx = __webpack_require__(19);
 var $export = __webpack_require__(0);
 var toObject = __webpack_require__(9);
 var call = __webpack_require__(105);
-var isArrayIter = __webpack_require__(79);
+var isArrayIter = __webpack_require__(80);
 var toLength = __webpack_require__(8);
-var createProperty = __webpack_require__(80);
-var getIterFn = __webpack_require__(81);
+var createProperty = __webpack_require__(81);
+var getIterFn = __webpack_require__(82);
 
 $export($export.S + $export.F * !__webpack_require__(54)(function (iter) { Array.from(iter); }), 'Array', {
   // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
   from: function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
     var O = toObject(arrayLike);
     var C = typeof this == 'function' ? this : Array;
     var aLen = arguments.length;
     var mapfn = aLen > 1 ? arguments[1] : undefined;
@@ -5658,17 +5665,17 @@ var getIterFn = __webpack_require__(81);
 
 /***/ }),
 /* 212 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $export = __webpack_require__(0);
-var createProperty = __webpack_require__(80);
+var createProperty = __webpack_require__(81);
 
 // WebKit Array.of isn't generic
 $export($export.S + $export.F * __webpack_require__(3)(function () {
   function F() { /* empty */ }
   return !(Array.of.call(F) instanceof F);
 }), 'Array', {
   // 22.1.2.3 Array.of( ...items)
   of: function of(/* ...args */) {
@@ -5689,32 +5696,32 @@ var createProperty = __webpack_require__
 "use strict";
 
 // 22.1.3.13 Array.prototype.join(separator)
 var $export = __webpack_require__(0);
 var toIObject = __webpack_require__(15);
 var arrayJoin = [].join;
 
 // fallback for not array-like strings
-$export($export.P + $export.F * (__webpack_require__(46) != Object || !__webpack_require__(20)(arrayJoin)), 'Array', {
+$export($export.P + $export.F * (__webpack_require__(46) != Object || !__webpack_require__(21)(arrayJoin)), 'Array', {
   join: function join(separator) {
     return arrayJoin.call(toIObject(this), separator === undefined ? ',' : separator);
   }
 });
 
 
 /***/ }),
 /* 214 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $export = __webpack_require__(0);
-var html = __webpack_require__(67);
-var cof = __webpack_require__(19);
+var html = __webpack_require__(68);
+var cof = __webpack_require__(20);
 var toAbsoluteIndex = __webpack_require__(35);
 var toLength = __webpack_require__(8);
 var arraySlice = [].slice;
 
 // fallback for not array-like ES3 strings and DOM objects
 $export($export.P + $export.F * __webpack_require__(3)(function () {
   if (html) arraySlice.call(html);
 }), 'Array', {
@@ -5751,17 +5758,17 @@ var test = [1, 2, 3];
 
 $export($export.P + $export.F * (fails(function () {
   // IE8-
   test.sort(undefined);
 }) || !fails(function () {
   // V8 bug
   test.sort(null);
   // Old WebKit
-}) || !__webpack_require__(20)($sort)), 'Array', {
+}) || !__webpack_require__(21)($sort)), 'Array', {
   // 22.1.3.25 Array.prototype.sort(comparefn)
   sort: function sort(comparefn) {
     return comparefn === undefined
       ? $sort.call(toObject(this))
       : $sort.call(toObject(this), aFunction(comparefn));
   }
 });
 
@@ -5769,17 +5776,17 @@ var test = [1, 2, 3];
 /***/ }),
 /* 216 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $export = __webpack_require__(0);
 var $forEach = __webpack_require__(26)(0);
-var STRICT = __webpack_require__(20)([].forEach, true);
+var STRICT = __webpack_require__(21)([].forEach, true);
 
 $export($export.P + $export.F * !STRICT, 'Array', {
   // 22.1.3.10 / 15.4.4.18 Array.prototype.forEach(callbackfn [, thisArg])
   forEach: function forEach(callbackfn /* , thisArg */) {
     return $forEach(this, callbackfn, arguments[1]);
   }
 });
 
@@ -5810,102 +5817,102 @@ module.exports = function (original) {
 /* 218 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $export = __webpack_require__(0);
 var $map = __webpack_require__(26)(1);
 
-$export($export.P + $export.F * !__webpack_require__(20)([].map, true), 'Array', {
+$export($export.P + $export.F * !__webpack_require__(21)([].map, true), 'Array', {
   // 22.1.3.15 / 15.4.4.19 Array.prototype.map(callbackfn [, thisArg])
   map: function map(callbackfn /* , thisArg */) {
     return $map(this, callbackfn, arguments[1]);
   }
 });
 
 
 /***/ }),
 /* 219 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $export = __webpack_require__(0);
 var $filter = __webpack_require__(26)(2);
 
-$export($export.P + $export.F * !__webpack_require__(20)([].filter, true), 'Array', {
+$export($export.P + $export.F * !__webpack_require__(21)([].filter, true), 'Array', {
   // 22.1.3.7 / 15.4.4.20 Array.prototype.filter(callbackfn [, thisArg])
   filter: function filter(callbackfn /* , thisArg */) {
     return $filter(this, callbackfn, arguments[1]);
   }
 });
 
 
 /***/ }),
 /* 220 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $export = __webpack_require__(0);
 var $some = __webpack_require__(26)(3);
 
-$export($export.P + $export.F * !__webpack_require__(20)([].some, true), 'Array', {
+$export($export.P + $export.F * !__webpack_require__(21)([].some, true), 'Array', {
   // 22.1.3.23 / 15.4.4.17 Array.prototype.some(callbackfn [, thisArg])
   some: function some(callbackfn /* , thisArg */) {
     return $some(this, callbackfn, arguments[1]);
   }
 });
 
 
 /***/ }),
 /* 221 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $export = __webpack_require__(0);
 var $every = __webpack_require__(26)(4);
 
-$export($export.P + $export.F * !__webpack_require__(20)([].every, true), 'Array', {
+$export($export.P + $export.F * !__webpack_require__(21)([].every, true), 'Array', {
   // 22.1.3.5 / 15.4.4.16 Array.prototype.every(callbackfn [, thisArg])
   every: function every(callbackfn /* , thisArg */) {
     return $every(this, callbackfn, arguments[1]);
   }
 });
 
 
 /***/ }),
 /* 222 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $export = __webpack_require__(0);
 var $reduce = __webpack_require__(106);
 
-$export($export.P + $export.F * !__webpack_require__(20)([].reduce, true), 'Array', {
+$export($export.P + $export.F * !__webpack_require__(21)([].reduce, true), 'Array', {
   // 22.1.3.18 / 15.4.4.21 Array.prototype.reduce(callbackfn [, initialValue])
   reduce: function reduce(callbackfn /* , initialValue */) {
     return $reduce(this, callbackfn, arguments.length, arguments[1], false);
   }
 });
 
 
 /***/ }),
 /* 223 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $export = __webpack_require__(0);
 var $reduce = __webpack_require__(106);
 
-$export($export.P + $export.F * !__webpack_require__(20)([].reduceRight, true), 'Array', {
+$export($export.P + $export.F * !__webpack_require__(21)([].reduceRight, true), 'Array', {
   // 22.1.3.19 / 15.4.4.22 Array.prototype.reduceRight(callbackfn [, initialValue])
   reduceRight: function reduceRight(callbackfn /* , initialValue */) {
     return $reduce(this, callbackfn, arguments.length, arguments[1], true);
   }
 });
 
 
 /***/ }),
@@ -5914,17 +5921,17 @@ var $reduce = __webpack_require__(106);
 
 "use strict";
 
 var $export = __webpack_require__(0);
 var $indexOf = __webpack_require__(50)(false);
 var $native = [].indexOf;
 var NEGATIVE_ZERO = !!$native && 1 / [1].indexOf(1, -0) < 0;
 
-$export($export.P + $export.F * (NEGATIVE_ZERO || !__webpack_require__(20)($native)), 'Array', {
+$export($export.P + $export.F * (NEGATIVE_ZERO || !__webpack_require__(21)($native)), 'Array', {
   // 22.1.3.11 / 15.4.4.14 Array.prototype.indexOf(searchElement [, fromIndex])
   indexOf: function indexOf(searchElement /* , fromIndex = 0 */) {
     return NEGATIVE_ZERO
       // convert -0 to +0
       ? $native.apply(this, arguments) || 0
       : $indexOf(this, searchElement, arguments[1]);
   }
 });
@@ -5938,17 +5945,17 @@ var NEGATIVE_ZERO = !!$native && 1 / [1]
 
 var $export = __webpack_require__(0);
 var toIObject = __webpack_require__(15);
 var toInteger = __webpack_require__(24);
 var toLength = __webpack_require__(8);
 var $native = [].lastIndexOf;
 var NEGATIVE_ZERO = !!$native && 1 / [1].lastIndexOf(1, -0) < 0;
 
-$export($export.P + $export.F * (NEGATIVE_ZERO || !__webpack_require__(20)($native)), 'Array', {
+$export($export.P + $export.F * (NEGATIVE_ZERO || !__webpack_require__(21)($native)), 'Array', {
   // 22.1.3.14 / 15.4.4.15 Array.prototype.lastIndexOf(searchElement [, fromIndex])
   lastIndexOf: function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) {
     // convert -0 to +0
     if (NEGATIVE_ZERO) return $native.apply(this, arguments) || 0;
     var O = toIObject(this);
     var length = toLength(O.length);
     var index = length - 1;
     if (arguments.length > 1) index = Math.min(index, toInteger(arguments[1]));
@@ -5963,29 +5970,29 @@ var NEGATIVE_ZERO = !!$native && 1 / [1]
 /* 226 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)
 var $export = __webpack_require__(0);
 
 $export($export.P, 'Array', { copyWithin: __webpack_require__(107) });
 
-__webpack_require__(30)('copyWithin');
+__webpack_require__(31)('copyWithin');
 
 
 /***/ }),
 /* 227 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)
 var $export = __webpack_require__(0);
 
-$export($export.P, 'Array', { fill: __webpack_require__(83) });
-
-__webpack_require__(30)('fill');
+$export($export.P, 'Array', { fill: __webpack_require__(84) });
+
+__webpack_require__(31)('fill');
 
 
 /***/ }),
 /* 228 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
@@ -5996,17 +6003,17 @@ var KEY = 'find';
 var forced = true;
 // Shouldn't skip holes
 if (KEY in []) Array(1)[KEY](function () { forced = false; });
 $export($export.P + $export.F * forced, 'Array', {
   find: function find(callbackfn /* , that = undefined */) {
     return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
   }
 });
-__webpack_require__(30)(KEY);
+__webpack_require__(31)(KEY);
 
 
 /***/ }),
 /* 229 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
@@ -6017,32 +6024,32 @@ var KEY = 'findIndex';
 var forced = true;
 // Shouldn't skip holes
 if (KEY in []) Array(1)[KEY](function () { forced = false; });
 $export($export.P + $export.F * forced, 'Array', {
   findIndex: function findIndex(callbackfn /* , that = undefined */) {
     return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
   }
 });
-__webpack_require__(30)(KEY);
+__webpack_require__(31)(KEY);
 
 
 /***/ }),
 /* 230 */
 /***/ (function(module, exports, __webpack_require__) {
 
 __webpack_require__(38)('Array');
 
 
 /***/ }),
 /* 231 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var global = __webpack_require__(2);
-var inheritIfRequired = __webpack_require__(70);
+var inheritIfRequired = __webpack_require__(71);
 var dP = __webpack_require__(7).f;
 var gOPN = __webpack_require__(37).f;
 var isRegExp = __webpack_require__(53);
 var $flags = __webpack_require__(55);
 var $RegExp = global.RegExp;
 var Base = $RegExp;
 var proto = $RegExp.prototype;
 var re1 = /a/g;
@@ -6241,49 +6248,58 @@ if (__webpack_require__(3)(function () {
 
 
 /***/ }),
 /* 237 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
-var LIBRARY = __webpack_require__(33);
+var LIBRARY = __webpack_require__(30);
 var global = __webpack_require__(2);
-var ctx = __webpack_require__(18);
+var ctx = __webpack_require__(19);
 var classof = __webpack_require__(48);
 var $export = __webpack_require__(0);
 var isObject = __webpack_require__(4);
 var aFunction = __webpack_require__(10);
 var anInstance = __webpack_require__(39);
 var forOf = __webpack_require__(40);
 var speciesConstructor = __webpack_require__(57);
-var task = __webpack_require__(85).set;
-var microtask = __webpack_require__(86)();
-var newPromiseCapabilityModule = __webpack_require__(87);
+var task = __webpack_require__(86).set;
+var microtask = __webpack_require__(87)();
+var newPromiseCapabilityModule = __webpack_require__(88);
 var perform = __webpack_require__(110);
+var userAgent = __webpack_require__(58);
 var promiseResolve = __webpack_require__(111);
 var PROMISE = 'Promise';
 var TypeError = global.TypeError;
 var process = global.process;
+var versions = process && process.versions;
+var v8 = versions && versions.v8 || '';
 var $Promise = global[PROMISE];
 var isNode = classof(process) == 'process';
 var empty = function () { /* empty */ };
 var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
 var newPromiseCapability = newGenericPromiseCapability = newPromiseCapabilityModule.f;
 
 var USE_NATIVE = !!function () {
   try {
     // correct subclassing with @@species support
     var promise = $Promise.resolve(1);
     var FakePromise = (promise.constructor = {})[__webpack_require__(5)('species')] = function (exec) {
       exec(empty, empty);
     };
     // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
-    return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;
+    return (isNode || typeof PromiseRejectionEvent == 'function')
+      && promise.then(empty) instanceof FakePromise
+      // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
+      // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
+      // we can't detect it synchronously, so just check versions
+      && v8.indexOf('6.6') !== 0
+      && userAgent.indexOf('Chrome/66') === -1;
   } catch (e) { /* empty */ }
 }();
 
 // helpers
 var isThenable = function (it) {
   var then;
   return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
 };
@@ -6455,17 +6471,17 @@ if (!USE_NATIVE) {
       ? new OwnPromiseCapability(C)
       : newGenericPromiseCapability(C);
   };
 }
 
 $export($export.G + $export.W + $export.F * !USE_NATIVE, { Promise: $Promise });
 __webpack_require__(42)($Promise, PROMISE);
 __webpack_require__(38)(PROMISE);
-Wrapper = __webpack_require__(21)[PROMISE];
+Wrapper = __webpack_require__(18)[PROMISE];
 
 // statics
 $export($export.S + $export.F * !USE_NATIVE, PROMISE, {
   // 25.4.4.5 Promise.reject(r)
   reject: function reject(r) {
     var capability = newPromiseCapability(this);
     var $$reject = capability.reject;
     $$reject(r);
@@ -6530,35 +6546,35 @@ Wrapper = __webpack_require__(21)[PROMIS
 
 "use strict";
 
 var weak = __webpack_require__(116);
 var validate = __webpack_require__(45);
 var WEAK_SET = 'WeakSet';
 
 // 23.4 WeakSet Objects
-__webpack_require__(58)(WEAK_SET, function (get) {
+__webpack_require__(59)(WEAK_SET, function (get) {
   return function WeakSet() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
 }, {
   // 23.4.3.1 WeakSet.prototype.add(value)
   add: function add(value) {
     return weak.def(validate(this, WEAK_SET), value, true);
   }
 }, weak, false, true);
 
 
 /***/ }),
 /* 239 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 var $export = __webpack_require__(0);
-var $typed = __webpack_require__(59);
-var buffer = __webpack_require__(88);
+var $typed = __webpack_require__(60);
+var buffer = __webpack_require__(89);
 var anObject = __webpack_require__(1);
 var toAbsoluteIndex = __webpack_require__(35);
 var toLength = __webpack_require__(8);
 var isObject = __webpack_require__(4);
 var ArrayBuffer = __webpack_require__(2).ArrayBuffer;
 var speciesConstructor = __webpack_require__(57);
 var $ArrayBuffer = buffer.ArrayBuffer;
 var $DataView = buffer.DataView;
@@ -6579,37 +6595,37 @@ var ARRAY_BUFFER = 'ArrayBuffer';
 $export($export.P + $export.U + $export.F * __webpack_require__(3)(function () {
   return !new $ArrayBuffer(2).slice(1, undefined).byteLength;
 }), ARRAY_BUFFER, {
   // 24.1.4.3 ArrayBuffer.prototype.slice(start, end)
   slice: function slice(start, end) {
     if ($slice !== undefined && end === undefined) return $slice.call(anObject(this), start); // FF fix
     var len = anObject(this).byteLength;
     var first = toAbsoluteIndex(start, len);
-    var final = toAbsoluteIndex(end === undefined ? len : end, len);
-    var result = new (speciesConstructor(this, $ArrayBuffer))(toLength(final - first));
+    var fin = toAbsoluteIndex(end === undefined ? len : end, len);
+    var result = new (speciesConstructor(this, $ArrayBuffer))(toLength(fin - first));
     var viewS = new $DataView(this);
     var viewT = new $DataView(result);
     var index = 0;
-    while (first < final) {
+    while (first < fin) {
       viewT.setUint8(index++, viewS.getUint8(first++));
     } return result;
   }
 });
 
 __webpack_require__(38)(ARRAY_BUFFER);
 
 
 /***/ }),
 /* 240 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var $export = __webpack_require__(0);
-$export($export.G + $export.W + $export.F * !__webpack_require__(59).ABV, {
-  DataView: __webpack_require__(88).DataView
+$export($export.G + $export.W + $export.F * !__webpack_require__(60).ABV, {
+  DataView: __webpack_require__(89).DataView
 });
 
 
 /***/ }),
 /* 241 */
 /***/ (function(module, exports, __webpack_require__) {
 
 __webpack_require__(27)('Int8', 1, function (init) {
@@ -6839,17 +6855,17 @@ var $export = __webpack_require__(0);
 var anObject = __webpack_require__(1);
 var Enumerate = function (iterated) {
   this._t = anObject(iterated); // target
   this._i = 0;                  // next index
   var keys = this._k = [];      // keys
   var key;
   for (key in iterated) keys.push(key);
 };
-__webpack_require__(76)(Enumerate, 'Object', function () {
+__webpack_require__(77)(Enumerate, 'Object', function () {
   var that = this;
   var keys = that._k;
   var key;
   do {
     if (that._i >= keys.length) return { value: undefined, done: true };
   } while (!((key = keys[that._i++]) in that._t));
   return { value: key, done: false };
 });
@@ -6988,17 +7004,17 @@ var $preventExtensions = Object.preventE
 /***/ (function(module, exports, __webpack_require__) {
 
 // 26.1.13 Reflect.set(target, propertyKey, V [, receiver])
 var dP = __webpack_require__(7);
 var gOPD = __webpack_require__(16);
 var getPrototypeOf = __webpack_require__(17);
 var has = __webpack_require__(14);
 var $export = __webpack_require__(0);
-var createDesc = __webpack_require__(31);
+var createDesc = __webpack_require__(32);
 var anObject = __webpack_require__(1);
 var isObject = __webpack_require__(4);
 
 function set(target, propertyKey, V /* , receiver */) {
   var receiver = arguments.length < 4 ? target : arguments[3];
   var ownDesc = gOPD.f(anObject(target), propertyKey);
   var existingDescriptor, proto;
   if (!ownDesc) {
@@ -7023,17 +7039,17 @@ function set(target, propertyKey, V /* ,
 
 
 /***/ }),
 /* 263 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // 26.1.14 Reflect.setPrototypeOf(target, proto)
 var $export = __webpack_require__(0);
-var setProto = __webpack_require__(68);
+var setProto = __webpack_require__(69);
 
 if (setProto) $export($export.S, 'Reflect', {
   setPrototypeOf: function setPrototypeOf(target, proto) {
     setProto.check(target, proto);
     try {
       setProto.set(target, proto);
       return true;
     } catch (e) {
@@ -7054,85 +7070,85 @@ var $export = __webpack_require__(0);
 var $includes = __webpack_require__(50)(true);
 
 $export($export.P, 'Array', {
   includes: function includes(el /* , fromIndex = 0 */) {
     return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
   }
 });
 
-__webpack_require__(30)('includes');
+__webpack_require__(31)('includes');
 
 
 /***/ }),
 /* 265 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 // https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap
 var $export = __webpack_require__(0);
 var flattenIntoArray = __webpack_require__(119);
 var toObject = __webpack_require__(9);
 var toLength = __webpack_require__(8);
 var aFunction = __webpack_require__(10);
-var arraySpeciesCreate = __webpack_require__(82);
+var arraySpeciesCreate = __webpack_require__(83);
 
 $export($export.P, 'Array', {
   flatMap: function flatMap(callbackfn /* , thisArg */) {
     var O = toObject(this);
     var sourceLen, A;
     aFunction(callbackfn);
     sourceLen = toLength(O.length);
     A = arraySpeciesCreate(O, 0);
     flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments[1]);
     return A;
   }
 });
 
-__webpack_require__(30)('flatMap');
+__webpack_require__(31)('flatMap');
 
 
 /***/ }),
 /* 266 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 // https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatten
 var $export = __webpack_require__(0);
 var flattenIntoArray = __webpack_require__(119);
 var toObject = __webpack_require__(9);
 var toLength = __webpack_require__(8);
 var toInteger = __webpack_require__(24);
-var arraySpeciesCreate = __webpack_require__(82);
+var arraySpeciesCreate = __webpack_require__(83);
 
 $export($export.P, 'Array', {
   flatten: function flatten(/* depthArg = 1 */) {
     var depthArg = arguments[0];
     var O = toObject(this);
     var sourceLen = toLength(O.length);
     var A = arraySpeciesCreate(O, 0);
     flattenIntoArray(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : toInteger(depthArg));
     return A;
   }
 });
 
-__webpack_require__(30)('flatten');
+__webpack_require__(31)('flatten');
 
 
 /***/ }),
 /* 267 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 // https://github.com/mathiasbynens/String.prototype.at
 var $export = __webpack_require__(0);
-var $at = __webpack_require__(74)(true);
+var $at = __webpack_require__(75)(true);
 
 $export($export.P, 'String', {
   at: function at(pos) {
     return $at(this, pos);
   }
 });
 
 
@@ -7140,17 +7156,17 @@ var $at = __webpack_require__(74)(true);
 /* 268 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 // https://github.com/tc39/proposal-string-pad-start-end
 var $export = __webpack_require__(0);
 var $pad = __webpack_require__(120);
-var userAgent = __webpack_require__(89);
+var userAgent = __webpack_require__(58);
 
 // https://github.com/zloirock/core-js/issues/280
 $export($export.P + $export.F * /Version\/10\.\d+(\.\d+)? Safari\//.test(userAgent), 'String', {
   padStart: function padStart(maxLength /* , fillString = ' ' */) {
     return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true);
   }
 });
 
@@ -7159,17 +7175,17 @@ var userAgent = __webpack_require__(89);
 /* 269 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 // https://github.com/tc39/proposal-string-pad-start-end
 var $export = __webpack_require__(0);
 var $pad = __webpack_require__(120);
-var userAgent = __webpack_require__(89);
+var userAgent = __webpack_require__(58);
 
 // https://github.com/zloirock/core-js/issues/280
 $export($export.P + $export.F * /Version\/10\.\d+(\.\d+)? Safari\//.test(userAgent), 'String', {
   padEnd: function padEnd(maxLength /* , fillString = ' ' */) {
     return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false);
   }
 });
 
@@ -7216,17 +7232,17 @@ var isRegExp = __webpack_require__(53);
 var getFlags = __webpack_require__(55);
 var RegExpProto = RegExp.prototype;
 
 var $RegExpStringIterator = function (regexp, string) {
   this._r = regexp;
   this._s = string;
 };
 
-__webpack_require__(76)($RegExpStringIterator, 'RegExp String', function next() {
+__webpack_require__(77)($RegExpStringIterator, 'RegExp String', function next() {
   var match = this._r.exec(this._s);
   return { value: match, done: match === null };
 });
 
 $export($export.P, 'String', {
   matchAll: function matchAll(regexp) {
     defined(this);
     if (!isRegExp(regexp)) throw TypeError(regexp + ' is not a regexp!');
@@ -7238,36 +7254,36 @@ var $RegExpStringIterator = function (re
   }
 });
 
 
 /***/ }),
 /* 273 */
 /***/ (function(module, exports, __webpack_require__) {
 
-__webpack_require__(64)('asyncIterator');
+__webpack_require__(65)('asyncIterator');
 
 
 /***/ }),
 /* 274 */
 /***/ (function(module, exports, __webpack_require__) {
 
-__webpack_require__(64)('observable');
+__webpack_require__(65)('observable');
 
 
 /***/ }),
 /* 275 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://github.com/tc39/proposal-object-getownpropertydescriptors
 var $export = __webpack_require__(0);
 var ownKeys = __webpack_require__(118);
 var toIObject = __webpack_require__(15);
 var gOPD = __webpack_require__(16);
-var createProperty = __webpack_require__(80);
+var createProperty = __webpack_require__(81);
 
 $export($export.S, 'Object', {
   getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) {
     var O = toIObject(object);
     var getDesc = gOPD.f;
     var keys = ownKeys(O);
     var result = {};
     var i = 0;
@@ -7318,17 +7334,17 @@ var $entries = __webpack_require__(121)(
 "use strict";
 
 var $export = __webpack_require__(0);
 var toObject = __webpack_require__(9);
 var aFunction = __webpack_require__(10);
 var $defineProperty = __webpack_require__(7);
 
 // B.2.2.2 Object.prototype.__defineGetter__(P, getter)
-__webpack_require__(6) && $export($export.P + __webpack_require__(60), 'Object', {
+__webpack_require__(6) && $export($export.P + __webpack_require__(61), 'Object', {
   __defineGetter__: function __defineGetter__(P, getter) {
     $defineProperty.f(toObject(this), P, { get: aFunction(getter), enumerable: true, configurable: true });
   }
 });
 
 
 /***/ }),
 /* 279 */
@@ -7337,17 +7353,17 @@ var $defineProperty = __webpack_require_
 "use strict";
 
 var $export = __webpack_require__(0);
 var toObject = __webpack_require__(9);
 var aFunction = __webpack_require__(10);
 var $defineProperty = __webpack_require__(7);
 
 // B.2.2.3 Object.prototype.__defineSetter__(P, setter)
-__webpack_require__(6) && $export($export.P + __webpack_require__(60), 'Object', {
+__webpack_require__(6) && $export($export.P + __webpack_require__(61), 'Object', {
   __defineSetter__: function __defineSetter__(P, setter) {
     $defineProperty.f(toObject(this), P, { set: aFunction(setter), enumerable: true, configurable: true });
   }
 });
 
 
 /***/ }),
 /* 280 */
@@ -7357,17 +7373,17 @@ var $defineProperty = __webpack_require_
 
 var $export = __webpack_require__(0);
 var toObject = __webpack_require__(9);
 var toPrimitive = __webpack_require__(22);
 var getPrototypeOf = __webpack_require__(17);
 var getOwnPropertyDescriptor = __webpack_require__(16).f;
 
 // B.2.2.4 Object.prototype.__lookupGetter__(P)
-__webpack_require__(6) && $export($export.P + __webpack_require__(60), 'Object', {
+__webpack_require__(6) && $export($export.P + __webpack_require__(61), 'Object', {
   __lookupGetter__: function __lookupGetter__(P) {
     var O = toObject(this);
     var K = toPrimitive(P, true);
     var D;
     do {
       if (D = getOwnPropertyDescriptor(O, K)) return D.get;
     } while (O = getPrototypeOf(O));
   }
@@ -7382,17 +7398,17 @@ var getOwnPropertyDescriptor = __webpack
 
 var $export = __webpack_require__(0);
 var toObject = __webpack_require__(9);
 var toPrimitive = __webpack_require__(22);
 var getPrototypeOf = __webpack_require__(17);
 var getOwnPropertyDescriptor = __webpack_require__(16).f;
 
 // B.2.2.5 Object.prototype.__lookupSetter__(P)
-__webpack_require__(6) && $export($export.P + __webpack_require__(60), 'Object', {
+__webpack_require__(6) && $export($export.P + __webpack_require__(61), 'Object', {
   __lookupSetter__: function __lookupSetter__(P) {
     var O = toObject(this);
     var K = toPrimitive(P, true);
     var D;
     do {
       if (D = getOwnPropertyDescriptor(O, K)) return D.set;
     } while (O = getPrototypeOf(O));
   }
@@ -7419,73 +7435,73 @@ var $export = __webpack_require__(0);
 $export($export.P + $export.R, 'Set', { toJSON: __webpack_require__(122)('Set') });
 
 
 /***/ }),
 /* 284 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://tc39.github.io/proposal-setmap-offrom/#sec-map.of
-__webpack_require__(61)('Map');
+__webpack_require__(62)('Map');
 
 
 /***/ }),
 /* 285 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://tc39.github.io/proposal-setmap-offrom/#sec-set.of
-__webpack_require__(61)('Set');
+__webpack_require__(62)('Set');
 
 
 /***/ }),
 /* 286 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of
-__webpack_require__(61)('WeakMap');
+__webpack_require__(62)('WeakMap');
 
 
 /***/ }),
 /* 287 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.of
-__webpack_require__(61)('WeakSet');
+__webpack_require__(62)('WeakSet');
 
 
 /***/ }),
 /* 288 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://tc39.github.io/proposal-setmap-offrom/#sec-map.from
-__webpack_require__(62)('Map');
+__webpack_require__(63)('Map');
 
 
 /***/ }),
 /* 289 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://tc39.github.io/proposal-setmap-offrom/#sec-set.from
-__webpack_require__(62)('Set');
+__webpack_require__(63)('Set');
 
 
 /***/ }),
 /* 290 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.from
-__webpack_require__(62)('WeakMap');
+__webpack_require__(63)('WeakMap');
 
 
 /***/ }),
 /* 291 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.from
-__webpack_require__(62)('WeakSet');
+__webpack_require__(63)('WeakSet');
 
 
 /***/ }),
 /* 292 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://github.com/tc39/proposal-global
 var $export = __webpack_require__(0);
@@ -7504,17 +7520,17 @@ var $export = __webpack_require__(0);
 
 
 /***/ }),
 /* 294 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://github.com/ljharb/proposal-is-error
 var $export = __webpack_require__(0);
-var cof = __webpack_require__(19);
+var cof = __webpack_require__(20);
 
 $export($export.S, 'Error', {
   isError: function isError(it) {
     return cof(it) === 'Error';
   }
 });
 
 
@@ -7702,17 +7718,17 @@ var $export = __webpack_require__(0);
 /***/ }),
 /* 307 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 // https://github.com/tc39/proposal-promise-finally
 
 var $export = __webpack_require__(0);
-var core = __webpack_require__(21);
+var core = __webpack_require__(18);
 var global = __webpack_require__(2);
 var speciesConstructor = __webpack_require__(57);
 var promiseResolve = __webpack_require__(111);
 
 $export($export.P + $export.R, 'Promise', { 'finally': function (onFinally) {
   var C = speciesConstructor(this, core.Promise || global.Promise);
   var isFunction = typeof onFinally == 'function';
   return this.then(
@@ -7729,17 +7745,17 @@ var promiseResolve = __webpack_require__
 /***/ }),
 /* 308 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 // https://github.com/tc39/proposal-promise-try
 var $export = __webpack_require__(0);
-var newPromiseCapability = __webpack_require__(87);
+var newPromiseCapability = __webpack_require__(88);
 var perform = __webpack_require__(110);
 
 $export($export.S, 'Promise', { 'try': function (callbackfn) {
   var promiseCapability = newPromiseCapability.f(this);
   var result = perform(callbackfn);
   (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v);
   return promiseCapability.promise;
 } });
@@ -7916,19 +7932,19 @@ var ordinaryDefineOwnMetadata = $metadat
 
 
 /***/ }),
 /* 318 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-09/sept-25.md#510-globalasap-for-enqueuing-a-microtask
 var $export = __webpack_require__(0);
-var microtask = __webpack_require__(86)();
+var microtask = __webpack_require__(87)();
 var process = __webpack_require__(2).process;
-var isNode = __webpack_require__(19)(process) == 'process';
+var isNode = __webpack_require__(20)(process) == 'process';
 
 $export($export.G, {
   asap: function asap(fn) {
     var domain = isNode && process.domain;
     microtask(domain ? domain.bind(fn) : fn);
   }
 });
 
@@ -7937,18 +7953,18 @@ var isNode = __webpack_require__(19)(pro
 /* 319 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 // https://github.com/zenparsing/es-observable
 var $export = __webpack_require__(0);
 var global = __webpack_require__(2);
-var core = __webpack_require__(21);
-var microtask = __webpack_require__(86)();
+var core = __webpack_require__(18);
+var microtask = __webpack_require__(87)();
 var OBSERVABLE = __webpack_require__(5)('observable');
 var aFunction = __webpack_require__(10);
 var anObject = __webpack_require__(1);
 var anInstance = __webpack_require__(39);
 var redefineAll = __webpack_require__(41);
 var hide = __webpack_require__(11);
 var forOf = __webpack_require__(40);
 var RETURN = forOf.RETURN;
@@ -8141,17 +8157,17 @@ hide($Observable.prototype, OBSERVABLE, 
 
 /***/ }),
 /* 320 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // ie9- setTimeout & setInterval additional parameters fix
 var global = __webpack_require__(2);
 var $export = __webpack_require__(0);
-var userAgent = __webpack_require__(89);
+var userAgent = __webpack_require__(58);
 var slice = [].slice;
 var MSIE = /MSIE .\./.test(userAgent); // <- dirty ie9- check
 var wrap = function (set) {
   return function (fn, time /* , ...args */) {
     var boundArgs = arguments.length > 2;
     var args = boundArgs ? slice.call(arguments, 2) : false;
     return set(boundArgs ? function () {
       // eslint-disable-next-line no-new-func
@@ -8165,28 +8181,28 @@ var wrap = function (set) {
 });
 
 
 /***/ }),
 /* 321 */
 /***/ (function(module, exports, __webpack_require__) {
 
 var $export = __webpack_require__(0);
-var $task = __webpack_require__(85);
+var $task = __webpack_require__(86);
 $export($export.G + $export.B, {
   setImmediate: $task.set,
   clearImmediate: $task.clear
 });
 
 
 /***/ }),
 /* 322 */
 /***/ (function(module, exports, __webpack_require__) {
 
-var $iterators = __webpack_require__(84);
+var $iterators = __webpack_require__(85);
 var getKeys = __webpack_require__(34);
 var redefine = __webpack_require__(12);
 var global = __webpack_require__(2);
 var hide = __webpack_require__(11);
 var Iterators = __webpack_require__(44);
 var wks = __webpack_require__(5);
 var ITERATOR = wks('iterator');
 var TO_STRING_TAG = wks('toStringTag');
@@ -8984,17 +9000,17 @@ for (var collections = getKeys(DOMIterab
 
 /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(90)))
 
 /***/ }),
 /* 324 */
 /***/ (function(module, exports, __webpack_require__) {
 
 __webpack_require__(325);
-module.exports = __webpack_require__(21).RegExp.escape;
+module.exports = __webpack_require__(18).RegExp.escape;
 
 
 /***/ }),
 /* 325 */
 /***/ (function(module, exports, __webpack_require__) {
 
 // https://github.com/benjamingr/RexExp.escape
 var $export = __webpack_require__(0);
--- a/devtools/client/debugger/new/test/mochitest/examples/wasm-sourcemaps/README.md
+++ b/devtools/client/debugger/new/test/mochitest/examples/wasm-sourcemaps/README.md
@@ -1,5 +1,11 @@
 # Building WebAssembly source and source maps
 
 ```
-emcc average.c -O2 -g4 -o average.js -s WASM=1 -s EXPORTED_FUNCTIONS="['_average','_sum']"
+# using https://github.com/yurydelendik/wasmception to build wasm
+$wasminception/dist/bin/clang --target=wasm32-unknown-unknown-wasm \
+  --sysroot $wasminception/bin/clang -nostartfiles -nostdlib \
+  -Wl,-no-entry,--export=fib -g fib.c -o fib.debug.wasm
+
+# remove dwarf sections and build map file
+wasm-dwarf fib.debug.wasm -o fib.wasm.map -s -p "`pwd`=wasm-src://" -x -w fib.wasm
 ```
deleted file mode 100644
--- a/devtools/client/debugger/new/test/mochitest/examples/wasm-sourcemaps/average.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Any copyright is dedicated to the Public Domain.
- * http://creativecommons.org/publicdomain/zero/1.0/ */
-
-extern float average(signed* numbers, unsigned length);
-extern signed sum(signed* numbers, unsigned length);
-
-signed __attribute__((noinline)) sum(signed* numbers, unsigned length)
-{
-  signed result;
-  unsigned i;
-  result = 0;
-  for (i = 0; i < length; i++)
-    result += numbers[i];
-  return result;
-}
-
-float average(signed* numbers, unsigned length)
-{
-  float s = (float)sum(numbers, length);
-  return s / length;
-}
deleted file mode 100644
--- a/devtools/client/debugger/new/test/mochitest/examples/wasm-sourcemaps/average.js
+++ /dev/null
@@ -1,2685 +0,0 @@
-// The Module object: Our interface to the outside world. We import
-// and export values on it, and do the work to get that through
-// closure compiler if necessary. There are various ways Module can be used:
-// 1. Not defined. We create it here
-// 2. A function parameter, function(Module) { ..generated code.. }
-// 3. pre-run appended it, var Module = {}; ..generated code..
-// 4. External script tag defines var Module.
-// We need to do an eval in order to handle the closure compiler
-// case, where this code here is minified but Module was defined
-// elsewhere (e.g. case 4 above). We also need to check if Module
-// already exists (e.g. case 3 above).
-// Note that if you want to run closure, and also to use Module
-// after the generated code, you will need to define   var Module = {};
-// before the code. Then that object will be used in the code, and you
-// can continue to use Module afterwards as well.
-var Module;
-if (!Module) Module = (typeof Module !== "undefined" ? Module : null) || {};
-
-// Sometimes an existing Module object exists with properties
-// meant to overwrite the default module functionality. Here
-// we collect those properties and reapply _after_ we configure
-// the current environment's defaults to avoid having to be so
-// defensive during initialization.
-var moduleOverrides = {};
-for (var key in Module) {
-  if (Module.hasOwnProperty(key)) {
-    moduleOverrides[key] = Module[key];
-  }
-}
-
-// The environment setup code below is customized to use Module.
-// *** Environment setup code ***
-var ENVIRONMENT_IS_WEB = false;
-var ENVIRONMENT_IS_WORKER = false;
-var ENVIRONMENT_IS_NODE = false;
-var ENVIRONMENT_IS_SHELL = false;
-
-// Three configurations we can be running in:
-// 1) We could be the application main() thread running in the main JS UI thread. (ENVIRONMENT_IS_WORKER == false and ENVIRONMENT_IS_PTHREAD == false)
-// 2) We could be the application main() thread proxied to worker. (with Emscripten -s PROXY_TO_WORKER=1) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false)
-// 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true)
-
-if (Module["ENVIRONMENT"]) {
-  if (Module["ENVIRONMENT"] === "WEB") {
-    ENVIRONMENT_IS_WEB = true;
-  } else if (Module["ENVIRONMENT"] === "WORKER") {
-    ENVIRONMENT_IS_WORKER = true;
-  } else if (Module["ENVIRONMENT"] === "NODE") {
-    ENVIRONMENT_IS_NODE = true;
-  } else if (Module["ENVIRONMENT"] === "SHELL") {
-    ENVIRONMENT_IS_SHELL = true;
-  } else {
-    throw new Error(
-      "The provided Module['ENVIRONMENT'] value is not valid. It must be one of: WEB|WORKER|NODE|SHELL."
-    );
-  }
-} else {
-  ENVIRONMENT_IS_WEB = typeof window === "object";
-  ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
-  ENVIRONMENT_IS_NODE =
-    typeof process === "object" &&
-    typeof require === "function" &&
-    !ENVIRONMENT_IS_WEB &&
-    !ENVIRONMENT_IS_WORKER;
-  ENVIRONMENT_IS_SHELL =
-    !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
-}
-
-if (ENVIRONMENT_IS_NODE) {
-  // Expose functionality in the same simple way that the shells work
-  // Note that we pollute the global namespace here, otherwise we break in node
-  if (!Module["print"]) Module["print"] = console.log;
-  if (!Module["printErr"]) Module["printErr"] = console.warn;
-
-  var nodeFS;
-  var nodePath;
-
-  Module["read"] = function shell_read(filename, binary) {
-    if (!nodeFS) nodeFS = require("fs");
-    if (!nodePath) nodePath = require("path");
-    filename = nodePath["normalize"](filename);
-    var ret = nodeFS["readFileSync"](filename);
-    return binary ? ret : ret.toString();
-  };
-
-  Module["readBinary"] = function readBinary(filename) {
-    var ret = Module["read"](filename, true);
-    if (!ret.buffer) {
-      ret = new Uint8Array(ret);
-    }
-    assert(ret.buffer);
-    return ret;
-  };
-
-  Module["load"] = function load(f) {
-    globalEval(read(f));
-  };
-
-  if (!Module["thisProgram"]) {
-    if (process["argv"].length > 1) {
-      Module["thisProgram"] = process["argv"][1].replace(/\\/g, "/");
-    } else {
-      Module["thisProgram"] = "unknown-program";
-    }
-  }
-
-  Module["arguments"] = process["argv"].slice(2);
-
-  if (typeof module !== "undefined") {
-    module["exports"] = Module;
-  }
-
-  process["on"]("uncaughtException", function(ex) {
-    // suppress ExitStatus exceptions from showing an error
-    if (!(ex instanceof ExitStatus)) {
-      throw ex;
-    }
-  });
-
-  Module["inspect"] = function() {
-    return "[Emscripten Module object]";
-  };
-} else if (ENVIRONMENT_IS_SHELL) {
-  if (!Module["print"]) Module["print"] = print;
-  if (typeof printErr != "undefined") Module["printErr"] = printErr; // not present in v8 or older sm
-
-  if (typeof read != "undefined") {
-    Module["read"] = read;
-  } else {
-    Module["read"] = function shell_read() {
-      throw "no read() available";
-    };
-  }
-
-  Module["readBinary"] = function readBinary(f) {
-    if (typeof readbuffer === "function") {
-      return new Uint8Array(readbuffer(f));
-    }
-    var data = read(f, "binary");
-    assert(typeof data === "object");
-    return data;
-  };
-
-  if (typeof scriptArgs != "undefined") {
-    Module["arguments"] = scriptArgs;
-  } else if (typeof arguments != "undefined") {
-    Module["arguments"] = arguments;
-  }
-
-  if (typeof quit === "function") {
-    Module["quit"] = function(status, toThrow) {
-      quit(status);
-    };
-  }
-} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
-  Module["read"] = function shell_read(url) {
-    var xhr = new XMLHttpRequest();
-    xhr.open("GET", url, false);
-    xhr.send(null);
-    return xhr.responseText;
-  };
-
-  if (ENVIRONMENT_IS_WORKER) {
-    Module["readBinary"] = function readBinary(url) {
-      var xhr = new XMLHttpRequest();
-      xhr.open("GET", url, false);
-      xhr.responseType = "arraybuffer";
-      xhr.send(null);
-      return new Uint8Array(xhr.response);
-    };
-  }
-
-  Module["readAsync"] = function readAsync(url, onload, onerror) {
-    var xhr = new XMLHttpRequest();
-    xhr.open("GET", url, true);
-    xhr.responseType = "arraybuffer";
-    xhr.onload = function xhr_onload() {
-      if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
-        // file URLs can return 0
-        onload(xhr.response);
-      } else {
-        onerror();
-      }
-    };
-    xhr.onerror = onerror;
-    xhr.send(null);
-  };
-
-  if (typeof arguments != "undefined") {
-    Module["arguments"] = arguments;
-  }
-
-  if (typeof console !== "undefined") {
-    if (!Module["print"])
-      Module["print"] = function shell_print(x) {
-        console.log(x);
-      };
-    if (!Module["printErr"])
-      Module["printErr"] = function shell_printErr(x) {
-        console.warn(x);
-      };
-  } else {
-    // Probably a worker, and without console.log. We can do very little here...
-    var TRY_USE_DUMP = false;
-    if (!Module["print"])
-      Module["print"] =
-        TRY_USE_DUMP && typeof dump !== "undefined"
-          ? function(x) {
-              dump(x);
-            }
-          : function(x) {
-              // self.postMessage(x); // enable this if you want stdout to be sent as messages
-            };
-  }
-
-  if (ENVIRONMENT_IS_WORKER) {
-    Module["load"] = importScripts;
-  }
-
-  if (typeof Module["setWindowTitle"] === "undefined") {
-    Module["setWindowTitle"] = function(title) {
-      document.title = title;
-    };
-  }
-} else {
-  // Unreachable because SHELL is dependant on the others
-  throw "Unknown runtime environment. Where are we?";
-}
-
-function globalEval(x) {
-  eval.call(null, x);
-}
-if (!Module["load"] && Module["read"]) {
-  Module["load"] = function load(f) {
-    globalEval(Module["read"](f));
-  };
-}
-if (!Module["print"]) {
-  Module["print"] = function() {};
-}
-if (!Module["printErr"]) {
-  Module["printErr"] = Module["print"];
-}
-if (!Module["arguments"]) {
-  Module["arguments"] = [];
-}
-if (!Module["thisProgram"]) {
-  Module["thisProgram"] = "./this.program";
-}
-if (!Module["quit"]) {
-  Module["quit"] = function(status, toThrow) {
-    throw toThrow;
-  };
-}
-
-// *** Environment setup code ***
-
-// Closure helpers
-Module.print = Module["print"];
-Module.printErr = Module["printErr"];
-
-// Callbacks
-Module["preRun"] = [];
-Module["postRun"] = [];
-
-// Merge back in the overrides
-for (var key in moduleOverrides) {
-  if (moduleOverrides.hasOwnProperty(key)) {
-    Module[key] = moduleOverrides[key];
-  }
-}
-// Free the object hierarchy contained in the overrides, this lets the GC
-// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
-moduleOverrides = undefined;
-
-// {{PREAMBLE_ADDITIONS}}
-
-// === Preamble library stuff ===
-
-// Documentation for the public APIs defined in this file must be updated in:
-//    site/source/docs/api_reference/preamble.js.rst
-// A prebuilt local version of the documentation is available at:
-//    site/build/text/docs/api_reference/preamble.js.txt
-// You can also build docs locally as HTML or other formats in site/
-// An online HTML version (which may be of a different version of Emscripten)
-//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
-
-//========================================
-// Runtime code shared with compiler
-//========================================
-
-var Runtime = {
-  setTempRet0: function(value) {
-    tempRet0 = value;
-    return value;
-  },
-  getTempRet0: function() {
-    return tempRet0;
-  },
-  stackSave: function() {
-    return STACKTOP;
-  },
-  stackRestore: function(stackTop) {
-    STACKTOP = stackTop;
-  },
-  getNativeTypeSize: function(type) {
-    switch (type) {
-      case "i1":
-      case "i8":
-        return 1;
-      case "i16":
-        return 2;
-      case "i32":
-        return 4;
-      case "i64":
-        return 8;
-      case "float":
-        return 4;
-      case "double":
-        return 8;
-      default: {
-        if (type[type.length - 1] === "*") {
-          return Runtime.QUANTUM_SIZE; // A pointer
-        } else if (type[0] === "i") {
-          var bits = parseInt(type.substr(1));
-          assert(bits % 8 === 0);
-          return bits / 8;
-        } else {
-          return 0;
-        }
-      }
-    }
-  },
-  getNativeFieldSize: function(type) {
-    return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
-  },
-  STACK_ALIGN: 16,
-  prepVararg: function(ptr, type) {
-    if (type === "double" || type === "i64") {
-      // move so the load is aligned
-      if (ptr & 7) {
-        assert((ptr & 7) === 4);
-        ptr += 4;
-      }
-    } else {
-      assert((ptr & 3) === 0);
-    }
-    return ptr;
-  },
-  getAlignSize: function(type, size, vararg) {
-    // we align i64s and doubles on 64-bit boundaries, unlike x86
-    if (!vararg && (type == "i64" || type == "double")) return 8;
-    if (!type) return Math.min(size, 8); // align structures internally to 64 bits
-    return Math.min(
-      size || (type ? Runtime.getNativeFieldSize(type) : 0),
-      Runtime.QUANTUM_SIZE
-    );
-  },
-  dynCall: function(sig, ptr, args) {
-    if (args && args.length) {
-      return Module["dynCall_" + sig].apply(null, [ptr].concat(args));
-    } else {
-      return Module["dynCall_" + sig].call(null, ptr);
-    }
-  },
-  functionPointers: [],
-  addFunction: function(func) {
-    for (var i = 0; i < Runtime.functionPointers.length; i++) {
-      if (!Runtime.functionPointers[i]) {
-        Runtime.functionPointers[i] = func;
-        return 2 * (1 + i);
-      }
-    }
-    throw "Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.";
-  },
-  removeFunction: function(index) {
-    Runtime.functionPointers[(index - 2) / 2] = null;
-  },
-  warnOnce: function(text) {
-    if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
-    if (!Runtime.warnOnce.shown[text]) {
-      Runtime.warnOnce.shown[text] = 1;
-      Module.printErr(text);
-    }
-  },
-  funcWrappers: {},
-  getFuncWrapper: function(func, sig) {
-    if (!func) return; // on null pointer, return undefined
-    assert(sig);
-    if (!Runtime.funcWrappers[sig]) {
-      Runtime.funcWrappers[sig] = {};
-    }
-    var sigCache = Runtime.funcWrappers[sig];
-    if (!sigCache[func]) {
-      // optimize away arguments usage in common cases
-      if (sig.length === 1) {
-        sigCache[func] = function dynCall_wrapper() {
-          return Runtime.dynCall(sig, func);
-        };
-      } else if (sig.length === 2) {
-        sigCache[func] = function dynCall_wrapper(arg) {
-          return Runtime.dynCall(sig, func, [arg]);
-        };
-      } else {
-        // general case
-        sigCache[func] = function dynCall_wrapper() {
-          return Runtime.dynCall(
-            sig,
-            func,
-            Array.prototype.slice.call(arguments)
-          );
-        };
-      }
-    }
-    return sigCache[func];
-  },
-  getCompilerSetting: function(name) {
-    throw "You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work";
-  },
-  stackAlloc: function(size) {
-    var ret = STACKTOP;
-    STACKTOP = (STACKTOP + size) | 0;
-    STACKTOP = (STACKTOP + 15) & -16;
-    return ret;
-  },
-  staticAlloc: function(size) {