Merge mozilla-central to autoland
authorarthur.iakab <aiakab@mozilla.com>
Tue, 03 Jul 2018 11:57:10 +0300
changeset 424799 e06c40d73f8d1c0b616b57e4ff6355e62616c0d6
parent 424755 2a62423eaaa98c3829226ad181caad94d5e72d24 (current diff)
parent 424798 a0e47ebc4c06e652b919dabee711fdbd6bfd31b5 (diff)
child 424800 b42a4a801685e9aa379c96b8741a4f03bc200da1
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)
milestone63.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge mozilla-central to autoland
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
--- 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) {
-    var ret = STATICTOP;
-    STATICTOP = (STATICTOP + size) | 0;
-    STATICTOP = (STATICTOP + 15) & -16;
-    return ret;
-  },
-  dynamicAlloc: function(size) {
-    var ret = HEAP32[DYNAMICTOP_PTR >> 2];
-    var end = ((ret + size + 15) | 0) & -16;
-    HEAP32[DYNAMICTOP_PTR >> 2] = end;
-    if (end >= TOTAL_MEMORY) {
-      var success = enlargeMemory();
-      if (!success) {
-        HEAP32[DYNAMICTOP_PTR >> 2] = ret;
-        return 0;
-      }
-    }
-    return ret;
-  },
-  alignMemory: function(size, quantum) {
-    var ret = (size =
-      Math.ceil(size / (quantum ? quantum : 16)) * (quantum ? quantum : 16));
-    return ret;
-  },
-  makeBigInt: function(low, high, unsigned) {
-    var ret = unsigned
-      ? +(low >>> 0) + +(high >>> 0) * 4294967296.0
-      : +(low >>> 0) + +(high | 0) * 4294967296.0;
-    return ret;
-  },
-  GLOBAL_BASE: 1024,
-  QUANTUM_SIZE: 4,
-  __dummy__: 0
-};
-
-Module["Runtime"] = Runtime;
-
-//========================================
-// Runtime essentials
-//========================================
-
-var ABORT = 0; // whether we are quitting the application. no code should run after this. set in exit() and abort()
-var EXITSTATUS = 0;
-
-/** @type {function(*, string=)} */
-function assert(condition, text) {
-  if (!condition) {
-    abort("Assertion failed: " + text);
-  }
-}
-
-var globalScope = this;
-
-// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
-function getCFunc(ident) {
-  var func = Module["_" + ident]; // closure exported function
-  if (!func) {
-    try {
-      func = eval("_" + ident);
-    } catch (e) {}
-  }
-  assert(
-    func,
-    "Cannot call unknown function " +
-      ident +
-      " (perhaps LLVM optimizations or closure removed it?)"
-  );
-  return func;
-}
-
-var cwrap, ccall;
-(function() {<