text: !function(root, factory) {
      "object" == typeof exports && "object" == typeof module ? module.exports = factory() : "function" == typeof define && define.amd ? define([], factory) : "object" == typeof exports ? exports.ReactDevToolsBackend = factory() : root.ReactDevToolsBackend = factory();
  }(this, function() {
      return function(modules) {
          function __webpack_require__(moduleId) {
              if (installedModules[moduleId]) return installedModules[moduleId].exports;
              var module = installedModules[moduleId] = {
                  exports: {},
                  id: moduleId,
                  loaded: !1
              };
              return modules[moduleId].call(module.exports, module, module.exports, __webpack_require__), 
              module.loaded = !0, module.exports;
          }
          var installedModules = {};
          return __webpack_require__.m = modules, __webpack_require__.c = installedModules, 
          __webpack_require__.p = "", __webpack_require__(0);
      }([ function(module, exports, __webpack_require__) {
          "use strict";
          function connectToDevTools(options) {
              function scheduleRetry() {
                  setTimeout(function() {
                      return connectToDevTools(options);
                  }, 2e3);
              }
              function handleClose() {
                  hasClosed || (hasClosed = !0, scheduleRetry(), closeListeners.forEach(function(fn) {
                      return fn();
                  }));
              }
              function handleMessage(evt) {
                  var data;
                  if (0 !== evt.data.indexOf("eval:")) {
                      try {
                          data = JSON.parse(evt.data);
                      } catch (e) {
                          return void console.error("failed to parse json: " + evt.data);
                      }
                      messageListeners.forEach(function(fn) {
                          try {
                              fn(data);
                          } catch (e) {
                              throw console.log(data), e;
                          }
                      });
                  }
              }
              var _ref = options || {}, _ref$host = _ref.host, host = void 0 === _ref$host ? "localhost" : _ref$host, _ref$port = _ref.port, port = void 0 === _ref$port ? 8097 : _ref$port, _ref$resolveRNStyle = _ref.resolveRNStyle, resolveRNStyle = void 0 === _ref$resolveRNStyle ? null : _ref$resolveRNStyle, _ref$isAppActive = _ref.isAppActive, isAppActive = void 0 === _ref$isAppActive ? function() {
                  return !0;
              } : _ref$isAppActive;
              if (!isAppActive()) return void scheduleRetry();
              var messageListeners = [], closeListeners = [], uri = "ws://" + host + ":" + port, ws = new window.WebSocket(uri);
              ws.onclose = handleClose, ws.onerror = handleClose, ws.onmessage = handleMessage, 
              ws.onopen = function() {
                  var wall = {
                      listen: function(fn) {
                          messageListeners.push(fn);
                      },
                      onClose: function(fn) {
                          closeListeners.push(fn);
                      },
                      send: function(data) {
                          ws.send(JSON.stringify(data));
                      }
                  };
                  setupBackend(wall, resolveRNStyle);
              };
              var hasClosed = !1;
          }
          function setupBackend(wall, resolveRNStyle) {
              wall.onClose(function() {
                  agent && agent.emit("shutdown"), window.__REACT_DEVTOOLS_GLOBAL_HOOK__.emit("shutdown"), 
                  bridge = null, agent = null, console.log("closing devtools");
              });
              var bridge = new Bridge(wall), agent = new Agent(window, {
                  rnStyle: !!resolveRNStyle,
                  rnStyleMeasure: !!resolveRNStyle
              });
              agent.addBridge(bridge), resolveRNStyle && setupRNStyle(bridge, agent, resolveRNStyle), 
              setupRelay(bridge, agent, window.__REACT_DEVTOOLS_GLOBAL_HOOK__);
              var _connectTimeout = setTimeout(function() {
                  console.warn("react-devtools agent got no connection");
              }, 2e4);
              agent.once("connected", function() {
                  agent && (inject(window.__REACT_DEVTOOLS_GLOBAL_HOOK__, agent), clearTimeout(_connectTimeout));
              });
          }
          var Agent = __webpack_require__(1), Bridge = __webpack_require__(6), installGlobalHook = __webpack_require__(31), installRelayHook = __webpack_require__(32), inject = __webpack_require__(33), setupRNStyle = __webpack_require__(43), setupRelay = __webpack_require__(45);
          installGlobalHook(window), installRelayHook(window), window.document && window.__REACT_DEVTOOLS_GLOBAL_HOOK__.on("react-devtools", function(agent) {
              var setupHighlighter = __webpack_require__(46);
              setupHighlighter(agent);
          }), module.exports = {
              connectToDevTools: connectToDevTools
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          function _classCallCheck(instance, Constructor) {
              if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
          }
          function _possibleConstructorReturn(self, call) {
              if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
              return !call || "object" != typeof call && "function" != typeof call ? self : call;
          }
          function _inherits(subClass, superClass) {
              if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
              subClass.prototype = Object.create(superClass && superClass.prototype, {
                  constructor: {
                      value: subClass,
                      enumerable: !1,
                      writable: !0,
                      configurable: !0
                  }
              }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
          }
          var _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) {
              return typeof obj;
          } : function(obj) {
              return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
          }, _createClass = function() {
              function defineProperties(target, props) {
                  for (var i = 0; i < props.length; i++) {
                      var descriptor = props[i];
                      descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
                      "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
                  }
              }
              return function(Constructor, protoProps, staticProps) {
                  return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
                  Constructor;
              };
          }(), _require = __webpack_require__(2), EventEmitter = _require.EventEmitter, assign = __webpack_require__(3), guid = __webpack_require__(4), getIn = __webpack_require__(5), Agent = function(_EventEmitter) {
              function Agent(global, capabilities) {
                  _classCallCheck(this, Agent);
                  var _this = _possibleConstructorReturn(this, (Agent.__proto__ || Object.getPrototypeOf(Agent)).call(this));
                  _this.global = global, _this.internalInstancesById = new Map(), _this.idsByInternalInstances = new WeakMap(), 
                  _this.renderers = new Map(), _this.elementData = new Map(), _this.roots = new Set(), 
                  _this.reactInternals = {};
                  var lastSelected;
                  _this.on("selected", function(id) {
                      var data = _this.elementData.get(id);
                      data && data.publicInstance && _this.global.$r === lastSelected && (_this.global.$r = data.publicInstance, 
                      lastSelected = data.publicInstance);
                  }), _this._prevSelected = null, _this._scrollUpdate = !1;
                  var isReactDOM = window.document && "function" == typeof window.document.createElement;
                  return _this.capabilities = assign({
                      scroll: isReactDOM && "function" == typeof window.document.body.scrollIntoView,
                      dom: isReactDOM,
                      editTextContent: !1
                  }, capabilities), isReactDOM && (_this._updateScroll = _this._updateScroll.bind(_this), 
                  window.addEventListener("scroll", _this._onScroll.bind(_this), !0), window.addEventListener("click", _this._onClick.bind(_this), !0), 
                  window.addEventListener("mouseover", _this._onMouseOver.bind(_this), !0), window.addEventListener("resize", _this._onResize.bind(_this), !0)), 
                  _this;
              }
              return _inherits(Agent, _EventEmitter), _createClass(Agent, [ {
                  key: "sub",
                  value: function(ev, fn) {
                      var _this2 = this;
                      return this.on(ev, fn), function() {
                          _this2.removeListener(ev, fn);
                      };
                  }
              }, {
                  key: "setReactInternals",
                  value: function(renderer, reactInternals) {
                      this.reactInternals[renderer] = reactInternals;
                  }
              }, {
                  key: "addBridge",
                  value: function(bridge) {
                      var _this3 = this;
                      bridge.on("requestCapabilities", function() {
                          bridge.send("capabilities", _this3.capabilities), _this3.emit("connected");
                      }), bridge.on("setState", this._setState.bind(this)), bridge.on("setProps", this._setProps.bind(this)), 
                      bridge.on("setContext", this._setContext.bind(this)), bridge.on("makeGlobal", this._makeGlobal.bind(this)), 
                      bridge.on("highlight", function(id) {
                          return _this3.highlight(id);
                      }), bridge.on("highlightMany", function(id) {
                          return _this3.highlightMany(id);
                      }), bridge.on("hideHighlight", function() {
                          return _this3.emit("hideHighlight");
                      }), bridge.on("startInspecting", function() {
                          return _this3.emit("startInspecting");
                      }), bridge.on("stopInspecting", function() {
                          return _this3.emit("stopInspecting");
                      }), bridge.on("selected", function(id) {
                          return _this3.emit("selected", id);
                      }), bridge.on("setInspectEnabled", function(enabled) {
                          _this3._inspectEnabled = enabled, _this3.emit("stopInspecting");
                      }), bridge.on("shutdown", function() {
                          return _this3.emit("shutdown");
                      }), bridge.on("changeTextContent", function(_ref) {
                          var id = _ref.id, text = _ref.text, node = _this3.getNodeForID(id);
                          node && (node.textContent = text);
                      }), bridge.on("putSelectedNode", function(id) {
                          window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$node = _this3.getNodeForID(id);
                      }), bridge.on("putSelectedInstance", function(id) {
                          var node = _this3.elementData.get(id);
                          node ? window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$type = node.type : window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$type = null, 
                          node && node.publicInstance ? window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$inst = node.publicInstance : window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$inst = null;
                      }), bridge.on("checkSelection", function() {
                          var newSelected = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0;
                          if (newSelected !== _this3._prevSelected) {
                              _this3._prevSelected = newSelected;
                              var sentSelected = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$node;
                              newSelected !== sentSelected && _this3.selectFromDOMNode(newSelected, !0);
                          }
                      }), bridge.on("scrollToNode", function(id) {
                          return _this3.scrollToNode(id);
                      }), bridge.on("traceupdatesstatechange", function(value) {
                          return _this3.emit("traceupdatesstatechange", value);
                      }), bridge.on("colorizerchange", function(value) {
                          return _this3.emit("colorizerchange", value);
                      }), this.on("root", function(id) {
                          return bridge.send("root", id);
                      }), this.on("mount", function(data) {
                          return bridge.send("mount", data);
                      }), this.on("update", function(data) {
                          return bridge.send("update", data);
                      }), this.on("unmount", function(id) {
                          bridge.send("unmount", id), bridge.forget(id);
                      }), this.on("setSelection", function(data) {
                          return bridge.send("select", data);
                      }), this.on("setInspectEnabled", function(data) {
                          return bridge.send("setInspectEnabled", data);
                      });
                  }
              }, {
                  key: "scrollToNode",
                  value: function(id) {
                      var node = this.getNodeForID(id);
                      if (!node) return void console.warn("unable to get the node for scrolling");
                      var domElement = node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
                      return domElement ? ("function" == typeof domElement.scrollIntoViewIfNeeded ? domElement.scrollIntoViewIfNeeded() : "function" == typeof domElement.scrollIntoView && domElement.scrollIntoView(), 
                      void this.highlight(id)) : void console.warn("unable to get the domElement for scrolling");
                  }
              }, {
                  key: "highlight",
                  value: function(id) {
                      var data = this.elementData.get(id), node = this.getNodeForID(id);
                      data && node && this.emit("highlight", {
                          node: node,
                          name: data.name,
                          props: data.props
                      });
                  }
              }, {
                  key: "highlightMany",
                  value: function(ids) {
                      var _this4 = this, nodes = [];
                      ids.forEach(function(id) {
                          var node = _this4.getNodeForID(id);
                          node && nodes.push(node);
                      }), nodes.length && this.emit("highlightMany", nodes);
                  }
              }, {
                  key: "getNodeForID",
                  value: function(id) {
                      var component = this.internalInstancesById.get(id);
                      if (!component) return null;
                      var renderer = this.renderers.get(id);
                      return renderer && this.reactInternals[renderer].getNativeFromReactElement ? this.reactInternals[renderer].getNativeFromReactElement(component) : null;
                  }
              }, {
                  key: "selectFromDOMNode",
                  value: function(node, quiet) {
                      var offsetFromLeaf = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 0, id = this.getIDForNode(node);
                      id && this.emit("setSelection", {
                          id: id,
                          quiet: quiet,
                          offsetFromLeaf: offsetFromLeaf
                      });
                  }
              }, {
                  key: "selectFromReactInstance",
                  value: function(instance, quiet) {
                      var id = this.getId(instance);
                      return id ? void this.emit("setSelection", {
                          id: id,
                          quiet: quiet
                      }) : void console.log("no instance id", instance);
                  }
              }, {
                  key: "getIDForNode",
                  value: function(node) {
                      if (!this.reactInternals) return null;
                      var component;
                      for (var renderer in this.reactInternals) {
                          try {
                              component = this.reactInternals[renderer].getReactElementFromNative(node);
                          } catch (e) {}
                          if (component) return this.getId(component);
                      }
                      return null;
                  }
              }, {
                  key: "_setProps",
                  value: function(_ref2) {
                      var id = _ref2.id, path = _ref2.path, value = _ref2.value, data = this.elementData.get(id);
                      data && data.updater && data.updater.setInProps ? data.updater.setInProps(path, value) : console.warn("trying to set props on a component that doesn't support it");
                  }
              }, {
                  key: "_setState",
                  value: function(_ref3) {
                      var id = _ref3.id, path = _ref3.path, value = _ref3.value, data = this.elementData.get(id);
                      data && data.updater && data.updater.setInState ? data.updater.setInState(path, value) : console.warn("trying to set state on a component that doesn't support it");
                  }
              }, {
                  key: "_setContext",
                  value: function(_ref4) {
                      var id = _ref4.id, path = _ref4.path, value = _ref4.value, data = this.elementData.get(id);
                      data && data.updater && data.updater.setInContext ? data.updater.setInContext(path, value) : console.warn("trying to set context on a component that doesn't support it");
                  }
              }, {
                  key: "_makeGlobal",
                  value: function(_ref5) {
                      var id = _ref5.id, path = _ref5.path, data = this.elementData.get(id);
                      if (data) {
                          var value;
                          value = "instance" === path ? data.publicInstance : getIn(data, path), this.global.$tmp = value, 
                          console.log("$tmp =", value);
                      }
                  }
              }, {
                  key: "getId",
                  value: function(internalInstance) {
                      return "object" === ("undefined" == typeof internalInstance ? "undefined" : _typeof(internalInstance)) && internalInstance ? (this.idsByInternalInstances.has(internalInstance) || (this.idsByInternalInstances.set(internalInstance, guid()), 
                      this.internalInstancesById.set(this.idsByInternalInstances.get(internalInstance), internalInstance)), 
                      this.idsByInternalInstances.get(internalInstance)) : internalInstance;
                  }
              }, {
                  key: "addRoot",
                  value: function(renderer, internalInstance) {
                      var id = this.getId(internalInstance);
                      this.roots.add(id), this.emit("root", id);
                  }
              }, {
                  key: "onMounted",
                  value: function(renderer, component, data) {
                      var _this5 = this, id = this.getId(component);
                      this.renderers.set(id, renderer), this.elementData.set(id, data);
                      var send = assign({}, data);
                      send.children && send.children.map && (send.children = send.children.map(function(c) {
                          return _this5.getId(c);
                      })), send.id = id, send.canUpdate = send.updater && !!send.updater.forceUpdate, 
                      delete send.type, delete send.updater, this.emit("mount", send);
                  }
              }, {
                  key: "onUpdated",
                  value: function(component, data) {
                      var _this6 = this, id = this.getId(component);
                      this.elementData.set(id, data);
                      var send = assign({}, data);
                      send.children && send.children.map && (send.children = send.children.map(function(c) {
                          return _this6.getId(c);
                      })), send.id = id, send.canUpdate = send.updater && !!send.updater.forceUpdate, 
                      delete send.type, delete send.updater, this.emit("update", send);
                  }
              }, {
                  key: "onUnmounted",
                  value: function(component) {
                      var id = this.getId(component);
                      this.elementData["delete"](id), this.roots["delete"](id), this.renderers["delete"](id), 
                      this.emit("unmount", id), this.idsByInternalInstances["delete"](component);
                  }
              }, {
                  key: "_onScroll",
                  value: function() {
                      this._scrollUpdate || (this._scrollUpdate = !0, window.requestAnimationFrame(this._updateScroll));
                  }
              }, {
                  key: "_updateScroll",
                  value: function() {
                      this.emit("refreshMultiOverlay"), this.emit("stopInspecting"), this._scrollUpdate = !1;
                  }
              }, {
                  key: "_onClick",
                  value: function(event) {
                      if (this._inspectEnabled) {
                          var id = this.getIDForNode(event.target);
                          id && (event.stopPropagation(), event.preventDefault(), this.emit("setSelection", {
                              id: id
                          }), this.emit("setInspectEnabled", !1));
                      }
                  }
              }, {
                  key: "_onMouseOver",
                  value: function(event) {
                      if (this._inspectEnabled) {
                          var id = this.getIDForNode(event.target);
                          if (!id) return;
                          this.highlight(id);
                      }
                  }
              }, {
                  key: "_onResize",
                  value: function(event) {
                      this.emit("stopInspecting");
                  }
              } ]), Agent;
          }(EventEmitter);
          module.exports = Agent;
      }, function(module, exports) {
          function EventEmitter() {
              this._events = this._events || {}, this._maxListeners = this._maxListeners || void 0;
          }
          function isFunction(arg) {
              return "function" == typeof arg;
          }
          function isNumber(arg) {
              return "number" == typeof arg;
          }
          function isObject(arg) {
              return "object" == typeof arg && null !== arg;
          }
          function isUndefined(arg) {
              return void 0 === arg;
          }
          module.exports = EventEmitter, EventEmitter.EventEmitter = EventEmitter, EventEmitter.prototype._events = void 0, 
          EventEmitter.prototype._maxListeners = void 0, EventEmitter.defaultMaxListeners = 10, 
          EventEmitter.prototype.setMaxListeners = function(n) {
              if (!isNumber(n) || n < 0 || isNaN(n)) throw TypeError("n must be a positive number");
              return this._maxListeners = n, this;
          }, EventEmitter.prototype.emit = function(type) {
              var er, handler, len, args, i, listeners;
              if (this._events || (this._events = {}), "error" === type && (!this._events.error || isObject(this._events.error) && !this._events.error.length)) {
                  if (er = arguments[1], er instanceof Error) throw er;
                  var err = new Error('Uncaught, unspecified "error" event. (' + er + ")");
                  throw err.context = er, err;
              }
              if (handler = this._events[type], isUndefined(handler)) return !1;
              if (isFunction(handler)) switch (arguments.length) {
                case 1:
                  handler.call(this);
                  break;
  
                case 2:
                  handler.call(this, arguments[1]);
                  break;
  
                case 3:
                  handler.call(this, arguments[1], arguments[2]);
                  break;
  
                default:
                  args = Array.prototype.slice.call(arguments, 1), handler.apply(this, args);
              } else if (isObject(handler)) for (args = Array.prototype.slice.call(arguments, 1), 
              listeners = handler.slice(), len = listeners.length, i = 0; i < len; i++) listeners[i].apply(this, args);
              return !0;
          }, EventEmitter.prototype.addListener = function(type, listener) {
              var m;
              if (!isFunction(listener)) throw TypeError("listener must be a function");
              return this._events || (this._events = {}), this._events.newListener && this.emit("newListener", type, isFunction(listener.listener) ? listener.listener : listener), 
              this._events[type] ? isObject(this._events[type]) ? this._events[type].push(listener) : this._events[type] = [ this._events[type], listener ] : this._events[type] = listener, 
              isObject(this._events[type]) && !this._events[type].warned && (m = isUndefined(this._maxListeners) ? EventEmitter.defaultMaxListeners : this._maxListeners, 
              m && m > 0 && this._events[type].length > m && (this._events[type].warned = !0, 
              console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.", this._events[type].length), 
              "function" == typeof console.trace && console.trace())), this;
          }, EventEmitter.prototype.on = EventEmitter.prototype.addListener, EventEmitter.prototype.once = function(type, listener) {
              function g() {
                  this.removeListener(type, g), fired || (fired = !0, listener.apply(this, arguments));
              }
              if (!isFunction(listener)) throw TypeError("listener must be a function");
              var fired = !1;
              return g.listener = listener, this.on(type, g), this;
          }, EventEmitter.prototype.removeListener = function(type, listener) {
              var list, position, length, i;
              if (!isFunction(listener)) throw TypeError("listener must be a function");
              if (!this._events || !this._events[type]) return this;
              if (list = this._events[type], length = list.length, position = -1, list === listener || isFunction(list.listener) && list.listener === listener) delete this._events[type], 
              this._events.removeListener && this.emit("removeListener", type, listener); else if (isObject(list)) {
                  for (i = length; i-- > 0; ) if (list[i] === listener || list[i].listener && list[i].listener === listener) {
                      position = i;
                      break;
                  }
                  if (position < 0) return this;
                  1 === list.length ? (list.length = 0, delete this._events[type]) : list.splice(position, 1), 
                  this._events.removeListener && this.emit("removeListener", type, listener);
              }
              return this;
          }, EventEmitter.prototype.removeAllListeners = function(type) {
              var key, listeners;
              if (!this._events) return this;
              if (!this._events.removeListener) return 0 === arguments.length ? this._events = {} : this._events[type] && delete this._events[type], 
              this;
              if (0 === arguments.length) {
                  for (key in this._events) "removeListener" !== key && this.removeAllListeners(key);
                  return this.removeAllListeners("removeListener"), this._events = {}, this;
              }
              if (listeners = this._events[type], isFunction(listeners)) this.removeListener(type, listeners); else if (listeners) for (;listeners.length; ) this.removeListener(type, listeners[listeners.length - 1]);
              return delete this._events[type], this;
          }, EventEmitter.prototype.listeners = function(type) {
              var ret;
              return ret = this._events && this._events[type] ? isFunction(this._events[type]) ? [ this._events[type] ] : this._events[type].slice() : [];
          }, EventEmitter.prototype.listenerCount = function(type) {
              if (this._events) {
                  var evlistener = this._events[type];
                  if (isFunction(evlistener)) return 1;
                  if (evlistener) return evlistener.length;
              }
              return 0;
          }, EventEmitter.listenerCount = function(emitter, type) {
              return emitter.listenerCount(type);
          };
      }, function(module, exports) {
          "use strict";
          function toObject(val) {
              if (null === val || void 0 === val) throw new TypeError("Object.assign cannot be called with null or undefined");
              return Object(val);
          }
          var hasOwnProperty = Object.prototype.hasOwnProperty, propIsEnumerable = Object.prototype.propertyIsEnumerable;
          module.exports = Object.assign || function(target, source) {
              for (var from, symbols, to = toObject(target), s = 1; s < arguments.length; s++) {
                  from = Object(arguments[s]);
                  for (var key in from) hasOwnProperty.call(from, key) && (to[key] = from[key]);
                  if (Object.getOwnPropertySymbols) {
                      symbols = Object.getOwnPropertySymbols(from);
                      for (var i = 0; i < symbols.length; i++) propIsEnumerable.call(from, symbols[i]) && (to[symbols[i]] = from[symbols[i]]);
                  }
              }
              return to;
          };
      }, function(module, exports) {
          "use strict";
          function guid() {
              return "g" + Math.random().toString(16).substr(2);
          }
          module.exports = guid;
      }, function(module, exports) {
          "use strict";
          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;
              }
              return Array.from(arr);
          }
          function getIn(base, path) {
              return path.reduce(function(obj, attr) {
                  if (obj) {
                      if (obj.hasOwnProperty(attr)) return obj[attr];
                      if ("function" == typeof obj[Symbol.iterator]) return [].concat(_toConsumableArray(obj))[attr];
                  }
                  return null;
              }, base);
          }
          module.exports = getIn;
      }, function(module, exports, __webpack_require__) {
          "use strict";
          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;
              }
              return Array.from(arr);
          }
          function _classCallCheck(instance, Constructor) {
              if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
          }
          function getWindowFunction(name, polyfill) {
              return String(window[name]).indexOf("[native code]") === -1 ? polyfill : window[name];
          }
          var _extends = Object.assign || function(target) {
              for (var i = 1; i < arguments.length; i++) {
                  var source = arguments[i];
                  for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
              }
              return target;
          }, _createClass = function() {
              function defineProperties(target, props) {
                  for (var i = 0; i < props.length; i++) {
                      var descriptor = props[i];
                      descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
                      "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
                  }
              }
              return function(Constructor, protoProps, staticProps) {
                  return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
                  Constructor;
              };
          }(), consts = __webpack_require__(7), hydrate = __webpack_require__(26), dehydrate = __webpack_require__(27), getIn = __webpack_require__(5), performanceNow = __webpack_require__(28), lastRunTimeMS = 5, cancelIdleCallback = getWindowFunction("cancelIdleCallback", clearTimeout), requestIdleCallback = getWindowFunction("requestIdleCallback", function(cb, options) {
              var delayMS = 3e3 * lastRunTimeMS;
              return delayMS > 500 && (delayMS = 500), setTimeout(function() {
                  var startTime = performanceNow();
                  cb({
                      didTimeout: !1,
                      timeRemaining: function() {
                          return 1 / 0;
                      }
                  });
                  var endTime = performanceNow();
                  lastRunTimeMS = (endTime - startTime) / 1e3;
              }, delayMS);
          }), Bridge = function() {
              function Bridge(wall) {
                  _classCallCheck(this, Bridge), this._cbs = new Map(), this._inspectables = new Map(), 
                  this._cid = 0, this._listeners = {}, this._buffer = [], this._flushHandle = null, 
                  this._callers = {}, this._paused = !1, this._wall = wall, wall.listen(this._handleMessage.bind(this));
              }
              return _createClass(Bridge, [ {
                  key: "inspect",
                  value: function(id, path, cb) {
                      var _cid = this._cid++;
                      this._cbs.set(_cid, function(data, cleaned, proto, protoclean) {
                          cleaned.length && hydrate(data, cleaned), proto && protoclean.length && hydrate(proto, protoclean), 
                          proto && (data[consts.proto] = proto), cb(data);
                      }), this._wall.send({
                          type: "inspect",
                          callback: _cid,
                          path: path,
                          id: id
                      });
                  }
              }, {
                  key: "call",
                  value: function(name, args, cb) {
                      var _cid = this._cid++;
                      this._cbs.set(_cid, cb), this._wall.send({
                          type: "call",
                          callback: _cid,
                          args: args,
                          name: name
                      });
                  }
              }, {
                  key: "onCall",
                  value: function(name, handler) {
                      if (this._callers[name]) throw new Error("only one call handler per call name allowed");
                      this._callers[name] = handler;
                  }
              }, {
                  key: "pause",
                  value: function() {
                      this._wall.send({
                          type: "pause"
                      });
                  }
              }, {
                  key: "resume",
                  value: function() {
                      this._wall.send({
                          type: "resume"
                      });
                  }
              }, {
                  key: "setInspectable",
                  value: function(id, data) {
                      var prev = this._inspectables.get(id);
                      return prev ? void this._inspectables.set(id, _extends({}, prev, data)) : void this._inspectables.set(id, data);
                  }
              }, {
                  key: "send",
                  value: function(evt, data) {
                      this._buffer.push({
                          evt: evt,
                          data: data
                      }), this.scheduleFlush();
                  }
              }, {
                  key: "scheduleFlush",
                  value: function() {
                      if (!this._flushHandle && this._buffer.length) {
                          var timeout = this._paused ? 5e3 : 500;
                          this._flushHandle = requestIdleCallback(this.flushBufferWhileIdle.bind(this), {
                              timeout: timeout
                          });
                      }
                  }
              }, {
                  key: "cancelFlush",
                  value: function() {
                      this._flushHandle && (cancelIdleCallback(this._flushHandle), this._flushHandle = null);
                  }
              }, {
                  key: "flushBufferWhileIdle",
                  value: function(deadline) {
                      this._flushHandle = null;
                      for (var chunkCount = this._paused ? 20 : 10, chunkSize = Math.round(this._buffer.length / chunkCount), minChunkSize = this._paused ? 50 : 100; this._buffer.length && (deadline.timeRemaining() > 0 || deadline.didTimeout); ) {
                          var take = Math.min(this._buffer.length, Math.max(minChunkSize, chunkSize)), currentBuffer = this._buffer.splice(0, take);
                          this.flushBufferSlice(currentBuffer);
                      }
                      this._buffer.length && this.scheduleFlush();
                  }
              }, {
                  key: "flushBufferSlice",
                  value: function(bufferSlice) {
                      var _this = this, events = bufferSlice.map(function(_ref) {
                          var evt = _ref.evt, data = _ref.data, cleaned = [], san = dehydrate(data, cleaned);
                          return cleaned.length && _this.setInspectable(data.id, data), {
                              type: "event",
                              evt: evt,
                              data: san,
                              cleaned: cleaned
                          };
                      });
                      this._wall.send({
                          type: "many-events",
                          events: events
                      });
                  }
              }, {
                  key: "forget",
                  value: function(id) {
                      this._inspectables["delete"](id);
                  }
              }, {
                  key: "on",
                  value: function(evt, fn) {
                      this._listeners[evt] ? this._listeners[evt].push(fn) : this._listeners[evt] = [ fn ];
                  }
              }, {
                  key: "off",
                  value: function(evt, fn) {
                      if (this._listeners[evt]) {
                          var ix = this._listeners[evt].indexOf(fn);
                          ix !== -1 && this._listeners[evt].splice(ix, 1);
                      }
                  }
              }, {
                  key: "once",
                  value: function(evt, fn) {
                      var self = this, listener = function listener() {
                          fn.apply(this, arguments), self.off(evt, listener);
                      };
                      this.on(evt, listener);
                  }
              }, {
                  key: "_handleMessage",
                  value: function(payload) {
                      var _this2 = this;
                      if ("resume" === payload.type) return this._paused = !1, void this.scheduleFlush();
                      if ("pause" === payload.type) return this._paused = !0, void this.cancelFlush();
                      if ("callback" === payload.type) {
                          var callback = this._cbs.get(payload.id);
                          return void (callback && (callback.apply(void 0, _toConsumableArray(payload.args)), 
                          this._cbs["delete"](payload.id)));
                      }
                      if ("call" === payload.type) return void this._handleCall(payload.name, payload.args, payload.callback);
                      if ("inspect" === payload.type) return void this._inspectResponse(payload.id, payload.path, payload.callback);
                      if ("event" === payload.type) {
                          payload.cleaned && hydrate(payload.data, payload.cleaned);
                          var fns = this._listeners[payload.evt], data = payload.data;
                          fns && fns.forEach(function(fn) {
                              return fn(data);
                          });
                      }
                      "many-events" === payload.type && payload.events.forEach(function(event) {
                          event.cleaned && hydrate(event.data, event.cleaned);
                          var handlers = _this2._listeners[event.evt];
                          handlers && handlers.forEach(function(fn) {
                              return fn(event.data);
                          });
                      });
                  }
              }, {
                  key: "_handleCall",
                  value: function(name, args, callback) {
                      if (!this._callers[name]) return void console.warn('unknown call: "' + name + '"');
                      args = Array.isArray(args) ? args : [ args ];
                      var result;
                      try {
                          result = this._callers[name].apply(null, args);
                      } catch (e) {
                          return void console.error("Failed to call", e);
                      }
                      this._wall.send({
                          type: "callback",
                          id: callback,
                          args: [ result ]
                      });
                  }
              }, {
                  key: "_inspectResponse",
                  value: function(id, path, callback) {
                      var inspectable = this._inspectables.get(id), result = {}, cleaned = [], proto = null, protoclean = [];
                      if (inspectable) {
                          var val = getIn(inspectable, path), protod = !1, isFn = "function" == typeof val;
                          if (val && "function" == typeof val[Symbol.iterator]) {
                              var iterVal = Object.create({}), count = 0, _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
                              try {
                                  for (var _step, _iterator = val[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
                                      var entry = _step.value;
                                      if (count > 100) break;
                                      iterVal[count] = entry, count++;
                                  }
                              } catch (err) {
                                  _didIteratorError = !0, _iteratorError = err;
                              } finally {
                                  try {
                                      !_iteratorNormalCompletion && _iterator["return"] && _iterator["return"]();
                                  } finally {
                                      if (_didIteratorError) throw _iteratorError;
                                  }
                              }
                              val = iterVal;
                          }
                          if (Object.getOwnPropertyNames(val).forEach(function(name) {
                              "__proto__" === name && (protod = !0), (!isFn || "arguments" !== name && "callee" !== name && "caller" !== name) && (result[name] = dehydrate(val[name], cleaned, [ name ]));
                          }), !protod && val.__proto__ && "Object" !== val.constructor.name) {
                              var newProto = {}, pIsFn = "function" == typeof val.__proto__;
                              Object.getOwnPropertyNames(val.__proto__).forEach(function(name) {
                                  (!pIsFn || "arguments" !== name && "callee" !== name && "caller" !== name) && (newProto[name] = dehydrate(val.__proto__[name], protoclean, [ name ]));
                              }), proto = newProto;
                          }
                      }
                      this._wall.send({
                          type: "callback",
                          id: callback,
                          args: [ result, cleaned, proto, protoclean ]
                      });
                  }
              } ]), Bridge;
          }();
          module.exports = Bridge;
      }, function(module, exports, __webpack_require__) {
          "use strict";
          var _Symbol = __webpack_require__(8);
          module.exports = {
              name: _Symbol("name"),
              type: _Symbol("type"),
              inspected: _Symbol("inspected"),
              meta: _Symbol("meta"),
              proto: _Symbol("proto")
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          module.exports = __webpack_require__(9)() ? Symbol : __webpack_require__(10);
      }, function(module, exports) {
          "use strict";
          module.exports = function() {
              var symbol;
              if ("function" != typeof Symbol) return !1;
              symbol = Symbol("test symbol");
              try {
                  String(symbol);
              } catch (e) {
                  return !1;
              }
              return "symbol" == typeof Symbol.iterator || "object" == typeof Symbol.isConcatSpreadable && ("object" == typeof Symbol.iterator && ("object" == typeof Symbol.toPrimitive && ("object" == typeof Symbol.toStringTag && "object" == typeof Symbol.unscopables)));
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          var NativeSymbol, SymbolPolyfill, HiddenSymbol, d = __webpack_require__(11), validateSymbol = __webpack_require__(24), create = Object.create, defineProperties = Object.defineProperties, defineProperty = Object.defineProperty, objPrototype = Object.prototype, globalSymbols = create(null);
          "function" == typeof Symbol && (NativeSymbol = Symbol);
          var generateName = function() {
              var created = create(null);
              return function(desc) {
                  for (var name, ie11BugWorkaround, postfix = 0; created[desc + (postfix || "")]; ) ++postfix;
                  return desc += postfix || "", created[desc] = !0, name = "@@" + desc, defineProperty(objPrototype, name, d.gs(null, function(value) {
                      ie11BugWorkaround || (ie11BugWorkaround = !0, defineProperty(this, name, d(value)), 
                      ie11BugWorkaround = !1);
                  })), name;
              };
          }();
          HiddenSymbol = function(description) {
              if (this instanceof HiddenSymbol) throw new TypeError("TypeError: Symbol is not a constructor");
              return SymbolPolyfill(description);
          }, module.exports = SymbolPolyfill = function Symbol(description) {
              var symbol;
              if (this instanceof Symbol) throw new TypeError("TypeError: Symbol is not a constructor");
              return symbol = create(HiddenSymbol.prototype), description = void 0 === description ? "" : String(description), 
              defineProperties(symbol, {
                  __description__: d("", description),
                  __name__: d("", generateName(description))
              });
          }, defineProperties(SymbolPolyfill, {
              "for": d(function(key) {
                  return globalSymbols[key] ? globalSymbols[key] : globalSymbols[key] = SymbolPolyfill(String(key));
              }),
              keyFor: d(function(s) {
                  var key;
                  validateSymbol(s);
                  for (key in globalSymbols) if (globalSymbols[key] === s) return key;
              }),
              hasInstance: d("", NativeSymbol && NativeSymbol.hasInstance || SymbolPolyfill("hasInstance")),
              isConcatSpreadable: d("", NativeSymbol && NativeSymbol.isConcatSpreadable || SymbolPolyfill("isConcatSpreadable")),
              iterator: d("", NativeSymbol && NativeSymbol.iterator || SymbolPolyfill("iterator")),
              match: d("", NativeSymbol && NativeSymbol.match || SymbolPolyfill("match")),
              replace: d("", NativeSymbol && NativeSymbol.replace || SymbolPolyfill("replace")),
              search: d("", NativeSymbol && NativeSymbol.search || SymbolPolyfill("search")),
              species: d("", NativeSymbol && NativeSymbol.species || SymbolPolyfill("species")),
              split: d("", NativeSymbol && NativeSymbol.split || SymbolPolyfill("split")),
              toPrimitive: d("", NativeSymbol && NativeSymbol.toPrimitive || SymbolPolyfill("toPrimitive")),
              toStringTag: d("", NativeSymbol && NativeSymbol.toStringTag || SymbolPolyfill("toStringTag")),
              unscopables: d("", NativeSymbol && NativeSymbol.unscopables || SymbolPolyfill("unscopables"))
          }), defineProperties(HiddenSymbol.prototype, {
              constructor: d(SymbolPolyfill),
              toString: d("", function() {
                  return this.__name__;
              })
          }), defineProperties(SymbolPolyfill.prototype, {
              toString: d(function() {
                  return "Symbol (" + validateSymbol(this).__description__ + ")";
              }),
              valueOf: d(function() {
                  return validateSymbol(this);
              })
          }), defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d("", function() {
              return validateSymbol(this);
          })), defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d("c", "Symbol")), 
          defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag, d("c", SymbolPolyfill.prototype[SymbolPolyfill.toStringTag])), 
          defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive, d("c", SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]));
      }, function(module, exports, __webpack_require__) {
          "use strict";
          var d, assign = __webpack_require__(12), normalizeOpts = __webpack_require__(19), isCallable = __webpack_require__(20), contains = __webpack_require__(21);
          d = module.exports = function(dscr, value) {
              var c, e, w, options, desc;
              return arguments.length < 2 || "string" != typeof dscr ? (options = value, value = dscr, 
              dscr = null) : options = arguments[2], null == dscr ? (c = w = !0, e = !1) : (c = contains.call(dscr, "c"), 
              e = contains.call(dscr, "e"), w = contains.call(dscr, "w")), desc = {
                  value: value,
                  configurable: c,
                  enumerable: e,
                  writable: w
              }, options ? assign(normalizeOpts(options), desc) : desc;
          }, d.gs = function(dscr, get, set) {
              var c, e, options, desc;
              return "string" != typeof dscr ? (options = set, set = get, get = dscr, dscr = null) : options = arguments[3], 
              null == get ? get = void 0 : isCallable(get) ? null == set ? set = void 0 : isCallable(set) || (options = set, 
              set = void 0) : (options = get, get = set = void 0), null == dscr ? (c = !0, e = !1) : (c = contains.call(dscr, "c"), 
              e = contains.call(dscr, "e")), desc = {
                  get: get,
                  set: set,
                  configurable: c,
                  enumerable: e
              }, options ? assign(normalizeOpts(options), desc) : desc;
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          module.exports = __webpack_require__(13)() ? Object.assign : __webpack_require__(14);
      }, function(module, exports) {
          "use strict";
          module.exports = function() {
              var obj, assign = Object.assign;
              return "function" == typeof assign && (obj = {
                  foo: "raz"
              }, assign(obj, {
                  bar: "dwa"
              }, {
                  trzy: "trzy"
              }), obj.foo + obj.bar + obj.trzy === "razdwatrzy");
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          var keys = __webpack_require__(15), value = __webpack_require__(18), max = Math.max;
          module.exports = function(dest, src) {
              var error, i, assign, l = max(arguments.length, 2);
              for (dest = Object(value(dest)), assign = function(key) {
                  try {
                      dest[key] = src[key];
                  } catch (e) {
                      error || (error = e);
                  }
              }, i = 1; i < l; ++i) src = arguments[i], keys(src).forEach(assign);
              if (void 0 !== error) throw error;
              return dest;
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          module.exports = __webpack_require__(16)() ? Object.keys : __webpack_require__(17);
      }, function(module, exports) {
          "use strict";
          module.exports = function() {
              try {
                  return Object.keys("primitive"), !0;
              } catch (e) {
                  return !1;
              }
          };
      }, function(module, exports) {
          "use strict";
          var keys = Object.keys;
          module.exports = function(object) {
              return keys(null == object ? object : Object(object));
          };
      }, function(module, exports) {
          "use strict";
          module.exports = function(value) {
              if (null == value) throw new TypeError("Cannot use null or undefined");
              return value;
          };
      }, function(module, exports) {
          "use strict";
          var forEach = Array.prototype.forEach, create = Object.create, process = function(src, obj) {
              var key;
              for (key in src) obj[key] = src[key];
          };
          module.exports = function(options) {
              var result = create(null);
              return forEach.call(arguments, function(options) {
                  null != options && process(Object(options), result);
              }), result;
          };
      }, function(module, exports) {
          "use strict";
          module.exports = function(obj) {
              return "function" == typeof obj;
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          module.exports = __webpack_require__(22)() ? String.prototype.contains : __webpack_require__(23);
      }, function(module, exports) {
          "use strict";
          var str = "razdwatrzy";
          module.exports = function() {
              return "function" == typeof str.contains && (str.contains("dwa") === !0 && str.contains("foo") === !1);
          };
      }, function(module, exports) {
          "use strict";
          var indexOf = String.prototype.indexOf;
          module.exports = function(searchString) {
              return indexOf.call(this, searchString, arguments[1]) > -1;
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          var isSymbol = __webpack_require__(25);
          module.exports = function(value) {
              if (!isSymbol(value)) throw new TypeError(value + " is not a symbol");
              return value;
          };
      }, function(module, exports) {
          "use strict";
          module.exports = function(x) {
              return x && ("symbol" == typeof x || "Symbol" === x["@@toStringTag"]) || !1;
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          function hydrate(data, cleaned) {
              cleaned.forEach(function(path) {
                  var last = path.pop(), obj = path.reduce(function(obj_, attr) {
                      return obj_ ? obj_[attr] : null;
                  }, data);
                  if (obj && obj[last]) {
                      var replace = {};
                      replace[consts.name] = obj[last].name, replace[consts.type] = obj[last].type, replace[consts.meta] = obj[last].meta, 
                      replace[consts.inspected] = !1, obj[last] = replace;
                  }
              });
          }
          var consts = __webpack_require__(7);
          module.exports = hydrate;
      }, function(module, exports) {
          "use strict";
          function getPropType(data) {
              if (!data) return null;
              var type = "undefined" == typeof data ? "undefined" : _typeof(data);
              if ("object" === type) {
                  if (data._reactFragment) return "react_fragment";
                  if (Array.isArray(data)) return "array";
                  if (ArrayBuffer.isView(data)) return data instanceof DataView ? "data_view" : "typed_array";
                  if (data instanceof ArrayBuffer) return "array_buffer";
                  if ("function" == typeof data[Symbol.iterator]) return "iterator";
                  if ("[object Date]" === Object.prototype.toString.call(data)) return "date";
              }
              return type;
          }
          function createDehydrated(type, data, cleaned, path) {
              var meta = {};
              return "array" !== type && "typed_array" !== type || (meta.length = data.length), 
              "iterator" !== type && "typed_array" !== type || (meta.readOnly = !0), cleaned.push(path), 
              {
                  type: type,
                  meta: meta,
                  name: data.constructor && "Object" !== data.constructor.name ? data.constructor.name : ""
              };
          }
          function dehydrate(data, cleaned) {
              var path = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : [], level = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : 0, type = getPropType(data);
              switch (type) {
                case "function":
                  return cleaned.push(path), {
                      name: data.name,
                      type: "function"
                  };
  
                case "string":
                  return data.length <= 500 ? data : data.slice(0, 500) + "...";
  
                case "symbol":
                  return cleaned.push(path), {
                      type: "symbol",
                      name: data.toString()
                  };
  
                case "react_fragment":
                  return "A React Fragment";
  
                case "array_buffer":
                case "data_view":
                  return cleaned.push(path), {
                      type: type,
                      name: "data_view" === type ? "DataView" : "ArrayBuffer",
                      meta: {
                          length: data.byteLength,
                          uninspectable: !0
                      }
                  };
  
                case "array":
                  return level > 2 ? createDehydrated(type, data, cleaned, path) : data.map(function(item, i) {
                      return dehydrate(item, cleaned, path.concat([ i ]), level + 1);
                  });
  
                case "typed_array":
                case "iterator":
                  return createDehydrated(type, data, cleaned, path);
  
                case "date":
                  return cleaned.push(path), {
                      name: data.toString(),
                      type: "date",
                      meta: {
                          uninspectable: !0
                      }
                  };
  
                case "object":
                  if (level > 2 || data.constructor && "function" == typeof data.constructor && "Object" !== data.constructor.name) return createDehydrated(type, data, cleaned, path);
                  var res = {};
                  for (var name in data) res[name] = dehydrate(data[name], cleaned, path.concat([ name ]), level + 1);
                  return res;
  
                default:
                  return data;
              }
          }
          var _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) {
              return typeof obj;
          } : function(obj) {
              return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
          };
          module.exports = dehydrate;
      }, function(module, exports, __webpack_require__) {
          "use strict";
          var performanceNow, performance = __webpack_require__(29);
          performanceNow = performance.now ? function() {
              return performance.now();
          } : function() {
              return Date.now();
          }, module.exports = performanceNow;
      }, function(module, exports, __webpack_require__) {
          "use strict";
          var performance, ExecutionEnvironment = __webpack_require__(30);
          ExecutionEnvironment.canUseDOM && (performance = window.performance || window.msPerformance || window.webkitPerformance), 
          module.exports = performance || {};
      }, function(module, exports) {
          "use strict";
          var canUseDOM = !("undefined" == typeof window || !window.document || !window.document.createElement), ExecutionEnvironment = {
              canUseDOM: canUseDOM,
              canUseWorkers: "undefined" != typeof Worker,
              canUseEventListeners: canUseDOM && !(!window.addEventListener && !window.attachEvent),
              canUseViewport: canUseDOM && !!window.screen,
              isInWorker: !canUseDOM
          };
          module.exports = ExecutionEnvironment;
      }, function(module, exports) {
          "use strict";
          function installGlobalHook(window) {
              function detectReactBuildType(renderer) {
                  try {
                      var toString = Function.prototype.toString;
                      if ("string" == typeof renderer.version) {
                          if (renderer.bundleType > 0) return "development";
                          var findFiberCode = toString.call(renderer.findFiberByHostInstance);
                          return 0 !== findFiberCode.indexOf("function") ? "production" : findFiberCode.indexOf("getClosestInstanceFromNode") !== -1 ? "unminified" : "production";
                      }
                      if (renderer.Mount && renderer.Mount._renderNewRootComponent) {
                          var renderRootCode = toString.call(renderer.Mount._renderNewRootComponent);
                          return 0 !== renderRootCode.indexOf("function") ? "production" : renderRootCode.indexOf("storedMeasure") !== -1 ? "development" : renderRootCode.indexOf("should be a pure function") !== -1 ? renderRootCode.indexOf("NODE_ENV") !== -1 ? "development" : renderRootCode.indexOf("development") !== -1 ? "development" : renderRootCode.indexOf("true") !== -1 ? "development" : renderRootCode.indexOf("nextElement") !== -1 || renderRootCode.indexOf("nextComponent") !== -1 ? "unminified" : "development" : renderRootCode.indexOf("nextElement") !== -1 || renderRootCode.indexOf("nextComponent") !== -1 ? "unminified" : renderRootCode.indexOf("._registerComponent") !== -1 ? "outdated" : "production";
                      }
                  } catch (err) {}
                  return "production";
              }
              if (!window.__REACT_DEVTOOLS_GLOBAL_HOOK__) {
                  var hook = {
                      _renderers: {},
                      helpers: {},
                      inject: function(renderer) {
                          var id = Math.random().toString(16).slice(2);
                          hook._renderers[id] = renderer;
                          var reactBuildType = detectReactBuildType(renderer);
                          return hook.emit("renderer", {
                              id: id,
                              renderer: renderer,
                              reactBuildType: reactBuildType
                          }), id;
                      },
                      _listeners: {},
                      sub: function(evt, fn) {
                          return hook.on(evt, fn), function() {
                              return hook.off(evt, fn);
                          };
                      },
                      on: function(evt, fn) {
                          hook._listeners[evt] || (hook._listeners[evt] = []), hook._listeners[evt].push(fn);
                      },
                      off: function(evt, fn) {
                          if (hook._listeners[evt]) {
                              var ix = hook._listeners[evt].indexOf(fn);
                              ix !== -1 && hook._listeners[evt].splice(ix, 1), hook._listeners[evt].length || (hook._listeners[evt] = null);
                          }
                      },
                      emit: function(evt, data) {
                          hook._listeners[evt] && hook._listeners[evt].map(function(fn) {
                              return fn(data);
                          });
                      },
                      supportsFiber: !0,
                      _fiberRoots: {},
                      getFiberRoots: function(rendererID) {
                          var roots = hook._fiberRoots;
                          return roots[rendererID] || (roots[rendererID] = new Set()), roots[rendererID];
                      },
                      onCommitFiberUnmount: function(rendererID, fiber) {
                          hook.helpers[rendererID] && hook.helpers[rendererID].handleCommitFiberUnmount(fiber);
                      },
                      onCommitFiberRoot: function(rendererID, root) {
                          var mountedRoots = hook.getFiberRoots(rendererID), current = root.current, isKnownRoot = mountedRoots.has(root), isUnmounting = null == current.memoizedState || null == current.memoizedState.element;
                          isKnownRoot || isUnmounting ? isKnownRoot && isUnmounting && mountedRoots["delete"](root) : mountedRoots.add(root), 
                          hook.helpers[rendererID] && hook.helpers[rendererID].handleCommitFiberRoot(root);
                      }
                  };
                  Object.defineProperty(window, "__REACT_DEVTOOLS_GLOBAL_HOOK__", {
                      value: hook
                  });
              }
          }
          module.exports = installGlobalHook;
      }, function(module, exports) {
          "use strict";
          function installRelayHook(window) {
              function decorate(obj, attr, fn) {
                  var old = obj[attr];
                  obj[attr] = function() {
                      var res = old.apply(this, arguments);
                      return fn.apply(this, arguments), res;
                  };
              }
              function emit(name, data) {
                  _eventQueue.push({
                      name: name,
                      data: data
                  }), _listener && _listener(name, data);
              }
              function setRequestListener(listener) {
                  if (_listener) throw new Error("Relay Devtools: Called only call setRequestListener once.");
                  return _listener = listener, _eventQueue.forEach(function(_ref) {
                      var name = _ref.name, data = _ref.data;
                      listener(name, data);
                  }), function() {
                      _listener = null;
                  };
              }
              function recordRequest(type, start, request, requestNumber) {
                  var id = Math.random().toString(16).substr(2);
                  request.then(function(response) {
                      emit("relay:success", {
                          id: id,
                          end: performanceNow(),
                          response: response.response
                      });
                  }, function(error) {
                      emit("relay:failure", {
                          id: id,
                          end: performanceNow(),
                          error: error
                      });
                  });
                  for (var textChunks = [], text = request.getQueryString(); text.length > 0; ) textChunks.push(text.substr(0, TEXT_CHUNK_LENGTH)), 
                  text = text.substr(TEXT_CHUNK_LENGTH);
                  return {
                      id: id,
                      name: request.getDebugName(),
                      requestNumber: requestNumber,
                      start: start,
                      text: textChunks,
                      type: type,
                      variables: request.getVariables()
                  };
              }
              function instrumentRelayRequests(relayInternals) {
                  var NetworkLayer = relayInternals.NetworkLayer;
                  decorate(NetworkLayer, "sendMutation", function(mutation) {
                      requestNumber++, emit("relay:pending", [ recordRequest("mutation", performanceNow(), mutation, requestNumber) ]);
                  }), decorate(NetworkLayer, "sendQueries", function(queries) {
                      requestNumber++;
                      var start = performanceNow();
                      emit("relay:pending", queries.map(function(query) {
                          return recordRequest("query", start, query, requestNumber);
                      }));
                  });
                  var instrumented = {};
                  for (var key in relayInternals) relayInternals.hasOwnProperty(key) && (instrumented[key] = relayInternals[key]);
                  return instrumented.setRequestListener = setRequestListener, instrumented;
              }
              var performanceNow, performance = window.performance;
              performanceNow = performance && "function" == typeof performance.now ? function() {
                  return performance.now();
              } : function() {
                  return Date.now();
              };
              var TEXT_CHUNK_LENGTH = 500, hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
              if (hook) {
                  var _eventQueue = [], _listener = null, requestNumber = 0, _relayInternals = null;
                  Object.defineProperty(hook, "_relayInternals", {
                      configurable: !0,
                      set: function(relayInternals) {
                          _relayInternals = instrumentRelayRequests(relayInternals);
                      },
                      get: function() {
                          return _relayInternals;
                      }
                  });
              }
          }
          module.exports = installRelayHook;
      }, function(module, exports, __webpack_require__) {
          "use strict";
          var setupBackend = __webpack_require__(34);
          module.exports = function(hook, agent) {
              var subs = [ hook.sub("renderer-attached", function(_ref) {
                  var id = _ref.id, helpers = (_ref.renderer, _ref.helpers);
                  agent.setReactInternals(id, helpers), helpers.walkTree(agent.onMounted.bind(agent, id), agent.addRoot.bind(agent, id));
              }), hook.sub("root", function(_ref2) {
                  var renderer = _ref2.renderer, internalInstance = _ref2.internalInstance;
                  return agent.addRoot(renderer, internalInstance);
              }), hook.sub("mount", function(_ref3) {
                  var renderer = _ref3.renderer, internalInstance = _ref3.internalInstance, data = _ref3.data;
                  return agent.onMounted(renderer, internalInstance, data);
              }), hook.sub("update", function(_ref4) {
                  var internalInstance = (_ref4.renderer, _ref4.internalInstance), data = _ref4.data;
                  return agent.onUpdated(internalInstance, data);
              }), hook.sub("unmount", function(_ref5) {
                  var internalInstance = (_ref5.renderer, _ref5.internalInstance);
                  return agent.onUnmounted(internalInstance);
              }) ], success = setupBackend(hook);
              success && (hook.emit("react-devtools", agent), hook.reactDevtoolsAgent = agent, 
              agent.on("shutdown", function() {
                  subs.forEach(function(fn) {
                      return fn();
                  }), hook.reactDevtoolsAgent = null;
              }));
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          var attachRenderer = __webpack_require__(35);
          module.exports = function(hook) {
              var oldReact = window.React && window.React.__internals;
              oldReact && 0 === Object.keys(hook._renderers).length && hook.inject(oldReact);
              for (var rid in hook._renderers) hook.helpers[rid] = attachRenderer(hook, rid, hook._renderers[rid]), 
              hook.emit("renderer-attached", {
                  id: rid,
                  renderer: hook._renderers[rid],
                  helpers: hook.helpers[rid]
              });
              hook.on("renderer", function(_ref) {
                  var id = _ref.id, renderer = _ref.renderer;
                  hook.helpers[id] = attachRenderer(hook, id, renderer), hook.emit("renderer-attached", {
                      id: id,
                      renderer: renderer,
                      helpers: hook.helpers[id]
                  });
              });
              var shutdown = function shutdown() {
                  for (var id in hook.helpers) hook.helpers[id].cleanup();
                  hook.off("shutdown", shutdown);
              };
              return hook.on("shutdown", shutdown), !0;
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          function attachRenderer(hook, rid, renderer) {
              var rootNodeIDMap = new Map(), extras = {}, isPre013 = !renderer.Reconciler;
              if ("function" == typeof renderer.findFiberByHostInstance) return attachRendererFiber(hook, rid, renderer);
              renderer.Mount.findNodeHandle && renderer.Mount.nativeTagToRootNodeID ? (extras.getNativeFromReactElement = function(component) {
                  return renderer.Mount.findNodeHandle(component);
              }, extras.getReactElementFromNative = function(nativeTag) {
                  var id = renderer.Mount.nativeTagToRootNodeID(nativeTag);
                  return rootNodeIDMap.get(id);
              }) : renderer.ComponentTree ? (extras.getNativeFromReactElement = function(component) {
                  return renderer.ComponentTree.getNodeFromInstance(component);
              }, extras.getReactElementFromNative = function(node) {
                  return renderer.ComponentTree.getClosestInstanceFromNode(node);
              }) : renderer.Mount.getID && renderer.Mount.getNode ? (extras.getNativeFromReactElement = function(component) {
                  try {
                      return renderer.Mount.getNode(component._rootNodeID);
                  } catch (e) {
                      return;
                  }
              }, extras.getReactElementFromNative = function(node) {
                  for (var id = renderer.Mount.getID(node); node && node.parentNode && !id; ) node = node.parentNode, 
                  id = renderer.Mount.getID(node);
                  return rootNodeIDMap.get(id);
              }) : console.warn("Unknown react version (does not have getID), probably an unshimmed React Native");
              var oldMethods, oldRenderComponent, oldRenderRoot;
              return renderer.Mount._renderNewRootComponent ? oldRenderRoot = decorateResult(renderer.Mount, "_renderNewRootComponent", function(internalInstance) {
                  hook.emit("root", {
                      renderer: rid,
                      internalInstance: internalInstance
                  });
              }) : renderer.Mount.renderComponent && (oldRenderComponent = decorateResult(renderer.Mount, "renderComponent", function(internalInstance) {
                  hook.emit("root", {
                      renderer: rid,
                      internalInstance: internalInstance._reactInternalInstance
                  });
              })), renderer.Component ? (console.error("You are using a version of React with limited support in this version of the devtools.\nPlease upgrade to use at least 0.13, or you can downgrade to use the old version of the devtools:\ninstructions here https://github.com/facebook/react-devtools/tree/devtools-next#how-do-i-use-this-for-react--013"), 
              oldMethods = decorateMany(renderer.Component.Mixin, {
                  mountComponent: function() {
                      var _this = this;
                      rootNodeIDMap.set(this._rootNodeID, this), setTimeout(function() {
                          hook.emit("mount", {
                              internalInstance: _this,
                              data: getData012(_this),
                              renderer: rid
                          });
                      }, 0);
                  },
                  updateComponent: function() {
                      var _this2 = this;
                      setTimeout(function() {
                          hook.emit("update", {
                              internalInstance: _this2,
                              data: getData012(_this2),
                              renderer: rid
                          });
                      }, 0);
                  },
                  unmountComponent: function() {
                      hook.emit("unmount", {
                          internalInstance: this,
                          renderer: rid
                      }), rootNodeIDMap["delete"](this._rootNodeID, this);
                  }
              })) : renderer.Reconciler && (oldMethods = decorateMany(renderer.Reconciler, {
                  mountComponent: function(internalInstance, rootID, transaction, context) {
                      var data = getData(internalInstance);
                      rootNodeIDMap.set(internalInstance._rootNodeID, internalInstance), hook.emit("mount", {
                          internalInstance: internalInstance,
                          data: data,
                          renderer: rid
                      });
                  },
                  performUpdateIfNecessary: function(internalInstance, nextChild, transaction, context) {
                      hook.emit("update", {
                          internalInstance: internalInstance,
                          data: getData(internalInstance),
                          renderer: rid
                      });
                  },
                  receiveComponent: function(internalInstance, nextChild, transaction, context) {
                      hook.emit("update", {
                          internalInstance: internalInstance,
                          data: getData(internalInstance),
                          renderer: rid
                      });
                  },
                  unmountComponent: function(internalInstance) {
                      hook.emit("unmount", {
                          internalInstance: internalInstance,
                          renderer: rid
                      }), rootNodeIDMap["delete"](internalInstance._rootNodeID, internalInstance);
                  }
              })), extras.walkTree = function(visit, visitRoot) {
                  var onMount = function(component, data) {
                      rootNodeIDMap.set(component._rootNodeID, component), visit(component, data);
                  };
                  walkRoots(renderer.Mount._instancesByReactRootID || renderer.Mount._instancesByContainerID, onMount, visitRoot, isPre013);
              }, extras.cleanup = function() {
                  oldMethods && (renderer.Component ? restoreMany(renderer.Component.Mixin, oldMethods) : restoreMany(renderer.Reconciler, oldMethods)), 
                  oldRenderRoot && (renderer.Mount._renderNewRootComponent = oldRenderRoot), oldRenderComponent && (renderer.Mount.renderComponent = oldRenderComponent), 
                  oldMethods = null, oldRenderRoot = null, oldRenderComponent = null;
              }, extras;
          }
          function walkRoots(roots, onMount, onRoot, isPre013) {
              for (var name in roots) walkNode(roots[name], onMount, isPre013), onRoot(roots[name]);
          }
          function walkNode(internalInstance, onMount, isPre013) {
              var data = isPre013 ? getData012(internalInstance) : getData(internalInstance);
              data.children && Array.isArray(data.children) && data.children.forEach(function(child) {
                  return walkNode(child, onMount, isPre013);
              }), onMount(internalInstance, data);
          }
          function decorateResult(obj, attr, fn) {
              var old = obj[attr];
              return obj[attr] = function(instance) {
                  var res = old.apply(this, arguments);
                  return fn(res), res;
              }, old;
          }
          function decorate(obj, attr, fn) {
              var old = obj[attr];
              return obj[attr] = function(instance) {
                  var res = old.apply(this, arguments);
                  return fn.apply(this, arguments), res;
              }, old;
          }
          function decorateMany(source, fns) {
              var olds = {};
              for (var name in fns) olds[name] = decorate(source, name, fns[name]);
              return olds;
          }
          function restoreMany(source, olds) {
              for (var name in olds) source[name] = olds[name];
          }
          var getData = __webpack_require__(36), getData012 = __webpack_require__(39), attachRendererFiber = __webpack_require__(40);
          module.exports = attachRenderer;
      }, function(module, exports, __webpack_require__) {
          "use strict";
          function getData(internalInstance) {
              var children = null, props = null, state = null, context = null, updater = null, name = null, type = null, key = null, ref = null, source = null, text = null, publicInstance = null, nodeType = "Native";
              if ("object" !== ("undefined" == typeof internalInstance ? "undefined" : _typeof(internalInstance)) ? (nodeType = "Text", 
              text = internalInstance + "") : null === internalInstance._currentElement || internalInstance._currentElement === !1 ? nodeType = "Empty" : internalInstance._renderedComponent ? (nodeType = "NativeWrapper", 
              children = [ internalInstance._renderedComponent ], props = internalInstance._instance.props, 
              state = internalInstance._instance.state, context = internalInstance._instance.context, 
              context && 0 === Object.keys(context).length && (context = null)) : internalInstance._renderedChildren ? children = childrenList(internalInstance._renderedChildren) : internalInstance._currentElement && internalInstance._currentElement.props && (children = internalInstance._currentElement.props.children), 
              !props && internalInstance._currentElement && internalInstance._currentElement.props && (props = internalInstance._currentElement.props), 
              null != internalInstance._currentElement && (type = internalInstance._currentElement.type, 
              internalInstance._currentElement.key && (key = String(internalInstance._currentElement.key)), 
              source = internalInstance._currentElement._source, ref = internalInstance._currentElement.ref, 
              "string" == typeof type ? (name = type, null != internalInstance._nativeNode && (publicInstance = internalInstance._nativeNode), 
              null != internalInstance._hostNode && (publicInstance = internalInstance._hostNode)) : "function" == typeof type ? (nodeType = "Composite", 
              name = getDisplayName(type), internalInstance._renderedComponent && (internalInstance._currentElement.props === internalInstance._renderedComponent._currentElement || internalInstance._currentElement.type.isReactTopLevelWrapper) && (nodeType = "Wrapper"), 
              null === name && (name = "No display name")) : "string" == typeof internalInstance._stringText ? (nodeType = "Text", 
              text = internalInstance._stringText) : name = getDisplayName(type)), internalInstance._instance) {
                  var inst = internalInstance._instance;
                  updater = {
                      setState: inst.setState && inst.setState.bind(inst),
                      forceUpdate: inst.forceUpdate && inst.forceUpdate.bind(inst),
                      setInProps: inst.forceUpdate && setInProps.bind(null, internalInstance),
                      setInState: inst.forceUpdate && setInState.bind(null, inst),
                      setInContext: inst.forceUpdate && setInContext.bind(null, inst)
                  }, "function" == typeof type && (publicInstance = inst), inst._renderedChildren && (children = childrenList(inst._renderedChildren));
              }
              return "function" == typeof internalInstance.setNativeProps && (updater = {
                  setNativeProps: function(nativeProps) {
                      internalInstance.setNativeProps(nativeProps);
                  }
              }), {
                  nodeType: nodeType,
                  type: type,
                  key: key,
                  ref: ref,
                  source: source,
                  name: name,
                  props: props,
                  state: state,
                  context: context,
                  children: children,
                  text: text,
                  updater: updater,
                  publicInstance: publicInstance
              };
          }
          function setInProps(internalInst, path, value) {
              var element = internalInst._currentElement;
              internalInst._currentElement = _extends({}, element, {
                  props: copyWithSet(element.props, path, value)
              }), internalInst._instance.forceUpdate();
          }
          function setInState(inst, path, value) {
              setIn(inst.state, path, value), inst.forceUpdate();
          }
          function setInContext(inst, path, value) {
              setIn(inst.context, path, value), inst.forceUpdate();
          }
          function setIn(obj, path, value) {
              var last = path.pop(), parent = path.reduce(function(obj_, attr) {
                  return obj_ ? obj_[attr] : null;
              }, obj);
              parent && (parent[last] = value);
          }
          function childrenList(children) {
              var res = [];
              for (var name in children) res.push(children[name]);
              return res;
          }
          var _extends = Object.assign || function(target) {
              for (var i = 1; i < arguments.length; i++) {
                  var source = arguments[i];
                  for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
              }
              return target;
          }, _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) {
              return typeof obj;
          } : function(obj) {
              return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
          }, copyWithSet = __webpack_require__(37), getDisplayName = __webpack_require__(38);
          module.exports = getData;
      }, function(module, exports) {
          "use strict";
          function copyWithSetImpl(obj, path, idx, value) {
              if (idx >= path.length) return value;
              var key = path[idx], updated = Array.isArray(obj) ? obj.slice() : _extends({}, obj);
              return updated[key] = copyWithSetImpl(obj[key], path, idx + 1, value), updated;
          }
          function copyWithSet(obj, path, value) {
              return copyWithSetImpl(obj, path, 0, value);
          }
          var _extends = Object.assign || function(target) {
              for (var i = 1; i < arguments.length; i++) {
                  var source = arguments[i];
                  for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
              }
              return target;
          };
          module.exports = copyWithSet;
      }, function(module, exports) {
          "use strict";
          function getDisplayName(type) {
              if (cachedDisplayNames.has(type)) return cachedDisplayNames.get(type);
              var displayName = type.displayName || type.name;
              if ("function" == typeof displayName) try {
                  displayName = displayName();
              } catch (error) {}
              displayName && "string" == typeof displayName || (displayName = "Unknown");
              var match = displayName.match(FB_MODULE_RE);
              if (match) {
                  var componentName = match[1], moduleName = match[2];
                  componentName && moduleName && (moduleName === componentName || moduleName.startsWith(componentName + ".")) && (displayName = componentName);
              }
              return cachedDisplayNames.set(type, displayName), displayName;
          }
          var FB_MODULE_RE = /^(.*) \[from (.*)\]$/, cachedDisplayNames = new WeakMap();
          module.exports = getDisplayName;
      }, function(module, exports, __webpack_require__) {
          "use strict";
          function getData012(internalInstance) {
              var children = null, props = internalInstance.props, state = internalInstance.state, context = internalInstance.context, updater = null, name = null, type = null, key = null, ref = null, text = null, publicInstance = null, nodeType = "Native";
              return internalInstance._renderedComponent ? (nodeType = "Wrapper", children = [ internalInstance._renderedComponent ], 
              context && 0 === Object.keys(context).length && (context = null)) : internalInstance._renderedChildren ? (name = internalInstance.constructor.displayName, 
              children = childrenList(internalInstance._renderedChildren)) : "string" == typeof props.children && (name = internalInstance.constructor.displayName, 
              children = props.children, nodeType = "Native"), !props && internalInstance._currentElement && internalInstance._currentElement.props && (props = internalInstance._currentElement.props), 
              internalInstance._currentElement && (type = internalInstance._currentElement.type, 
              internalInstance._currentElement.key && (key = String(internalInstance._currentElement.key)), 
              ref = internalInstance._currentElement.ref, "string" == typeof type ? name = type : (nodeType = "Composite", 
              name = type.displayName, name || (name = "No display name"))), name || (name = internalInstance.constructor.displayName || "No display name", 
              nodeType = "Composite"), "string" == typeof props && (nodeType = "Text", text = props, 
              props = null, name = null), internalInstance.forceUpdate && (updater = {
                  setState: internalInstance.setState.bind(internalInstance),
                  forceUpdate: internalInstance.forceUpdate.bind(internalInstance),
                  setInProps: internalInstance.forceUpdate && setInProps.bind(null, internalInstance),
                  setInState: internalInstance.forceUpdate && setInState.bind(null, internalInstance),
                  setInContext: internalInstance.forceUpdate && setInContext.bind(null, internalInstance)
              }, publicInstance = internalInstance), {
                  nodeType: nodeType,
                  type: type,
                  key: key,
                  ref: ref,
                  source: null,
                  name: name,
                  props: props,
                  state: state,
                  context: context,
                  children: children,
                  text: text,
                  updater: updater,
                  publicInstance: publicInstance
              };
          }
          function setInProps(inst, path, value) {
              inst.props = copyWithSet(inst.props, path, value), inst.forceUpdate();
          }
          function setInState(inst, path, value) {
              setIn(inst.state, path, value), inst.forceUpdate();
          }
          function setInContext(inst, path, value) {
              setIn(inst.context, path, value), inst.forceUpdate();
          }
          function setIn(obj, path, value) {
              var last = path.pop(), parent = path.reduce(function(obj_, attr) {
                  return obj_ ? obj_[attr] : null;
              }, obj);
              parent && (parent[last] = value);
          }
          function childrenList(children) {
              var res = [];
              for (var name in children) res.push(children[name]);
              return res;
          }
          var copyWithSet = __webpack_require__(37);
          module.exports = getData012;
      }, function(module, exports, __webpack_require__) {
          "use strict";
          function attachRendererFiber(hook, rid, renderer) {
              function getOpaqueNode(fiber) {
                  if (opaqueNodes.has(fiber)) return fiber;
                  var alternate = fiber.alternate;
                  return null != alternate && opaqueNodes.has(alternate) ? alternate : (opaqueNodes.add(fiber), 
                  fiber);
              }
              function hasDataChanged(prevFiber, nextFiber) {
                  if (prevFiber.tag === ClassComponent) {
                      if ((nextFiber.effectTag & PerformedWork) !== PerformedWork) return !1;
                      if (prevFiber.stateNode.context !== nextFiber.stateNode.context) return !0;
                      if (null != nextFiber.updateQueue && nextFiber.updateQueue.hasForceUpdate) return !0;
                  }
                  return prevFiber.memoizedProps !== nextFiber.memoizedProps || prevFiber.memoizedState !== nextFiber.memoizedState || prevFiber.ref !== nextFiber.ref || prevFiber._debugSource !== nextFiber._debugSource;
              }
              function flushPendingEvents() {
                  var events = pendingEvents;
                  pendingEvents = [];
                  for (var i = 0; i < events.length; i++) {
                      var event = events[i];
                      hook.emit(event.type, event);
                  }
              }
              function enqueueMount(fiber) {
                  pendingEvents.push({
                      internalInstance: getOpaqueNode(fiber),
                      data: getDataFiber(fiber, getOpaqueNode),
                      renderer: rid,
                      type: "mount"
                  });
                  var isRoot = fiber.tag === HostRoot;
                  isRoot && pendingEvents.push({
                      internalInstance: getOpaqueNode(fiber),
                      renderer: rid,
                      type: "root"
                  });
              }
              function enqueueUpdateIfNecessary(fiber, hasChildOrderChanged) {
                  (hasChildOrderChanged || hasDataChanged(fiber.alternate, fiber)) && pendingEvents.push({
                      internalInstance: getOpaqueNode(fiber),
                      data: getDataFiber(fiber, getOpaqueNode),
                      renderer: rid,
                      type: "update"
                  });
              }
              function enqueueUnmount(fiber) {
                  var isRoot = fiber.tag === HostRoot, opaqueNode = getOpaqueNode(fiber), event = {
                      internalInstance: opaqueNode,
                      renderer: rid,
                      type: "unmount"
                  };
                  isRoot ? pendingEvents.push(event) : pendingEvents.unshift(event), opaqueNodes["delete"](opaqueNode);
              }
              function mountFiber(fiber) {
                  var node = fiber;
                  outer: for (;;) if (node.child) node.child["return"] = node, node = node.child; else {
                      if (enqueueMount(node), node == fiber) return;
                      if (!node.sibling) {
                          for (;node["return"]; ) {
                              if (node = node["return"], enqueueMount(node), node == fiber) return;
                              if (node.sibling) {
                                  node.sibling["return"] = node["return"], node = node.sibling;
                                  continue outer;
                              }
                          }
                          return;
                      }
                      node.sibling["return"] = node["return"], node = node.sibling;
                  }
              }
              function updateFiber(nextFiber, prevFiber) {
                  var hasChildOrderChanged = !1;
                  if (nextFiber.child !== prevFiber.child) {
                      for (var nextChild = nextFiber.child, prevChildAtSameIndex = prevFiber.child; nextChild; ) {
                          if (nextChild.alternate) {
                              var prevChild = nextChild.alternate;
                              updateFiber(nextChild, prevChild), hasChildOrderChanged || prevChild === prevChildAtSameIndex || (hasChildOrderChanged = !0);
                          } else mountFiber(nextChild), hasChildOrderChanged || (hasChildOrderChanged = !0);
                          nextChild = nextChild.sibling, hasChildOrderChanged || null == prevChildAtSameIndex || (prevChildAtSameIndex = prevChildAtSameIndex.sibling);
                      }
                      hasChildOrderChanged || null == prevChildAtSameIndex || (hasChildOrderChanged = !0);
                  }
                  enqueueUpdateIfNecessary(nextFiber, hasChildOrderChanged);
              }
              function walkTree() {
                  hook.getFiberRoots(rid).forEach(function(root) {
                      mountFiber(root.current);
                  }), flushPendingEvents();
              }
              function cleanup() {}
              function handleCommitFiberUnmount(fiber) {
                  enqueueUnmount(fiber);
              }
              function handleCommitFiberRoot(root) {
                  var current = root.current, alternate = current.alternate;
                  if (alternate) {
                      var wasMounted = null != alternate.memoizedState && null != alternate.memoizedState.element, isMounted = null != current.memoizedState && null != current.memoizedState.element;
                      !wasMounted && isMounted ? mountFiber(current) : wasMounted && isMounted ? updateFiber(current, alternate) : wasMounted && !isMounted && enqueueUnmount(current);
                  } else mountFiber(current);
                  flushPendingEvents();
              }
              function getNativeFromReactElement(fiber) {
                  try {
                      var opaqueNode = fiber, hostInstance = renderer.findHostInstanceByFiber(opaqueNode);
                      return hostInstance;
                  } catch (err) {
                      return null;
                  }
              }
              function getReactElementFromNative(hostInstance) {
                  var fiber = renderer.findFiberByHostInstance(hostInstance);
                  if (null != fiber) {
                      var opaqueNode = getOpaqueNode(fiber);
                      return opaqueNode;
                  }
                  return null;
              }
              var opaqueNodes = new Set(), pendingEvents = [];
              return {
                  getNativeFromReactElement: getNativeFromReactElement,
                  getReactElementFromNative: getReactElementFromNative,
                  handleCommitFiberRoot: handleCommitFiberRoot,
                  handleCommitFiberUnmount: handleCommitFiberUnmount,
                  cleanup: cleanup,
                  walkTree: walkTree
              };
          }
          var getDataFiber = __webpack_require__(41), _require = __webpack_require__(42), ClassComponent = _require.ClassComponent, HostRoot = _require.HostRoot, PerformedWork = 1;
          module.exports = attachRendererFiber;
      }, function(module, exports, __webpack_require__) {
          "use strict";
          function getDataFiber(fiber, getOpaqueNode) {
              var type = fiber.type, key = fiber.key, ref = fiber.ref, source = fiber._debugSource, publicInstance = null, props = null, state = null, children = null, context = null, updater = null, nodeType = null, name = null, text = null;
              switch (fiber.tag) {
                case FunctionalComponent:
                case ClassComponent:
                  nodeType = "Composite", name = getDisplayName(fiber.type), publicInstance = fiber.stateNode, 
                  props = fiber.memoizedProps, state = fiber.memoizedState, null != publicInstance && (context = publicInstance.context, 
                  context && 0 === Object.keys(context).length && (context = null));
                  var inst = publicInstance;
                  inst && (updater = {
                      setState: inst.setState && inst.setState.bind(inst),
                      forceUpdate: inst.forceUpdate && inst.forceUpdate.bind(inst),
                      setInProps: inst.forceUpdate && setInProps.bind(null, fiber),
                      setInState: inst.forceUpdate && setInState.bind(null, inst),
                      setInContext: inst.forceUpdate && setInContext.bind(null, inst)
                  }), children = [];
                  break;
  
                case HostRoot:
                  nodeType = "Wrapper", children = [];
                  break;
  
                case HostPortal:
                  nodeType = "Portal", name = "ReactPortal", props = {
                      target: fiber.stateNode.containerInfo
                  }, children = [];
                  break;
  
                case HostComponent:
                  nodeType = "Native", name = fiber.type, name = name.replace("topsecret-", ""), publicInstance = fiber.stateNode, 
                  props = fiber.memoizedProps, children = "string" == typeof props.children || "number" == typeof props.children ? props.children.toString() : [], 
                  "function" == typeof fiber.stateNode.setNativeProps && (updater = {
                      setNativeProps: function(nativeProps) {
                          fiber.stateNode.setNativeProps(nativeProps);
                      }
                  });
                  break;
  
                case HostText:
                  nodeType = "Text", text = fiber.memoizedProps;
                  break;
  
                case Fragment:
                  nodeType = "Wrapper", children = [];
                  break;
  
                default:
                  nodeType = "Native", props = fiber.memoizedProps, name = "TODO_NOT_IMPLEMENTED_YET", 
                  children = [];
              }
              if (Array.isArray(children)) for (var child = fiber.child; child; ) children.push(getOpaqueNode(child)), 
              child = child.sibling;
              return {
                  nodeType: nodeType,
                  type: type,
                  key: key,
                  ref: ref,
                  source: source,
                  name: name,
                  props: props,
                  state: state,
                  context: context,
                  children: children,
                  text: text,
                  updater: updater,
                  publicInstance: publicInstance
              };
          }
          function setInProps(fiber, path, value) {
              var inst = fiber.stateNode;
              fiber.pendingProps = copyWithSet(inst.props, path, value), fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps), 
              fiber.stateNode.forceUpdate();
          }
          function setInState(inst, path, value) {
              setIn(inst.state, path, value), inst.forceUpdate();
          }
          function setInContext(inst, path, value) {
              setIn(inst.context, path, value), inst.forceUpdate();
          }
          function setIn(obj, path, value) {
              var last = path.pop(), parent = path.reduce(function(obj_, attr) {
                  return obj_ ? obj_[attr] : null;
              }, obj);
              parent && (parent[last] = value);
          }
          var copyWithSet = __webpack_require__(37), getDisplayName = __webpack_require__(38), _require = __webpack_require__(42), FunctionalComponent = _require.FunctionalComponent, ClassComponent = _require.ClassComponent, HostRoot = _require.HostRoot, HostPortal = _require.HostPortal, HostComponent = _require.HostComponent, HostText = _require.HostText, Fragment = _require.Fragment;
          module.exports = getDataFiber;
      }, function(module, exports) {
          "use strict";
          module.exports = {
              IndeterminateComponent: 0,
              FunctionalComponent: 1,
              ClassComponent: 2,
              HostRoot: 3,
              HostPortal: 4,
              HostComponent: 5,
              HostText: 6,
              CoroutineComponent: 7,
              CoroutineHandlerPhase: 8,
              YieldComponent: 9,
              Fragment: 10
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          function _defineProperty(obj, key, value) {
              return key in obj ? Object.defineProperty(obj, key, {
                  value: value,
                  enumerable: !0,
                  configurable: !0,
                  writable: !0
              }) : obj[key] = value, obj;
          }
          function measureStyle(agent, bridge, resolveRNStyle, id) {
              var node = agent.elementData.get(id);
              if (!node || !node.props) return void bridge.send("rn-style:measure", {});
              var style = resolveRNStyle(node.props.style);
              styleOverridesByHostComponentId[id] && (style = Object.assign({}, style, styleOverridesByHostComponentId[id]));
              var instance = node.publicInstance;
              return instance && instance.measure ? void instance.measure(function(x, y, width, height, left, top) {
                  if ("number" != typeof x) return void bridge.send("rn-style:measure", {
                      style: style
                  });
                  var margin = style && resolveBoxStyle("margin", style) || blank, padding = style && resolveBoxStyle("padding", style) || blank;
                  bridge.send("rn-style:measure", {
                      style: style,
                      measuredLayout: {
                          x: x,
                          y: y,
                          width: width,
                          height: height,
                          left: left,
                          top: top,
                          margin: margin,
                          padding: padding
                      }
                  });
              }) : void bridge.send("rn-style:measure", {
                  style: style
              });
          }
          function shallowClone(obj) {
              var nobj = {};
              for (var n in obj) nobj[n] = obj[n];
              return nobj;
          }
          function renameStyle(agent, id, oldName, newName, val) {
              var _ref3, data = agent.elementData.get(id), newStyle = newName ? (_ref3 = {}, _defineProperty(_ref3, oldName, void 0), 
              _defineProperty(_ref3, newName, val), _ref3) : _defineProperty({}, oldName, void 0);
              if (data && data.updater && data.updater.setInProps) {
                  var customStyle, style = data && data.props && data.props.style;
                  if (Array.isArray(style)) {
                      var lastLength = style.length - 1;
                      "object" !== _typeof(style[lastLength]) || Array.isArray(style[lastLength]) ? (style = style.concat([ newStyle ]), 
                      data.updater.setInProps([ "style" ], style)) : (customStyle = shallowClone(style[lastLength]), 
                      delete customStyle[oldName], newName ? customStyle[newName] = val : customStyle[oldName] = void 0, 
                      data.updater.setInProps([ "style", lastLength ], customStyle));
                  } else "object" === ("undefined" == typeof style ? "undefined" : _typeof(style)) ? (customStyle = shallowClone(style), 
                  delete customStyle[oldName], newName ? customStyle[newName] = val : customStyle[oldName] = void 0, 
                  data.updater.setInProps([ "style" ], customStyle)) : (style = [ style, newStyle ], 
                  data.updater.setInProps([ "style" ], style));
              } else {
                  if (!(data && data.updater && data.updater.setNativeProps)) return;
                  styleOverridesByHostComponentId[id] ? Object.assign(styleOverridesByHostComponentId[id], newStyle) : styleOverridesByHostComponentId[id] = newStyle, 
                  data.updater.setNativeProps({
                      style: newStyle
                  });
              }
              agent.emit("hideHighlight");
          }
          function setStyle(agent, id, attr, val) {
              var data = agent.elementData.get(id), newStyle = _defineProperty({}, attr, val);
              if (data && data.updater && data.updater.setInProps) {
                  var style = data.props && data.props.style;
                  if (Array.isArray(style)) {
                      var lastLength = style.length - 1;
                      "object" !== _typeof(style[lastLength]) || Array.isArray(style[lastLength]) ? (style = style.concat([ newStyle ]), 
                      data.updater.setInProps([ "style" ], style)) : data.updater.setInProps([ "style", lastLength, attr ], val);
                  } else style = [ style, newStyle ], data.updater.setInProps([ "style" ], style);
              } else {
                  if (!(data && data.updater && data.updater.setNativeProps)) return;
                  styleOverridesByHostComponentId[id] ? Object.assign(styleOverridesByHostComponentId[id], newStyle) : styleOverridesByHostComponentId[id] = newStyle, 
                  data.updater.setNativeProps({
                      style: newStyle
                  });
              }
              agent.emit("hideHighlight");
          }
          var _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) {
              return typeof obj;
          } : function(obj) {
              return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
          }, resolveBoxStyle = __webpack_require__(44), styleOverridesByHostComponentId = {};
          module.exports = function(bridge, agent, resolveRNStyle) {
              bridge.onCall("rn-style:get", function(id) {
                  var node = agent.elementData.get(id);
                  return node && node.props ? resolveRNStyle(node.props.style) : null;
              }), bridge.on("rn-style:measure", function(id) {
                  measureStyle(agent, bridge, resolveRNStyle, id);
              }), bridge.on("rn-style:rename", function(_ref) {
                  var id = _ref.id, oldName = _ref.oldName, newName = _ref.newName, val = _ref.val;
                  renameStyle(agent, id, oldName, newName, val), setTimeout(function() {
                      return measureStyle(agent, bridge, resolveRNStyle, id);
                  });
              }), bridge.on("rn-style:set", function(_ref2) {
                  var id = _ref2.id, attr = _ref2.attr, val = _ref2.val;
                  setStyle(agent, id, attr, val), setTimeout(function() {
                      return measureStyle(agent, bridge, resolveRNStyle, id);
                  });
              });
          };
          var blank = {
              top: 0,
              left: 0,
              right: 0,
              bottom: 0
          };
      }, function(module, exports) {
          "use strict";
          function resolveBoxStyle(prefix, style) {
              var res = {}, subs = [ "top", "left", "bottom", "right" ], set = !1;
              return subs.forEach(function(sub) {
                  res[sub] = style[prefix] || 0;
              }), style[prefix] && (set = !0), style[prefix + "Vertical"] && (res.top = res.bottom = style[prefix + "Vertical"], 
              set = !0), style[prefix + "Horizontal"] && (res.left = res.right = style[prefix + "Horizontal"], 
              set = !0), subs.forEach(function(sub) {
                  var val = style[prefix + capFirst(sub)];
                  val && (res[sub] = val, set = !0);
              }), set ? res : null;
          }
          function capFirst(text) {
              return text[0].toUpperCase() + text.slice(1);
          }
          module.exports = resolveBoxStyle;
      }, function(module, exports) {
          "use strict";
          function decorate(obj, attr, fn) {
              var old = obj[attr];
              return obj[attr] = function() {
                  var res = old.apply(this, arguments);
                  return fn.apply(this, arguments), res;
              }, function() {
                  obj[attr] = old;
              };
          }
          var subscriptionEnabled = !1;
          module.exports = function(bridge, agent, hook) {
              function sendStoreData() {
                  subscriptionEnabled && bridge.send("relay:store", {
                      id: "relay:store",
                      nodes: DefaultStoreData.getNodeData()
                  });
              }
              var shouldEnable = !!hook._relayInternals;
              if (bridge.onCall("relay:check", function() {
                  return shouldEnable;
              }), shouldEnable) {
                  var _hook$_relayInternals = hook._relayInternals, DefaultStoreData = _hook$_relayInternals.DefaultStoreData, setRequestListener = _hook$_relayInternals.setRequestListener;
                  bridge.onCall("relay:store:enable", function() {
                      subscriptionEnabled = !0, sendStoreData();
                  }), bridge.onCall("relay:store:disable", function() {
                      subscriptionEnabled = !1;
                  }), sendStoreData(), decorate(DefaultStoreData, "handleUpdatePayload", sendStoreData), 
                  decorate(DefaultStoreData, "handleQueryPayload", sendStoreData);
                  var removeListener = setRequestListener(function(event, data) {
                      bridge.send(event, data);
                  });
                  hook.on("shutdown", removeListener);
              }
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          var Highlighter = __webpack_require__(47);
          module.exports = function(agent) {
              var hl = new Highlighter(window, function(node) {
                  agent.selectFromDOMNode(node);
              });
              agent.on("highlight", function(data) {
                  return hl.highlight(data.node, data.name);
              }), agent.on("highlightMany", function(nodes) {
                  return hl.highlightMany(nodes);
              }), agent.on("hideHighlight", function() {
                  return hl.hideHighlight();
              }), agent.on("refreshMultiOverlay", function() {
                  return hl.refreshMultiOverlay();
              }), agent.on("startInspecting", function() {
                  return hl.startInspecting();
              }), agent.on("stopInspecting", function() {
                  return hl.stopInspecting();
              }), agent.on("shutdown", function() {
                  hl.remove();
              });
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          function _classCallCheck(instance, Constructor) {
              if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
          }
          function captureSubscription(obj, evt, cb) {
              return obj.addEventListener(evt, cb, !0), function() {
                  return obj.removeEventListener(evt, cb, !0);
              };
          }
          function makeMagnifier() {
              var button = window.document.createElement("button");
              return button.innerHTML = "&#128269;", button.style.backgroundColor = "transparent", 
              button.style.border = "none", button.style.outline = "none", button.style.cursor = "pointer", 
              button.style.position = "fixed", button.style.bottom = "10px", button.style.right = "10px", 
              button.style.fontSize = "30px", button.style.zIndex = 1e7, button;
          }
          var _createClass = function() {
              function defineProperties(target, props) {
                  for (var i = 0; i < props.length; i++) {
                      var descriptor = props[i];
                      descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
                      "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
                  }
              }
              return function(Constructor, protoProps, staticProps) {
                  return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
                  Constructor;
              };
          }(), Overlay = __webpack_require__(48), MultiOverlay = __webpack_require__(50), Highlighter = function() {
              function Highlighter(win, onSelect) {
                  _classCallCheck(this, Highlighter), this._win = win, this._onSelect = onSelect, 
                  this._overlay = null, this._multiOverlay = null, this._subs = [];
              }
              return _createClass(Highlighter, [ {
                  key: "startInspecting",
                  value: function() {
                      this._inspecting = !0, this._subs = [ captureSubscription(this._win, "mouseover", this.onHover.bind(this)), captureSubscription(this._win, "mousedown", this.onMouseDown.bind(this)), captureSubscription(this._win, "click", this.onClick.bind(this)) ];
                  }
              }, {
                  key: "stopInspecting",
                  value: function() {
                      this._subs.forEach(function(unsub) {
                          return unsub();
                      }), this.hideHighlight();
                  }
              }, {
                  key: "remove",
                  value: function() {
                      this.stopInspecting(), this._button && this._button.parentNode && this._button.parentNode.removeChild(this._button);
                  }
              }, {
                  key: "highlight",
                  value: function(node, name) {
                      this.removeMultiOverlay(), node.nodeType !== Node.COMMENT_NODE && (this._overlay || (this._overlay = new Overlay(this._win)), 
                      this._overlay.inspect(node, name));
                  }
              }, {
                  key: "highlightMany",
                  value: function(nodes) {
                      this.removeOverlay(), this._multiOverlay || (this._multiOverlay = new MultiOverlay(this._win)), 
                      this._multiOverlay.highlightMany(nodes);
                  }
              }, {
                  key: "hideHighlight",
                  value: function() {
                      this._inspecting = !1, this.removeOverlay(), this.removeMultiOverlay();
                  }
              }, {
                  key: "refreshMultiOverlay",
                  value: function() {
                      this._multiOverlay && this._multiOverlay.refresh();
                  }
              }, {
                  key: "removeOverlay",
                  value: function() {
                      this._overlay && (this._overlay.remove(), this._overlay = null);
                  }
              }, {
                  key: "removeMultiOverlay",
                  value: function() {
                      this._multiOverlay && (this._multiOverlay.remove(), this._multiOverlay = null);
                  }
              }, {
                  key: "onMouseDown",
                  value: function(evt) {
                      this._inspecting && (evt.preventDefault(), evt.stopPropagation(), evt.cancelBubble = !0, 
                      this._onSelect(evt.target));
                  }
              }, {
                  key: "onClick",
                  value: function(evt) {
                      this._inspecting && (this._subs.forEach(function(unsub) {
                          return unsub();
                      }), evt.preventDefault(), evt.stopPropagation(), evt.cancelBubble = !0, this.hideHighlight());
                  }
              }, {
                  key: "onHover",
                  value: function(evt) {
                      this._inspecting && (evt.preventDefault(), evt.stopPropagation(), evt.cancelBubble = !0, 
                      this.highlight(evt.target));
                  }
              }, {
                  key: "injectButton",
                  value: function() {
                      this._button = makeMagnifier(), this._button.onclick = this.startInspecting.bind(this), 
                      this._win.document.body.appendChild(this._button);
                  }
              } ]), Highlighter;
          }();
          module.exports = Highlighter;
      }, function(module, exports, __webpack_require__) {
          "use strict";
          function _classCallCheck(instance, Constructor) {
              if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
          }
          function findTipPos(dims, win) {
              var top, tipHeight = 20, margin = 5;
              return top = dims.top + dims.height + tipHeight <= win.innerHeight ? dims.top + dims.height < 0 ? margin : dims.top + dims.height + margin : dims.top - tipHeight <= win.innerHeight ? dims.top - tipHeight - margin < margin ? margin : dims.top - tipHeight - margin : win.innerHeight - tipHeight - margin, 
              top += "px", dims.left < 0 ? {
                  top: top,
                  left: margin
              } : dims.left + 200 > win.innerWidth ? {
                  top: top,
                  right: margin
              } : {
                  top: top,
                  left: dims.left + margin + "px"
              };
          }
          function getElementDimensions(domElement) {
              var calculatedStyle = window.getComputedStyle(domElement);
              return {
                  borderLeft: +calculatedStyle.borderLeftWidth.match(/[0-9]*/)[0],
                  borderRight: +calculatedStyle.borderRightWidth.match(/[0-9]*/)[0],
                  borderTop: +calculatedStyle.borderTopWidth.match(/[0-9]*/)[0],
                  borderBottom: +calculatedStyle.borderBottomWidth.match(/[0-9]*/)[0],
                  marginLeft: +calculatedStyle.marginLeft.match(/[0-9]*/)[0],
                  marginRight: +calculatedStyle.marginRight.match(/[0-9]*/)[0],
                  marginTop: +calculatedStyle.marginTop.match(/[0-9]*/)[0],
                  marginBottom: +calculatedStyle.marginBottom.match(/[0-9]*/)[0],
                  paddingLeft: +calculatedStyle.paddingLeft.match(/[0-9]*/)[0],
                  paddingRight: +calculatedStyle.paddingRight.match(/[0-9]*/)[0],
                  paddingTop: +calculatedStyle.paddingTop.match(/[0-9]*/)[0],
                  paddingBottom: +calculatedStyle.paddingBottom.match(/[0-9]*/)[0]
              };
          }
          function getOwnerWindow(node) {
              return node.ownerDocument ? node.ownerDocument.defaultView : null;
          }
          function getOwnerIframe(node) {
              var nodeWindow = getOwnerWindow(node);
              return nodeWindow ? nodeWindow.frameElement : null;
          }
          function getBoundingClientRectWithBorderOffset(node) {
              var dimensions = getElementDimensions(node);
              return mergeRectOffsets([ node.getBoundingClientRect(), {
                  top: dimensions.borderTop,
                  left: dimensions.borderLeft,
                  bottom: dimensions.borderBottom,
                  right: dimensions.borderRight,
                  width: 0,
                  height: 0
              } ]);
          }
          function mergeRectOffsets(rects) {
              return rects.reduce(function(previousRect, rect) {
                  return null == previousRect ? rect : {
                      top: previousRect.top + rect.top,
                      left: previousRect.left + rect.left,
                      width: previousRect.width,
                      height: previousRect.height,
                      bottom: previousRect.bottom + rect.bottom,
                      right: previousRect.right + rect.right
                  };
              });
          }
          function getNestedBoundingClientRect(node, boundaryWindow) {
              var ownerIframe = getOwnerIframe(node);
              if (ownerIframe && ownerIframe !== boundaryWindow) {
                  for (var rects = [ node.getBoundingClientRect() ], currentIframe = ownerIframe, onlyOneMore = !1; currentIframe; ) {
                      var rect = getBoundingClientRectWithBorderOffset(currentIframe);
                      if (rects.push(rect), currentIframe = getOwnerIframe(currentIframe), onlyOneMore) break;
                      currentIframe && getOwnerWindow(currentIframe) === boundaryWindow && (onlyOneMore = !0);
                  }
                  return mergeRectOffsets(rects);
              }
              return node.getBoundingClientRect();
          }
          function boxWrap(dims, what, node) {
              assign(node.style, {
                  borderTopWidth: dims[what + "Top"] + "px",
                  borderLeftWidth: dims[what + "Left"] + "px",
                  borderRightWidth: dims[what + "Right"] + "px",
                  borderBottomWidth: dims[what + "Bottom"] + "px",
                  borderStyle: "solid"
              });
          }
          var _createClass = function() {
              function defineProperties(target, props) {
                  for (var i = 0; i < props.length; i++) {
                      var descriptor = props[i];
                      descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
                      "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
                  }
              }
              return function(Constructor, protoProps, staticProps) {
                  return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
                  Constructor;
              };
          }(), assign = __webpack_require__(3), _require = __webpack_require__(49), monospace = _require.monospace, Overlay = function() {
              function Overlay(window) {
                  _classCallCheck(this, Overlay);
                  var doc = window.document;
                  this.win = window, this.container = doc.createElement("div"), this.node = doc.createElement("div"), 
                  this.border = doc.createElement("div"), this.padding = doc.createElement("div"), 
                  this.content = doc.createElement("div"), this.border.style.borderColor = overlayStyles.border, 
                  this.padding.style.borderColor = overlayStyles.padding, this.content.style.backgroundColor = overlayStyles.background, 
                  assign(this.node.style, {
                      borderColor: overlayStyles.margin,
                      pointerEvents: "none",
                      position: "fixed"
                  }), this.tip = doc.createElement("div"), assign(this.tip.style, {
                      backgroundColor: "#333740",
                      borderRadius: "2px",
                      fontFamily: monospace.family,
                      fontWeight: "bold",
                      padding: "3px 5px",
                      position: "fixed",
                      fontSize: monospace.sizes.normal
                  }), this.nameSpan = doc.createElement("span"), this.tip.appendChild(this.nameSpan), 
                  assign(this.nameSpan.style, {
                      color: "#ee78e6",
                      borderRight: "1px solid #aaaaaa",
                      paddingRight: "0.5rem",
                      marginRight: "0.5rem"
                  }), this.dimSpan = doc.createElement("span"), this.tip.appendChild(this.dimSpan), 
                  assign(this.dimSpan.style, {
                      color: "#d7d7d7"
                  }), this.container.style.zIndex = 1e7, this.node.style.zIndex = 1e7, this.tip.style.zIndex = 1e7, 
                  this.container.appendChild(this.node), this.container.appendChild(this.tip), this.node.appendChild(this.border), 
                  this.border.appendChild(this.padding), this.padding.appendChild(this.content), doc.body.appendChild(this.container);
              }
              return _createClass(Overlay, [ {
                  key: "remove",
                  value: function() {
                      this.container.parentNode && this.container.parentNode.removeChild(this.container);
                  }
              }, {
                  key: "inspect",
                  value: function(node, name) {
                      if (node.nodeType === Node.ELEMENT_NODE) {
                          var box = getNestedBoundingClientRect(node, this.win), dims = getElementDimensions(node);
                          boxWrap(dims, "margin", this.node), boxWrap(dims, "border", this.border), boxWrap(dims, "padding", this.padding), 
                          assign(this.content.style, {
                              height: box.height - dims.borderTop - dims.borderBottom - dims.paddingTop - dims.paddingBottom + "px",
                              width: box.width - dims.borderLeft - dims.borderRight - dims.paddingLeft - dims.paddingRight + "px"
                          }), assign(this.node.style, {
                              top: box.top - dims.marginTop + "px",
                              left: box.left - dims.marginLeft + "px"
                          }), this.nameSpan.textContent = name || node.nodeName.toLowerCase(), this.dimSpan.textContent = box.width + "px × " + box.height + "px";
                          var tipPos = findTipPos({
                              top: box.top - dims.marginTop,
                              left: box.left - dims.marginLeft,
                              height: box.height + dims.marginTop + dims.marginBottom,
                              width: box.width + dims.marginLeft + dims.marginRight
                          }, this.win);
                          assign(this.tip.style, tipPos);
                      }
                  }
              } ]), Overlay;
          }(), overlayStyles = {
              background: "rgba(120, 170, 210, 0.7)",
              padding: "rgba(77, 200, 0, 0.3)",
              margin: "rgba(255, 155, 0, 0.3)",
              border: "rgba(255, 200, 50, 0.3)"
          };
          module.exports = Overlay;
      }, function(module, exports) {
          "use strict";
          module.exports = {
              monospace: {
                  family: "Menlo, Consolas, monospace",
                  sizes: {
                      normal: 11,
                      large: 14
                  }
              },
              sansSerif: {
                  family: '"Helvetica Neue", "Lucida Grande", -apple-system, BlinkMacSystemFont, "Segoe UI", Ubuntu, sans-serif',
                  sizes: {
                      small: 10,
                      normal: 12,
                      large: 14
                  }
              }
          };
      }, function(module, exports, __webpack_require__) {
          "use strict";
          function _classCallCheck(instance, Constructor) {
              if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
          }
          var _createClass = function() {
              function defineProperties(target, props) {
                  for (var i = 0; i < props.length; i++) {
                      var descriptor = props[i];
                      descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
                      "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
                  }
              }
              return function(Constructor, protoProps, staticProps) {
                  return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
                  Constructor;
              };
          }(), assign = __webpack_require__(3), MultiOverlay = function() {
              function MultiOverlay(window) {
                  _classCallCheck(this, MultiOverlay), this.win = window;
                  var doc = window.document;
                  this.container = doc.createElement("div"), doc.body.appendChild(this.container), 
                  this._currentNodes = null;
              }
              return _createClass(MultiOverlay, [ {
                  key: "highlightMany",
                  value: function(nodes) {
                      var _this = this;
                      this._currentNodes = nodes, this.container.innerHTML = "", nodes.forEach(function(node) {
                          var div = _this.win.document.createElement("div");
                          if ("function" == typeof node.getBoundingClientRect) {
                              var box = node.getBoundingClientRect();
                              box.bottom < 0 || box.top > window.innerHeight || (assign(div.style, {
                                  top: box.top + "px",
                                  left: box.left + "px",
                                  width: box.width + "px",
                                  height: box.height + "px",
                                  border: "2px dotted rgba(200, 100, 100, .8)",
                                  boxSizing: "border-box",
                                  backgroundColor: "rgba(200, 100, 100, .2)",
                                  position: "fixed",
                                  zIndex: 1e7,
                                  pointerEvents: "none"
                              }), _this.container.appendChild(div));
                          }
                      });
                  }
              }, {
                  key: "refresh",
                  value: function() {
                      this._currentNodes && this.highlightMany(this._currentNodes);
                  }
              }, {
                  key: "remove",
                  value: function() {
                      this.container.parentNode && (this.container.parentNode.removeChild(this.container), 
                      this._currentNodes = null);
                  }
              } ]), MultiOverlay;
          }();
          module.exports = MultiOverlay;
      } ]);
  });
  //# sourceMappingURL=backend.js.map