output.js

/******/ (function(modules) {
  // webpackBootstrap
  /******/ // The module cache
  /******/ var installedModules = {}; // The require function
  /******/
  /******/ /******/ function __webpack_require__(moduleId) {
    /******/
    /******/ // Check if module is in cache
    /******/ if (installedModules[moduleId]) {
      /******/ return installedModules[moduleId].exports;
      /******/
    } // Create a new module (and put it into the cache)
    /******/ /******/ var module = (installedModules[moduleId] = {
      /******/ i: moduleId,
      /******/ l: false,
      /******/ exports: {},
      /******/
    }); // Execute the module function
    /******/
    /******/ /******/ modules[moduleId].call(
      module.exports,
      module,
      module.exports,
      __webpack_require__
    ); // Flag the module as loaded
    /******/
    /******/ /******/ module.l = true; // Return the exports of the module
    /******/
    /******/ /******/ return module.exports;
    /******/
  } // expose the modules object (__webpack_modules__)
  /******/
  /******/
  /******/ /******/ __webpack_require__.m = modules; // expose the module cache
  /******/
  /******/ /******/ __webpack_require__.c = installedModules; // define getter function for harmony exports
  /******/
  /******/ /******/ __webpack_require__.d = function(exports, name, getter) {
    /******/ if (!__webpack_require__.o(exports, name)) {
      /******/ Object.defineProperty(exports, name, {
        /******/ configurable: false,
        /******/ enumerable: true,
        /******/ get: getter,
        /******/
      });
      /******/
    }
    /******/
  }; // getDefaultExport function for compatibility with non-harmony modules
  /******/
  /******/ /******/ __webpack_require__.n = function(module) {
    /******/ var getter =
      module && module.__esModule
        ? /******/ function getDefault() {
            return module['default'];
          }
        : /******/ function getModuleExports() {
            return module;
          };
    /******/ __webpack_require__.d(getter, 'a', getter);
    /******/ return getter;
    /******/
  }; // Object.prototype.hasOwnProperty.call
  /******/
  /******/ /******/ __webpack_require__.o = function(object, property) {
    return Object.prototype.hasOwnProperty.call(object, property);
  }; // __webpack_public_path__
  /******/
  /******/ /******/ __webpack_require__.p = ''; // Load entry module and return exports
  /******/
  /******/ /******/ return __webpack_require__((__webpack_require__.s = 17));
  /******/
})(
  /************************************************************************/
  /******/ [
    /* 0 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      if (true) {
        module.exports = __webpack_require__(23);
      } else {
        module.exports = require('./cjs/react.development.js');
      }

      /***/
    },
    /* 1 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.yellowTransparent = exports.redTransparent = exports.red = exports.darkGray = exports.black = exports.secondaryErrorStyle = exports.primaryErrorStyle = exports.overlayStyle = exports.iframeStyle = void 0;

      /**
 * Copyright (c) 2015-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
      var black = '#293238',
        darkGray = '#878e91',
        red = '#ce1126',
        redTransparent = 'rgba(206, 17, 38, 0.05)',
        lightRed = '#fccfcf',
        yellow = '#fbf5b4',
        yellowTransparent = 'rgba(251, 245, 180, 0.3)',
        white = '#ffffff';
      exports.yellowTransparent = yellowTransparent;
      exports.redTransparent = redTransparent;
      exports.red = red;
      exports.darkGray = darkGray;
      exports.black = black;
      var iframeStyle = {
        position: 'fixed',
        top: '0',
        left: '0',
        width: '100%',
        height: '100%',
        border: 'none',
        'z-index': 2147483647,
      };
      exports.iframeStyle = iframeStyle;
      var overlayStyle = {
        width: '100%',
        height: '100%',
        'box-sizing': 'border-box',
        'text-align': 'center',
        'background-color': white,
      };
      exports.overlayStyle = overlayStyle;
      var primaryErrorStyle = {
        'background-color': lightRed,
      };
      exports.primaryErrorStyle = primaryErrorStyle;
      var secondaryErrorStyle = {
        'background-color': yellow,
      };
      exports.secondaryErrorStyle = secondaryErrorStyle;

      /***/
    },
    /* 2 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';
      /*
object-assign
(c) Sindre Sorhus
@license MIT
*/

      /* eslint-disable no-unused-vars */
      var getOwnPropertySymbols = Object.getOwnPropertySymbols;
      var hasOwnProperty = Object.prototype.hasOwnProperty;
      var propIsEnumerable = Object.prototype.propertyIsEnumerable;

      function toObject(val) {
        if (val === null || val === undefined) {
          throw new TypeError(
            'Object.assign cannot be called with null or undefined'
          );
        }

        return Object(val);
      }

      function shouldUseNative() {
        try {
          if (!Object.assign) {
            return false;
          }

          // Detect buggy property enumeration order in older V8 versions.

          // https://bugs.chromium.org/p/v8/issues/detail?id=4118
          var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
          test1[5] = 'de';
          if (Object.getOwnPropertyNames(test1)[0] === '5') {
            return false;
          }

          // https://bugs.chromium.org/p/v8/issues/detail?id=3056
          var test2 = {};
          for (var i = 0; i < 10; i++) {
            test2['_' + String.fromCharCode(i)] = i;
          }
          var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
            return test2[n];
          });
          if (order2.join('') !== '0123456789') {
            return false;
          }

          // https://bugs.chromium.org/p/v8/issues/detail?id=3056
          var test3 = {};
          'abcdefghijklmnopqrst'.split('').forEach(function(letter) {
            test3[letter] = letter;
          });
          if (
            Object.keys(Object.assign({}, test3)).join('') !==
            'abcdefghijklmnopqrst'
          ) {
            return false;
          }

          return true;
        } catch (err) {
          // We don't expect any of the above to throw, but better to be safe.
          return false;
        }
      }

      module.exports = shouldUseNative()
        ? Object.assign
        : function(target, source) {
            var from;
            var to = toObject(target);
            var symbols;

            for (var s = 1; s < arguments.length; s++) {
              from = Object(arguments[s]);

              for (var key in from) {
                if (hasOwnProperty.call(from, key)) {
                  to[key] = from[key];
                }
              }

              if (getOwnPropertySymbols) {
                symbols = getOwnPropertySymbols(from);
                for (var i = 0; i < symbols.length; i++) {
                  if (propIsEnumerable.call(from, symbols[i])) {
                    to[symbols[i]] = from[symbols[i]];
                  }
                }
              }
            }

            return to;
          };

      /***/
    },
    /* 3 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      /**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 */

      function makeEmptyFunction(arg) {
        return function() {
          return arg;
        };
      }

      /**
 * This function accepts and discards inputs; it has no side effects. This is
 * primarily useful idiomatically for overridable function endpoints which
 * always need to be callable, since JS lacks a null-call idiom ala Cocoa.
 */
      var emptyFunction = function emptyFunction() {};

      emptyFunction.thatReturns = makeEmptyFunction;
      emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
      emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
      emptyFunction.thatReturnsNull = makeEmptyFunction(null);
      emptyFunction.thatReturnsThis = function() {
        return this;
      };
      emptyFunction.thatReturnsArgument = function(arg) {
        return arg;
      };

      module.exports = emptyFunction;

      /***/
    },
    /* 4 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      var asap = __webpack_require__(20);

      function noop() {}

      // States:
      //
      // 0 - pending
      // 1 - fulfilled with _value
      // 2 - rejected with _value
      // 3 - adopted the state of another promise, _value
      //
      // once the state is no longer pending (0) it is immutable

      // All `_` prefixed properties will be reduced to `_{random number}`
      // at build time to obfuscate them and discourage their use.
      // We don't use symbols or Object.defineProperty to fully hide them
      // because the performance isn't good enough.

      // to avoid using try/catch inside critical functions, we
      // extract them to here.
      var LAST_ERROR = null;
      var IS_ERROR = {};
      function getThen(obj) {
        try {
          return obj.then;
        } catch (ex) {
          LAST_ERROR = ex;
          return IS_ERROR;
        }
      }

      function tryCallOne(fn, a) {
        try {
          return fn(a);
        } catch (ex) {
          LAST_ERROR = ex;
          return IS_ERROR;
        }
      }
      function tryCallTwo(fn, a, b) {
        try {
          fn(a, b);
        } catch (ex) {
          LAST_ERROR = ex;
          return IS_ERROR;
        }
      }

      module.exports = Promise;

      function Promise(fn) {
        if (typeof this !== 'object') {
          throw new TypeError('Promises must be constructed via new');
        }
        if (typeof fn !== 'function') {
          throw new TypeError(
            "Promise constructor's argument is not a function"
          );
        }
        this._75 = 0;
        this._83 = 0;
        this._18 = null;
        this._38 = null;
        if (fn === noop) return;
        doResolve(fn, this);
      }
      Promise._47 = null;
      Promise._71 = null;
      Promise._44 = noop;

      Promise.prototype.then = function(onFulfilled, onRejected) {
        if (this.constructor !== Promise) {
          return safeThen(this, onFulfilled, onRejected);
        }
        var res = new Promise(noop);
        handle(this, new Handler(onFulfilled, onRejected, res));
        return res;
      };

      function safeThen(self, onFulfilled, onRejected) {
        return new self.constructor(function(resolve, reject) {
          var res = new Promise(noop);
          res.then(resolve, reject);
          handle(self, new Handler(onFulfilled, onRejected, res));
        });
      }
      function handle(self, deferred) {
        while (self._83 === 3) {
          self = self._18;
        }
        if (Promise._47) {
          Promise._47(self);
        }
        if (self._83 === 0) {
          if (self._75 === 0) {
            self._75 = 1;
            self._38 = deferred;
            return;
          }
          if (self._75 === 1) {
            self._75 = 2;
            self._38 = [self._38, deferred];
            return;
          }
          self._38.push(deferred);
          return;
        }
        handleResolved(self, deferred);
      }

      function handleResolved(self, deferred) {
        asap(function() {
          var cb = self._83 === 1 ? deferred.onFulfilled : deferred.onRejected;
          if (cb === null) {
            if (self._83 === 1) {
              resolve(deferred.promise, self._18);
            } else {
              reject(deferred.promise, self._18);
            }
            return;
          }
          var ret = tryCallOne(cb, self._18);
          if (ret === IS_ERROR) {
            reject(deferred.promise, LAST_ERROR);
          } else {
            resolve(deferred.promise, ret);
          }
        });
      }
      function resolve(self, newValue) {
        // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
        if (newValue === self) {
          return reject(
            self,
            new TypeError('A promise cannot be resolved with itself.')
          );
        }
        if (
          newValue &&
          (typeof newValue === 'object' || typeof newValue === 'function')
        ) {
          var then = getThen(newValue);
          if (then === IS_ERROR) {
            return reject(self, LAST_ERROR);
          }
          if (then === self.then && newValue instanceof Promise) {
            self._83 = 3;
            self._18 = newValue;
            finale(self);
            return;
          } else if (typeof then === 'function') {
            doResolve(then.bind(newValue), self);
            return;
          }
        }
        self._83 = 1;
        self._18 = newValue;
        finale(self);
      }

      function reject(self, newValue) {
        self._83 = 2;
        self._18 = newValue;
        if (Promise._71) {
          Promise._71(self, newValue);
        }
        finale(self);
      }
      function finale(self) {
        if (self._75 === 1) {
          handle(self, self._38);
          self._38 = null;
        }
        if (self._75 === 2) {
          for (var i = 0; i < self._38.length; i++) {
            handle(self, self._38[i]);
          }
          self._38 = null;
        }
      }

      function Handler(onFulfilled, onRejected, promise) {
        this.onFulfilled =
          typeof onFulfilled === 'function' ? onFulfilled : null;
        this.onRejected = typeof onRejected === 'function' ? onRejected : null;
        this.promise = promise;
      }

      /**
 * Take a potentially misbehaving resolver function and make sure
 * onFulfilled and onRejected are only called once.
 *
 * Makes no guarantees about asynchrony.
 */
      function doResolve(fn, promise) {
        var done = false;
        var res = tryCallTwo(
          fn,
          function(value) {
            if (done) return;
            done = true;
            resolve(promise, value);
          },
          function(reason) {
            if (done) return;
            done = true;
            reject(promise, reason);
          }
        );
        if (!done && res === IS_ERROR) {
          done = true;
          reject(promise, LAST_ERROR);
        }
      }

      /***/
    },
    /* 5 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';
      /**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

      var emptyObject = {};

      if (false) {
        Object.freeze(emptyObject);
      }

      module.exports = emptyObject;

      /***/
    },
    /* 6 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireWildcard(__webpack_require__(0));

      var _styles = __webpack_require__(1);

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/components/ErrorOverlay.js';

      function _interopRequireWildcard(obj) {
        if (obj && obj.__esModule) {
          return obj;
        } else {
          var newObj = {};
          if (obj != null) {
            for (var key in obj) {
              if (Object.prototype.hasOwnProperty.call(obj, key))
                newObj[key] = obj[key];
            }
          }
          newObj.default = obj;
          return newObj;
        }
      }

      function _typeof(obj) {
        if (
          typeof Symbol === 'function' &&
          typeof Symbol.iterator === 'symbol'
        ) {
          _typeof = function _typeof(obj) {
            return typeof obj;
          };
        } else {
          _typeof = function _typeof(obj) {
            return obj &&
            typeof Symbol === 'function' &&
            obj.constructor === Symbol &&
            obj !== Symbol.prototype
              ? 'symbol'
              : typeof obj;
          };
        }
        return _typeof(obj);
      }

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError('Cannot call a class as a function');
        }
      }

      function _defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ('value' in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }

      function _createClass(Constructor, protoProps, staticProps) {
        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
        if (staticProps) _defineProperties(Constructor, staticProps);
        return Constructor;
      }

      function _possibleConstructorReturn(self, call) {
        if (
          call &&
          (_typeof(call) === 'object' || typeof call === 'function')
        ) {
          return call;
        }
        if (!self) {
          throw new ReferenceError(
            "this hasn't been initialised - super() hasn't been called"
          );
        }
        return self;
      }

      function _inherits(subClass, superClass) {
        if (typeof superClass !== 'function' && superClass !== null) {
          throw new TypeError(
            'Super expression must either be null or a function'
          );
        }
        subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
            value: subClass,
            enumerable: false,
            writable: true,
            configurable: true,
          },
        });
        if (superClass)
          Object.setPrototypeOf
            ? Object.setPrototypeOf(subClass, superClass)
            : (subClass.__proto__ = superClass);
      }

      var overlayStyle = {
        position: 'relative',
        display: 'inline-flex',
        flexDirection: 'column',
        height: '100%',
        width: '1024px',
        maxWidth: '100%',
        overflowX: 'hidden',
        overflowY: 'auto',
        padding: '0.5rem',
        boxSizing: 'border-box',
        textAlign: 'left',
        fontFamily: 'Consolas, Menlo, monospace',
        fontSize: '11px',
        whiteSpace: 'pre-wrap',
        wordBreak: 'break-word',
        lineHeight: 1.5,
        color: _styles.black,
      };

      var ErrorOverlay =
        /*#__PURE__*/
        (function(_Component) {
          _inherits(ErrorOverlay, _Component);

          function ErrorOverlay() {
            var _ref;

            var _temp, _this;

            _classCallCheck(this, ErrorOverlay);

            for (
              var _len = arguments.length, args = new Array(_len), _key = 0;
              _key < _len;
              _key++
            ) {
              args[_key] = arguments[_key];
            }

            return _possibleConstructorReturn(
              _this,
              ((_temp = _this = _possibleConstructorReturn(
                this,
                (_ref =
                  ErrorOverlay.__proto__ ||
                  Object.getPrototypeOf(ErrorOverlay)).call.apply(
                  _ref,
                  [this].concat(args)
                )
              )),
              Object.defineProperty(_this, 'iframeWindow', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: null,
              }),
              Object.defineProperty(_this, 'getIframeWindow', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: function value(element) {
                  if (element) {
                    var document = element.ownerDocument;
                    _this.iframeWindow = document.defaultView;
                  }
                },
              }),
              Object.defineProperty(_this, 'onKeyDown', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: function value(e) {
                  var shortcutHandler = _this.props.shortcutHandler;

                  if (shortcutHandler) {
                    shortcutHandler(e.key);
                  }
                },
              }),
              _temp)
            );
          }

          _createClass(ErrorOverlay, [
            {
              key: 'componentDidMount',
              value: function componentDidMount() {
                window.addEventListener('keydown', this.onKeyDown);

                if (this.iframeWindow) {
                  this.iframeWindow.addEventListener('keydown', this.onKeyDown);
                }
              },
            },
            {
              key: 'componentWillUnmount',
              value: function componentWillUnmount() {
                window.removeEventListener('keydown', this.onKeyDown);

                if (this.iframeWindow) {
                  this.iframeWindow.removeEventListener(
                    'keydown',
                    this.onKeyDown
                  );
                }
              },
            },
            {
              key: 'render',
              value: function render() {
                return _react.default.createElement(
                  'div',
                  {
                    style: overlayStyle,
                    ref: this.getIframeWindow,
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 76,
                    },
                    __self: this,
                  },
                  this.props.children
                );
              },
            },
          ]);

          return ErrorOverlay;
        })(_react.Component);

      var _default = ErrorOverlay;
      exports.default = _default;

      /***/
    },
    /* 7 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireDefault(__webpack_require__(0));

      var _styles = __webpack_require__(1);

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/components/Footer.js';

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      var footerStyle = {
        fontFamily: 'sans-serif',
        color: _styles.darkGray,
        marginTop: '0.5rem',
        flex: '0 0 auto',
      };

      function Footer(props) {
        return _react.default.createElement(
          'div',
          {
            style: footerStyle,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 26,
            },
            __self: this,
          },
          props.line1,
          _react.default.createElement('br', {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 28,
            },
            __self: this,
          }),
          props.line2
        );
      }

      var _default = Footer;
      exports.default = _default;

      /***/
    },
    /* 8 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireDefault(__webpack_require__(0));

      var _styles = __webpack_require__(1);

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/components/Header.js';

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      var headerStyle = {
        fontSize: '2em',
        fontFamily: 'sans-serif',
        color: _styles.red,
        whiteSpace: 'pre-wrap',
        // Top bottom margin spaces header
        // Right margin revents overlap with close button
        margin: '0 2rem 0.75rem 0',
        flex: '0 0 auto',
        maxHeight: '50%',
        overflow: 'auto',
      };

      function Header(props) {
        return _react.default.createElement(
          'div',
          {
            style: headerStyle,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 30,
            },
            __self: this,
          },
          props.headerText
        );
      }

      var _default = Header;
      exports.default = _default;

      /***/
    },
    /* 9 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireDefault(__webpack_require__(0));

      var _styles = __webpack_require__(1);

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/components/CodeBlock.js';

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      function _extends() {
        _extends =
          Object.assign ||
          function(target) {
            for (var i = 1; i < arguments.length; i++) {
              var source = arguments[i];
              for (var key in source) {
                if (Object.prototype.hasOwnProperty.call(source, key)) {
                  target[key] = source[key];
                }
              }
            }
            return target;
          };
        return _extends.apply(this, arguments);
      }

      var _preStyle = {
        display: 'block',
        padding: '0.5em',
        marginTop: '0.5em',
        marginBottom: '0.5em',
        overflowX: 'auto',
        whiteSpace: 'pre-wrap',
        borderRadius: '0.25rem',
      };

      var primaryPreStyle = _extends({}, _preStyle, {
        backgroundColor: _styles.redTransparent,
      });

      var secondaryPreStyle = _extends({}, _preStyle, {
        backgroundColor: _styles.yellowTransparent,
      });

      var codeStyle = {
        fontFamily: 'Consolas, Menlo, monospace',
      };

      function CodeBlock(props) {
        var preStyle = props.main ? primaryPreStyle : secondaryPreStyle;
        var codeBlock = {
          __html: props.codeHTML,
        };
        return _react.default.createElement(
          'pre',
          {
            style: preStyle,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 46,
            },
            __self: this,
          },
          _react.default.createElement('code', {
            style: codeStyle,
            dangerouslySetInnerHTML: codeBlock,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 47,
            },
            __self: this,
          })
        );
      }

      var _default = CodeBlock;
      exports.default = _default;

      /***/
    },
    /* 10 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _anser = _interopRequireDefault(__webpack_require__(11));

      var _htmlEntities = __webpack_require__(35);

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      /**
 * Copyright (c) 2015-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
      var entities = new _htmlEntities.AllHtmlEntities(); // Color scheme inspired by https://chriskempson.github.io/base16/css/base16-github.css
      // var base00 = 'ffffff'; // Default Background

      var base01 = 'f5f5f5'; // Lighter Background (Used for status bars)
      // var base02 = 'c8c8fa'; // Selection Background

      var base03 = '6e6e6e'; // Comments, Invisibles, Line Highlighting
      // var base04 = 'e8e8e8'; // Dark Foreground (Used for status bars)

      var base05 = '333333'; // Default Foreground, Caret, Delimiters, Operators
      // var base06 = 'ffffff'; // Light Foreground (Not often used)
      // var base07 = 'ffffff'; // Light Background (Not often used)

      var base08 = '881280'; // Variables, XML Tags, Markup Link Text, Markup Lists, Diff Deleted
      // var base09 = '0086b3'; // Integers, Boolean, Constants, XML Attributes, Markup Link Url
      // var base0A = '795da3'; // Classes, Markup Bold, Search Text Background

      var base0B = '1155cc'; // Strings, Inherited Class, Markup Code, Diff Inserted

      var base0C = '994500'; // Support, Regular Expressions, Escape Characters, Markup Quotes
      // var base0D = '795da3'; // Functions, Methods, Attribute IDs, Headings

      var base0E = 'c80000'; // Keywords, Storage, Selector, Markup Italic, Diff Changed
      // var base0F = '333333'; // Deprecated, Opening/Closing Embedded Language Tags e.g. <?php ?>
      // Map ANSI colors from what babel-code-frame uses to base16-github
      // See: https://github.com/babel/babel/blob/e86f62b304d280d0bab52c38d61842b853848ba6/packages/babel-code-frame/src/index.js#L9-L22

      var colors = {
        reset: [base05, 'transparent'],
        black: base05,
        red: base08,
        /* marker, bg-invalid */
        green: base0B,
        /* string */
        yellow: base08,
        /* capitalized, jsx_tag, punctuator */
        blue: base0C,
        magenta: base0C,
        /* regex */
        cyan: base0E,
        /* keyword */
        gray: base03,
        /* comment, gutter */
        lightgrey: base01,
        darkgrey: base03,
      };
      var anserMap = {
        'ansi-bright-black': 'black',
        'ansi-bright-yellow': 'yellow',
        'ansi-yellow': 'yellow',
        'ansi-bright-green': 'green',
        'ansi-green': 'green',
        'ansi-bright-cyan': 'cyan',
        'ansi-cyan': 'cyan',
        'ansi-bright-red': 'red',
        'ansi-red': 'red',
        'ansi-bright-magenta': 'magenta',
        'ansi-magenta': 'magenta',
        'ansi-white': 'darkgrey',
      };

      function generateAnsiHTML(txt) {
        var arr = new _anser.default().ansiToJson(entities.encode(txt), {
          use_classes: true,
        });
        var result = '';
        var open = false;

        for (var index = 0; index < arr.length; ++index) {
          var c = arr[index];
          var content = c.content,
            fg = c.fg;
          var contentParts = content.split('\n');

          for (var _index = 0; _index < contentParts.length; ++_index) {
            if (!open) {
              result += '<span data-ansi-line="true">';
              open = true;
            }

            var part = contentParts[_index].replace('\r', '');

            var color = colors[anserMap[fg]];

            if (color != null) {
              result +=
                '<span style="color: #' + color + ';">' + part + '</span>';
            } else {
              if (fg != null) {
                console.log('Missing color mapping: ', fg);
              }

              result += '<span>' + part + '</span>';
            }

            if (_index < contentParts.length - 1) {
              result += '</span>';
              open = false;
              result += '<br/>';
            }
          }
        }

        if (open) {
          result += '</span>';
          open = false;
        }

        return result;
      }

      var _default = generateAnsiHTML;
      exports.default = _default;

      /***/
    },
    /* 11 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      // This file was originally written by @drudru (https://github.com/drudru/ansi_up), MIT, 2011

      var _createClass = (function() {
        function defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ('value' in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }
        return function(Constructor, protoProps, staticProps) {
          if (protoProps) defineProperties(Constructor.prototype, protoProps);
          if (staticProps) defineProperties(Constructor, staticProps);
          return Constructor;
        };
      })();

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError('Cannot call a class as a function');
        }
      }

      var ANSI_COLORS = [
        [
          { color: '0, 0, 0', class: 'ansi-black' },
          { color: '187, 0, 0', class: 'ansi-red' },
          { color: '0, 187, 0', class: 'ansi-green' },
          { color: '187, 187, 0', class: 'ansi-yellow' },
          { color: '0, 0, 187', class: 'ansi-blue' },
          { color: '187, 0, 187', class: 'ansi-magenta' },
          { color: '0, 187, 187', class: 'ansi-cyan' },
          { color: '255,255,255', class: 'ansi-white' },
        ],
        [
          { color: '85, 85, 85', class: 'ansi-bright-black' },
          { color: '255, 85, 85', class: 'ansi-bright-red' },
          { color: '0, 255, 0', class: 'ansi-bright-green' },
          { color: '255, 255, 85', class: 'ansi-bright-yellow' },
          { color: '85, 85, 255', class: 'ansi-bright-blue' },
          { color: '255, 85, 255', class: 'ansi-bright-magenta' },
          { color: '85, 255, 255', class: 'ansi-bright-cyan' },
          { color: '255, 255, 255', class: 'ansi-bright-white' },
        ],
      ];

      var Anser = (function() {
        _createClass(Anser, null, [
          {
            key: 'escapeForHtml',

            /**
         * Anser.escapeForHtml
         * Escape the input HTML.
         *
         * This does the minimum escaping of text to make it compliant with HTML.
         * In particular, the '&','<', and '>' characters are escaped. This should
         * be run prior to `ansiToHtml`.
         *
         * @name Anser.escapeForHtml
         * @function
         * @param {String} txt The input text (containing the ANSI snippets).
         * @returns {String} The escaped html.
         */
            value: function escapeForHtml(txt) {
              return new Anser().escapeForHtml(txt);
            },

            /**
         * Anser.linkify
         * Adds the links in the HTML.
         *
         * This replaces any links in the text with anchor tags that display the
         * link. The links should have at least one whitespace character
         * surrounding it. Also, you should apply this after you have run
         * `ansiToHtml` on the text.
         *
         * @name Anser.linkify
         * @function
         * @param {String} txt The input text.
         * @returns {String} The HTML containing the <a> tags (unescaped).
         */
          },
          {
            key: 'linkify',
            value: function linkify(txt) {
              return new Anser().linkify(txt);
            },

            /**
         * Anser.ansiToHtml
         * This replaces ANSI terminal escape codes with SPAN tags that wrap the
         * content.
         *
         * This function only interprets ANSI SGR (Select Graphic Rendition) codes
         * that can be represented in HTML.
         * For example, cursor movement codes are ignored and hidden from output.
         * The default style uses colors that are very close to the prescribed
         * standard. The standard assumes that the text will have a black
         * background. These colors are set as inline styles on the SPAN tags.
         *
         * Another option is to set `use_classes: true` in the options argument.
         * This will instead set classes on the spans so the colors can be set via
         * CSS. The class names used are of the format `ansi-*-fg/bg` and
         * `ansi-bright-*-fg/bg` where `*` is the color name,
         * i.e black/red/green/yellow/blue/magenta/cyan/white.
         *
         * @name Anser.ansiToHtml
         * @function
         * @param {String} txt The input text.
         * @param {Object} options The options passed to the ansiToHTML method.
         * @returns {String} The HTML output.
         */
          },
          {
            key: 'ansiToHtml',
            value: function ansiToHtml(txt, options) {
              return new Anser().ansiToHtml(txt, options);
            },

            /**
         * Anser.ansiToJson
         * Converts ANSI input into JSON output.
         *
         * @name Anser.ansiToJson
         * @function
         * @param {String} txt The input text.
         * @param {Object} options The options passed to the ansiToHTML method.
         * @returns {String} The HTML output.
         */
          },
          {
            key: 'ansiToJson',
            value: function ansiToJson(txt, options) {
              return new Anser().ansiToJson(txt, options);
            },

            /**
         * Anser.ansiToText
         * Converts ANSI input into text output.
         *
         * @name Anser.ansiToText
         * @function
         * @param {String} txt The input text.
         * @returns {String} The text output.
         */
          },
          {
            key: 'ansiToText',
            value: function ansiToText(txt) {
              return new Anser().ansiToText(txt);
            },

            /**
         * Anser
         * The `Anser` class.
         *
         * @name Anser
         * @function
         * @returns {Anser}
         */
          },
        ]);

        function Anser() {
          _classCallCheck(this, Anser);

          this.fg = this.bg = this.fg_truecolor = this.bg_truecolor = null;
          this.bright = 0;
        }

        /**
     * setupPalette
     * Sets up the palette.
     *
     * @name setupPalette
     * @function
     */

        _createClass(Anser, [
          {
            key: 'setupPalette',
            value: function setupPalette() {
              this.PALETTE_COLORS = [];

              // Index 0..15 : System color
              for (var i = 0; i < 2; ++i) {
                for (var j = 0; j < 8; ++j) {
                  this.PALETTE_COLORS.push(ANSI_COLORS[i][j].color);
                }
              }

              // Index 16..231 : RGB 6x6x6
              // https://gist.github.com/jasonm23/2868981#file-xterm-256color-yaml
              var levels = [0, 95, 135, 175, 215, 255];
              var format = function format(r, g, b) {
                return levels[r] + ', ' + levels[g] + ', ' + levels[b];
              };
              var r = void 0,
                g = void 0,
                b = void 0;
              for (var _r = 0; _r < 6; ++_r) {
                for (var _g = 0; _g < 6; ++_g) {
                  for (var _b = 0; _b < 6; ++_b) {
                    this.PALETTE_COLORS.push(format(_r, _g, _b));
                  }
                }
              }

              // Index 232..255 : Grayscale
              var level = 8;
              for (var _i = 0; _i < 24; ++_i, level += 10) {
                this.PALETTE_COLORS.push(format(level, level, level));
              }
            },

            /**
         * escapeForHtml
         * Escapes the input text.
         *
         * @name escapeForHtml
         * @function
         * @param {String} txt The input text.
         * @returns {String} The escpaed HTML output.
         */
          },
          {
            key: 'escapeForHtml',
            value: function escapeForHtml(txt) {
              return txt.replace(/[&<>]/gm, function(str) {
                return str == '&'
                  ? '&amp;'
                  : str == '<' ? '&lt;' : str == '>' ? '&gt;' : '';
              });
            },

            /**
         * linkify
         * Adds HTML link elements.
         *
         * @name linkify
         * @function
         * @param {String} txt The input text.
         * @returns {String} The HTML output containing link elements.
         */
          },
          {
            key: 'linkify',
            value: function linkify(txt) {
              return txt.replace(/(https?:\/\/[^\s]+)/gm, function(str) {
                return '<a href="' + str + '">' + str + '</a>';
              });
            },

            /**
         * ansiToHtml
         * Converts ANSI input into HTML output.
         *
         * @name ansiToHtml
         * @function
         * @param {String} txt The input text.
         * @param {Object} options The options passed ot the `process` method.
         * @returns {String} The HTML output.
         */
          },
          {
            key: 'ansiToHtml',
            value: function ansiToHtml(txt, options) {
              return this.process(txt, options, true);
            },

            /**
         * ansiToJson
         * Converts ANSI input into HTML output.
         *
         * @name ansiToJson
         * @function
         * @param {String} txt The input text.
         * @param {Object} options The options passed ot the `process` method.
         * @returns {String} The JSON output.
         */
          },
          {
            key: 'ansiToJson',
            value: function ansiToJson(txt, options) {
              options = options || {};
              options.json = true;
              options.clearLine = false;
              return this.process(txt, options, true);
            },

            /**
         * ansiToText
         * Converts ANSI input into HTML output.
         *
         * @name ansiToText
         * @function
         * @param {String} txt The input text.
         * @returns {String} The text output.
         */
          },
          {
            key: 'ansiToText',
            value: function ansiToText(txt) {
              return this.process(txt, {}, false);
            },

            /**
         * process
         * Processes the input.
         *
         * @name process
         * @function
         * @param {String} txt The input text.
         * @param {Object} options An object passed to `processChunk` method, extended with:
         *
         *  - `json` (Boolean): If `true`, the result will be an object.
         *  - `use_classes` (Boolean): If `true`, HTML classes will be appended to the HTML output.
         *
         * @param {Boolean} markup
         */
          },
          {
            key: 'process',
            value: function process(txt, options, markup) {
              var _this = this;

              var self = this;
              var raw_text_chunks = txt.split(/\033\[/);
              var first_chunk = raw_text_chunks.shift(); // the first chunk is not the result of the split

              if (options === undefined || options === null) {
                options = {};
              }
              options.clearLine = /\r/.test(txt); // check for Carriage Return
              var color_chunks = raw_text_chunks.map(function(chunk) {
                return _this.processChunk(chunk, options, markup);
              });

              if (options && options.json) {
                var first = self.processChunkJson('');
                first.content = first_chunk;
                first.clearLine = options.clearLine;
                color_chunks.unshift(first);
                if (options.remove_empty) {
                  color_chunks = color_chunks.filter(function(c) {
                    return !c.isEmpty();
                  });
                }
                return color_chunks;
              } else {
                color_chunks.unshift(first_chunk);
              }

              return color_chunks.join('');
            },

            /**
         * processChunkJson
         * Processes the current chunk into json output.
         *
         * @name processChunkJson
         * @function
         * @param {String} text The input text.
         * @param {Object} options An object containing the following fields:
         *
         *  - `json` (Boolean): If `true`, the result will be an object.
         *  - `use_classes` (Boolean): If `true`, HTML classes will be appended to the HTML output.
         *
         * @param {Boolean} markup If false, the colors will not be parsed.
         * @return {Object} The result object:
         *
         *  - `content` (String): The text.
         *  - `fg` (String|null): The foreground color.
         *  - `bg` (String|null): The background color.
         *  - `fg_truecolor` (String|null): The foreground true color (if 16m color is enabled).
         *  - `bg_truecolor` (String|null): The background true color (if 16m color is enabled).
         *  - `clearLine` (Boolean): `true` if a carriageReturn \r was fount at end of line.
         *  - `was_processed` (Bolean): `true` if the colors were processed, `false` otherwise.
         *  - `isEmpty` (Function): A function returning `true` if the content is empty, or `false` otherwise.
         *
         */
          },
          {
            key: 'processChunkJson',
            value: function processChunkJson(text, options, markup) {
              // Are we using classes or styles?
              options = typeof options == 'undefined' ? {} : options;
              var use_classes = (options.use_classes =
                typeof options.use_classes != 'undefined' &&
                options.use_classes);
              var key = (options.key = use_classes ? 'class' : 'color');

              var result = {
                content: text,
                fg: null,
                bg: null,
                fg_truecolor: null,
                bg_truecolor: null,
                clearLine: options.clearLine,
                decoration: null,
                was_processed: false,
                isEmpty: function isEmpty() {
                  return !result.content;
                },
              };

              // Each "chunk" is the text after the CSI (ESC + "[") and before the next CSI/EOF.
              //
              // This regex matches four groups within a chunk.
              //
              // The first and third groups match code type.
              // We supported only SGR command. It has empty first group and "m" in third.
              //
              // The second group matches all of the number+semicolon command sequences
              // before the "m" (or other trailing) character.
              // These are the graphics or SGR commands.
              //
              // The last group is the text (including newlines) that is colored by
              // the other group"s commands.
              var matches = text.match(
                /^([!\x3c-\x3f]*)([\d;]*)([\x20-\x2c]*[\x40-\x7e])([\s\S]*)/m
              );

              if (!matches) return result;

              var orig_txt = (result.content = matches[4]);
              var nums = matches[2].split(';');

              // We currently support only "SGR" (Select Graphic Rendition)
              // Simply ignore if not a SGR command.
              if (matches[1] !== '' || matches[3] !== 'm') {
                return result;
              }

              if (!markup) {
                return result;
              }

              var self = this;

              self.decoration = null;

              while (nums.length > 0) {
                var num_str = nums.shift();
                var num = parseInt(num_str);

                if (isNaN(num) || num === 0) {
                  self.fg = self.bg = self.decoration = null;
                } else if (num === 1) {
                  self.decoration = 'bold';
                } else if (num === 2) {
                  self.decoration = 'dim';
                  // Enable code 2 to get string
                } else if (num == 3) {
                  self.decoration = 'italic';
                } else if (num == 4) {
                  self.decoration = 'underline';
                } else if (num == 5) {
                  self.decoration = 'blink';
                } else if (num === 7) {
                  self.decoration = 'reverse';
                } else if (num === 8) {
                  self.decoration = 'hidden';
                  // Enable code 9 to get strikethrough
                } else if (num === 9) {
                  self.decoration = 'strikethrough';
                } else if (num == 39) {
                  self.fg = null;
                } else if (num == 49) {
                  self.bg = null;
                  // Foreground color
                } else if (num >= 30 && num < 38) {
                  self.fg = ANSI_COLORS[0][num % 10][key];
                  // Foreground bright color
                } else if (num >= 90 && num < 98) {
                  self.fg = ANSI_COLORS[1][num % 10][key];
                  // Background color
                } else if (num >= 40 && num < 48) {
                  self.bg = ANSI_COLORS[0][num % 10][key];
                  // Background bright color
                } else if (num >= 100 && num < 108) {
                  self.bg = ANSI_COLORS[1][num % 10][key];
                } else if (num === 38 || num === 48) {
                  // extend color (38=fg, 48=bg)
                  var is_foreground = num === 38;
                  if (nums.length >= 1) {
                    var mode = nums.shift();
                    if (mode === '5' && nums.length >= 1) {
                      // palette color
                      var palette_index = parseInt(nums.shift());
                      if (palette_index >= 0 && palette_index <= 255) {
                        if (!use_classes) {
                          if (!this.PALETTE_COLORS) {
                            self.setupPalette();
                          }
                          if (is_foreground) {
                            self.fg = this.PALETTE_COLORS[palette_index];
                          } else {
                            self.bg = this.PALETTE_COLORS[palette_index];
                          }
                        } else {
                          var klass =
                            palette_index >= 16
                              ? 'ansi-palette-' + palette_index
                              : ANSI_COLORS[palette_index > 7 ? 1 : 0][
                                  palette_index % 8
                                ]['class'];
                          if (is_foreground) {
                            self.fg = klass;
                          } else {
                            self.bg = klass;
                          }
                        }
                      }
                    } else if (mode === '2' && nums.length >= 3) {
                      // true color
                      var r = parseInt(nums.shift());
                      var g = parseInt(nums.shift());
                      var b = parseInt(nums.shift());
                      if (
                        r >= 0 &&
                        r <= 255 &&
                        g >= 0 &&
                        g <= 255 &&
                        b >= 0 &&
                        b <= 255
                      ) {
                        var color = r + ', ' + g + ', ' + b;
                        if (!use_classes) {
                          if (is_foreground) {
                            self.fg = color;
                          } else {
                            self.bg = color;
                          }
                        } else {
                          if (is_foreground) {
                            self.fg = 'ansi-truecolor';
                            self.fg_truecolor = color;
                          } else {
                            self.bg = 'ansi-truecolor';
                            self.bg_truecolor = color;
                          }
                        }
                      }
                    }
                  }
                }
              }

              if (
                self.fg === null &&
                self.bg === null &&
                self.decoration === null
              ) {
                return result;
              } else {
                var styles = [];
                var classes = [];
                var data = {};

                result.fg = self.fg;
                result.bg = self.bg;
                result.fg_truecolor = self.fg_truecolor;
                result.bg_truecolor = self.bg_truecolor;
                result.decoration = self.decoration;
                result.was_processed = true;

                return result;
              }
            },

            /**
         * processChunk
         * Processes the current chunk of text.
         *
         * @name processChunk
         * @function
         * @param {String} text The input text.
         * @param {Object} options An object containing the following fields:
         *
         *  - `json` (Boolean): If `true`, the result will be an object.
         *  - `use_classes` (Boolean): If `true`, HTML classes will be appended to the HTML output.
         *
         * @param {Boolean} markup If false, the colors will not be parsed.
         * @return {Object|String} The result (object if `json` is wanted back or string otherwise).
         */
          },
          {
            key: 'processChunk',
            value: function processChunk(text, options, markup) {
              var _this2 = this;

              var self = this;
              options = options || {};
              var jsonChunk = this.processChunkJson(text, options, markup);

              if (options.json) {
                return jsonChunk;
              }
              if (jsonChunk.isEmpty()) {
                return '';
              }
              if (!jsonChunk.was_processed) {
                return jsonChunk.content;
              }

              var use_classes = options.use_classes;

              var styles = [];
              var classes = [];
              var data = {};
              var render_data = function render_data(data) {
                var fragments = [];
                var key = void 0;
                for (key in data) {
                  if (data.hasOwnProperty(key)) {
                    fragments.push(
                      'data-' +
                        key +
                        '="' +
                        _this2.escapeForHtml(data[key]) +
                        '"'
                    );
                  }
                }
                return fragments.length > 0 ? ' ' + fragments.join(' ') : '';
              };

              if (jsonChunk.fg) {
                if (use_classes) {
                  classes.push(jsonChunk.fg + '-fg');
                  if (jsonChunk.fg_truecolor !== null) {
                    data['ansi-truecolor-fg'] = jsonChunk.fg_truecolor;
                    jsonChunk.fg_truecolor = null;
                  }
                } else {
                  styles.push('color:rgb(' + jsonChunk.fg + ')');
                }
              }

              if (jsonChunk.bg) {
                if (use_classes) {
                  classes.push(jsonChunk.bg + '-bg');
                  if (jsonChunk.bg_truecolor !== null) {
                    data['ansi-truecolor-bg'] = jsonChunk.bg_truecolor;
                    jsonChunk.bg_truecolor = null;
                  }
                } else {
                  styles.push('background-color:rgb(' + jsonChunk.bg + ')');
                }
              }

              if (jsonChunk.decoration) {
                if (use_classes) {
                  classes.push('ansi-' + jsonChunk.decoration);
                } else if (jsonChunk.decoration === 'bold') {
                  styles.push('font-weight:bold');
                } else if (jsonChunk.decoration === 'dim') {
                  styles.push('opacity:0.5');
                } else if (jsonChunk.decoration === 'italic') {
                  styles.push('font-style:italic');
                  // underline and blink are treated bellow
                } else if (jsonChunk.decoration === 'reverse') {
                  styles.push('filter:invert(100%)');
                } else if (jsonChunk.decoration === 'hidden') {
                  styles.push('visibility:hidden');
                } else if (jsonChunk.decoration === 'strikethrough') {
                  styles.push('text-decoration:line-through');
                } else {
                  styles.push('text-decoration:' + jsonChunk.decoration);
                }
              }

              if (use_classes) {
                return (
                  '<span class="' +
                  classes.join(' ') +
                  '"' +
                  render_data(data) +
                  '>' +
                  jsonChunk.content +
                  '</span>'
                );
              } else {
                return (
                  '<span style="' +
                  styles.join(';') +
                  '"' +
                  render_data(data) +
                  '>' +
                  jsonChunk.content +
                  '</span>'
                );
              }
            },
          },
        ]);

        return Anser;
      })();

      module.exports = Anser;

      /***/
    },
    /* 12 */
    /***/ function(module, exports) {
      var ENTITIES = [
        ['Aacute', [193]],
        ['aacute', [225]],
        ['Abreve', [258]],
        ['abreve', [259]],
        ['ac', [8766]],
        ['acd', [8767]],
        ['acE', [8766, 819]],
        ['Acirc', [194]],
        ['acirc', [226]],
        ['acute', [180]],
        ['Acy', [1040]],
        ['acy', [1072]],
        ['AElig', [198]],
        ['aelig', [230]],
        ['af', [8289]],
        ['Afr', [120068]],
        ['afr', [120094]],
        ['Agrave', [192]],
        ['agrave', [224]],
        ['alefsym', [8501]],
        ['aleph', [8501]],
        ['Alpha', [913]],
        ['alpha', [945]],
        ['Amacr', [256]],
        ['amacr', [257]],
        ['amalg', [10815]],
        ['amp', [38]],
        ['AMP', [38]],
        ['andand', [10837]],
        ['And', [10835]],
        ['and', [8743]],
        ['andd', [10844]],
        ['andslope', [10840]],
        ['andv', [10842]],
        ['ang', [8736]],
        ['ange', [10660]],
        ['angle', [8736]],
        ['angmsdaa', [10664]],
        ['angmsdab', [10665]],
        ['angmsdac', [10666]],
        ['angmsdad', [10667]],
        ['angmsdae', [10668]],
        ['angmsdaf', [10669]],
        ['angmsdag', [10670]],
        ['angmsdah', [10671]],
        ['angmsd', [8737]],
        ['angrt', [8735]],
        ['angrtvb', [8894]],
        ['angrtvbd', [10653]],
        ['angsph', [8738]],
        ['angst', [197]],
        ['angzarr', [9084]],
        ['Aogon', [260]],
        ['aogon', [261]],
        ['Aopf', [120120]],
        ['aopf', [120146]],
        ['apacir', [10863]],
        ['ap', [8776]],
        ['apE', [10864]],
        ['ape', [8778]],
        ['apid', [8779]],
        ['apos', [39]],
        ['ApplyFunction', [8289]],
        ['approx', [8776]],
        ['approxeq', [8778]],
        ['Aring', [197]],
        ['aring', [229]],
        ['Ascr', [119964]],
        ['ascr', [119990]],
        ['Assign', [8788]],
        ['ast', [42]],
        ['asymp', [8776]],
        ['asympeq', [8781]],
        ['Atilde', [195]],
        ['atilde', [227]],
        ['Auml', [196]],
        ['auml', [228]],
        ['awconint', [8755]],
        ['awint', [10769]],
        ['backcong', [8780]],
        ['backepsilon', [1014]],
        ['backprime', [8245]],
        ['backsim', [8765]],
        ['backsimeq', [8909]],
        ['Backslash', [8726]],
        ['Barv', [10983]],
        ['barvee', [8893]],
        ['barwed', [8965]],
        ['Barwed', [8966]],
        ['barwedge', [8965]],
        ['bbrk', [9141]],
        ['bbrktbrk', [9142]],
        ['bcong', [8780]],
        ['Bcy', [1041]],
        ['bcy', [1073]],
        ['bdquo', [8222]],
        ['becaus', [8757]],
        ['because', [8757]],
        ['Because', [8757]],
        ['bemptyv', [10672]],
        ['bepsi', [1014]],
        ['bernou', [8492]],
        ['Bernoullis', [8492]],
        ['Beta', [914]],
        ['beta', [946]],
        ['beth', [8502]],
        ['between', [8812]],
        ['Bfr', [120069]],
        ['bfr', [120095]],
        ['bigcap', [8898]],
        ['bigcirc', [9711]],
        ['bigcup', [8899]],
        ['bigodot', [10752]],
        ['bigoplus', [10753]],
        ['bigotimes', [10754]],
        ['bigsqcup', [10758]],
        ['bigstar', [9733]],
        ['bigtriangledown', [9661]],
        ['bigtriangleup', [9651]],
        ['biguplus', [10756]],
        ['bigvee', [8897]],
        ['bigwedge', [8896]],
        ['bkarow', [10509]],
        ['blacklozenge', [10731]],
        ['blacksquare', [9642]],
        ['blacktriangle', [9652]],
        ['blacktriangledown', [9662]],
        ['blacktriangleleft', [9666]],
        ['blacktriangleright', [9656]],
        ['blank', [9251]],
        ['blk12', [9618]],
        ['blk14', [9617]],
        ['blk34', [9619]],
        ['block', [9608]],
        ['bne', [61, 8421]],
        ['bnequiv', [8801, 8421]],
        ['bNot', [10989]],
        ['bnot', [8976]],
        ['Bopf', [120121]],
        ['bopf', [120147]],
        ['bot', [8869]],
        ['bottom', [8869]],
        ['bowtie', [8904]],
        ['boxbox', [10697]],
        ['boxdl', [9488]],
        ['boxdL', [9557]],
        ['boxDl', [9558]],
        ['boxDL', [9559]],
        ['boxdr', [9484]],
        ['boxdR', [9554]],
        ['boxDr', [9555]],
        ['boxDR', [9556]],
        ['boxh', [9472]],
        ['boxH', [9552]],
        ['boxhd', [9516]],
        ['boxHd', [9572]],
        ['boxhD', [9573]],
        ['boxHD', [9574]],
        ['boxhu', [9524]],
        ['boxHu', [9575]],
        ['boxhU', [9576]],
        ['boxHU', [9577]],
        ['boxminus', [8863]],
        ['boxplus', [8862]],
        ['boxtimes', [8864]],
        ['boxul', [9496]],
        ['boxuL', [9563]],
        ['boxUl', [9564]],
        ['boxUL', [9565]],
        ['boxur', [9492]],
        ['boxuR', [9560]],
        ['boxUr', [9561]],
        ['boxUR', [9562]],
        ['boxv', [9474]],
        ['boxV', [9553]],
        ['boxvh', [9532]],
        ['boxvH', [9578]],
        ['boxVh', [9579]],
        ['boxVH', [9580]],
        ['boxvl', [9508]],
        ['boxvL', [9569]],
        ['boxVl', [9570]],
        ['boxVL', [9571]],
        ['boxvr', [9500]],
        ['boxvR', [9566]],
        ['boxVr', [9567]],
        ['boxVR', [9568]],
        ['bprime', [8245]],
        ['breve', [728]],
        ['Breve', [728]],
        ['brvbar', [166]],
        ['bscr', [119991]],
        ['Bscr', [8492]],
        ['bsemi', [8271]],
        ['bsim', [8765]],
        ['bsime', [8909]],
        ['bsolb', [10693]],
        ['bsol', [92]],
        ['bsolhsub', [10184]],
        ['bull', [8226]],
        ['bullet', [8226]],
        ['bump', [8782]],
        ['bumpE', [10926]],
        ['bumpe', [8783]],
        ['Bumpeq', [8782]],
        ['bumpeq', [8783]],
        ['Cacute', [262]],
        ['cacute', [263]],
        ['capand', [10820]],
        ['capbrcup', [10825]],
        ['capcap', [10827]],
        ['cap', [8745]],
        ['Cap', [8914]],
        ['capcup', [10823]],
        ['capdot', [10816]],
        ['CapitalDifferentialD', [8517]],
        ['caps', [8745, 65024]],
        ['caret', [8257]],
        ['caron', [711]],
        ['Cayleys', [8493]],
        ['ccaps', [10829]],
        ['Ccaron', [268]],
        ['ccaron', [269]],
        ['Ccedil', [199]],
        ['ccedil', [231]],
        ['Ccirc', [264]],
        ['ccirc', [265]],
        ['Cconint', [8752]],
        ['ccups', [10828]],
        ['ccupssm', [10832]],
        ['Cdot', [266]],
        ['cdot', [267]],
        ['cedil', [184]],
        ['Cedilla', [184]],
        ['cemptyv', [10674]],
        ['cent', [162]],
        ['centerdot', [183]],
        ['CenterDot', [183]],
        ['cfr', [120096]],
        ['Cfr', [8493]],
        ['CHcy', [1063]],
        ['chcy', [1095]],
        ['check', [10003]],
        ['checkmark', [10003]],
        ['Chi', [935]],
        ['chi', [967]],
        ['circ', [710]],
        ['circeq', [8791]],
        ['circlearrowleft', [8634]],
        ['circlearrowright', [8635]],
        ['circledast', [8859]],
        ['circledcirc', [8858]],
        ['circleddash', [8861]],
        ['CircleDot', [8857]],
        ['circledR', [174]],
        ['circledS', [9416]],
        ['CircleMinus', [8854]],
        ['CirclePlus', [8853]],
        ['CircleTimes', [8855]],
        ['cir', [9675]],
        ['cirE', [10691]],
        ['cire', [8791]],
        ['cirfnint', [10768]],
        ['cirmid', [10991]],
        ['cirscir', [10690]],
        ['ClockwiseContourIntegral', [8754]],
        ['clubs', [9827]],
        ['clubsuit', [9827]],
        ['colon', [58]],
        ['Colon', [8759]],
        ['Colone', [10868]],
        ['colone', [8788]],
        ['coloneq', [8788]],
        ['comma', [44]],
        ['commat', [64]],
        ['comp', [8705]],
        ['compfn', [8728]],
        ['complement', [8705]],
        ['complexes', [8450]],
        ['cong', [8773]],
        ['congdot', [10861]],
        ['Congruent', [8801]],
        ['conint', [8750]],
        ['Conint', [8751]],
        ['ContourIntegral', [8750]],
        ['copf', [120148]],
        ['Copf', [8450]],
        ['coprod', [8720]],
        ['Coproduct', [8720]],
        ['copy', [169]],
        ['COPY', [169]],
        ['copysr', [8471]],
        ['CounterClockwiseContourIntegral', [8755]],
        ['crarr', [8629]],
        ['cross', [10007]],
        ['Cross', [10799]],
        ['Cscr', [119966]],
        ['cscr', [119992]],
        ['csub', [10959]],
        ['csube', [10961]],
        ['csup', [10960]],
        ['csupe', [10962]],
        ['ctdot', [8943]],
        ['cudarrl', [10552]],
        ['cudarrr', [10549]],
        ['cuepr', [8926]],
        ['cuesc', [8927]],
        ['cularr', [8630]],
        ['cularrp', [10557]],
        ['cupbrcap', [10824]],
        ['cupcap', [10822]],
        ['CupCap', [8781]],
        ['cup', [8746]],
        ['Cup', [8915]],
        ['cupcup', [10826]],
        ['cupdot', [8845]],
        ['cupor', [10821]],
        ['cups', [8746, 65024]],
        ['curarr', [8631]],
        ['curarrm', [10556]],
        ['curlyeqprec', [8926]],
        ['curlyeqsucc', [8927]],
        ['curlyvee', [8910]],
        ['curlywedge', [8911]],
        ['curren', [164]],
        ['curvearrowleft', [8630]],
        ['curvearrowright', [8631]],
        ['cuvee', [8910]],
        ['cuwed', [8911]],
        ['cwconint', [8754]],
        ['cwint', [8753]],
        ['cylcty', [9005]],
        ['dagger', [8224]],
        ['Dagger', [8225]],
        ['daleth', [8504]],
        ['darr', [8595]],
        ['Darr', [8609]],
        ['dArr', [8659]],
        ['dash', [8208]],
        ['Dashv', [10980]],
        ['dashv', [8867]],
        ['dbkarow', [10511]],
        ['dblac', [733]],
        ['Dcaron', [270]],
        ['dcaron', [271]],
        ['Dcy', [1044]],
        ['dcy', [1076]],
        ['ddagger', [8225]],
        ['ddarr', [8650]],
        ['DD', [8517]],
        ['dd', [8518]],
        ['DDotrahd', [10513]],
        ['ddotseq', [10871]],
        ['deg', [176]],
        ['Del', [8711]],
        ['Delta', [916]],
        ['delta', [948]],
        ['demptyv', [10673]],
        ['dfisht', [10623]],
        ['Dfr', [120071]],
        ['dfr', [120097]],
        ['dHar', [10597]],
        ['dharl', [8643]],
        ['dharr', [8642]],
        ['DiacriticalAcute', [180]],
        ['DiacriticalDot', [729]],
        ['DiacriticalDoubleAcute', [733]],
        ['DiacriticalGrave', [96]],
        ['DiacriticalTilde', [732]],
        ['diam', [8900]],
        ['diamond', [8900]],
        ['Diamond', [8900]],
        ['diamondsuit', [9830]],
        ['diams', [9830]],
        ['die', [168]],
        ['DifferentialD', [8518]],
        ['digamma', [989]],
        ['disin', [8946]],
        ['div', [247]],
        ['divide', [247]],
        ['divideontimes', [8903]],
        ['divonx', [8903]],
        ['DJcy', [1026]],
        ['djcy', [1106]],
        ['dlcorn', [8990]],
        ['dlcrop', [8973]],
        ['dollar', [36]],
        ['Dopf', [120123]],
        ['dopf', [120149]],
        ['Dot', [168]],
        ['dot', [729]],
        ['DotDot', [8412]],
        ['doteq', [8784]],
        ['doteqdot', [8785]],
        ['DotEqual', [8784]],
        ['dotminus', [8760]],
        ['dotplus', [8724]],
        ['dotsquare', [8865]],
        ['doublebarwedge', [8966]],
        ['DoubleContourIntegral', [8751]],
        ['DoubleDot', [168]],
        ['DoubleDownArrow', [8659]],
        ['DoubleLeftArrow', [8656]],
        ['DoubleLeftRightArrow', [8660]],
        ['DoubleLeftTee', [10980]],
        ['DoubleLongLeftArrow', [10232]],
        ['DoubleLongLeftRightArrow', [10234]],
        ['DoubleLongRightArrow', [10233]],
        ['DoubleRightArrow', [8658]],
        ['DoubleRightTee', [8872]],
        ['DoubleUpArrow', [8657]],
        ['DoubleUpDownArrow', [8661]],
        ['DoubleVerticalBar', [8741]],
        ['DownArrowBar', [10515]],
        ['downarrow', [8595]],
        ['DownArrow', [8595]],
        ['Downarrow', [8659]],
        ['DownArrowUpArrow', [8693]],
        ['DownBreve', [785]],
        ['downdownarrows', [8650]],
        ['downharpoonleft', [8643]],
        ['downharpoonright', [8642]],
        ['DownLeftRightVector', [10576]],
        ['DownLeftTeeVector', [10590]],
        ['DownLeftVectorBar', [10582]],
        ['DownLeftVector', [8637]],
        ['DownRightTeeVector', [10591]],
        ['DownRightVectorBar', [10583]],
        ['DownRightVector', [8641]],
        ['DownTeeArrow', [8615]],
        ['DownTee', [8868]],
        ['drbkarow', [10512]],
        ['drcorn', [8991]],
        ['drcrop', [8972]],
        ['Dscr', [119967]],
        ['dscr', [119993]],
        ['DScy', [1029]],
        ['dscy', [1109]],
        ['dsol', [10742]],
        ['Dstrok', [272]],
        ['dstrok', [273]],
        ['dtdot', [8945]],
        ['dtri', [9663]],
        ['dtrif', [9662]],
        ['duarr', [8693]],
        ['duhar', [10607]],
        ['dwangle', [10662]],
        ['DZcy', [1039]],
        ['dzcy', [1119]],
        ['dzigrarr', [10239]],
        ['Eacute', [201]],
        ['eacute', [233]],
        ['easter', [10862]],
        ['Ecaron', [282]],
        ['ecaron', [283]],
        ['Ecirc', [202]],
        ['ecirc', [234]],
        ['ecir', [8790]],
        ['ecolon', [8789]],
        ['Ecy', [1069]],
        ['ecy', [1101]],
        ['eDDot', [10871]],
        ['Edot', [278]],
        ['edot', [279]],
        ['eDot', [8785]],
        ['ee', [8519]],
        ['efDot', [8786]],
        ['Efr', [120072]],
        ['efr', [120098]],
        ['eg', [10906]],
        ['Egrave', [200]],
        ['egrave', [232]],
        ['egs', [10902]],
        ['egsdot', [10904]],
        ['el', [10905]],
        ['Element', [8712]],
        ['elinters', [9191]],
        ['ell', [8467]],
        ['els', [10901]],
        ['elsdot', [10903]],
        ['Emacr', [274]],
        ['emacr', [275]],
        ['empty', [8709]],
        ['emptyset', [8709]],
        ['EmptySmallSquare', [9723]],
        ['emptyv', [8709]],
        ['EmptyVerySmallSquare', [9643]],
        ['emsp13', [8196]],
        ['emsp14', [8197]],
        ['emsp', [8195]],
        ['ENG', [330]],
        ['eng', [331]],
        ['ensp', [8194]],
        ['Eogon', [280]],
        ['eogon', [281]],
        ['Eopf', [120124]],
        ['eopf', [120150]],
        ['epar', [8917]],
        ['eparsl', [10723]],
        ['eplus', [10865]],
        ['epsi', [949]],
        ['Epsilon', [917]],
        ['epsilon', [949]],
        ['epsiv', [1013]],
        ['eqcirc', [8790]],
        ['eqcolon', [8789]],
        ['eqsim', [8770]],
        ['eqslantgtr', [10902]],
        ['eqslantless', [10901]],
        ['Equal', [10869]],
        ['equals', [61]],
        ['EqualTilde', [8770]],
        ['equest', [8799]],
        ['Equilibrium', [8652]],
        ['equiv', [8801]],
        ['equivDD', [10872]],
        ['eqvparsl', [10725]],
        ['erarr', [10609]],
        ['erDot', [8787]],
        ['escr', [8495]],
        ['Escr', [8496]],
        ['esdot', [8784]],
        ['Esim', [10867]],
        ['esim', [8770]],
        ['Eta', [919]],
        ['eta', [951]],
        ['ETH', [208]],
        ['eth', [240]],
        ['Euml', [203]],
        ['euml', [235]],
        ['euro', [8364]],
        ['excl', [33]],
        ['exist', [8707]],
        ['Exists', [8707]],
        ['expectation', [8496]],
        ['exponentiale', [8519]],
        ['ExponentialE', [8519]],
        ['fallingdotseq', [8786]],
        ['Fcy', [1060]],
        ['fcy', [1092]],
        ['female', [9792]],
        ['ffilig', [64259]],
        ['fflig', [64256]],
        ['ffllig', [64260]],
        ['Ffr', [120073]],
        ['ffr', [120099]],
        ['filig', [64257]],
        ['FilledSmallSquare', [9724]],
        ['FilledVerySmallSquare', [9642]],
        ['fjlig', [102, 106]],
        ['flat', [9837]],
        ['fllig', [64258]],
        ['fltns', [9649]],
        ['fnof', [402]],
        ['Fopf', [120125]],
        ['fopf', [120151]],
        ['forall', [8704]],
        ['ForAll', [8704]],
        ['fork', [8916]],
        ['forkv', [10969]],
        ['Fouriertrf', [8497]],
        ['fpartint', [10765]],
        ['frac12', [189]],
        ['frac13', [8531]],
        ['frac14', [188]],
        ['frac15', [8533]],
        ['frac16', [8537]],
        ['frac18', [8539]],
        ['frac23', [8532]],
        ['frac25', [8534]],
        ['frac34', [190]],
        ['frac35', [8535]],
        ['frac38', [8540]],
        ['frac45', [8536]],
        ['frac56', [8538]],
        ['frac58', [8541]],
        ['frac78', [8542]],
        ['frasl', [8260]],
        ['frown', [8994]],
        ['fscr', [119995]],
        ['Fscr', [8497]],
        ['gacute', [501]],
        ['Gamma', [915]],
        ['gamma', [947]],
        ['Gammad', [988]],
        ['gammad', [989]],
        ['gap', [10886]],
        ['Gbreve', [286]],
        ['gbreve', [287]],
        ['Gcedil', [290]],
        ['Gcirc', [284]],
        ['gcirc', [285]],
        ['Gcy', [1043]],
        ['gcy', [1075]],
        ['Gdot', [288]],
        ['gdot', [289]],
        ['ge', [8805]],
        ['gE', [8807]],
        ['gEl', [10892]],
        ['gel', [8923]],
        ['geq', [8805]],
        ['geqq', [8807]],
        ['geqslant', [10878]],
        ['gescc', [10921]],
        ['ges', [10878]],
        ['gesdot', [10880]],
        ['gesdoto', [10882]],
        ['gesdotol', [10884]],
        ['gesl', [8923, 65024]],
        ['gesles', [10900]],
        ['Gfr', [120074]],
        ['gfr', [120100]],
        ['gg', [8811]],
        ['Gg', [8921]],
        ['ggg', [8921]],
        ['gimel', [8503]],
        ['GJcy', [1027]],
        ['gjcy', [1107]],
        ['gla', [10917]],
        ['gl', [8823]],
        ['glE', [10898]],
        ['glj', [10916]],
        ['gnap', [10890]],
        ['gnapprox', [10890]],
        ['gne', [10888]],
        ['gnE', [8809]],
        ['gneq', [10888]],
        ['gneqq', [8809]],
        ['gnsim', [8935]],
        ['Gopf', [120126]],
        ['gopf', [120152]],
        ['grave', [96]],
        ['GreaterEqual', [8805]],
        ['GreaterEqualLess', [8923]],
        ['GreaterFullEqual', [8807]],
        ['GreaterGreater', [10914]],
        ['GreaterLess', [8823]],
        ['GreaterSlantEqual', [10878]],
        ['GreaterTilde', [8819]],
        ['Gscr', [119970]],
        ['gscr', [8458]],
        ['gsim', [8819]],
        ['gsime', [10894]],
        ['gsiml', [10896]],
        ['gtcc', [10919]],
        ['gtcir', [10874]],
        ['gt', [62]],
        ['GT', [62]],
        ['Gt', [8811]],
        ['gtdot', [8919]],
        ['gtlPar', [10645]],
        ['gtquest', [10876]],
        ['gtrapprox', [10886]],
        ['gtrarr', [10616]],
        ['gtrdot', [8919]],
        ['gtreqless', [8923]],
        ['gtreqqless', [10892]],
        ['gtrless', [8823]],
        ['gtrsim', [8819]],
        ['gvertneqq', [8809, 65024]],
        ['gvnE', [8809, 65024]],
        ['Hacek', [711]],
        ['hairsp', [8202]],
        ['half', [189]],
        ['hamilt', [8459]],
        ['HARDcy', [1066]],
        ['hardcy', [1098]],
        ['harrcir', [10568]],
        ['harr', [8596]],
        ['hArr', [8660]],
        ['harrw', [8621]],
        ['Hat', [94]],
        ['hbar', [8463]],
        ['Hcirc', [292]],
        ['hcirc', [293]],
        ['hearts', [9829]],
        ['heartsuit', [9829]],
        ['hellip', [8230]],
        ['hercon', [8889]],
        ['hfr', [120101]],
        ['Hfr', [8460]],
        ['HilbertSpace', [8459]],
        ['hksearow', [10533]],
        ['hkswarow', [10534]],
        ['hoarr', [8703]],
        ['homtht', [8763]],
        ['hookleftarrow', [8617]],
        ['hookrightarrow', [8618]],
        ['hopf', [120153]],
        ['Hopf', [8461]],
        ['horbar', [8213]],
        ['HorizontalLine', [9472]],
        ['hscr', [119997]],
        ['Hscr', [8459]],
        ['hslash', [8463]],
        ['Hstrok', [294]],
        ['hstrok', [295]],
        ['HumpDownHump', [8782]],
        ['HumpEqual', [8783]],
        ['hybull', [8259]],
        ['hyphen', [8208]],
        ['Iacute', [205]],
        ['iacute', [237]],
        ['ic', [8291]],
        ['Icirc', [206]],
        ['icirc', [238]],
        ['Icy', [1048]],
        ['icy', [1080]],
        ['Idot', [304]],
        ['IEcy', [1045]],
        ['iecy', [1077]],
        ['iexcl', [161]],
        ['iff', [8660]],
        ['ifr', [120102]],
        ['Ifr', [8465]],
        ['Igrave', [204]],
        ['igrave', [236]],
        ['ii', [8520]],
        ['iiiint', [10764]],
        ['iiint', [8749]],
        ['iinfin', [10716]],
        ['iiota', [8489]],
        ['IJlig', [306]],
        ['ijlig', [307]],
        ['Imacr', [298]],
        ['imacr', [299]],
        ['image', [8465]],
        ['ImaginaryI', [8520]],
        ['imagline', [8464]],
        ['imagpart', [8465]],
        ['imath', [305]],
        ['Im', [8465]],
        ['imof', [8887]],
        ['imped', [437]],
        ['Implies', [8658]],
        ['incare', [8453]],
        ['in', [8712]],
        ['infin', [8734]],
        ['infintie', [10717]],
        ['inodot', [305]],
        ['intcal', [8890]],
        ['int', [8747]],
        ['Int', [8748]],
        ['integers', [8484]],
        ['Integral', [8747]],
        ['intercal', [8890]],
        ['Intersection', [8898]],
        ['intlarhk', [10775]],
        ['intprod', [10812]],
        ['InvisibleComma', [8291]],
        ['InvisibleTimes', [8290]],
        ['IOcy', [1025]],
        ['iocy', [1105]],
        ['Iogon', [302]],
        ['iogon', [303]],
        ['Iopf', [120128]],
        ['iopf', [120154]],
        ['Iota', [921]],
        ['iota', [953]],
        ['iprod', [10812]],
        ['iquest', [191]],
        ['iscr', [119998]],
        ['Iscr', [8464]],
        ['isin', [8712]],
        ['isindot', [8949]],
        ['isinE', [8953]],
        ['isins', [8948]],
        ['isinsv', [8947]],
        ['isinv', [8712]],
        ['it', [8290]],
        ['Itilde', [296]],
        ['itilde', [297]],
        ['Iukcy', [1030]],
        ['iukcy', [1110]],
        ['Iuml', [207]],
        ['iuml', [239]],
        ['Jcirc', [308]],
        ['jcirc', [309]],
        ['Jcy', [1049]],
        ['jcy', [1081]],
        ['Jfr', [120077]],
        ['jfr', [120103]],
        ['jmath', [567]],
        ['Jopf', [120129]],
        ['jopf', [120155]],
        ['Jscr', [119973]],
        ['jscr', [119999]],
        ['Jsercy', [1032]],
        ['jsercy', [1112]],
        ['Jukcy', [1028]],
        ['jukcy', [1108]],
        ['Kappa', [922]],
        ['kappa', [954]],
        ['kappav', [1008]],
        ['Kcedil', [310]],
        ['kcedil', [311]],
        ['Kcy', [1050]],
        ['kcy', [1082]],
        ['Kfr', [120078]],
        ['kfr', [120104]],
        ['kgreen', [312]],
        ['KHcy', [1061]],
        ['khcy', [1093]],
        ['KJcy', [1036]],
        ['kjcy', [1116]],
        ['Kopf', [120130]],
        ['kopf', [120156]],
        ['Kscr', [119974]],
        ['kscr', [120000]],
        ['lAarr', [8666]],
        ['Lacute', [313]],
        ['lacute', [314]],
        ['laemptyv', [10676]],
        ['lagran', [8466]],
        ['Lambda', [923]],
        ['lambda', [955]],
        ['lang', [10216]],
        ['Lang', [10218]],
        ['langd', [10641]],
        ['langle', [10216]],
        ['lap', [10885]],
        ['Laplacetrf', [8466]],
        ['laquo', [171]],
        ['larrb', [8676]],
        ['larrbfs', [10527]],
        ['larr', [8592]],
        ['Larr', [8606]],
        ['lArr', [8656]],
        ['larrfs', [10525]],
        ['larrhk', [8617]],
        ['larrlp', [8619]],
        ['larrpl', [10553]],
        ['larrsim', [10611]],
        ['larrtl', [8610]],
        ['latail', [10521]],
        ['lAtail', [10523]],
        ['lat', [10923]],
        ['late', [10925]],
        ['lates', [10925, 65024]],
        ['lbarr', [10508]],
        ['lBarr', [10510]],
        ['lbbrk', [10098]],
        ['lbrace', [123]],
        ['lbrack', [91]],
        ['lbrke', [10635]],
        ['lbrksld', [10639]],
        ['lbrkslu', [10637]],
        ['Lcaron', [317]],
        ['lcaron', [318]],
        ['Lcedil', [315]],
        ['lcedil', [316]],
        ['lceil', [8968]],
        ['lcub', [123]],
        ['Lcy', [1051]],
        ['lcy', [1083]],
        ['ldca', [10550]],
        ['ldquo', [8220]],
        ['ldquor', [8222]],
        ['ldrdhar', [10599]],
        ['ldrushar', [10571]],
        ['ldsh', [8626]],
        ['le', [8804]],
        ['lE', [8806]],
        ['LeftAngleBracket', [10216]],
        ['LeftArrowBar', [8676]],
        ['leftarrow', [8592]],
        ['LeftArrow', [8592]],
        ['Leftarrow', [8656]],
        ['LeftArrowRightArrow', [8646]],
        ['leftarrowtail', [8610]],
        ['LeftCeiling', [8968]],
        ['LeftDoubleBracket', [10214]],
        ['LeftDownTeeVector', [10593]],
        ['LeftDownVectorBar', [10585]],
        ['LeftDownVector', [8643]],
        ['LeftFloor', [8970]],
        ['leftharpoondown', [8637]],
        ['leftharpoonup', [8636]],
        ['leftleftarrows', [8647]],
        ['leftrightarrow', [8596]],
        ['LeftRightArrow', [8596]],
        ['Leftrightarrow', [8660]],
        ['leftrightarrows', [8646]],
        ['leftrightharpoons', [8651]],
        ['leftrightsquigarrow', [8621]],
        ['LeftRightVector', [10574]],
        ['LeftTeeArrow', [8612]],
        ['LeftTee', [8867]],
        ['LeftTeeVector', [10586]],
        ['leftthreetimes', [8907]],
        ['LeftTriangleBar', [10703]],
        ['LeftTriangle', [8882]],
        ['LeftTriangleEqual', [8884]],
        ['LeftUpDownVector', [10577]],
        ['LeftUpTeeVector', [10592]],
        ['LeftUpVectorBar', [10584]],
        ['LeftUpVector', [8639]],
        ['LeftVectorBar', [10578]],
        ['LeftVector', [8636]],
        ['lEg', [10891]],
        ['leg', [8922]],
        ['leq', [8804]],
        ['leqq', [8806]],
        ['leqslant', [10877]],
        ['lescc', [10920]],
        ['les', [10877]],
        ['lesdot', [10879]],
        ['lesdoto', [10881]],
        ['lesdotor', [10883]],
        ['lesg', [8922, 65024]],
        ['lesges', [10899]],
        ['lessapprox', [10885]],
        ['lessdot', [8918]],
        ['lesseqgtr', [8922]],
        ['lesseqqgtr', [10891]],
        ['LessEqualGreater', [8922]],
        ['LessFullEqual', [8806]],
        ['LessGreater', [8822]],
        ['lessgtr', [8822]],
        ['LessLess', [10913]],
        ['lesssim', [8818]],
        ['LessSlantEqual', [10877]],
        ['LessTilde', [8818]],
        ['lfisht', [10620]],
        ['lfloor', [8970]],
        ['Lfr', [120079]],
        ['lfr', [120105]],
        ['lg', [8822]],
        ['lgE', [10897]],
        ['lHar', [10594]],
        ['lhard', [8637]],
        ['lharu', [8636]],
        ['lharul', [10602]],
        ['lhblk', [9604]],
        ['LJcy', [1033]],
        ['ljcy', [1113]],
        ['llarr', [8647]],
        ['ll', [8810]],
        ['Ll', [8920]],
        ['llcorner', [8990]],
        ['Lleftarrow', [8666]],
        ['llhard', [10603]],
        ['lltri', [9722]],
        ['Lmidot', [319]],
        ['lmidot', [320]],
        ['lmoustache', [9136]],
        ['lmoust', [9136]],
        ['lnap', [10889]],
        ['lnapprox', [10889]],
        ['lne', [10887]],
        ['lnE', [8808]],
        ['lneq', [10887]],
        ['lneqq', [8808]],
        ['lnsim', [8934]],
        ['loang', [10220]],
        ['loarr', [8701]],
        ['lobrk', [10214]],
        ['longleftarrow', [10229]],
        ['LongLeftArrow', [10229]],
        ['Longleftarrow', [10232]],
        ['longleftrightarrow', [10231]],
        ['LongLeftRightArrow', [10231]],
        ['Longleftrightarrow', [10234]],
        ['longmapsto', [10236]],
        ['longrightarrow', [10230]],
        ['LongRightArrow', [10230]],
        ['Longrightarrow', [10233]],
        ['looparrowleft', [8619]],
        ['looparrowright', [8620]],
        ['lopar', [10629]],
        ['Lopf', [120131]],
        ['lopf', [120157]],
        ['loplus', [10797]],
        ['lotimes', [10804]],
        ['lowast', [8727]],
        ['lowbar', [95]],
        ['LowerLeftArrow', [8601]],
        ['LowerRightArrow', [8600]],
        ['loz', [9674]],
        ['lozenge', [9674]],
        ['lozf', [10731]],
        ['lpar', [40]],
        ['lparlt', [10643]],
        ['lrarr', [8646]],
        ['lrcorner', [8991]],
        ['lrhar', [8651]],
        ['lrhard', [10605]],
        ['lrm', [8206]],
        ['lrtri', [8895]],
        ['lsaquo', [8249]],
        ['lscr', [120001]],
        ['Lscr', [8466]],
        ['lsh', [8624]],
        ['Lsh', [8624]],
        ['lsim', [8818]],
        ['lsime', [10893]],
        ['lsimg', [10895]],
        ['lsqb', [91]],
        ['lsquo', [8216]],
        ['lsquor', [8218]],
        ['Lstrok', [321]],
        ['lstrok', [322]],
        ['ltcc', [10918]],
        ['ltcir', [10873]],
        ['lt', [60]],
        ['LT', [60]],
        ['Lt', [8810]],
        ['ltdot', [8918]],
        ['lthree', [8907]],
        ['ltimes', [8905]],
        ['ltlarr', [10614]],
        ['ltquest', [10875]],
        ['ltri', [9667]],
        ['ltrie', [8884]],
        ['ltrif', [9666]],
        ['ltrPar', [10646]],
        ['lurdshar', [10570]],
        ['luruhar', [10598]],
        ['lvertneqq', [8808, 65024]],
        ['lvnE', [8808, 65024]],
        ['macr', [175]],
        ['male', [9794]],
        ['malt', [10016]],
        ['maltese', [10016]],
        ['Map', [10501]],
        ['map', [8614]],
        ['mapsto', [8614]],
        ['mapstodown', [8615]],
        ['mapstoleft', [8612]],
        ['mapstoup', [8613]],
        ['marker', [9646]],
        ['mcomma', [10793]],
        ['Mcy', [1052]],
        ['mcy', [1084]],
        ['mdash', [8212]],
        ['mDDot', [8762]],
        ['measuredangle', [8737]],
        ['MediumSpace', [8287]],
        ['Mellintrf', [8499]],
        ['Mfr', [120080]],
        ['mfr', [120106]],
        ['mho', [8487]],
        ['micro', [181]],
        ['midast', [42]],
        ['midcir', [10992]],
        ['mid', [8739]],
        ['middot', [183]],
        ['minusb', [8863]],
        ['minus', [8722]],
        ['minusd', [8760]],
        ['minusdu', [10794]],
        ['MinusPlus', [8723]],
        ['mlcp', [10971]],
        ['mldr', [8230]],
        ['mnplus', [8723]],
        ['models', [8871]],
        ['Mopf', [120132]],
        ['mopf', [120158]],
        ['mp', [8723]],
        ['mscr', [120002]],
        ['Mscr', [8499]],
        ['mstpos', [8766]],
        ['Mu', [924]],
        ['mu', [956]],
        ['multimap', [8888]],
        ['mumap', [8888]],
        ['nabla', [8711]],
        ['Nacute', [323]],
        ['nacute', [324]],
        ['nang', [8736, 8402]],
        ['nap', [8777]],
        ['napE', [10864, 824]],
        ['napid', [8779, 824]],
        ['napos', [329]],
        ['napprox', [8777]],
        ['natural', [9838]],
        ['naturals', [8469]],
        ['natur', [9838]],
        ['nbsp', [160]],
        ['nbump', [8782, 824]],
        ['nbumpe', [8783, 824]],
        ['ncap', [10819]],
        ['Ncaron', [327]],
        ['ncaron', [328]],
        ['Ncedil', [325]],
        ['ncedil', [326]],
        ['ncong', [8775]],
        ['ncongdot', [10861, 824]],
        ['ncup', [10818]],
        ['Ncy', [1053]],
        ['ncy', [1085]],
        ['ndash', [8211]],
        ['nearhk', [10532]],
        ['nearr', [8599]],
        ['neArr', [8663]],
        ['nearrow', [8599]],
        ['ne', [8800]],
        ['nedot', [8784, 824]],
        ['NegativeMediumSpace', [8203]],
        ['NegativeThickSpace', [8203]],
        ['NegativeThinSpace', [8203]],
        ['NegativeVeryThinSpace', [8203]],
        ['nequiv', [8802]],
        ['nesear', [10536]],
        ['nesim', [8770, 824]],
        ['NestedGreaterGreater', [8811]],
        ['NestedLessLess', [8810]],
        ['nexist', [8708]],
        ['nexists', [8708]],
        ['Nfr', [120081]],
        ['nfr', [120107]],
        ['ngE', [8807, 824]],
        ['nge', [8817]],
        ['ngeq', [8817]],
        ['ngeqq', [8807, 824]],
        ['ngeqslant', [10878, 824]],
        ['nges', [10878, 824]],
        ['nGg', [8921, 824]],
        ['ngsim', [8821]],
        ['nGt', [8811, 8402]],
        ['ngt', [8815]],
        ['ngtr', [8815]],
        ['nGtv', [8811, 824]],
        ['nharr', [8622]],
        ['nhArr', [8654]],
        ['nhpar', [10994]],
        ['ni', [8715]],
        ['nis', [8956]],
        ['nisd', [8954]],
        ['niv', [8715]],
        ['NJcy', [1034]],
        ['njcy', [1114]],
        ['nlarr', [8602]],
        ['nlArr', [8653]],
        ['nldr', [8229]],
        ['nlE', [8806, 824]],
        ['nle', [8816]],
        ['nleftarrow', [8602]],
        ['nLeftarrow', [8653]],
        ['nleftrightarrow', [8622]],
        ['nLeftrightarrow', [8654]],
        ['nleq', [8816]],
        ['nleqq', [8806, 824]],
        ['nleqslant', [10877, 824]],
        ['nles', [10877, 824]],
        ['nless', [8814]],
        ['nLl', [8920, 824]],
        ['nlsim', [8820]],
        ['nLt', [8810, 8402]],
        ['nlt', [8814]],
        ['nltri', [8938]],
        ['nltrie', [8940]],
        ['nLtv', [8810, 824]],
        ['nmid', [8740]],
        ['NoBreak', [8288]],
        ['NonBreakingSpace', [160]],
        ['nopf', [120159]],
        ['Nopf', [8469]],
        ['Not', [10988]],
        ['not', [172]],
        ['NotCongruent', [8802]],
        ['NotCupCap', [8813]],
        ['NotDoubleVerticalBar', [8742]],
        ['NotElement', [8713]],
        ['NotEqual', [8800]],
        ['NotEqualTilde', [8770, 824]],
        ['NotExists', [8708]],
        ['NotGreater', [8815]],
        ['NotGreaterEqual', [8817]],
        ['NotGreaterFullEqual', [8807, 824]],
        ['NotGreaterGreater', [8811, 824]],
        ['NotGreaterLess', [8825]],
        ['NotGreaterSlantEqual', [10878, 824]],
        ['NotGreaterTilde', [8821]],
        ['NotHumpDownHump', [8782, 824]],
        ['NotHumpEqual', [8783, 824]],
        ['notin', [8713]],
        ['notindot', [8949, 824]],
        ['notinE', [8953, 824]],
        ['notinva', [8713]],
        ['notinvb', [8951]],
        ['notinvc', [8950]],
        ['NotLeftTriangleBar', [10703, 824]],
        ['NotLeftTriangle', [8938]],
        ['NotLeftTriangleEqual', [8940]],
        ['NotLess', [8814]],
        ['NotLessEqual', [8816]],
        ['NotLessGreater', [8824]],
        ['NotLessLess', [8810, 824]],
        ['NotLessSlantEqual', [10877, 824]],
        ['NotLessTilde', [8820]],
        ['NotNestedGreaterGreater', [10914, 824]],
        ['NotNestedLessLess', [10913, 824]],
        ['notni', [8716]],
        ['notniva', [8716]],
        ['notnivb', [8958]],
        ['notnivc', [8957]],
        ['NotPrecedes', [8832]],
        ['NotPrecedesEqual', [10927, 824]],
        ['NotPrecedesSlantEqual', [8928]],
        ['NotReverseElement', [8716]],
        ['NotRightTriangleBar', [10704, 824]],
        ['NotRightTriangle', [8939]],
        ['NotRightTriangleEqual', [8941]],
        ['NotSquareSubset', [8847, 824]],
        ['NotSquareSubsetEqual', [8930]],
        ['NotSquareSuperset', [8848, 824]],
        ['NotSquareSupersetEqual', [8931]],
        ['NotSubset', [8834, 8402]],
        ['NotSubsetEqual', [8840]],
        ['NotSucceeds', [8833]],
        ['NotSucceedsEqual', [10928, 824]],
        ['NotSucceedsSlantEqual', [8929]],
        ['NotSucceedsTilde', [8831, 824]],
        ['NotSuperset', [8835, 8402]],
        ['NotSupersetEqual', [8841]],
        ['NotTilde', [8769]],
        ['NotTildeEqual', [8772]],
        ['NotTildeFullEqual', [8775]],
        ['NotTildeTilde', [8777]],
        ['NotVerticalBar', [8740]],
        ['nparallel', [8742]],
        ['npar', [8742]],
        ['nparsl', [11005, 8421]],
        ['npart', [8706, 824]],
        ['npolint', [10772]],
        ['npr', [8832]],
        ['nprcue', [8928]],
        ['nprec', [8832]],
        ['npreceq', [10927, 824]],
        ['npre', [10927, 824]],
        ['nrarrc', [10547, 824]],
        ['nrarr', [8603]],
        ['nrArr', [8655]],
        ['nrarrw', [8605, 824]],
        ['nrightarrow', [8603]],
        ['nRightarrow', [8655]],
        ['nrtri', [8939]],
        ['nrtrie', [8941]],
        ['nsc', [8833]],
        ['nsccue', [8929]],
        ['nsce', [10928, 824]],
        ['Nscr', [119977]],
        ['nscr', [120003]],
        ['nshortmid', [8740]],
        ['nshortparallel', [8742]],
        ['nsim', [8769]],
        ['nsime', [8772]],
        ['nsimeq', [8772]],
        ['nsmid', [8740]],
        ['nspar', [8742]],
        ['nsqsube', [8930]],
        ['nsqsupe', [8931]],
        ['nsub', [8836]],
        ['nsubE', [10949, 824]],
        ['nsube', [8840]],
        ['nsubset', [8834, 8402]],
        ['nsubseteq', [8840]],
        ['nsubseteqq', [10949, 824]],
        ['nsucc', [8833]],
        ['nsucceq', [10928, 824]],
        ['nsup', [8837]],
        ['nsupE', [10950, 824]],
        ['nsupe', [8841]],
        ['nsupset', [8835, 8402]],
        ['nsupseteq', [8841]],
        ['nsupseteqq', [10950, 824]],
        ['ntgl', [8825]],
        ['Ntilde', [209]],
        ['ntilde', [241]],
        ['ntlg', [8824]],
        ['ntriangleleft', [8938]],
        ['ntrianglelefteq', [8940]],
        ['ntriangleright', [8939]],
        ['ntrianglerighteq', [8941]],
        ['Nu', [925]],
        ['nu', [957]],
        ['num', [35]],
        ['numero', [8470]],
        ['numsp', [8199]],
        ['nvap', [8781, 8402]],
        ['nvdash', [8876]],
        ['nvDash', [8877]],
        ['nVdash', [8878]],
        ['nVDash', [8879]],
        ['nvge', [8805, 8402]],
        ['nvgt', [62, 8402]],
        ['nvHarr', [10500]],
        ['nvinfin', [10718]],
        ['nvlArr', [10498]],
        ['nvle', [8804, 8402]],
        ['nvlt', [60, 8402]],
        ['nvltrie', [8884, 8402]],
        ['nvrArr', [10499]],
        ['nvrtrie', [8885, 8402]],
        ['nvsim', [8764, 8402]],
        ['nwarhk', [10531]],
        ['nwarr', [8598]],
        ['nwArr', [8662]],
        ['nwarrow', [8598]],
        ['nwnear', [10535]],
        ['Oacute', [211]],
        ['oacute', [243]],
        ['oast', [8859]],
        ['Ocirc', [212]],
        ['ocirc', [244]],
        ['ocir', [8858]],
        ['Ocy', [1054]],
        ['ocy', [1086]],
        ['odash', [8861]],
        ['Odblac', [336]],
        ['odblac', [337]],
        ['odiv', [10808]],
        ['odot', [8857]],
        ['odsold', [10684]],
        ['OElig', [338]],
        ['oelig', [339]],
        ['ofcir', [10687]],
        ['Ofr', [120082]],
        ['ofr', [120108]],
        ['ogon', [731]],
        ['Ograve', [210]],
        ['ograve', [242]],
        ['ogt', [10689]],
        ['ohbar', [10677]],
        ['ohm', [937]],
        ['oint', [8750]],
        ['olarr', [8634]],
        ['olcir', [10686]],
        ['olcross', [10683]],
        ['oline', [8254]],
        ['olt', [10688]],
        ['Omacr', [332]],
        ['omacr', [333]],
        ['Omega', [937]],
        ['omega', [969]],
        ['Omicron', [927]],
        ['omicron', [959]],
        ['omid', [10678]],
        ['ominus', [8854]],
        ['Oopf', [120134]],
        ['oopf', [120160]],
        ['opar', [10679]],
        ['OpenCurlyDoubleQuote', [8220]],
        ['OpenCurlyQuote', [8216]],
        ['operp', [10681]],
        ['oplus', [8853]],
        ['orarr', [8635]],
        ['Or', [10836]],
        ['or', [8744]],
        ['ord', [10845]],
        ['order', [8500]],
        ['orderof', [8500]],
        ['ordf', [170]],
        ['ordm', [186]],
        ['origof', [8886]],
        ['oror', [10838]],
        ['orslope', [10839]],
        ['orv', [10843]],
        ['oS', [9416]],
        ['Oscr', [119978]],
        ['oscr', [8500]],
        ['Oslash', [216]],
        ['oslash', [248]],
        ['osol', [8856]],
        ['Otilde', [213]],
        ['otilde', [245]],
        ['otimesas', [10806]],
        ['Otimes', [10807]],
        ['otimes', [8855]],
        ['Ouml', [214]],
        ['ouml', [246]],
        ['ovbar', [9021]],
        ['OverBar', [8254]],
        ['OverBrace', [9182]],
        ['OverBracket', [9140]],
        ['OverParenthesis', [9180]],
        ['para', [182]],
        ['parallel', [8741]],
        ['par', [8741]],
        ['parsim', [10995]],
        ['parsl', [11005]],
        ['part', [8706]],
        ['PartialD', [8706]],
        ['Pcy', [1055]],
        ['pcy', [1087]],
        ['percnt', [37]],
        ['period', [46]],
        ['permil', [8240]],
        ['perp', [8869]],
        ['pertenk', [8241]],
        ['Pfr', [120083]],
        ['pfr', [120109]],
        ['Phi', [934]],
        ['phi', [966]],
        ['phiv', [981]],
        ['phmmat', [8499]],
        ['phone', [9742]],
        ['Pi', [928]],
        ['pi', [960]],
        ['pitchfork', [8916]],
        ['piv', [982]],
        ['planck', [8463]],
        ['planckh', [8462]],
        ['plankv', [8463]],
        ['plusacir', [10787]],
        ['plusb', [8862]],
        ['pluscir', [10786]],
        ['plus', [43]],
        ['plusdo', [8724]],
        ['plusdu', [10789]],
        ['pluse', [10866]],
        ['PlusMinus', [177]],
        ['plusmn', [177]],
        ['plussim', [10790]],
        ['plustwo', [10791]],
        ['pm', [177]],
        ['Poincareplane', [8460]],
        ['pointint', [10773]],
        ['popf', [120161]],
        ['Popf', [8473]],
        ['pound', [163]],
        ['prap', [10935]],
        ['Pr', [10939]],
        ['pr', [8826]],
        ['prcue', [8828]],
        ['precapprox', [10935]],
        ['prec', [8826]],
        ['preccurlyeq', [8828]],
        ['Precedes', [8826]],
        ['PrecedesEqual', [10927]],
        ['PrecedesSlantEqual', [8828]],
        ['PrecedesTilde', [8830]],
        ['preceq', [10927]],
        ['precnapprox', [10937]],
        ['precneqq', [10933]],
        ['precnsim', [8936]],
        ['pre', [10927]],
        ['prE', [10931]],
        ['precsim', [8830]],
        ['prime', [8242]],
        ['Prime', [8243]],
        ['primes', [8473]],
        ['prnap', [10937]],
        ['prnE', [10933]],
        ['prnsim', [8936]],
        ['prod', [8719]],
        ['Product', [8719]],
        ['profalar', [9006]],
        ['profline', [8978]],
        ['profsurf', [8979]],
        ['prop', [8733]],
        ['Proportional', [8733]],
        ['Proportion', [8759]],
        ['propto', [8733]],
        ['prsim', [8830]],
        ['prurel', [8880]],
        ['Pscr', [119979]],
        ['pscr', [120005]],
        ['Psi', [936]],
        ['psi', [968]],
        ['puncsp', [8200]],
        ['Qfr', [120084]],
        ['qfr', [120110]],
        ['qint', [10764]],
        ['qopf', [120162]],
        ['Qopf', [8474]],
        ['qprime', [8279]],
        ['Qscr', [119980]],
        ['qscr', [120006]],
        ['quaternions', [8461]],
        ['quatint', [10774]],
        ['quest', [63]],
        ['questeq', [8799]],
        ['quot', [34]],
        ['QUOT', [34]],
        ['rAarr', [8667]],
        ['race', [8765, 817]],
        ['Racute', [340]],
        ['racute', [341]],
        ['radic', [8730]],
        ['raemptyv', [10675]],
        ['rang', [10217]],
        ['Rang', [10219]],
        ['rangd', [10642]],
        ['range', [10661]],
        ['rangle', [10217]],
        ['raquo', [187]],
        ['rarrap', [10613]],
        ['rarrb', [8677]],
        ['rarrbfs', [10528]],
        ['rarrc', [10547]],
        ['rarr', [8594]],
        ['Rarr', [8608]],
        ['rArr', [8658]],
        ['rarrfs', [10526]],
        ['rarrhk', [8618]],
        ['rarrlp', [8620]],
        ['rarrpl', [10565]],
        ['rarrsim', [10612]],
        ['Rarrtl', [10518]],
        ['rarrtl', [8611]],
        ['rarrw', [8605]],
        ['ratail', [10522]],
        ['rAtail', [10524]],
        ['ratio', [8758]],
        ['rationals', [8474]],
        ['rbarr', [10509]],
        ['rBarr', [10511]],
        ['RBarr', [10512]],
        ['rbbrk', [10099]],
        ['rbrace', [125]],
        ['rbrack', [93]],
        ['rbrke', [10636]],
        ['rbrksld', [10638]],
        ['rbrkslu', [10640]],
        ['Rcaron', [344]],
        ['rcaron', [345]],
        ['Rcedil', [342]],
        ['rcedil', [343]],
        ['rceil', [8969]],
        ['rcub', [125]],
        ['Rcy', [1056]],
        ['rcy', [1088]],
        ['rdca', [10551]],
        ['rdldhar', [10601]],
        ['rdquo', [8221]],
        ['rdquor', [8221]],
        ['CloseCurlyDoubleQuote', [8221]],
        ['rdsh', [8627]],
        ['real', [8476]],
        ['realine', [8475]],
        ['realpart', [8476]],
        ['reals', [8477]],
        ['Re', [8476]],
        ['rect', [9645]],
        ['reg', [174]],
        ['REG', [174]],
        ['ReverseElement', [8715]],
        ['ReverseEquilibrium', [8651]],
        ['ReverseUpEquilibrium', [10607]],
        ['rfisht', [10621]],
        ['rfloor', [8971]],
        ['rfr', [120111]],
        ['Rfr', [8476]],
        ['rHar', [10596]],
        ['rhard', [8641]],
        ['rharu', [8640]],
        ['rharul', [10604]],
        ['Rho', [929]],
        ['rho', [961]],
        ['rhov', [1009]],
        ['RightAngleBracket', [10217]],
        ['RightArrowBar', [8677]],
        ['rightarrow', [8594]],
        ['RightArrow', [8594]],
        ['Rightarrow', [8658]],
        ['RightArrowLeftArrow', [8644]],
        ['rightarrowtail', [8611]],
        ['RightCeiling', [8969]],
        ['RightDoubleBracket', [10215]],
        ['RightDownTeeVector', [10589]],
        ['RightDownVectorBar', [10581]],
        ['RightDownVector', [8642]],
        ['RightFloor', [8971]],
        ['rightharpoondown', [8641]],
        ['rightharpoonup', [8640]],
        ['rightleftarrows', [8644]],
        ['rightleftharpoons', [8652]],
        ['rightrightarrows', [8649]],
        ['rightsquigarrow', [8605]],
        ['RightTeeArrow', [8614]],
        ['RightTee', [8866]],
        ['RightTeeVector', [10587]],
        ['rightthreetimes', [8908]],
        ['RightTriangleBar', [10704]],
        ['RightTriangle', [8883]],
        ['RightTriangleEqual', [8885]],
        ['RightUpDownVector', [10575]],
        ['RightUpTeeVector', [10588]],
        ['RightUpVectorBar', [10580]],
        ['RightUpVector', [8638]],
        ['RightVectorBar', [10579]],
        ['RightVector', [8640]],
        ['ring', [730]],
        ['risingdotseq', [8787]],
        ['rlarr', [8644]],
        ['rlhar', [8652]],
        ['rlm', [8207]],
        ['rmoustache', [9137]],
        ['rmoust', [9137]],
        ['rnmid', [10990]],
        ['roang', [10221]],
        ['roarr', [8702]],
        ['robrk', [10215]],
        ['ropar', [10630]],
        ['ropf', [120163]],
        ['Ropf', [8477]],
        ['roplus', [10798]],
        ['rotimes', [10805]],
        ['RoundImplies', [10608]],
        ['rpar', [41]],
        ['rpargt', [10644]],
        ['rppolint', [10770]],
        ['rrarr', [8649]],
        ['Rrightarrow', [8667]],
        ['rsaquo', [8250]],
        ['rscr', [120007]],
        ['Rscr', [8475]],
        ['rsh', [8625]],
        ['Rsh', [8625]],
        ['rsqb', [93]],
        ['rsquo', [8217]],
        ['rsquor', [8217]],
        ['CloseCurlyQuote', [8217]],
        ['rthree', [8908]],
        ['rtimes', [8906]],
        ['rtri', [9657]],
        ['rtrie', [8885]],
        ['rtrif', [9656]],
        ['rtriltri', [10702]],
        ['RuleDelayed', [10740]],
        ['ruluhar', [10600]],
        ['rx', [8478]],
        ['Sacute', [346]],
        ['sacute', [347]],
        ['sbquo', [8218]],
        ['scap', [10936]],
        ['Scaron', [352]],
        ['scaron', [353]],
        ['Sc', [10940]],
        ['sc', [8827]],
        ['sccue', [8829]],
        ['sce', [10928]],
        ['scE', [10932]],
        ['Scedil', [350]],
        ['scedil', [351]],
        ['Scirc', [348]],
        ['scirc', [349]],
        ['scnap', [10938]],
        ['scnE', [10934]],
        ['scnsim', [8937]],
        ['scpolint', [10771]],
        ['scsim', [8831]],
        ['Scy', [1057]],
        ['scy', [1089]],
        ['sdotb', [8865]],
        ['sdot', [8901]],
        ['sdote', [10854]],
        ['searhk', [10533]],
        ['searr', [8600]],
        ['seArr', [8664]],
        ['searrow', [8600]],
        ['sect', [167]],
        ['semi', [59]],
        ['seswar', [10537]],
        ['setminus', [8726]],
        ['setmn', [8726]],
        ['sext', [10038]],
        ['Sfr', [120086]],
        ['sfr', [120112]],
        ['sfrown', [8994]],
        ['sharp', [9839]],
        ['SHCHcy', [1065]],
        ['shchcy', [1097]],
        ['SHcy', [1064]],
        ['shcy', [1096]],
        ['ShortDownArrow', [8595]],
        ['ShortLeftArrow', [8592]],
        ['shortmid', [8739]],
        ['shortparallel', [8741]],
        ['ShortRightArrow', [8594]],
        ['ShortUpArrow', [8593]],
        ['shy', [173]],
        ['Sigma', [931]],
        ['sigma', [963]],
        ['sigmaf', [962]],
        ['sigmav', [962]],
        ['sim', [8764]],
        ['simdot', [10858]],
        ['sime', [8771]],
        ['simeq', [8771]],
        ['simg', [10910]],
        ['simgE', [10912]],
        ['siml', [10909]],
        ['simlE', [10911]],
        ['simne', [8774]],
        ['simplus', [10788]],
        ['simrarr', [10610]],
        ['slarr', [8592]],
        ['SmallCircle', [8728]],
        ['smallsetminus', [8726]],
        ['smashp', [10803]],
        ['smeparsl', [10724]],
        ['smid', [8739]],
        ['smile', [8995]],
        ['smt', [10922]],
        ['smte', [10924]],
        ['smtes', [10924, 65024]],
        ['SOFTcy', [1068]],
        ['softcy', [1100]],
        ['solbar', [9023]],
        ['solb', [10692]],
        ['sol', [47]],
        ['Sopf', [120138]],
        ['sopf', [120164]],
        ['spades', [9824]],
        ['spadesuit', [9824]],
        ['spar', [8741]],
        ['sqcap', [8851]],
        ['sqcaps', [8851, 65024]],
        ['sqcup', [8852]],
        ['sqcups', [8852, 65024]],
        ['Sqrt', [8730]],
        ['sqsub', [8847]],
        ['sqsube', [8849]],
        ['sqsubset', [8847]],
        ['sqsubseteq', [8849]],
        ['sqsup', [8848]],
        ['sqsupe', [8850]],
        ['sqsupset', [8848]],
        ['sqsupseteq', [8850]],
        ['square', [9633]],
        ['Square', [9633]],
        ['SquareIntersection', [8851]],
        ['SquareSubset', [8847]],
        ['SquareSubsetEqual', [8849]],
        ['SquareSuperset', [8848]],
        ['SquareSupersetEqual', [8850]],
        ['SquareUnion', [8852]],
        ['squarf', [9642]],
        ['squ', [9633]],
        ['squf', [9642]],
        ['srarr', [8594]],
        ['Sscr', [119982]],
        ['sscr', [120008]],
        ['ssetmn', [8726]],
        ['ssmile', [8995]],
        ['sstarf', [8902]],
        ['Star', [8902]],
        ['star', [9734]],
        ['starf', [9733]],
        ['straightepsilon', [1013]],
        ['straightphi', [981]],
        ['strns', [175]],
        ['sub', [8834]],
        ['Sub', [8912]],
        ['subdot', [10941]],
        ['subE', [10949]],
        ['sube', [8838]],
        ['subedot', [10947]],
        ['submult', [10945]],
        ['subnE', [10955]],
        ['subne', [8842]],
        ['subplus', [10943]],
        ['subrarr', [10617]],
        ['subset', [8834]],
        ['Subset', [8912]],
        ['subseteq', [8838]],
        ['subseteqq', [10949]],
        ['SubsetEqual', [8838]],
        ['subsetneq', [8842]],
        ['subsetneqq', [10955]],
        ['subsim', [10951]],
        ['subsub', [10965]],
        ['subsup', [10963]],
        ['succapprox', [10936]],
        ['succ', [8827]],
        ['succcurlyeq', [8829]],
        ['Succeeds', [8827]],
        ['SucceedsEqual', [10928]],
        ['SucceedsSlantEqual', [8829]],
        ['SucceedsTilde', [8831]],
        ['succeq', [10928]],
        ['succnapprox', [10938]],
        ['succneqq', [10934]],
        ['succnsim', [8937]],
        ['succsim', [8831]],
        ['SuchThat', [8715]],
        ['sum', [8721]],
        ['Sum', [8721]],
        ['sung', [9834]],
        ['sup1', [185]],
        ['sup2', [178]],
        ['sup3', [179]],
        ['sup', [8835]],
        ['Sup', [8913]],
        ['supdot', [10942]],
        ['supdsub', [10968]],
        ['supE', [10950]],
        ['supe', [8839]],
        ['supedot', [10948]],
        ['Superset', [8835]],
        ['SupersetEqual', [8839]],
        ['suphsol', [10185]],
        ['suphsub', [10967]],
        ['suplarr', [10619]],
        ['supmult', [10946]],
        ['supnE', [10956]],
        ['supne', [8843]],
        ['supplus', [10944]],
        ['supset', [8835]],
        ['Supset', [8913]],
        ['supseteq', [8839]],
        ['supseteqq', [10950]],
        ['supsetneq', [8843]],
        ['supsetneqq', [10956]],
        ['supsim', [10952]],
        ['supsub', [10964]],
        ['supsup', [10966]],
        ['swarhk', [10534]],
        ['swarr', [8601]],
        ['swArr', [8665]],
        ['swarrow', [8601]],
        ['swnwar', [10538]],
        ['szlig', [223]],
        ['Tab', [9]],
        ['target', [8982]],
        ['Tau', [932]],
        ['tau', [964]],
        ['tbrk', [9140]],
        ['Tcaron', [356]],
        ['tcaron', [357]],
        ['Tcedil', [354]],
        ['tcedil', [355]],
        ['Tcy', [1058]],
        ['tcy', [1090]],
        ['tdot', [8411]],
        ['telrec', [8981]],
        ['Tfr', [120087]],
        ['tfr', [120113]],
        ['there4', [8756]],
        ['therefore', [8756]],
        ['Therefore', [8756]],
        ['Theta', [920]],
        ['theta', [952]],
        ['thetasym', [977]],
        ['thetav', [977]],
        ['thickapprox', [8776]],
        ['thicksim', [8764]],
        ['ThickSpace', [8287, 8202]],
        ['ThinSpace', [8201]],
        ['thinsp', [8201]],
        ['thkap', [8776]],
        ['thksim', [8764]],
        ['THORN', [222]],
        ['thorn', [254]],
        ['tilde', [732]],
        ['Tilde', [8764]],
        ['TildeEqual', [8771]],
        ['TildeFullEqual', [8773]],
        ['TildeTilde', [8776]],
        ['timesbar', [10801]],
        ['timesb', [8864]],
        ['times', [215]],
        ['timesd', [10800]],
        ['tint', [8749]],
        ['toea', [10536]],
        ['topbot', [9014]],
        ['topcir', [10993]],
        ['top', [8868]],
        ['Topf', [120139]],
        ['topf', [120165]],
        ['topfork', [10970]],
        ['tosa', [10537]],
        ['tprime', [8244]],
        ['trade', [8482]],
        ['TRADE', [8482]],
        ['triangle', [9653]],
        ['triangledown', [9663]],
        ['triangleleft', [9667]],
        ['trianglelefteq', [8884]],
        ['triangleq', [8796]],
        ['triangleright', [9657]],
        ['trianglerighteq', [8885]],
        ['tridot', [9708]],
        ['trie', [8796]],
        ['triminus', [10810]],
        ['TripleDot', [8411]],
        ['triplus', [10809]],
        ['trisb', [10701]],
        ['tritime', [10811]],
        ['trpezium', [9186]],
        ['Tscr', [119983]],
        ['tscr', [120009]],
        ['TScy', [1062]],
        ['tscy', [1094]],
        ['TSHcy', [1035]],
        ['tshcy', [1115]],
        ['Tstrok', [358]],
        ['tstrok', [359]],
        ['twixt', [8812]],
        ['twoheadleftarrow', [8606]],
        ['twoheadrightarrow', [8608]],
        ['Uacute', [218]],
        ['uacute', [250]],
        ['uarr', [8593]],
        ['Uarr', [8607]],
        ['uArr', [8657]],
        ['Uarrocir', [10569]],
        ['Ubrcy', [1038]],
        ['ubrcy', [1118]],
        ['Ubreve', [364]],
        ['ubreve', [365]],
        ['Ucirc', [219]],
        ['ucirc', [251]],
        ['Ucy', [1059]],
        ['ucy', [1091]],
        ['udarr', [8645]],
        ['Udblac', [368]],
        ['udblac', [369]],
        ['udhar', [10606]],
        ['ufisht', [10622]],
        ['Ufr', [120088]],
        ['ufr', [120114]],
        ['Ugrave', [217]],
        ['ugrave', [249]],
        ['uHar', [10595]],
        ['uharl', [8639]],
        ['uharr', [8638]],
        ['uhblk', [9600]],
        ['ulcorn', [8988]],
        ['ulcorner', [8988]],
        ['ulcrop', [8975]],
        ['ultri', [9720]],
        ['Umacr', [362]],
        ['umacr', [363]],
        ['uml', [168]],
        ['UnderBar', [95]],
        ['UnderBrace', [9183]],
        ['UnderBracket', [9141]],
        ['UnderParenthesis', [9181]],
        ['Union', [8899]],
        ['UnionPlus', [8846]],
        ['Uogon', [370]],
        ['uogon', [371]],
        ['Uopf', [120140]],
        ['uopf', [120166]],
        ['UpArrowBar', [10514]],
        ['uparrow', [8593]],
        ['UpArrow', [8593]],
        ['Uparrow', [8657]],
        ['UpArrowDownArrow', [8645]],
        ['updownarrow', [8597]],
        ['UpDownArrow', [8597]],
        ['Updownarrow', [8661]],
        ['UpEquilibrium', [10606]],
        ['upharpoonleft', [8639]],
        ['upharpoonright', [8638]],
        ['uplus', [8846]],
        ['UpperLeftArrow', [8598]],
        ['UpperRightArrow', [8599]],
        ['upsi', [965]],
        ['Upsi', [978]],
        ['upsih', [978]],
        ['Upsilon', [933]],
        ['upsilon', [965]],
        ['UpTeeArrow', [8613]],
        ['UpTee', [8869]],
        ['upuparrows', [8648]],
        ['urcorn', [8989]],
        ['urcorner', [8989]],
        ['urcrop', [8974]],
        ['Uring', [366]],
        ['uring', [367]],
        ['urtri', [9721]],
        ['Uscr', [119984]],
        ['uscr', [120010]],
        ['utdot', [8944]],
        ['Utilde', [360]],
        ['utilde', [361]],
        ['utri', [9653]],
        ['utrif', [9652]],
        ['uuarr', [8648]],
        ['Uuml', [220]],
        ['uuml', [252]],
        ['uwangle', [10663]],
        ['vangrt', [10652]],
        ['varepsilon', [1013]],
        ['varkappa', [1008]],
        ['varnothing', [8709]],
        ['varphi', [981]],
        ['varpi', [982]],
        ['varpropto', [8733]],
        ['varr', [8597]],
        ['vArr', [8661]],
        ['varrho', [1009]],
        ['varsigma', [962]],
        ['varsubsetneq', [8842, 65024]],
        ['varsubsetneqq', [10955, 65024]],
        ['varsupsetneq', [8843, 65024]],
        ['varsupsetneqq', [10956, 65024]],
        ['vartheta', [977]],
        ['vartriangleleft', [8882]],
        ['vartriangleright', [8883]],
        ['vBar', [10984]],
        ['Vbar', [10987]],
        ['vBarv', [10985]],
        ['Vcy', [1042]],
        ['vcy', [1074]],
        ['vdash', [8866]],
        ['vDash', [8872]],
        ['Vdash', [8873]],
        ['VDash', [8875]],
        ['Vdashl', [10982]],
        ['veebar', [8891]],
        ['vee', [8744]],
        ['Vee', [8897]],
        ['veeeq', [8794]],
        ['vellip', [8942]],
        ['verbar', [124]],
        ['Verbar', [8214]],
        ['vert', [124]],
        ['Vert', [8214]],
        ['VerticalBar', [8739]],
        ['VerticalLine', [124]],
        ['VerticalSeparator', [10072]],
        ['VerticalTilde', [8768]],
        ['VeryThinSpace', [8202]],
        ['Vfr', [120089]],
        ['vfr', [120115]],
        ['vltri', [8882]],
        ['vnsub', [8834, 8402]],
        ['vnsup', [8835, 8402]],
        ['Vopf', [120141]],
        ['vopf', [120167]],
        ['vprop', [8733]],
        ['vrtri', [8883]],
        ['Vscr', [119985]],
        ['vscr', [120011]],
        ['vsubnE', [10955, 65024]],
        ['vsubne', [8842, 65024]],
        ['vsupnE', [10956, 65024]],
        ['vsupne', [8843, 65024]],
        ['Vvdash', [8874]],
        ['vzigzag', [10650]],
        ['Wcirc', [372]],
        ['wcirc', [373]],
        ['wedbar', [10847]],
        ['wedge', [8743]],
        ['Wedge', [8896]],
        ['wedgeq', [8793]],
        ['weierp', [8472]],
        ['Wfr', [120090]],
        ['wfr', [120116]],
        ['Wopf', [120142]],
        ['wopf', [120168]],
        ['wp', [8472]],
        ['wr', [8768]],
        ['wreath', [8768]],
        ['Wscr', [119986]],
        ['wscr', [120012]],
        ['xcap', [8898]],
        ['xcirc', [9711]],
        ['xcup', [8899]],
        ['xdtri', [9661]],
        ['Xfr', [120091]],
        ['xfr', [120117]],
        ['xharr', [10231]],
        ['xhArr', [10234]],
        ['Xi', [926]],
        ['xi', [958]],
        ['xlarr', [10229]],
        ['xlArr', [10232]],
        ['xmap', [10236]],
        ['xnis', [8955]],
        ['xodot', [10752]],
        ['Xopf', [120143]],
        ['xopf', [120169]],
        ['xoplus', [10753]],
        ['xotime', [10754]],
        ['xrarr', [10230]],
        ['xrArr', [10233]],
        ['Xscr', [119987]],
        ['xscr', [120013]],
        ['xsqcup', [10758]],
        ['xuplus', [10756]],
        ['xutri', [9651]],
        ['xvee', [8897]],
        ['xwedge', [8896]],
        ['Yacute', [221]],
        ['yacute', [253]],
        ['YAcy', [1071]],
        ['yacy', [1103]],
        ['Ycirc', [374]],
        ['ycirc', [375]],
        ['Ycy', [1067]],
        ['ycy', [1099]],
        ['yen', [165]],
        ['Yfr', [120092]],
        ['yfr', [120118]],
        ['YIcy', [1031]],
        ['yicy', [1111]],
        ['Yopf', [120144]],
        ['yopf', [120170]],
        ['Yscr', [119988]],
        ['yscr', [120014]],
        ['YUcy', [1070]],
        ['yucy', [1102]],
        ['yuml', [255]],
        ['Yuml', [376]],
        ['Zacute', [377]],
        ['zacute', [378]],
        ['Zcaron', [381]],
        ['zcaron', [382]],
        ['Zcy', [1047]],
        ['zcy', [1079]],
        ['Zdot', [379]],
        ['zdot', [380]],
        ['zeetrf', [8488]],
        ['ZeroWidthSpace', [8203]],
        ['Zeta', [918]],
        ['zeta', [950]],
        ['zfr', [120119]],
        ['Zfr', [8488]],
        ['ZHcy', [1046]],
        ['zhcy', [1078]],
        ['zigrarr', [8669]],
        ['zopf', [120171]],
        ['Zopf', [8484]],
        ['Zscr', [119989]],
        ['zscr', [120015]],
        ['zwj', [8205]],
        ['zwnj', [8204]],
      ];

      var alphaIndex = {};
      var charIndex = {};

      createIndexes(alphaIndex, charIndex);

      /**
 * @constructor
 */
      function Html5Entities() {}

      /**
 * @param {String} str
 * @returns {String}
 */
      Html5Entities.prototype.decode = function(str) {
        if (!str || !str.length) {
          return '';
        }
        return str.replace(/&(#?[\w\d]+);?/g, function(s, entity) {
          var chr;
          if (entity.charAt(0) === '#') {
            var code =
              entity.charAt(1) === 'x'
                ? parseInt(entity.substr(2).toLowerCase(), 16)
                : parseInt(entity.substr(1));

            if (!(isNaN(code) || code < -32768 || code > 65535)) {
              chr = String.fromCharCode(code);
            }
          } else {
            chr = alphaIndex[entity];
          }
          return chr || s;
        });
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html5Entities.decode = function(str) {
        return new Html5Entities().decode(str);
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html5Entities.prototype.encode = function(str) {
        if (!str || !str.length) {
          return '';
        }
        var strLength = str.length;
        var result = '';
        var i = 0;
        while (i < strLength) {
          var charInfo = charIndex[str.charCodeAt(i)];
          if (charInfo) {
            var alpha = charInfo[str.charCodeAt(i + 1)];
            if (alpha) {
              i++;
            } else {
              alpha = charInfo[''];
            }
            if (alpha) {
              result += '&' + alpha + ';';
              i++;
              continue;
            }
          }
          result += str.charAt(i);
          i++;
        }
        return result;
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html5Entities.encode = function(str) {
        return new Html5Entities().encode(str);
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html5Entities.prototype.encodeNonUTF = function(str) {
        if (!str || !str.length) {
          return '';
        }
        var strLength = str.length;
        var result = '';
        var i = 0;
        while (i < strLength) {
          var c = str.charCodeAt(i);
          var charInfo = charIndex[c];
          if (charInfo) {
            var alpha = charInfo[str.charCodeAt(i + 1)];
            if (alpha) {
              i++;
            } else {
              alpha = charInfo[''];
            }
            if (alpha) {
              result += '&' + alpha + ';';
              i++;
              continue;
            }
          }
          if (c < 32 || c > 126) {
            result += '&#' + c + ';';
          } else {
            result += str.charAt(i);
          }
          i++;
        }
        return result;
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html5Entities.encodeNonUTF = function(str) {
        return new Html5Entities().encodeNonUTF(str);
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html5Entities.prototype.encodeNonASCII = function(str) {
        if (!str || !str.length) {
          return '';
        }
        var strLength = str.length;
        var result = '';
        var i = 0;
        while (i < strLength) {
          var c = str.charCodeAt(i);
          if (c <= 255) {
            result += str[i++];
            continue;
          }
          result += '&#' + c + ';';
          i++;
        }
        return result;
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html5Entities.encodeNonASCII = function(str) {
        return new Html5Entities().encodeNonASCII(str);
      };

      /**
 * @param {Object} alphaIndex Passed by reference.
 * @param {Object} charIndex Passed by reference.
 */
      function createIndexes(alphaIndex, charIndex) {
        var i = ENTITIES.length;
        var _results = [];
        while (i--) {
          var e = ENTITIES[i];
          var alpha = e[0];
          var chars = e[1];
          var chr = chars[0];
          var addChar =
            chr < 32 ||
            chr > 126 ||
            chr === 62 ||
            chr === 60 ||
            chr === 38 ||
            chr === 34 ||
            chr === 39;
          var charInfo;
          if (addChar) {
            charInfo = charIndex[chr] = charIndex[chr] || {};
          }
          if (chars[1]) {
            var chr2 = chars[1];
            alphaIndex[alpha] =
              String.fromCharCode(chr) + String.fromCharCode(chr2);
            _results.push(addChar && (charInfo[chr2] = alpha));
          } else {
            alphaIndex[alpha] = String.fromCharCode(chr);
            _results.push(addChar && (charInfo[''] = alpha));
          }
        }
      }

      module.exports = Html5Entities;

      /***/
    },
    /* 13 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.getHead = getHead;
      exports.injectCss = injectCss;
      exports.removeCss = removeCss;
      exports.applyStyles = applyStyles;

      /**
 * Copyright (c) 2015-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
      var injectedCount = 0;
      var injectedCache = {};

      function getHead(document) {
        return document.head || document.getElementsByTagName('head')[0];
      }

      function injectCss(document, css) {
        var head = getHead(document);
        var style = document.createElement('style');
        style.type = 'text/css';
        style.appendChild(document.createTextNode(css));
        head.appendChild(style);
        injectedCache[++injectedCount] = style;
        return injectedCount;
      }

      function removeCss(document, ref) {
        if (injectedCache[ref] == null) {
          return;
        }

        var head = getHead(document);
        head.removeChild(injectedCache[ref]);
        delete injectedCache[ref];
      }

      function applyStyles(element, styles) {
        element.setAttribute('style', '');

        for (var key in styles) {
          if (!styles.hasOwnProperty(key)) {
            continue;
          } // $FlowFixMe

          element.style[key] = styles[key];
        }
      }

      /***/
    },
    /* 14 */
    /***/ function(module, exports) {
      // shim for using process in browser
      var process = (module.exports = {});

      // cached from whatever global is present so that test runners that stub it
      // don't break things.  But we need to wrap it in a try catch in case it is
      // wrapped in strict mode code which doesn't define any globals.  It's inside a
      // function because try/catches deoptimize in certain engines.

      var cachedSetTimeout;
      var cachedClearTimeout;

      function defaultSetTimout() {
        throw new Error('setTimeout has not been defined');
      }
      function defaultClearTimeout() {
        throw new Error('clearTimeout has not been defined');
      }
      (function() {
        try {
          if (typeof setTimeout === 'function') {
            cachedSetTimeout = setTimeout;
          } else {
            cachedSetTimeout = defaultSetTimout;
          }
        } catch (e) {
          cachedSetTimeout = defaultSetTimout;
        }
        try {
          if (typeof clearTimeout === 'function') {
            cachedClearTimeout = clearTimeout;
          } else {
            cachedClearTimeout = defaultClearTimeout;
          }
        } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
        }
      })();
      function runTimeout(fun) {
        if (cachedSetTimeout === setTimeout) {
          //normal enviroments in sane situations
          return setTimeout(fun, 0);
        }
        // if setTimeout wasn't available but was latter defined
        if (
          (cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) &&
          setTimeout
        ) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
        }
        try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedSetTimeout(fun, 0);
        } catch (e) {
          try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
            return cachedSetTimeout.call(null, fun, 0);
          } catch (e) {
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
            return cachedSetTimeout.call(this, fun, 0);
          }
        }
      }
      function runClearTimeout(marker) {
        if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
        }
        // if clearTimeout wasn't available but was latter defined
        if (
          (cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) &&
          clearTimeout
        ) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
        }
        try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
        } catch (e) {
          try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
            return cachedClearTimeout.call(null, marker);
          } catch (e) {
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
            return cachedClearTimeout.call(this, marker);
          }
        }
      }
      var queue = [];
      var draining = false;
      var currentQueue;
      var queueIndex = -1;

      function cleanUpNextTick() {
        if (!draining || !currentQueue) {
          return;
        }
        draining = false;
        if (currentQueue.length) {
          queue = currentQueue.concat(queue);
        } else {
          queueIndex = -1;
        }
        if (queue.length) {
          drainQueue();
        }
      }

      function drainQueue() {
        if (draining) {
          return;
        }
        var timeout = runTimeout(cleanUpNextTick);
        draining = true;

        var len = queue.length;
        while (len) {
          currentQueue = queue;
          queue = [];
          while (++queueIndex < len) {
            if (currentQueue) {
              currentQueue[queueIndex].run();
            }
          }
          queueIndex = -1;
          len = queue.length;
        }
        currentQueue = null;
        draining = false;
        runClearTimeout(timeout);
      }

      process.nextTick = function(fun) {
        var args = new Array(arguments.length - 1);
        if (arguments.length > 1) {
          for (var i = 1; i < arguments.length; i++) {
            args[i - 1] = arguments[i];
          }
        }
        queue.push(new Item(fun, args));
        if (queue.length === 1 && !draining) {
          runTimeout(drainQueue);
        }
      };

      // v8 likes predictible objects
      function Item(fun, array) {
        this.fun = fun;
        this.array = array;
      }
      Item.prototype.run = function() {
        this.fun.apply(null, this.array);
      };
      process.title = 'browser';
      process.browser = true;
      process.env = {};
      process.argv = [];
      process.version = ''; // empty string to avoid regexp issues
      process.versions = {};

      function noop() {}

      process.on = noop;
      process.addListener = noop;
      process.once = noop;
      process.off = noop;
      process.removeListener = noop;
      process.removeAllListeners = noop;
      process.emit = noop;
      process.prependListener = noop;
      process.prependOnceListener = noop;

      process.listeners = function(name) {
        return [];
      };

      process.binding = function(name) {
        throw new Error('process.binding is not supported');
      };

      process.cwd = function() {
        return '/';
      };
      process.chdir = function(dir) {
        throw new Error('process.chdir is not supported');
      };
      process.umask = function() {
        return 0;
      };

      /***/
    },
    /* 15 */
    /***/ function(module, exports) {
      /*
  Copyright (C) 2013-2014 Yusuke Suzuki <utatane.tea@gmail.com>
  Copyright (C) 2014 Ivan Nikulin <ifaaan@gmail.com>

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

      (function() {
        'use strict';

        var ES6Regex,
          ES5Regex,
          NON_ASCII_WHITESPACES,
          IDENTIFIER_START,
          IDENTIFIER_PART,
          ch;

        // See `tools/generate-identifier-regex.js`.
        ES5Regex = {
          // ECMAScript 5.1/Unicode v7.0.0 NonAsciiIdentifierStart:
          NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B2\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/,
          // ECMAScript 5.1/Unicode v7.0.0 NonAsciiIdentifierPart:
          NonAsciiIdentifierPart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B2\u08E4-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA69D\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/,
        };

        ES6Regex = {
          // ECMAScript 6/Unicode v7.0.0 NonAsciiIdentifierStart:
          NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B2\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDE00-\uDE11\uDE13-\uDE2B\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDE00-\uDE2F\uDE44\uDE80-\uDEAA]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF98]|\uD809[\uDC00-\uDC6E]|[\uD80C\uD840-\uD868\uD86A-\uD86C][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D]|\uD87E[\uDC00-\uDE1D]/,
          // ECMAScript 6/Unicode v7.0.0 NonAsciiIdentifierPart:
          NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B2\u08E4-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA69D\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDD0-\uDDDA\uDE00-\uDE11\uDE13-\uDE37\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF01-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF98]|\uD809[\uDC00-\uDC6E]|[\uD80C\uD840-\uD868\uD86A-\uD86C][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/,
        };

        function isDecimalDigit(ch) {
          return 0x30 <= ch && ch <= 0x39; // 0..9
        }

        function isHexDigit(ch) {
          return (
            (0x30 <= ch && ch <= 0x39) || // 0..9
            (0x61 <= ch && ch <= 0x66) || // a..f
            (0x41 <= ch && ch <= 0x46)
          ); // A..F
        }

        function isOctalDigit(ch) {
          return ch >= 0x30 && ch <= 0x37; // 0..7
        }

        // 7.2 White Space

        NON_ASCII_WHITESPACES = [
          0x1680,
          0x180e,
          0x2000,
          0x2001,
          0x2002,
          0x2003,
          0x2004,
          0x2005,
          0x2006,
          0x2007,
          0x2008,
          0x2009,
          0x200a,
          0x202f,
          0x205f,
          0x3000,
          0xfeff,
        ];

        function isWhiteSpace(ch) {
          return (
            ch === 0x20 ||
            ch === 0x09 ||
            ch === 0x0b ||
            ch === 0x0c ||
            ch === 0xa0 ||
            (ch >= 0x1680 && NON_ASCII_WHITESPACES.indexOf(ch) >= 0)
          );
        }

        // 7.3 Line Terminators

        function isLineTerminator(ch) {
          return ch === 0x0a || ch === 0x0d || ch === 0x2028 || ch === 0x2029;
        }

        // 7.6 Identifier Names and Identifiers

        function fromCodePoint(cp) {
          if (cp <= 0xffff) {
            return String.fromCharCode(cp);
          }
          var cu1 = String.fromCharCode(
            Math.floor((cp - 0x10000) / 0x400) + 0xd800
          );
          var cu2 = String.fromCharCode((cp - 0x10000) % 0x400 + 0xdc00);
          return cu1 + cu2;
        }

        IDENTIFIER_START = new Array(0x80);
        for (ch = 0; ch < 0x80; ++ch) {
          IDENTIFIER_START[ch] =
            (ch >= 0x61 && ch <= 0x7a) || // a..z
            (ch >= 0x41 && ch <= 0x5a) || // A..Z
            ch === 0x24 ||
            ch === 0x5f; // $ (dollar) and _ (underscore)
        }

        IDENTIFIER_PART = new Array(0x80);
        for (ch = 0; ch < 0x80; ++ch) {
          IDENTIFIER_PART[ch] =
            (ch >= 0x61 && ch <= 0x7a) || // a..z
            (ch >= 0x41 && ch <= 0x5a) || // A..Z
            (ch >= 0x30 && ch <= 0x39) || // 0..9
            ch === 0x24 ||
            ch === 0x5f; // $ (dollar) and _ (underscore)
        }

        function isIdentifierStartES5(ch) {
          return ch < 0x80
            ? IDENTIFIER_START[ch]
            : ES5Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch));
        }

        function isIdentifierPartES5(ch) {
          return ch < 0x80
            ? IDENTIFIER_PART[ch]
            : ES5Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch));
        }

        function isIdentifierStartES6(ch) {
          return ch < 0x80
            ? IDENTIFIER_START[ch]
            : ES6Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch));
        }

        function isIdentifierPartES6(ch) {
          return ch < 0x80
            ? IDENTIFIER_PART[ch]
            : ES6Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch));
        }

        module.exports = {
          isDecimalDigit: isDecimalDigit,
          isHexDigit: isHexDigit,
          isOctalDigit: isOctalDigit,
          isWhiteSpace: isWhiteSpace,
          isLineTerminator: isLineTerminator,
          isIdentifierStartES5: isIdentifierStartES5,
          isIdentifierPartES5: isIdentifierPartES5,
          isIdentifierStartES6: isIdentifierStartES6,
          isIdentifierPartES6: isIdentifierPartES6,
        };
      })();
      /* vim: set sw=4 ts=4 et tw=80 : */

      /***/
    },
    /* 16 */
    /***/ function(module, exports, __webpack_require__) {
      /* MIT license */
      var cssKeywords = __webpack_require__(57);

      // NOTE: conversions should only return primitive values (i.e. arrays, or
      //       values that give correct `typeof` results).
      //       do not use box values types (i.e. Number(), String(), etc.)

      var reverseKeywords = {};
      for (var key in cssKeywords) {
        if (cssKeywords.hasOwnProperty(key)) {
          reverseKeywords[cssKeywords[key]] = key;
        }
      }

      var convert = (module.exports = {
        rgb: { channels: 3, labels: 'rgb' },
        hsl: { channels: 3, labels: 'hsl' },
        hsv: { channels: 3, labels: 'hsv' },
        hwb: { channels: 3, labels: 'hwb' },
        cmyk: { channels: 4, labels: 'cmyk' },
        xyz: { channels: 3, labels: 'xyz' },
        lab: { channels: 3, labels: 'lab' },
        lch: { channels: 3, labels: 'lch' },
        hex: { channels: 1, labels: ['hex'] },
        keyword: { channels: 1, labels: ['keyword'] },
        ansi16: { channels: 1, labels: ['ansi16'] },
        ansi256: { channels: 1, labels: ['ansi256'] },
        hcg: { channels: 3, labels: ['h', 'c', 'g'] },
        apple: { channels: 3, labels: ['r16', 'g16', 'b16'] },
        gray: { channels: 1, labels: ['gray'] },
      });

      // hide .channels and .labels properties
      for (var model in convert) {
        if (convert.hasOwnProperty(model)) {
          if (!('channels' in convert[model])) {
            throw new Error('missing channels property: ' + model);
          }

          if (!('labels' in convert[model])) {
            throw new Error('missing channel labels property: ' + model);
          }

          if (convert[model].labels.length !== convert[model].channels) {
            throw new Error('channel and label counts mismatch: ' + model);
          }

          var channels = convert[model].channels;
          var labels = convert[model].labels;
          delete convert[model].channels;
          delete convert[model].labels;
          Object.defineProperty(convert[model], 'channels', {
            value: channels,
          });
          Object.defineProperty(convert[model], 'labels', { value: labels });
        }
      }

      convert.rgb.hsl = function(rgb) {
        var r = rgb[0] / 255;
        var g = rgb[1] / 255;
        var b = rgb[2] / 255;
        var min = Math.min(r, g, b);
        var max = Math.max(r, g, b);
        var delta = max - min;
        var h;
        var s;
        var l;

        if (max === min) {
          h = 0;
        } else if (r === max) {
          h = (g - b) / delta;
        } else if (g === max) {
          h = 2 + (b - r) / delta;
        } else if (b === max) {
          h = 4 + (r - g) / delta;
        }

        h = Math.min(h * 60, 360);

        if (h < 0) {
          h += 360;
        }

        l = (min + max) / 2;

        if (max === min) {
          s = 0;
        } else if (l <= 0.5) {
          s = delta / (max + min);
        } else {
          s = delta / (2 - max - min);
        }

        return [h, s * 100, l * 100];
      };

      convert.rgb.hsv = function(rgb) {
        var r = rgb[0];
        var g = rgb[1];
        var b = rgb[2];
        var min = Math.min(r, g, b);
        var max = Math.max(r, g, b);
        var delta = max - min;
        var h;
        var s;
        var v;

        if (max === 0) {
          s = 0;
        } else {
          s = delta / max * 1000 / 10;
        }

        if (max === min) {
          h = 0;
        } else if (r === max) {
          h = (g - b) / delta;
        } else if (g === max) {
          h = 2 + (b - r) / delta;
        } else if (b === max) {
          h = 4 + (r - g) / delta;
        }

        h = Math.min(h * 60, 360);

        if (h < 0) {
          h += 360;
        }

        v = max / 255 * 1000 / 10;

        return [h, s, v];
      };

      convert.rgb.hwb = function(rgb) {
        var r = rgb[0];
        var g = rgb[1];
        var b = rgb[2];
        var h = convert.rgb.hsl(rgb)[0];
        var w = 1 / 255 * Math.min(r, Math.min(g, b));

        b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));

        return [h, w * 100, b * 100];
      };

      convert.rgb.cmyk = function(rgb) {
        var r = rgb[0] / 255;
        var g = rgb[1] / 255;
        var b = rgb[2] / 255;
        var c;
        var m;
        var y;
        var k;

        k = Math.min(1 - r, 1 - g, 1 - b);
        c = (1 - r - k) / (1 - k) || 0;
        m = (1 - g - k) / (1 - k) || 0;
        y = (1 - b - k) / (1 - k) || 0;

        return [c * 100, m * 100, y * 100, k * 100];
      };

      /**
 * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
 * */
      function comparativeDistance(x, y) {
        return (
          Math.pow(x[0] - y[0], 2) +
          Math.pow(x[1] - y[1], 2) +
          Math.pow(x[2] - y[2], 2)
        );
      }

      convert.rgb.keyword = function(rgb) {
        var reversed = reverseKeywords[rgb];
        if (reversed) {
          return reversed;
        }

        var currentClosestDistance = Infinity;
        var currentClosestKeyword;

        for (var keyword in cssKeywords) {
          if (cssKeywords.hasOwnProperty(keyword)) {
            var value = cssKeywords[keyword];

            // Compute comparative distance
            var distance = comparativeDistance(rgb, value);

            // Check if its less, if so set as closest
            if (distance < currentClosestDistance) {
              currentClosestDistance = distance;
              currentClosestKeyword = keyword;
            }
          }
        }

        return currentClosestKeyword;
      };

      convert.keyword.rgb = function(keyword) {
        return cssKeywords[keyword];
      };

      convert.rgb.xyz = function(rgb) {
        var r = rgb[0] / 255;
        var g = rgb[1] / 255;
        var b = rgb[2] / 255;

        // assume sRGB
        r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
        g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
        b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;

        var x = r * 0.4124 + g * 0.3576 + b * 0.1805;
        var y = r * 0.2126 + g * 0.7152 + b * 0.0722;
        var z = r * 0.0193 + g * 0.1192 + b * 0.9505;

        return [x * 100, y * 100, z * 100];
      };

      convert.rgb.lab = function(rgb) {
        var xyz = convert.rgb.xyz(rgb);
        var x = xyz[0];
        var y = xyz[1];
        var z = xyz[2];
        var l;
        var a;
        var b;

        x /= 95.047;
        y /= 100;
        z /= 108.883;

        x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
        y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
        z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;

        l = 116 * y - 16;
        a = 500 * (x - y);
        b = 200 * (y - z);

        return [l, a, b];
      };

      convert.hsl.rgb = function(hsl) {
        var h = hsl[0] / 360;
        var s = hsl[1] / 100;
        var l = hsl[2] / 100;
        var t1;
        var t2;
        var t3;
        var rgb;
        var val;

        if (s === 0) {
          val = l * 255;
          return [val, val, val];
        }

        if (l < 0.5) {
          t2 = l * (1 + s);
        } else {
          t2 = l + s - l * s;
        }

        t1 = 2 * l - t2;

        rgb = [0, 0, 0];
        for (var i = 0; i < 3; i++) {
          t3 = h + 1 / 3 * -(i - 1);
          if (t3 < 0) {
            t3++;
          }
          if (t3 > 1) {
            t3--;
          }

          if (6 * t3 < 1) {
            val = t1 + (t2 - t1) * 6 * t3;
          } else if (2 * t3 < 1) {
            val = t2;
          } else if (3 * t3 < 2) {
            val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
          } else {
            val = t1;
          }

          rgb[i] = val * 255;
        }

        return rgb;
      };

      convert.hsl.hsv = function(hsl) {
        var h = hsl[0];
        var s = hsl[1] / 100;
        var l = hsl[2] / 100;
        var smin = s;
        var lmin = Math.max(l, 0.01);
        var sv;
        var v;

        l *= 2;
        s *= l <= 1 ? l : 2 - l;
        smin *= lmin <= 1 ? lmin : 2 - lmin;
        v = (l + s) / 2;
        sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);

        return [h, sv * 100, v * 100];
      };

      convert.hsv.rgb = function(hsv) {
        var h = hsv[0] / 60;
        var s = hsv[1] / 100;
        var v = hsv[2] / 100;
        var hi = Math.floor(h) % 6;

        var f = h - Math.floor(h);
        var p = 255 * v * (1 - s);
        var q = 255 * v * (1 - s * f);
        var t = 255 * v * (1 - s * (1 - f));
        v *= 255;

        switch (hi) {
          case 0:
            return [v, t, p];
          case 1:
            return [q, v, p];
          case 2:
            return [p, v, t];
          case 3:
            return [p, q, v];
          case 4:
            return [t, p, v];
          case 5:
            return [v, p, q];
        }
      };

      convert.hsv.hsl = function(hsv) {
        var h = hsv[0];
        var s = hsv[1] / 100;
        var v = hsv[2] / 100;
        var vmin = Math.max(v, 0.01);
        var lmin;
        var sl;
        var l;

        l = (2 - s) * v;
        lmin = (2 - s) * vmin;
        sl = s * vmin;
        sl /= lmin <= 1 ? lmin : 2 - lmin;
        sl = sl || 0;
        l /= 2;

        return [h, sl * 100, l * 100];
      };

      // http://dev.w3.org/csswg/css-color/#hwb-to-rgb
      convert.hwb.rgb = function(hwb) {
        var h = hwb[0] / 360;
        var wh = hwb[1] / 100;
        var bl = hwb[2] / 100;
        var ratio = wh + bl;
        var i;
        var v;
        var f;
        var n;

        // wh + bl cant be > 1
        if (ratio > 1) {
          wh /= ratio;
          bl /= ratio;
        }

        i = Math.floor(6 * h);
        v = 1 - bl;
        f = 6 * h - i;

        if ((i & 0x01) !== 0) {
          f = 1 - f;
        }

        n = wh + f * (v - wh); // linear interpolation

        var r;
        var g;
        var b;
        switch (i) {
          default:
          case 6:
          case 0:
            r = v;
            g = n;
            b = wh;
            break;
          case 1:
            r = n;
            g = v;
            b = wh;
            break;
          case 2:
            r = wh;
            g = v;
            b = n;
            break;
          case 3:
            r = wh;
            g = n;
            b = v;
            break;
          case 4:
            r = n;
            g = wh;
            b = v;
            break;
          case 5:
            r = v;
            g = wh;
            b = n;
            break;
        }

        return [r * 255, g * 255, b * 255];
      };

      convert.cmyk.rgb = function(cmyk) {
        var c = cmyk[0] / 100;
        var m = cmyk[1] / 100;
        var y = cmyk[2] / 100;
        var k = cmyk[3] / 100;
        var r;
        var g;
        var b;

        r = 1 - Math.min(1, c * (1 - k) + k);
        g = 1 - Math.min(1, m * (1 - k) + k);
        b = 1 - Math.min(1, y * (1 - k) + k);

        return [r * 255, g * 255, b * 255];
      };

      convert.xyz.rgb = function(xyz) {
        var x = xyz[0] / 100;
        var y = xyz[1] / 100;
        var z = xyz[2] / 100;
        var r;
        var g;
        var b;

        r = x * 3.2406 + y * -1.5372 + z * -0.4986;
        g = x * -0.9689 + y * 1.8758 + z * 0.0415;
        b = x * 0.0557 + y * -0.204 + z * 1.057;

        // assume sRGB
        r = r > 0.0031308 ? 1.055 * Math.pow(r, 1.0 / 2.4) - 0.055 : r * 12.92;

        g = g > 0.0031308 ? 1.055 * Math.pow(g, 1.0 / 2.4) - 0.055 : g * 12.92;

        b = b > 0.0031308 ? 1.055 * Math.pow(b, 1.0 / 2.4) - 0.055 : b * 12.92;

        r = Math.min(Math.max(0, r), 1);
        g = Math.min(Math.max(0, g), 1);
        b = Math.min(Math.max(0, b), 1);

        return [r * 255, g * 255, b * 255];
      };

      convert.xyz.lab = function(xyz) {
        var x = xyz[0];
        var y = xyz[1];
        var z = xyz[2];
        var l;
        var a;
        var b;

        x /= 95.047;
        y /= 100;
        z /= 108.883;

        x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
        y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
        z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;

        l = 116 * y - 16;
        a = 500 * (x - y);
        b = 200 * (y - z);

        return [l, a, b];
      };

      convert.lab.xyz = function(lab) {
        var l = lab[0];
        var a = lab[1];
        var b = lab[2];
        var x;
        var y;
        var z;

        y = (l + 16) / 116;
        x = a / 500 + y;
        z = y - b / 200;

        var y2 = Math.pow(y, 3);
        var x2 = Math.pow(x, 3);
        var z2 = Math.pow(z, 3);
        y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
        x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
        z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;

        x *= 95.047;
        y *= 100;
        z *= 108.883;

        return [x, y, z];
      };

      convert.lab.lch = function(lab) {
        var l = lab[0];
        var a = lab[1];
        var b = lab[2];
        var hr;
        var h;
        var c;

        hr = Math.atan2(b, a);
        h = hr * 360 / 2 / Math.PI;

        if (h < 0) {
          h += 360;
        }

        c = Math.sqrt(a * a + b * b);

        return [l, c, h];
      };

      convert.lch.lab = function(lch) {
        var l = lch[0];
        var c = lch[1];
        var h = lch[2];
        var a;
        var b;
        var hr;

        hr = h / 360 * 2 * Math.PI;
        a = c * Math.cos(hr);
        b = c * Math.sin(hr);

        return [l, a, b];
      };

      convert.rgb.ansi16 = function(args) {
        var r = args[0];
        var g = args[1];
        var b = args[2];
        var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization

        value = Math.round(value / 50);

        if (value === 0) {
          return 30;
        }

        var ansi =
          30 +
          ((Math.round(b / 255) << 2) |
            (Math.round(g / 255) << 1) |
            Math.round(r / 255));

        if (value === 2) {
          ansi += 60;
        }

        return ansi;
      };

      convert.hsv.ansi16 = function(args) {
        // optimization here; we already know the value and don't need to get
        // it converted for us.
        return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
      };

      convert.rgb.ansi256 = function(args) {
        var r = args[0];
        var g = args[1];
        var b = args[2];

        // we use the extended greyscale palette here, with the exception of
        // black and white. normal palette only has 4 greyscale shades.
        if (r === g && g === b) {
          if (r < 8) {
            return 16;
          }

          if (r > 248) {
            return 231;
          }

          return Math.round((r - 8) / 247 * 24) + 232;
        }

        var ansi =
          16 +
          36 * Math.round(r / 255 * 5) +
          6 * Math.round(g / 255 * 5) +
          Math.round(b / 255 * 5);

        return ansi;
      };

      convert.ansi16.rgb = function(args) {
        var color = args % 10;

        // handle greyscale
        if (color === 0 || color === 7) {
          if (args > 50) {
            color += 3.5;
          }

          color = color / 10.5 * 255;

          return [color, color, color];
        }

        var mult = (~~(args > 50) + 1) * 0.5;
        var r = (color & 1) * mult * 255;
        var g = ((color >> 1) & 1) * mult * 255;
        var b = ((color >> 2) & 1) * mult * 255;

        return [r, g, b];
      };

      convert.ansi256.rgb = function(args) {
        // handle greyscale
        if (args >= 232) {
          var c = (args - 232) * 10 + 8;
          return [c, c, c];
        }

        args -= 16;

        var rem;
        var r = Math.floor(args / 36) / 5 * 255;
        var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
        var b = (rem % 6) / 5 * 255;

        return [r, g, b];
      };

      convert.rgb.hex = function(args) {
        var integer =
          ((Math.round(args[0]) & 0xff) << 16) +
          ((Math.round(args[1]) & 0xff) << 8) +
          (Math.round(args[2]) & 0xff);

        var string = integer.toString(16).toUpperCase();
        return '000000'.substring(string.length) + string;
      };

      convert.hex.rgb = function(args) {
        var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
        if (!match) {
          return [0, 0, 0];
        }

        var colorString = match[0];

        if (match[0].length === 3) {
          colorString = colorString
            .split('')
            .map(function(char) {
              return char + char;
            })
            .join('');
        }

        var integer = parseInt(colorString, 16);
        var r = (integer >> 16) & 0xff;
        var g = (integer >> 8) & 0xff;
        var b = integer & 0xff;

        return [r, g, b];
      };

      convert.rgb.hcg = function(rgb) {
        var r = rgb[0] / 255;
        var g = rgb[1] / 255;
        var b = rgb[2] / 255;
        var max = Math.max(Math.max(r, g), b);
        var min = Math.min(Math.min(r, g), b);
        var chroma = max - min;
        var grayscale;
        var hue;

        if (chroma < 1) {
          grayscale = min / (1 - chroma);
        } else {
          grayscale = 0;
        }

        if (chroma <= 0) {
          hue = 0;
        } else if (max === r) {
          hue = ((g - b) / chroma) % 6;
        } else if (max === g) {
          hue = 2 + (b - r) / chroma;
        } else {
          hue = 4 + (r - g) / chroma + 4;
        }

        hue /= 6;
        hue %= 1;

        return [hue * 360, chroma * 100, grayscale * 100];
      };

      convert.hsl.hcg = function(hsl) {
        var s = hsl[1] / 100;
        var l = hsl[2] / 100;
        var c = 1;
        var f = 0;

        if (l < 0.5) {
          c = 2.0 * s * l;
        } else {
          c = 2.0 * s * (1.0 - l);
        }

        if (c < 1.0) {
          f = (l - 0.5 * c) / (1.0 - c);
        }

        return [hsl[0], c * 100, f * 100];
      };

      convert.hsv.hcg = function(hsv) {
        var s = hsv[1] / 100;
        var v = hsv[2] / 100;

        var c = s * v;
        var f = 0;

        if (c < 1.0) {
          f = (v - c) / (1 - c);
        }

        return [hsv[0], c * 100, f * 100];
      };

      convert.hcg.rgb = function(hcg) {
        var h = hcg[0] / 360;
        var c = hcg[1] / 100;
        var g = hcg[2] / 100;

        if (c === 0.0) {
          return [g * 255, g * 255, g * 255];
        }

        var pure = [0, 0, 0];
        var hi = (h % 1) * 6;
        var v = hi % 1;
        var w = 1 - v;
        var mg = 0;

        switch (Math.floor(hi)) {
          case 0:
            pure[0] = 1;
            pure[1] = v;
            pure[2] = 0;
            break;
          case 1:
            pure[0] = w;
            pure[1] = 1;
            pure[2] = 0;
            break;
          case 2:
            pure[0] = 0;
            pure[1] = 1;
            pure[2] = v;
            break;
          case 3:
            pure[0] = 0;
            pure[1] = w;
            pure[2] = 1;
            break;
          case 4:
            pure[0] = v;
            pure[1] = 0;
            pure[2] = 1;
            break;
          default:
            pure[0] = 1;
            pure[1] = 0;
            pure[2] = w;
        }

        mg = (1.0 - c) * g;

        return [
          (c * pure[0] + mg) * 255,
          (c * pure[1] + mg) * 255,
          (c * pure[2] + mg) * 255,
        ];
      };

      convert.hcg.hsv = function(hcg) {
        var c = hcg[1] / 100;
        var g = hcg[2] / 100;

        var v = c + g * (1.0 - c);
        var f = 0;

        if (v > 0.0) {
          f = c / v;
        }

        return [hcg[0], f * 100, v * 100];
      };

      convert.hcg.hsl = function(hcg) {
        var c = hcg[1] / 100;
        var g = hcg[2] / 100;

        var l = g * (1.0 - c) + 0.5 * c;
        var s = 0;

        if (l > 0.0 && l < 0.5) {
          s = c / (2 * l);
        } else if (l >= 0.5 && l < 1.0) {
          s = c / (2 * (1 - l));
        }

        return [hcg[0], s * 100, l * 100];
      };

      convert.hcg.hwb = function(hcg) {
        var c = hcg[1] / 100;
        var g = hcg[2] / 100;
        var v = c + g * (1.0 - c);
        return [hcg[0], (v - c) * 100, (1 - v) * 100];
      };

      convert.hwb.hcg = function(hwb) {
        var w = hwb[1] / 100;
        var b = hwb[2] / 100;
        var v = 1 - b;
        var c = v - w;
        var g = 0;

        if (c < 1) {
          g = (v - c) / (1 - c);
        }

        return [hwb[0], c * 100, g * 100];
      };

      convert.apple.rgb = function(apple) {
        return [
          apple[0] / 65535 * 255,
          apple[1] / 65535 * 255,
          apple[2] / 65535 * 255,
        ];
      };

      convert.rgb.apple = function(rgb) {
        return [
          rgb[0] / 255 * 65535,
          rgb[1] / 255 * 65535,
          rgb[2] / 255 * 65535,
        ];
      };

      convert.gray.rgb = function(args) {
        return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
      };

      convert.gray.hsl = convert.gray.hsv = function(args) {
        return [0, 0, args[0]];
      };

      convert.gray.hwb = function(gray) {
        return [0, 100, gray[0]];
      };

      convert.gray.cmyk = function(gray) {
        return [0, 0, 0, gray[0]];
      };

      convert.gray.lab = function(gray) {
        return [gray[0], 0, 0];
      };

      convert.gray.hex = function(gray) {
        var val = Math.round(gray[0] / 100 * 255) & 0xff;
        var integer = (val << 16) + (val << 8) + val;

        var string = integer.toString(16).toUpperCase();
        return '000000'.substring(string.length) + string;
      };

      convert.rgb.gray = function(rgb) {
        var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
        return [val / 255 * 100];
      };

      /***/
    },
    /* 17 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      __webpack_require__(18);

      var _react = _interopRequireDefault(__webpack_require__(0));

      var _reactDom = _interopRequireDefault(__webpack_require__(24));

      var _CompileErrorContainer = _interopRequireDefault(
        __webpack_require__(34)
      );

      var _RuntimeErrorContainer = _interopRequireDefault(
        __webpack_require__(39)
      );

      var _styles = __webpack_require__(1);

      var _css = __webpack_require__(13);

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/iframeScript.js';

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      var iframeRoot = null;

      function render(_ref) {
        var currentBuildError = _ref.currentBuildError,
          currentRuntimeErrorRecords = _ref.currentRuntimeErrorRecords,
          dismissRuntimeErrors = _ref.dismissRuntimeErrors,
          editorHandler = _ref.editorHandler;

        if (currentBuildError) {
          return _react.default.createElement(_CompileErrorContainer.default, {
            error: currentBuildError,
            editorHandler: editorHandler,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 26,
            },
            __self: this,
          });
        }

        if (currentRuntimeErrorRecords.length > 0) {
          return _react.default.createElement(_RuntimeErrorContainer.default, {
            errorRecords: currentRuntimeErrorRecords,
            close: dismissRuntimeErrors,
            editorHandler: editorHandler,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 34,
            },
            __self: this,
          });
        }

        return null;
      }

      window.updateContent = function updateContent(errorOverlayProps) {
        var renderedElement = render(errorOverlayProps);

        if (renderedElement === null) {
          _reactDom.default.unmountComponentAtNode(iframeRoot);

          return false;
        } // Update the overlay

        _reactDom.default.render(renderedElement, iframeRoot);

        return true;
      };

      document.body.style.margin = '0'; // Keep popup within body boundaries for iOS Safari

      document.body.style['max-width'] = '100vw';
      iframeRoot = document.createElement('div');
      (0, _css.applyStyles)(iframeRoot, _styles.overlayStyle);
      document.body.appendChild(iframeRoot);

      window.parent.__REACT_ERROR_OVERLAY_GLOBAL_HOOK__.iframeReady();

      /***/
    },
    /* 18 */
    /***/ function(module, exports, __webpack_require__) {
      /**
 * Copyright (c) 2015-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
      if (typeof Promise === 'undefined') {
        // Rejection tracking prevents a common issue where React gets into an
        // inconsistent state due to an error, but it gets swallowed by a Promise,
        // and the user has no idea what causes React's erratic future behavior.
        __webpack_require__(19).enable();

        window.Promise = __webpack_require__(22);
      } // Object.assign() is commonly used with React.
      // It will use the native implementation if it's present and isn't buggy.

      Object.assign = __webpack_require__(2);

      /***/
    },
    /* 19 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      var Promise = __webpack_require__(4);

      var DEFAULT_WHITELIST = [ReferenceError, TypeError, RangeError];

      var enabled = false;
      exports.disable = disable;
      function disable() {
        enabled = false;
        Promise._47 = null;
        Promise._71 = null;
      }

      exports.enable = enable;
      function enable(options) {
        options = options || {};
        if (enabled) disable();
        enabled = true;
        var id = 0;
        var displayId = 0;
        var rejections = {};
        Promise._47 = function(promise) {
          if (
            promise._83 === 2 && // IS REJECTED
            rejections[promise._56]
          ) {
            if (rejections[promise._56].logged) {
              onHandled(promise._56);
            } else {
              clearTimeout(rejections[promise._56].timeout);
            }
            delete rejections[promise._56];
          }
        };
        Promise._71 = function(promise, err) {
          if (promise._75 === 0) {
            // not yet handled
            promise._56 = id++;
            rejections[promise._56] = {
              displayId: null,
              error: err,
              timeout: setTimeout(
                onUnhandled.bind(null, promise._56),
                // For reference errors and type errors, this almost always
                // means the programmer made a mistake, so log them after just
                // 100ms
                // otherwise, wait 2 seconds to see if they get handled
                matchWhitelist(err, DEFAULT_WHITELIST) ? 100 : 2000
              ),
              logged: false,
            };
          }
        };
        function onUnhandled(id) {
          if (
            options.allRejections ||
            matchWhitelist(
              rejections[id].error,
              options.whitelist || DEFAULT_WHITELIST
            )
          ) {
            rejections[id].displayId = displayId++;
            if (options.onUnhandled) {
              rejections[id].logged = true;
              options.onUnhandled(
                rejections[id].displayId,
                rejections[id].error
              );
            } else {
              rejections[id].logged = true;
              logError(rejections[id].displayId, rejections[id].error);
            }
          }
        }
        function onHandled(id) {
          if (rejections[id].logged) {
            if (options.onHandled) {
              options.onHandled(rejections[id].displayId, rejections[id].error);
            } else if (!rejections[id].onUnhandled) {
              console.warn(
                'Promise Rejection Handled (id: ' +
                  rejections[id].displayId +
                  '):'
              );
              console.warn(
                '  This means you can ignore any previous messages of the form "Possible Unhandled Promise Rejection" with id ' +
                  rejections[id].displayId +
                  '.'
              );
            }
          }
        }
      }

      function logError(id, error) {
        console.warn('Possible Unhandled Promise Rejection (id: ' + id + '):');
        var errStr = (error && (error.stack || error)) + '';
        errStr.split('\n').forEach(function(line) {
          console.warn('  ' + line);
        });
      }

      function matchWhitelist(error, list) {
        return list.some(function(cls) {
          return error instanceof cls;
        });
      }

      /***/
    },
    /* 20 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';
      /* WEBPACK VAR INJECTION */ (function(global) {
        // Use the fastest means possible to execute a task in its own turn, with
        // priority over other events including IO, animation, reflow, and redraw
        // events in browsers.
        //
        // An exception thrown by a task will permanently interrupt the processing of
        // subsequent tasks. The higher level `asap` function ensures that if an
        // exception is thrown by a task, that the task queue will continue flushing as
        // soon as possible, but if you use `rawAsap` directly, you are responsible to
        // either ensure that no exceptions are thrown from your task, or to manually
        // call `rawAsap.requestFlush` if an exception is thrown.
        module.exports = rawAsap;
        function rawAsap(task) {
          if (!queue.length) {
            requestFlush();
            flushing = true;
          }
          // Equivalent to push, but avoids a function call.
          queue[queue.length] = task;
        }

        var queue = [];
        // Once a flush has been requested, no further calls to `requestFlush` are
        // necessary until the next `flush` completes.
        var flushing = false;
        // `requestFlush` is an implementation-specific method that attempts to kick
        // off a `flush` event as quickly as possible. `flush` will attempt to exhaust
        // the event queue before yielding to the browser's own event loop.
        var requestFlush;
        // The position of the next task to execute in the task queue. This is
        // preserved between calls to `flush` so that it can be resumed if
        // a task throws an exception.
        var index = 0;
        // If a task schedules additional tasks recursively, the task queue can grow
        // unbounded. To prevent memory exhaustion, the task queue will periodically
        // truncate already-completed tasks.
        var capacity = 1024;

        // The flush function processes all tasks that have been scheduled with
        // `rawAsap` unless and until one of those tasks throws an exception.
        // If a task throws an exception, `flush` ensures that its state will remain
        // consistent and will resume where it left off when called again.
        // However, `flush` does not make any arrangements to be called again if an
        // exception is thrown.
        function flush() {
          while (index < queue.length) {
            var currentIndex = index;
            // Advance the index before calling the task. This ensures that we will
            // begin flushing on the next task the task throws an error.
            index = index + 1;
            queue[currentIndex].call();
            // Prevent leaking memory for long chains of recursive calls to `asap`.
            // If we call `asap` within tasks scheduled by `asap`, the queue will
            // grow, but to avoid an O(n) walk for every task we execute, we don't
            // shift tasks off the queue after they have been executed.
            // Instead, we periodically shift 1024 tasks off the queue.
            if (index > capacity) {
              // Manually shift all values starting at the index back to the
              // beginning of the queue.
              for (
                var scan = 0, newLength = queue.length - index;
                scan < newLength;
                scan++
              ) {
                queue[scan] = queue[scan + index];
              }
              queue.length -= index;
              index = 0;
            }
          }
          queue.length = 0;
          index = 0;
          flushing = false;
        }

        // `requestFlush` is implemented using a strategy based on data collected from
        // every available SauceLabs Selenium web driver worker at time of writing.
        // https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593

        // Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that
        // have WebKitMutationObserver but not un-prefixed MutationObserver.
        // Must use `global` or `self` instead of `window` to work in both frames and web
        // workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.

        /* globals self */
        var scope = typeof global !== 'undefined' ? global : self;
        var BrowserMutationObserver =
          scope.MutationObserver || scope.WebKitMutationObserver;

        // MutationObservers are desirable because they have high priority and work
        // reliably everywhere they are implemented.
        // They are implemented in all modern browsers.
        //
        // - Android 4-4.3
        // - Chrome 26-34
        // - Firefox 14-29
        // - Internet Explorer 11
        // - iPad Safari 6-7.1
        // - iPhone Safari 7-7.1
        // - Safari 6-7
        if (typeof BrowserMutationObserver === 'function') {
          requestFlush = makeRequestCallFromMutationObserver(flush);

          // MessageChannels are desirable because they give direct access to the HTML
          // task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera
          // 11-12, and in web workers in many engines.
          // Although message channels yield to any queued rendering and IO tasks, they
          // would be better than imposing the 4ms delay of timers.
          // However, they do not work reliably in Internet Explorer or Safari.

          // Internet Explorer 10 is the only browser that has setImmediate but does
          // not have MutationObservers.
          // Although setImmediate yields to the browser's renderer, it would be
          // preferrable to falling back to setTimeout since it does not have
          // the minimum 4ms penalty.
          // Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and
          // Desktop to a lesser extent) that renders both setImmediate and
          // MessageChannel useless for the purposes of ASAP.
          // https://github.com/kriskowal/q/issues/396

          // Timers are implemented universally.
          // We fall back to timers in workers in most engines, and in foreground
          // contexts in the following browsers.
          // However, note that even this simple case requires nuances to operate in a
          // broad spectrum of browsers.
          //
          // - Firefox 3-13
          // - Internet Explorer 6-9
          // - iPad Safari 4.3
          // - Lynx 2.8.7
        } else {
          requestFlush = makeRequestCallFromTimer(flush);
        }

        // `requestFlush` requests that the high priority event queue be flushed as
        // soon as possible.
        // This is useful to prevent an error thrown in a task from stalling the event
        // queue if the exception handled by Node.js’s
        // `process.on("uncaughtException")` or by a domain.
        rawAsap.requestFlush = requestFlush;

        // To request a high priority event, we induce a mutation observer by toggling
        // the text of a text node between "1" and "-1".
        function makeRequestCallFromMutationObserver(callback) {
          var toggle = 1;
          var observer = new BrowserMutationObserver(callback);
          var node = document.createTextNode('');
          observer.observe(node, { characterData: true });
          return function requestCall() {
            toggle = -toggle;
            node.data = toggle;
          };
        }

        // The message channel technique was discovered by Malte Ubl and was the
        // original foundation for this library.
        // http://www.nonblocking.io/2011/06/windownexttick.html

        // Safari 6.0.5 (at least) intermittently fails to create message ports on a
        // page's first load. Thankfully, this version of Safari supports
        // MutationObservers, so we don't need to fall back in that case.

        // function makeRequestCallFromMessageChannel(callback) {
        //     var channel = new MessageChannel();
        //     channel.port1.onmessage = callback;
        //     return function requestCall() {
        //         channel.port2.postMessage(0);
        //     };
        // }

        // For reasons explained above, we are also unable to use `setImmediate`
        // under any circumstances.
        // Even if we were, there is another bug in Internet Explorer 10.
        // It is not sufficient to assign `setImmediate` to `requestFlush` because
        // `setImmediate` must be called *by name* and therefore must be wrapped in a
        // closure.
        // Never forget.

        // function makeRequestCallFromSetImmediate(callback) {
        //     return function requestCall() {
        //         setImmediate(callback);
        //     };
        // }

        // Safari 6.0 has a problem where timers will get lost while the user is
        // scrolling. This problem does not impact ASAP because Safari 6.0 supports
        // mutation observers, so that implementation is used instead.
        // However, if we ever elect to use timers in Safari, the prevalent work-around
        // is to add a scroll event listener that calls for a flush.

        // `setTimeout` does not call the passed callback if the delay is less than
        // approximately 7 in web workers in Firefox 8 through 18, and sometimes not
        // even then.

        function makeRequestCallFromTimer(callback) {
          return function requestCall() {
            // We dispatch a timeout with a specified delay of 0 for engines that
            // can reliably accommodate that request. This will usually be snapped
            // to a 4 milisecond delay, but once we're flushing, there's no delay
            // between events.
            var timeoutHandle = setTimeout(handleTimer, 0);
            // However, since this timer gets frequently dropped in Firefox
            // workers, we enlist an interval handle that will try to fire
            // an event 20 times per second until it succeeds.
            var intervalHandle = setInterval(handleTimer, 50);

            function handleTimer() {
              // Whichever timer succeeds will cancel both timers and
              // execute the callback.
              clearTimeout(timeoutHandle);
              clearInterval(intervalHandle);
              callback();
            }
          };
        }

        // This is for `asap.js` only.
        // Its name will be periodically randomized to break any code that depends on
        // its existence.
        rawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;

        // ASAP was originally a nextTick shim included in Q. This was factored out
        // into this ASAP package. It was later adapted to RSVP which made further
        // amendments. These decisions, particularly to marginalize MessageChannel and
        // to capture the MutationObserver implementation in a closure, were integrated
        // back into ASAP proper.
        // https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js

        /* WEBPACK VAR INJECTION */
      }.call(exports, __webpack_require__(21)));

      /***/
    },
    /* 21 */
    /***/ function(module, exports) {
      var g;

      // This works in non-strict mode
      g = (function() {
        return this;
      })();

      try {
        // This works if eval is allowed (see CSP)
        g = g || Function('return this')() || (1, eval)('this');
      } catch (e) {
        // This works if the window reference is available
        if (typeof window === 'object') g = window;
      }

      // g can still be undefined, but nothing to do about it...
      // We return undefined, instead of nothing here, so it's
      // easier to handle this case. if(!global) { ...}

      module.exports = g;

      /***/
    },
    /* 22 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      //This file contains the ES6 extensions to the core Promises/A+ API

      var Promise = __webpack_require__(4);

      module.exports = Promise;

      /* Static Functions */

      var TRUE = valuePromise(true);
      var FALSE = valuePromise(false);
      var NULL = valuePromise(null);
      var UNDEFINED = valuePromise(undefined);
      var ZERO = valuePromise(0);
      var EMPTYSTRING = valuePromise('');

      function valuePromise(value) {
        var p = new Promise(Promise._44);
        p._83 = 1;
        p._18 = value;
        return p;
      }
      Promise.resolve = function(value) {
        if (value instanceof Promise) return value;

        if (value === null) return NULL;
        if (value === undefined) return UNDEFINED;
        if (value === true) return TRUE;
        if (value === false) return FALSE;
        if (value === 0) return ZERO;
        if (value === '') return EMPTYSTRING;

        if (typeof value === 'object' || typeof value === 'function') {
          try {
            var then = value.then;
            if (typeof then === 'function') {
              return new Promise(then.bind(value));
            }
          } catch (ex) {
            return new Promise(function(resolve, reject) {
              reject(ex);
            });
          }
        }
        return valuePromise(value);
      };

      Promise.all = function(arr) {
        var args = Array.prototype.slice.call(arr);

        return new Promise(function(resolve, reject) {
          if (args.length === 0) return resolve([]);
          var remaining = args.length;
          function res(i, val) {
            if (val && (typeof val === 'object' || typeof val === 'function')) {
              if (
                val instanceof Promise &&
                val.then === Promise.prototype.then
              ) {
                while (val._83 === 3) {
                  val = val._18;
                }
                if (val._83 === 1) return res(i, val._18);
                if (val._83 === 2) reject(val._18);
                val.then(function(val) {
                  res(i, val);
                }, reject);
                return;
              } else {
                var then = val.then;
                if (typeof then === 'function') {
                  var p = new Promise(then.bind(val));
                  p.then(function(val) {
                    res(i, val);
                  }, reject);
                  return;
                }
              }
            }
            args[i] = val;
            if (--remaining === 0) {
              resolve(args);
            }
          }
          for (var i = 0; i < args.length; i++) {
            res(i, args[i]);
          }
        });
      };

      Promise.reject = function(value) {
        return new Promise(function(resolve, reject) {
          reject(value);
        });
      };

      Promise.race = function(values) {
        return new Promise(function(resolve, reject) {
          values.forEach(function(value) {
            Promise.resolve(value).then(resolve, reject);
          });
        });
      };

      /* Prototype Methods */

      Promise.prototype['catch'] = function(onRejected) {
        return this.then(null, onRejected);
      };

      /***/
    },
    /* 23 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';
      /** @license React v16.2.0
 * react.production.min.js
 *
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

      var m = __webpack_require__(2),
        n = __webpack_require__(5),
        p = __webpack_require__(3),
        q = 'function' === typeof Symbol && Symbol['for'],
        r = q ? Symbol['for']('react.element') : 60103,
        t = q ? Symbol['for']('react.call') : 60104,
        u = q ? Symbol['for']('react.return') : 60105,
        v = q ? Symbol['for']('react.portal') : 60106,
        w = q ? Symbol['for']('react.fragment') : 60107,
        x = 'function' === typeof Symbol && Symbol.iterator;
      function y(a) {
        for (
          var b = arguments.length - 1,
            e =
              'Minified React error #' +
              a +
              '; visit http://facebook.github.io/react/docs/error-decoder.html?invariant\x3d' +
              a,
            c = 0;
          c < b;
          c++
        )
          e += '\x26args[]\x3d' + encodeURIComponent(arguments[c + 1]);
        b = Error(
          e +
            ' for the full message or use the non-minified dev environment for full errors and additional helpful warnings.'
        );
        b.name = 'Invariant Violation';
        b.framesToPop = 1;
        throw b;
      }
      var z = {
        isMounted: function() {
          return !1;
        },
        enqueueForceUpdate: function() {},
        enqueueReplaceState: function() {},
        enqueueSetState: function() {},
      };
      function A(a, b, e) {
        this.props = a;
        this.context = b;
        this.refs = n;
        this.updater = e || z;
      }
      A.prototype.isReactComponent = {};
      A.prototype.setState = function(a, b) {
        'object' !== typeof a && 'function' !== typeof a && null != a
          ? y('85')
          : void 0;
        this.updater.enqueueSetState(this, a, b, 'setState');
      };
      A.prototype.forceUpdate = function(a) {
        this.updater.enqueueForceUpdate(this, a, 'forceUpdate');
      };
      function B(a, b, e) {
        this.props = a;
        this.context = b;
        this.refs = n;
        this.updater = e || z;
      }
      function C() {}
      C.prototype = A.prototype;
      var D = (B.prototype = new C());
      D.constructor = B;
      m(D, A.prototype);
      D.isPureReactComponent = !0;
      function E(a, b, e) {
        this.props = a;
        this.context = b;
        this.refs = n;
        this.updater = e || z;
      }
      var F = (E.prototype = new C());
      F.constructor = E;
      m(F, A.prototype);
      F.unstable_isAsyncReactComponent = !0;
      F.render = function() {
        return this.props.children;
      };
      var G = { current: null },
        H = Object.prototype.hasOwnProperty,
        I = { key: !0, ref: !0, __self: !0, __source: !0 };
      function J(a, b, e) {
        var c,
          d = {},
          g = null,
          k = null;
        if (null != b)
          for (c in (void 0 !== b.ref && (k = b.ref),
          void 0 !== b.key && (g = '' + b.key),
          b))
            H.call(b, c) && !I.hasOwnProperty(c) && (d[c] = b[c]);
        var f = arguments.length - 2;
        if (1 === f) d.children = e;
        else if (1 < f) {
          for (var h = Array(f), l = 0; l < f; l++) h[l] = arguments[l + 2];
          d.children = h;
        }
        if (a && a.defaultProps)
          for (c in ((f = a.defaultProps), f)) void 0 === d[c] && (d[c] = f[c]);
        return {
          $$typeof: r,
          type: a,
          key: g,
          ref: k,
          props: d,
          _owner: G.current,
        };
      }
      function K(a) {
        return 'object' === typeof a && null !== a && a.$$typeof === r;
      }
      function escape(a) {
        var b = { '\x3d': '\x3d0', ':': '\x3d2' };
        return (
          '$' +
          ('' + a).replace(/[=:]/g, function(a) {
            return b[a];
          })
        );
      }
      var L = /\/+/g,
        M = [];
      function N(a, b, e, c) {
        if (M.length) {
          var d = M.pop();
          d.result = a;
          d.keyPrefix = b;
          d.func = e;
          d.context = c;
          d.count = 0;
          return d;
        }
        return { result: a, keyPrefix: b, func: e, context: c, count: 0 };
      }
      function O(a) {
        a.result = null;
        a.keyPrefix = null;
        a.func = null;
        a.context = null;
        a.count = 0;
        10 > M.length && M.push(a);
      }
      function P(a, b, e, c) {
        var d = typeof a;
        if ('undefined' === d || 'boolean' === d) a = null;
        var g = !1;
        if (null === a) g = !0;
        else
          switch (d) {
            case 'string':
            case 'number':
              g = !0;
              break;
            case 'object':
              switch (a.$$typeof) {
                case r:
                case t:
                case u:
                case v:
                  g = !0;
              }
          }
        if (g) return e(c, a, '' === b ? '.' + Q(a, 0) : b), 1;
        g = 0;
        b = '' === b ? '.' : b + ':';
        if (Array.isArray(a))
          for (var k = 0; k < a.length; k++) {
            d = a[k];
            var f = b + Q(d, k);
            g += P(d, f, e, c);
          }
        else if (
          (null === a || 'undefined' === typeof a
            ? (f = null)
            : ((f = (x && a[x]) || a['@@iterator']),
              (f = 'function' === typeof f ? f : null)),
          'function' === typeof f)
        )
          for (a = f.call(a), k = 0; !(d = a.next()).done; )
            (d = d.value), (f = b + Q(d, k++)), (g += P(d, f, e, c));
        else
          'object' === d &&
            ((e = '' + a),
            y(
              '31',
              '[object Object]' === e
                ? 'object with keys {' + Object.keys(a).join(', ') + '}'
                : e,
              ''
            ));
        return g;
      }
      function Q(a, b) {
        return 'object' === typeof a && null !== a && null != a.key
          ? escape(a.key)
          : b.toString(36);
      }
      function R(a, b) {
        a.func.call(a.context, b, a.count++);
      }
      function S(a, b, e) {
        var c = a.result,
          d = a.keyPrefix;
        a = a.func.call(a.context, b, a.count++);
        Array.isArray(a)
          ? T(a, c, e, p.thatReturnsArgument)
          : null != a &&
            (K(a) &&
              ((b =
                d +
                (!a.key || (b && b.key === a.key)
                  ? ''
                  : ('' + a.key).replace(L, '$\x26/') + '/') +
                e),
              (a = {
                $$typeof: r,
                type: a.type,
                key: b,
                ref: a.ref,
                props: a.props,
                _owner: a._owner,
              })),
            c.push(a));
      }
      function T(a, b, e, c, d) {
        var g = '';
        null != e && (g = ('' + e).replace(L, '$\x26/') + '/');
        b = N(b, g, c, d);
        null == a || P(a, '', S, b);
        O(b);
      }
      var U = {
          Children: {
            map: function(a, b, e) {
              if (null == a) return a;
              var c = [];
              T(a, c, null, b, e);
              return c;
            },
            forEach: function(a, b, e) {
              if (null == a) return a;
              b = N(null, null, b, e);
              null == a || P(a, '', R, b);
              O(b);
            },
            count: function(a) {
              return null == a ? 0 : P(a, '', p.thatReturnsNull, null);
            },
            toArray: function(a) {
              var b = [];
              T(a, b, null, p.thatReturnsArgument);
              return b;
            },
            only: function(a) {
              K(a) ? void 0 : y('143');
              return a;
            },
          },
          Component: A,
          PureComponent: B,
          unstable_AsyncComponent: E,
          Fragment: w,
          createElement: J,
          cloneElement: function(a, b, e) {
            var c = m({}, a.props),
              d = a.key,
              g = a.ref,
              k = a._owner;
            if (null != b) {
              void 0 !== b.ref && ((g = b.ref), (k = G.current));
              void 0 !== b.key && (d = '' + b.key);
              if (a.type && a.type.defaultProps) var f = a.type.defaultProps;
              for (h in b)
                H.call(b, h) &&
                  !I.hasOwnProperty(h) &&
                  (c[h] = void 0 === b[h] && void 0 !== f ? f[h] : b[h]);
            }
            var h = arguments.length - 2;
            if (1 === h) c.children = e;
            else if (1 < h) {
              f = Array(h);
              for (var l = 0; l < h; l++) f[l] = arguments[l + 2];
              c.children = f;
            }
            return {
              $$typeof: r,
              type: a.type,
              key: d,
              ref: g,
              props: c,
              _owner: k,
            };
          },
          createFactory: function(a) {
            var b = J.bind(null, a);
            b.type = a;
            return b;
          },
          isValidElement: K,
          version: '16.2.0',
          __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
            ReactCurrentOwner: G,
            assign: m,
          },
        },
        V = Object.freeze({ default: U }),
        W = (V && U) || V;
      module.exports = W['default'] ? W['default'] : W;

      /***/
    },
    /* 24 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      function checkDCE() {
        /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
        if (typeof {} === 'undefined' || typeof {}.checkDCE !== 'function') {
          return;
        }
        if (false) {
          // This branch is unreachable because this function is only called
          // in production, but the condition is true only in development.
          // Therefore if the branch is still here, dead code elimination wasn't
          // properly applied.
          // Don't change the message. React DevTools relies on it. Also make sure
          // this message doesn't occur elsewhere in this function, or it will cause
          // a false positive.
          throw new Error('^_^');
        }
        try {
          // Verify that the code above has been dead code eliminated (DCE'd).
          ({}.checkDCE(checkDCE));
        } catch (err) {
          // DevTools shouldn't crash React, no matter what.
          // We should still report in case we break this code.
          console.error(err);
        }
      }

      if (true) {
        // DCE check should happen before ReactDOM bundle executes so that
        // DevTools can report bad minification during injection.
        checkDCE();
        module.exports = __webpack_require__(25);
      } else {
        module.exports = require('./cjs/react-dom.development.js');
      }

      /***/
    },
    /* 25 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';
      /** @license React v16.2.0
 * react-dom.production.min.js
 *
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

      /*
 Modernizr 3.0.0pre (Custom Build) | MIT
*/
      var aa = __webpack_require__(0),
        l = __webpack_require__(26),
        B = __webpack_require__(2),
        C = __webpack_require__(3),
        ba = __webpack_require__(27),
        da = __webpack_require__(28),
        ea = __webpack_require__(29),
        fa = __webpack_require__(30),
        ia = __webpack_require__(33),
        D = __webpack_require__(5);
      function E(a) {
        for (
          var b = arguments.length - 1,
            c =
              'Minified React error #' +
              a +
              '; visit http://facebook.github.io/react/docs/error-decoder.html?invariant\x3d' +
              a,
            d = 0;
          d < b;
          d++
        )
          c += '\x26args[]\x3d' + encodeURIComponent(arguments[d + 1]);
        b = Error(
          c +
            ' for the full message or use the non-minified dev environment for full errors and additional helpful warnings.'
        );
        b.name = 'Invariant Violation';
        b.framesToPop = 1;
        throw b;
      }
      aa ? void 0 : E('227');
      var oa = {
        children: !0,
        dangerouslySetInnerHTML: !0,
        defaultValue: !0,
        defaultChecked: !0,
        innerHTML: !0,
        suppressContentEditableWarning: !0,
        suppressHydrationWarning: !0,
        style: !0,
      };
      function pa(a, b) {
        return (a & b) === b;
      }
      var ta = {
          MUST_USE_PROPERTY: 1,
          HAS_BOOLEAN_VALUE: 4,
          HAS_NUMERIC_VALUE: 8,
          HAS_POSITIVE_NUMERIC_VALUE: 24,
          HAS_OVERLOADED_BOOLEAN_VALUE: 32,
          HAS_STRING_BOOLEAN_VALUE: 64,
          injectDOMPropertyConfig: function(a) {
            var b = ta,
              c = a.Properties || {},
              d = a.DOMAttributeNamespaces || {},
              e = a.DOMAttributeNames || {};
            a = a.DOMMutationMethods || {};
            for (var f in c) {
              ua.hasOwnProperty(f) ? E('48', f) : void 0;
              var g = f.toLowerCase(),
                h = c[f];
              g = {
                attributeName: g,
                attributeNamespace: null,
                propertyName: f,
                mutationMethod: null,
                mustUseProperty: pa(h, b.MUST_USE_PROPERTY),
                hasBooleanValue: pa(h, b.HAS_BOOLEAN_VALUE),
                hasNumericValue: pa(h, b.HAS_NUMERIC_VALUE),
                hasPositiveNumericValue: pa(h, b.HAS_POSITIVE_NUMERIC_VALUE),
                hasOverloadedBooleanValue: pa(
                  h,
                  b.HAS_OVERLOADED_BOOLEAN_VALUE
                ),
                hasStringBooleanValue: pa(h, b.HAS_STRING_BOOLEAN_VALUE),
              };
              1 >=
              g.hasBooleanValue +
                g.hasNumericValue +
                g.hasOverloadedBooleanValue
                ? void 0
                : E('50', f);
              e.hasOwnProperty(f) && (g.attributeName = e[f]);
              d.hasOwnProperty(f) && (g.attributeNamespace = d[f]);
              a.hasOwnProperty(f) && (g.mutationMethod = a[f]);
              ua[f] = g;
            }
          },
        },
        ua = {};
      function va(a, b) {
        if (
          oa.hasOwnProperty(a) ||
          (2 < a.length &&
            ('o' === a[0] || 'O' === a[0]) &&
            ('n' === a[1] || 'N' === a[1]))
        )
          return !1;
        if (null === b) return !0;
        switch (typeof b) {
          case 'boolean':
            return (
              oa.hasOwnProperty(a)
                ? (a = !0)
                : (b = wa(a))
                  ? (a =
                      b.hasBooleanValue ||
                      b.hasStringBooleanValue ||
                      b.hasOverloadedBooleanValue)
                  : ((a = a.toLowerCase().slice(0, 5)),
                    (a = 'data-' === a || 'aria-' === a)),
              a
            );
          case 'undefined':
          case 'number':
          case 'string':
          case 'object':
            return !0;
          default:
            return !1;
        }
      }
      function wa(a) {
        return ua.hasOwnProperty(a) ? ua[a] : null;
      }
      var xa = ta,
        ya = xa.MUST_USE_PROPERTY,
        K = xa.HAS_BOOLEAN_VALUE,
        za = xa.HAS_NUMERIC_VALUE,
        Aa = xa.HAS_POSITIVE_NUMERIC_VALUE,
        Ba = xa.HAS_OVERLOADED_BOOLEAN_VALUE,
        Ca = xa.HAS_STRING_BOOLEAN_VALUE,
        Da = {
          Properties: {
            allowFullScreen: K,
            async: K,
            autoFocus: K,
            autoPlay: K,
            capture: Ba,
            checked: ya | K,
            cols: Aa,
            contentEditable: Ca,
            controls: K,
            default: K,
            defer: K,
            disabled: K,
            download: Ba,
            draggable: Ca,
            formNoValidate: K,
            hidden: K,
            loop: K,
            multiple: ya | K,
            muted: ya | K,
            noValidate: K,
            open: K,
            playsInline: K,
            readOnly: K,
            required: K,
            reversed: K,
            rows: Aa,
            rowSpan: za,
            scoped: K,
            seamless: K,
            selected: ya | K,
            size: Aa,
            start: za,
            span: Aa,
            spellCheck: Ca,
            style: 0,
            tabIndex: 0,
            itemScope: K,
            acceptCharset: 0,
            className: 0,
            htmlFor: 0,
            httpEquiv: 0,
            value: Ca,
          },
          DOMAttributeNames: {
            acceptCharset: 'accept-charset',
            className: 'class',
            htmlFor: 'for',
            httpEquiv: 'http-equiv',
          },
          DOMMutationMethods: {
            value: function(a, b) {
              if (null == b) return a.removeAttribute('value');
              'number' !== a.type || !1 === a.hasAttribute('value')
                ? a.setAttribute('value', '' + b)
                : a.validity &&
                  !a.validity.badInput &&
                  a.ownerDocument.activeElement !== a &&
                  a.setAttribute('value', '' + b);
            },
          },
        },
        Ea = xa.HAS_STRING_BOOLEAN_VALUE,
        M = {
          xlink: 'http://www.w3.org/1999/xlink',
          xml: 'http://www.w3.org/XML/1998/namespace',
        },
        Ga = {
          Properties: {
            autoReverse: Ea,
            externalResourcesRequired: Ea,
            preserveAlpha: Ea,
          },
          DOMAttributeNames: {
            autoReverse: 'autoReverse',
            externalResourcesRequired: 'externalResourcesRequired',
            preserveAlpha: 'preserveAlpha',
          },
          DOMAttributeNamespaces: {
            xlinkActuate: M.xlink,
            xlinkArcrole: M.xlink,
            xlinkHref: M.xlink,
            xlinkRole: M.xlink,
            xlinkShow: M.xlink,
            xlinkTitle: M.xlink,
            xlinkType: M.xlink,
            xmlBase: M.xml,
            xmlLang: M.xml,
            xmlSpace: M.xml,
          },
        },
        Ha = /[\-\:]([a-z])/g;
      function Ia(a) {
        return a[1].toUpperCase();
      }
      'accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode x-height xlink:actuate xlink:arcrole xlink:href xlink:role xlink:show xlink:title xlink:type xml:base xmlns:xlink xml:lang xml:space'
        .split(' ')
        .forEach(function(a) {
          var b = a.replace(Ha, Ia);
          Ga.Properties[b] = 0;
          Ga.DOMAttributeNames[b] = a;
        });
      xa.injectDOMPropertyConfig(Da);
      xa.injectDOMPropertyConfig(Ga);
      var P = {
        _caughtError: null,
        _hasCaughtError: !1,
        _rethrowError: null,
        _hasRethrowError: !1,
        injection: {
          injectErrorUtils: function(a) {
            'function' !== typeof a.invokeGuardedCallback ? E('197') : void 0;
            Ja = a.invokeGuardedCallback;
          },
        },
        invokeGuardedCallback: function(a, b, c, d, e, f, g, h, k) {
          Ja.apply(P, arguments);
        },
        invokeGuardedCallbackAndCatchFirstError: function(
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          k
        ) {
          P.invokeGuardedCallback.apply(this, arguments);
          if (P.hasCaughtError()) {
            var q = P.clearCaughtError();
            P._hasRethrowError ||
              ((P._hasRethrowError = !0), (P._rethrowError = q));
          }
        },
        rethrowCaughtError: function() {
          return Ka.apply(P, arguments);
        },
        hasCaughtError: function() {
          return P._hasCaughtError;
        },
        clearCaughtError: function() {
          if (P._hasCaughtError) {
            var a = P._caughtError;
            P._caughtError = null;
            P._hasCaughtError = !1;
            return a;
          }
          E('198');
        },
      };
      function Ja(a, b, c, d, e, f, g, h, k) {
        P._hasCaughtError = !1;
        P._caughtError = null;
        var q = Array.prototype.slice.call(arguments, 3);
        try {
          b.apply(c, q);
        } catch (v) {
          (P._caughtError = v), (P._hasCaughtError = !0);
        }
      }
      function Ka() {
        if (P._hasRethrowError) {
          var a = P._rethrowError;
          P._rethrowError = null;
          P._hasRethrowError = !1;
          throw a;
        }
      }
      var La = null,
        Ma = {};
      function Na() {
        if (La)
          for (var a in Ma) {
            var b = Ma[a],
              c = La.indexOf(a);
            -1 < c ? void 0 : E('96', a);
            if (!Oa[c]) {
              b.extractEvents ? void 0 : E('97', a);
              Oa[c] = b;
              c = b.eventTypes;
              for (var d in c) {
                var e = void 0;
                var f = c[d],
                  g = b,
                  h = d;
                Pa.hasOwnProperty(h) ? E('99', h) : void 0;
                Pa[h] = f;
                var k = f.phasedRegistrationNames;
                if (k) {
                  for (e in k) k.hasOwnProperty(e) && Qa(k[e], g, h);
                  e = !0;
                } else
                  f.registrationName
                    ? (Qa(f.registrationName, g, h), (e = !0))
                    : (e = !1);
                e ? void 0 : E('98', d, a);
              }
            }
          }
      }
      function Qa(a, b, c) {
        Ra[a] ? E('100', a) : void 0;
        Ra[a] = b;
        Sa[a] = b.eventTypes[c].dependencies;
      }
      var Oa = [],
        Pa = {},
        Ra = {},
        Sa = {};
      function Ta(a) {
        La ? E('101') : void 0;
        La = Array.prototype.slice.call(a);
        Na();
      }
      function Ua(a) {
        var b = !1,
          c;
        for (c in a)
          if (a.hasOwnProperty(c)) {
            var d = a[c];
            (Ma.hasOwnProperty(c) && Ma[c] === d) ||
              (Ma[c] ? E('102', c) : void 0, (Ma[c] = d), (b = !0));
          }
        b && Na();
      }
      var Va = Object.freeze({
          plugins: Oa,
          eventNameDispatchConfigs: Pa,
          registrationNameModules: Ra,
          registrationNameDependencies: Sa,
          possibleRegistrationNames: null,
          injectEventPluginOrder: Ta,
          injectEventPluginsByName: Ua,
        }),
        Wa = null,
        Xa = null,
        Ya = null;
      function Za(a, b, c, d) {
        b = a.type || 'unknown-event';
        a.currentTarget = Ya(d);
        P.invokeGuardedCallbackAndCatchFirstError(b, c, void 0, a);
        a.currentTarget = null;
      }
      function $a(a, b) {
        null == b ? E('30') : void 0;
        if (null == a) return b;
        if (Array.isArray(a)) {
          if (Array.isArray(b)) return a.push.apply(a, b), a;
          a.push(b);
          return a;
        }
        return Array.isArray(b) ? [a].concat(b) : [a, b];
      }
      function ab(a, b, c) {
        Array.isArray(a) ? a.forEach(b, c) : a && b.call(c, a);
      }
      var bb = null;
      function cb(a, b) {
        if (a) {
          var c = a._dispatchListeners,
            d = a._dispatchInstances;
          if (Array.isArray(c))
            for (var e = 0; e < c.length && !a.isPropagationStopped(); e++)
              Za(a, b, c[e], d[e]);
          else c && Za(a, b, c, d);
          a._dispatchListeners = null;
          a._dispatchInstances = null;
          a.isPersistent() || a.constructor.release(a);
        }
      }
      function db(a) {
        return cb(a, !0);
      }
      function gb(a) {
        return cb(a, !1);
      }
      var hb = { injectEventPluginOrder: Ta, injectEventPluginsByName: Ua };
      function ib(a, b) {
        var c = a.stateNode;
        if (!c) return null;
        var d = Wa(c);
        if (!d) return null;
        c = d[b];
        a: switch (b) {
          case 'onClick':
          case 'onClickCapture':
          case 'onDoubleClick':
          case 'onDoubleClickCapture':
          case 'onMouseDown':
          case 'onMouseDownCapture':
          case 'onMouseMove':
          case 'onMouseMoveCapture':
          case 'onMouseUp':
          case 'onMouseUpCapture':
            (d = !d.disabled) ||
              ((a = a.type),
              (d = !(
                'button' === a ||
                'input' === a ||
                'select' === a ||
                'textarea' === a
              )));
            a = !d;
            break a;
          default:
            a = !1;
        }
        if (a) return null;
        c && 'function' !== typeof c ? E('231', b, typeof c) : void 0;
        return c;
      }
      function jb(a, b, c, d) {
        for (var e, f = 0; f < Oa.length; f++) {
          var g = Oa[f];
          g && (g = g.extractEvents(a, b, c, d)) && (e = $a(e, g));
        }
        return e;
      }
      function kb(a) {
        a && (bb = $a(bb, a));
      }
      function lb(a) {
        var b = bb;
        bb = null;
        b &&
          (a ? ab(b, db) : ab(b, gb),
          bb ? E('95') : void 0,
          P.rethrowCaughtError());
      }
      var mb = Object.freeze({
          injection: hb,
          getListener: ib,
          extractEvents: jb,
          enqueueEvents: kb,
          processEventQueue: lb,
        }),
        nb = Math.random()
          .toString(36)
          .slice(2),
        Q = '__reactInternalInstance$' + nb,
        ob = '__reactEventHandlers$' + nb;
      function pb(a) {
        if (a[Q]) return a[Q];
        for (var b = []; !a[Q]; )
          if ((b.push(a), a.parentNode)) a = a.parentNode;
          else return null;
        var c = void 0,
          d = a[Q];
        if (5 === d.tag || 6 === d.tag) return d;
        for (; a && (d = a[Q]); a = b.pop()) c = d;
        return c;
      }
      function qb(a) {
        if (5 === a.tag || 6 === a.tag) return a.stateNode;
        E('33');
      }
      function rb(a) {
        return a[ob] || null;
      }
      var sb = Object.freeze({
        precacheFiberNode: function(a, b) {
          b[Q] = a;
        },
        getClosestInstanceFromNode: pb,
        getInstanceFromNode: function(a) {
          a = a[Q];
          return !a || (5 !== a.tag && 6 !== a.tag) ? null : a;
        },
        getNodeFromInstance: qb,
        getFiberCurrentPropsFromNode: rb,
        updateFiberProps: function(a, b) {
          a[ob] = b;
        },
      });
      function tb(a) {
        do a = a['return'];
        while (a && 5 !== a.tag);
        return a ? a : null;
      }
      function ub(a, b, c) {
        for (var d = []; a; ) d.push(a), (a = tb(a));
        for (a = d.length; 0 < a--; ) b(d[a], 'captured', c);
        for (a = 0; a < d.length; a++) b(d[a], 'bubbled', c);
      }
      function vb(a, b, c) {
        if ((b = ib(a, c.dispatchConfig.phasedRegistrationNames[b])))
          (c._dispatchListeners = $a(c._dispatchListeners, b)),
            (c._dispatchInstances = $a(c._dispatchInstances, a));
      }
      function wb(a) {
        a &&
          a.dispatchConfig.phasedRegistrationNames &&
          ub(a._targetInst, vb, a);
      }
      function xb(a) {
        if (a && a.dispatchConfig.phasedRegistrationNames) {
          var b = a._targetInst;
          b = b ? tb(b) : null;
          ub(b, vb, a);
        }
      }
      function yb(a, b, c) {
        a &&
          c &&
          c.dispatchConfig.registrationName &&
          (b = ib(a, c.dispatchConfig.registrationName)) &&
          ((c._dispatchListeners = $a(c._dispatchListeners, b)),
          (c._dispatchInstances = $a(c._dispatchInstances, a)));
      }
      function zb(a) {
        a && a.dispatchConfig.registrationName && yb(a._targetInst, null, a);
      }
      function Ab(a) {
        ab(a, wb);
      }
      function Bb(a, b, c, d) {
        if (c && d)
          a: {
            var e = c;
            for (var f = d, g = 0, h = e; h; h = tb(h)) g++;
            h = 0;
            for (var k = f; k; k = tb(k)) h++;
            for (; 0 < g - h; ) (e = tb(e)), g--;
            for (; 0 < h - g; ) (f = tb(f)), h--;
            for (; g--; ) {
              if (e === f || e === f.alternate) break a;
              e = tb(e);
              f = tb(f);
            }
            e = null;
          }
        else e = null;
        f = e;
        for (e = []; c && c !== f; ) {
          g = c.alternate;
          if (null !== g && g === f) break;
          e.push(c);
          c = tb(c);
        }
        for (c = []; d && d !== f; ) {
          g = d.alternate;
          if (null !== g && g === f) break;
          c.push(d);
          d = tb(d);
        }
        for (d = 0; d < e.length; d++) yb(e[d], 'bubbled', a);
        for (a = c.length; 0 < a--; ) yb(c[a], 'captured', b);
      }
      var Cb = Object.freeze({
          accumulateTwoPhaseDispatches: Ab,
          accumulateTwoPhaseDispatchesSkipTarget: function(a) {
            ab(a, xb);
          },
          accumulateEnterLeaveDispatches: Bb,
          accumulateDirectDispatches: function(a) {
            ab(a, zb);
          },
        }),
        Db = null;
      function Eb() {
        !Db &&
          l.canUseDOM &&
          (Db =
            'textContent' in document.documentElement
              ? 'textContent'
              : 'innerText');
        return Db;
      }
      var S = { _root: null, _startText: null, _fallbackText: null };
      function Fb() {
        if (S._fallbackText) return S._fallbackText;
        var a,
          b = S._startText,
          c = b.length,
          d,
          e = Gb(),
          f = e.length;
        for (a = 0; a < c && b[a] === e[a]; a++);
        var g = c - a;
        for (d = 1; d <= g && b[c - d] === e[f - d]; d++);
        S._fallbackText = e.slice(a, 1 < d ? 1 - d : void 0);
        return S._fallbackText;
      }
      function Gb() {
        return 'value' in S._root ? S._root.value : S._root[Eb()];
      }
      var Hb = 'dispatchConfig _targetInst nativeEvent isDefaultPrevented isPropagationStopped _dispatchListeners _dispatchInstances'.split(
          ' '
        ),
        Ib = {
          type: null,
          target: null,
          currentTarget: C.thatReturnsNull,
          eventPhase: null,
          bubbles: null,
          cancelable: null,
          timeStamp: function(a) {
            return a.timeStamp || Date.now();
          },
          defaultPrevented: null,
          isTrusted: null,
        };
      function T(a, b, c, d) {
        this.dispatchConfig = a;
        this._targetInst = b;
        this.nativeEvent = c;
        a = this.constructor.Interface;
        for (var e in a)
          a.hasOwnProperty(e) &&
            ((b = a[e])
              ? (this[e] = b(c))
              : 'target' === e ? (this.target = d) : (this[e] = c[e]));
        this.isDefaultPrevented = (null != c.defaultPrevented
        ? c.defaultPrevented
        : !1 === c.returnValue)
          ? C.thatReturnsTrue
          : C.thatReturnsFalse;
        this.isPropagationStopped = C.thatReturnsFalse;
        return this;
      }
      B(T.prototype, {
        preventDefault: function() {
          this.defaultPrevented = !0;
          var a = this.nativeEvent;
          a &&
            (a.preventDefault
              ? a.preventDefault()
              : 'unknown' !== typeof a.returnValue && (a.returnValue = !1),
            (this.isDefaultPrevented = C.thatReturnsTrue));
        },
        stopPropagation: function() {
          var a = this.nativeEvent;
          a &&
            (a.stopPropagation
              ? a.stopPropagation()
              : 'unknown' !== typeof a.cancelBubble && (a.cancelBubble = !0),
            (this.isPropagationStopped = C.thatReturnsTrue));
        },
        persist: function() {
          this.isPersistent = C.thatReturnsTrue;
        },
        isPersistent: C.thatReturnsFalse,
        destructor: function() {
          var a = this.constructor.Interface,
            b;
          for (b in a) this[b] = null;
          for (a = 0; a < Hb.length; a++) this[Hb[a]] = null;
        },
      });
      T.Interface = Ib;
      T.augmentClass = function(a, b) {
        function c() {}
        c.prototype = this.prototype;
        var d = new c();
        B(d, a.prototype);
        a.prototype = d;
        a.prototype.constructor = a;
        a.Interface = B({}, this.Interface, b);
        a.augmentClass = this.augmentClass;
        Jb(a);
      };
      Jb(T);
      function Kb(a, b, c, d) {
        if (this.eventPool.length) {
          var e = this.eventPool.pop();
          this.call(e, a, b, c, d);
          return e;
        }
        return new this(a, b, c, d);
      }
      function Lb(a) {
        a instanceof this ? void 0 : E('223');
        a.destructor();
        10 > this.eventPool.length && this.eventPool.push(a);
      }
      function Jb(a) {
        a.eventPool = [];
        a.getPooled = Kb;
        a.release = Lb;
      }
      function Mb(a, b, c, d) {
        return T.call(this, a, b, c, d);
      }
      T.augmentClass(Mb, { data: null });
      function Nb(a, b, c, d) {
        return T.call(this, a, b, c, d);
      }
      T.augmentClass(Nb, { data: null });
      var Pb = [9, 13, 27, 32],
        Vb = l.canUseDOM && 'CompositionEvent' in window,
        Wb = null;
      l.canUseDOM && 'documentMode' in document && (Wb = document.documentMode);
      var Xb;
      if ((Xb = l.canUseDOM && 'TextEvent' in window && !Wb)) {
        var Yb = window.opera;
        Xb = !(
          'object' === typeof Yb &&
          'function' === typeof Yb.version &&
          12 >= parseInt(Yb.version(), 10)
        );
      }
      var Zb = Xb,
        $b = l.canUseDOM && (!Vb || (Wb && 8 < Wb && 11 >= Wb)),
        ac = String.fromCharCode(32),
        bc = {
          beforeInput: {
            phasedRegistrationNames: {
              bubbled: 'onBeforeInput',
              captured: 'onBeforeInputCapture',
            },
            dependencies: [
              'topCompositionEnd',
              'topKeyPress',
              'topTextInput',
              'topPaste',
            ],
          },
          compositionEnd: {
            phasedRegistrationNames: {
              bubbled: 'onCompositionEnd',
              captured: 'onCompositionEndCapture',
            },
            dependencies: 'topBlur topCompositionEnd topKeyDown topKeyPress topKeyUp topMouseDown'.split(
              ' '
            ),
          },
          compositionStart: {
            phasedRegistrationNames: {
              bubbled: 'onCompositionStart',
              captured: 'onCompositionStartCapture',
            },
            dependencies: 'topBlur topCompositionStart topKeyDown topKeyPress topKeyUp topMouseDown'.split(
              ' '
            ),
          },
          compositionUpdate: {
            phasedRegistrationNames: {
              bubbled: 'onCompositionUpdate',
              captured: 'onCompositionUpdateCapture',
            },
            dependencies: 'topBlur topCompositionUpdate topKeyDown topKeyPress topKeyUp topMouseDown'.split(
              ' '
            ),
          },
        },
        cc = !1;
      function dc(a, b) {
        switch (a) {
          case 'topKeyUp':
            return -1 !== Pb.indexOf(b.keyCode);
          case 'topKeyDown':
            return 229 !== b.keyCode;
          case 'topKeyPress':
          case 'topMouseDown':
          case 'topBlur':
            return !0;
          default:
            return !1;
        }
      }
      function ec(a) {
        a = a.detail;
        return 'object' === typeof a && 'data' in a ? a.data : null;
      }
      var fc = !1;
      function gc(a, b) {
        switch (a) {
          case 'topCompositionEnd':
            return ec(b);
          case 'topKeyPress':
            if (32 !== b.which) return null;
            cc = !0;
            return ac;
          case 'topTextInput':
            return (a = b.data), a === ac && cc ? null : a;
          default:
            return null;
        }
      }
      function hc(a, b) {
        if (fc)
          return 'topCompositionEnd' === a || (!Vb && dc(a, b))
            ? ((a = Fb()),
              (S._root = null),
              (S._startText = null),
              (S._fallbackText = null),
              (fc = !1),
              a)
            : null;
        switch (a) {
          case 'topPaste':
            return null;
          case 'topKeyPress':
            if (
              !(b.ctrlKey || b.altKey || b.metaKey) ||
              (b.ctrlKey && b.altKey)
            ) {
              if (b.char && 1 < b.char.length) return b.char;
              if (b.which) return String.fromCharCode(b.which);
            }
            return null;
          case 'topCompositionEnd':
            return $b ? null : b.data;
          default:
            return null;
        }
      }
      var ic = {
          eventTypes: bc,
          extractEvents: function(a, b, c, d) {
            var e;
            if (Vb)
              b: {
                switch (a) {
                  case 'topCompositionStart':
                    var f = bc.compositionStart;
                    break b;
                  case 'topCompositionEnd':
                    f = bc.compositionEnd;
                    break b;
                  case 'topCompositionUpdate':
                    f = bc.compositionUpdate;
                    break b;
                }
                f = void 0;
              }
            else
              fc
                ? dc(a, c) && (f = bc.compositionEnd)
                : 'topKeyDown' === a &&
                  229 === c.keyCode &&
                  (f = bc.compositionStart);
            f
              ? ($b &&
                  (fc || f !== bc.compositionStart
                    ? f === bc.compositionEnd && fc && (e = Fb())
                    : ((S._root = d), (S._startText = Gb()), (fc = !0))),
                (f = Mb.getPooled(f, b, c, d)),
                e ? (f.data = e) : ((e = ec(c)), null !== e && (f.data = e)),
                Ab(f),
                (e = f))
              : (e = null);
            (a = Zb ? gc(a, c) : hc(a, c))
              ? ((b = Nb.getPooled(bc.beforeInput, b, c, d)),
                (b.data = a),
                Ab(b))
              : (b = null);
            return [e, b];
          },
        },
        jc = null,
        kc = null,
        lc = null;
      function mc(a) {
        if ((a = Xa(a))) {
          jc && 'function' === typeof jc.restoreControlledState
            ? void 0
            : E('194');
          var b = Wa(a.stateNode);
          jc.restoreControlledState(a.stateNode, a.type, b);
        }
      }
      var nc = {
        injectFiberControlledHostComponent: function(a) {
          jc = a;
        },
      };
      function oc(a) {
        kc ? (lc ? lc.push(a) : (lc = [a])) : (kc = a);
      }
      function pc() {
        if (kc) {
          var a = kc,
            b = lc;
          lc = kc = null;
          mc(a);
          if (b) for (a = 0; a < b.length; a++) mc(b[a]);
        }
      }
      var qc = Object.freeze({
        injection: nc,
        enqueueStateRestore: oc,
        restoreStateIfNeeded: pc,
      });
      function rc(a, b) {
        return a(b);
      }
      var sc = !1;
      function tc(a, b) {
        if (sc) return rc(a, b);
        sc = !0;
        try {
          return rc(a, b);
        } finally {
          (sc = !1), pc();
        }
      }
      var uc = {
        color: !0,
        date: !0,
        datetime: !0,
        'datetime-local': !0,
        email: !0,
        month: !0,
        number: !0,
        password: !0,
        range: !0,
        search: !0,
        tel: !0,
        text: !0,
        time: !0,
        url: !0,
        week: !0,
      };
      function vc(a) {
        var b = a && a.nodeName && a.nodeName.toLowerCase();
        return 'input' === b ? !!uc[a.type] : 'textarea' === b ? !0 : !1;
      }
      function wc(a) {
        a = a.target || a.srcElement || window;
        a.correspondingUseElement && (a = a.correspondingUseElement);
        return 3 === a.nodeType ? a.parentNode : a;
      }
      var xc;
      l.canUseDOM &&
        (xc =
          document.implementation &&
          document.implementation.hasFeature &&
          !0 !== document.implementation.hasFeature('', ''));
      function yc(a, b) {
        if (!l.canUseDOM || (b && !('addEventListener' in document))) return !1;
        b = 'on' + a;
        var c = b in document;
        c ||
          ((c = document.createElement('div')),
          c.setAttribute(b, 'return;'),
          (c = 'function' === typeof c[b]));
        !c &&
          xc &&
          'wheel' === a &&
          (c = document.implementation.hasFeature('Events.wheel', '3.0'));
        return c;
      }
      function zc(a) {
        var b = a.type;
        return (
          (a = a.nodeName) &&
          'input' === a.toLowerCase() &&
          ('checkbox' === b || 'radio' === b)
        );
      }
      function Ac(a) {
        var b = zc(a) ? 'checked' : 'value',
          c = Object.getOwnPropertyDescriptor(a.constructor.prototype, b),
          d = '' + a[b];
        if (
          !a.hasOwnProperty(b) &&
          'function' === typeof c.get &&
          'function' === typeof c.set
        )
          return (
            Object.defineProperty(a, b, {
              enumerable: c.enumerable,
              configurable: !0,
              get: function() {
                return c.get.call(this);
              },
              set: function(a) {
                d = '' + a;
                c.set.call(this, a);
              },
            }),
            {
              getValue: function() {
                return d;
              },
              setValue: function(a) {
                d = '' + a;
              },
              stopTracking: function() {
                a._valueTracker = null;
                delete a[b];
              },
            }
          );
      }
      function Bc(a) {
        a._valueTracker || (a._valueTracker = Ac(a));
      }
      function Cc(a) {
        if (!a) return !1;
        var b = a._valueTracker;
        if (!b) return !0;
        var c = b.getValue();
        var d = '';
        a && (d = zc(a) ? (a.checked ? 'true' : 'false') : a.value);
        a = d;
        return a !== c ? (b.setValue(a), !0) : !1;
      }
      var Dc = {
        change: {
          phasedRegistrationNames: {
            bubbled: 'onChange',
            captured: 'onChangeCapture',
          },
          dependencies: 'topBlur topChange topClick topFocus topInput topKeyDown topKeyUp topSelectionChange'.split(
            ' '
          ),
        },
      };
      function Ec(a, b, c) {
        a = T.getPooled(Dc.change, a, b, c);
        a.type = 'change';
        oc(c);
        Ab(a);
        return a;
      }
      var Fc = null,
        Gc = null;
      function Hc(a) {
        kb(a);
        lb(!1);
      }
      function Ic(a) {
        var b = qb(a);
        if (Cc(b)) return a;
      }
      function Jc(a, b) {
        if ('topChange' === a) return b;
      }
      var Kc = !1;
      l.canUseDOM &&
        (Kc =
          yc('input') && (!document.documentMode || 9 < document.documentMode));
      function Lc() {
        Fc && (Fc.detachEvent('onpropertychange', Mc), (Gc = Fc = null));
      }
      function Mc(a) {
        'value' === a.propertyName &&
          Ic(Gc) &&
          ((a = Ec(Gc, a, wc(a))), tc(Hc, a));
      }
      function Nc(a, b, c) {
        'topFocus' === a
          ? (Lc(), (Fc = b), (Gc = c), Fc.attachEvent('onpropertychange', Mc))
          : 'topBlur' === a && Lc();
      }
      function Oc(a) {
        if (
          'topSelectionChange' === a ||
          'topKeyUp' === a ||
          'topKeyDown' === a
        )
          return Ic(Gc);
      }
      function Pc(a, b) {
        if ('topClick' === a) return Ic(b);
      }
      function $c(a, b) {
        if ('topInput' === a || 'topChange' === a) return Ic(b);
      }
      var ad = {
        eventTypes: Dc,
        _isInputEventSupported: Kc,
        extractEvents: function(a, b, c, d) {
          var e = b ? qb(b) : window,
            f = e.nodeName && e.nodeName.toLowerCase();
          if ('select' === f || ('input' === f && 'file' === e.type))
            var g = Jc;
          else if (vc(e))
            if (Kc) g = $c;
            else {
              g = Oc;
              var h = Nc;
            }
          else
            (f = e.nodeName),
              !f ||
                'input' !== f.toLowerCase() ||
                ('checkbox' !== e.type && 'radio' !== e.type) ||
                (g = Pc);
          if (g && (g = g(a, b))) return Ec(g, c, d);
          h && h(a, e, b);
          'topBlur' === a &&
            null != b &&
            (a = b._wrapperState || e._wrapperState) &&
            a.controlled &&
            'number' === e.type &&
            ((a = '' + e.value),
            e.getAttribute('value') !== a && e.setAttribute('value', a));
        },
      };
      function bd(a, b, c, d) {
        return T.call(this, a, b, c, d);
      }
      T.augmentClass(bd, { view: null, detail: null });
      var cd = {
        Alt: 'altKey',
        Control: 'ctrlKey',
        Meta: 'metaKey',
        Shift: 'shiftKey',
      };
      function dd(a) {
        var b = this.nativeEvent;
        return b.getModifierState
          ? b.getModifierState(a)
          : (a = cd[a]) ? !!b[a] : !1;
      }
      function ed() {
        return dd;
      }
      function fd(a, b, c, d) {
        return T.call(this, a, b, c, d);
      }
      bd.augmentClass(fd, {
        screenX: null,
        screenY: null,
        clientX: null,
        clientY: null,
        pageX: null,
        pageY: null,
        ctrlKey: null,
        shiftKey: null,
        altKey: null,
        metaKey: null,
        getModifierState: ed,
        button: null,
        buttons: null,
        relatedTarget: function(a) {
          return (
            a.relatedTarget ||
            (a.fromElement === a.srcElement ? a.toElement : a.fromElement)
          );
        },
      });
      var gd = {
          mouseEnter: {
            registrationName: 'onMouseEnter',
            dependencies: ['topMouseOut', 'topMouseOver'],
          },
          mouseLeave: {
            registrationName: 'onMouseLeave',
            dependencies: ['topMouseOut', 'topMouseOver'],
          },
        },
        hd = {
          eventTypes: gd,
          extractEvents: function(a, b, c, d) {
            if (
              ('topMouseOver' === a && (c.relatedTarget || c.fromElement)) ||
              ('topMouseOut' !== a && 'topMouseOver' !== a)
            )
              return null;
            var e =
              d.window === d
                ? d
                : (e = d.ownerDocument)
                  ? e.defaultView || e.parentWindow
                  : window;
            'topMouseOut' === a
              ? ((a = b),
                (b = (b = c.relatedTarget || c.toElement) ? pb(b) : null))
              : (a = null);
            if (a === b) return null;
            var f = null == a ? e : qb(a);
            e = null == b ? e : qb(b);
            var g = fd.getPooled(gd.mouseLeave, a, c, d);
            g.type = 'mouseleave';
            g.target = f;
            g.relatedTarget = e;
            c = fd.getPooled(gd.mouseEnter, b, c, d);
            c.type = 'mouseenter';
            c.target = e;
            c.relatedTarget = f;
            Bb(g, c, a, b);
            return [g, c];
          },
        },
        id =
          aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
            .ReactCurrentOwner;
      function jd(a) {
        a = a.type;
        return 'string' === typeof a
          ? a
          : 'function' === typeof a ? a.displayName || a.name : null;
      }
      function kd(a) {
        var b = a;
        if (a.alternate) for (; b['return']; ) b = b['return'];
        else {
          if (0 !== (b.effectTag & 2)) return 1;
          for (; b['return']; )
            if (((b = b['return']), 0 !== (b.effectTag & 2))) return 1;
        }
        return 3 === b.tag ? 2 : 3;
      }
      function ld(a) {
        return (a = a._reactInternalFiber) ? 2 === kd(a) : !1;
      }
      function md(a) {
        2 !== kd(a) ? E('188') : void 0;
      }
      function nd(a) {
        var b = a.alternate;
        if (!b)
          return (b = kd(a)), 3 === b ? E('188') : void 0, 1 === b ? null : a;
        for (var c = a, d = b; ; ) {
          var e = c['return'],
            f = e ? e.alternate : null;
          if (!e || !f) break;
          if (e.child === f.child) {
            for (var g = e.child; g; ) {
              if (g === c) return md(e), a;
              if (g === d) return md(e), b;
              g = g.sibling;
            }
            E('188');
          }
          if (c['return'] !== d['return']) (c = e), (d = f);
          else {
            g = !1;
            for (var h = e.child; h; ) {
              if (h === c) {
                g = !0;
                c = e;
                d = f;
                break;
              }
              if (h === d) {
                g = !0;
                d = e;
                c = f;
                break;
              }
              h = h.sibling;
            }
            if (!g) {
              for (h = f.child; h; ) {
                if (h === c) {
                  g = !0;
                  c = f;
                  d = e;
                  break;
                }
                if (h === d) {
                  g = !0;
                  d = f;
                  c = e;
                  break;
                }
                h = h.sibling;
              }
              g ? void 0 : E('189');
            }
          }
          c.alternate !== d ? E('190') : void 0;
        }
        3 !== c.tag ? E('188') : void 0;
        return c.stateNode.current === c ? a : b;
      }
      function od(a) {
        a = nd(a);
        if (!a) return null;
        for (var b = a; ; ) {
          if (5 === b.tag || 6 === b.tag) return b;
          if (b.child) (b.child['return'] = b), (b = b.child);
          else {
            if (b === a) break;
            for (; !b.sibling; ) {
              if (!b['return'] || b['return'] === a) return null;
              b = b['return'];
            }
            b.sibling['return'] = b['return'];
            b = b.sibling;
          }
        }
        return null;
      }
      function pd(a) {
        a = nd(a);
        if (!a) return null;
        for (var b = a; ; ) {
          if (5 === b.tag || 6 === b.tag) return b;
          if (b.child && 4 !== b.tag) (b.child['return'] = b), (b = b.child);
          else {
            if (b === a) break;
            for (; !b.sibling; ) {
              if (!b['return'] || b['return'] === a) return null;
              b = b['return'];
            }
            b.sibling['return'] = b['return'];
            b = b.sibling;
          }
        }
        return null;
      }
      var qd = [];
      function rd(a) {
        var b = a.targetInst;
        do {
          if (!b) {
            a.ancestors.push(b);
            break;
          }
          var c;
          for (c = b; c['return']; ) c = c['return'];
          c = 3 !== c.tag ? null : c.stateNode.containerInfo;
          if (!c) break;
          a.ancestors.push(b);
          b = pb(c);
        } while (b);
        for (c = 0; c < a.ancestors.length; c++)
          (b = a.ancestors[c]),
            sd(a.topLevelType, b, a.nativeEvent, wc(a.nativeEvent));
      }
      var td = !0,
        sd = void 0;
      function ud(a) {
        td = !!a;
      }
      function U(a, b, c) {
        return c ? ba.listen(c, b, vd.bind(null, a)) : null;
      }
      function wd(a, b, c) {
        return c ? ba.capture(c, b, vd.bind(null, a)) : null;
      }
      function vd(a, b) {
        if (td) {
          var c = wc(b);
          c = pb(c);
          null === c || 'number' !== typeof c.tag || 2 === kd(c) || (c = null);
          if (qd.length) {
            var d = qd.pop();
            d.topLevelType = a;
            d.nativeEvent = b;
            d.targetInst = c;
            a = d;
          } else
            a = {
              topLevelType: a,
              nativeEvent: b,
              targetInst: c,
              ancestors: [],
            };
          try {
            tc(rd, a);
          } finally {
            (a.topLevelType = null),
              (a.nativeEvent = null),
              (a.targetInst = null),
              (a.ancestors.length = 0),
              10 > qd.length && qd.push(a);
          }
        }
      }
      var xd = Object.freeze({
        get _enabled() {
          return td;
        },
        get _handleTopLevel() {
          return sd;
        },
        setHandleTopLevel: function(a) {
          sd = a;
        },
        setEnabled: ud,
        isEnabled: function() {
          return td;
        },
        trapBubbledEvent: U,
        trapCapturedEvent: wd,
        dispatchEvent: vd,
      });
      function yd(a, b) {
        var c = {};
        c[a.toLowerCase()] = b.toLowerCase();
        c['Webkit' + a] = 'webkit' + b;
        c['Moz' + a] = 'moz' + b;
        c['ms' + a] = 'MS' + b;
        c['O' + a] = 'o' + b.toLowerCase();
        return c;
      }
      var zd = {
          animationend: yd('Animation', 'AnimationEnd'),
          animationiteration: yd('Animation', 'AnimationIteration'),
          animationstart: yd('Animation', 'AnimationStart'),
          transitionend: yd('Transition', 'TransitionEnd'),
        },
        Ad = {},
        Bd = {};
      l.canUseDOM &&
        ((Bd = document.createElement('div').style),
        'AnimationEvent' in window ||
          (delete zd.animationend.animation,
          delete zd.animationiteration.animation,
          delete zd.animationstart.animation),
        'TransitionEvent' in window || delete zd.transitionend.transition);
      function Cd(a) {
        if (Ad[a]) return Ad[a];
        if (!zd[a]) return a;
        var b = zd[a],
          c;
        for (c in b) if (b.hasOwnProperty(c) && c in Bd) return (Ad[a] = b[c]);
        return '';
      }
      var Dd = {
          topAbort: 'abort',
          topAnimationEnd: Cd('animationend') || 'animationend',
          topAnimationIteration:
            Cd('animationiteration') || 'animationiteration',
          topAnimationStart: Cd('animationstart') || 'animationstart',
          topBlur: 'blur',
          topCancel: 'cancel',
          topCanPlay: 'canplay',
          topCanPlayThrough: 'canplaythrough',
          topChange: 'change',
          topClick: 'click',
          topClose: 'close',
          topCompositionEnd: 'compositionend',
          topCompositionStart: 'compositionstart',
          topCompositionUpdate: 'compositionupdate',
          topContextMenu: 'contextmenu',
          topCopy: 'copy',
          topCut: 'cut',
          topDoubleClick: 'dblclick',
          topDrag: 'drag',
          topDragEnd: 'dragend',
          topDragEnter: 'dragenter',
          topDragExit: 'dragexit',
          topDragLeave: 'dragleave',
          topDragOver: 'dragover',
          topDragStart: 'dragstart',
          topDrop: 'drop',
          topDurationChange: 'durationchange',
          topEmptied: 'emptied',
          topEncrypted: 'encrypted',
          topEnded: 'ended',
          topError: 'error',
          topFocus: 'focus',
          topInput: 'input',
          topKeyDown: 'keydown',
          topKeyPress: 'keypress',
          topKeyUp: 'keyup',
          topLoadedData: 'loadeddata',
          topLoad: 'load',
          topLoadedMetadata: 'loadedmetadata',
          topLoadStart: 'loadstart',
          topMouseDown: 'mousedown',
          topMouseMove: 'mousemove',
          topMouseOut: 'mouseout',
          topMouseOver: 'mouseover',
          topMouseUp: 'mouseup',
          topPaste: 'paste',
          topPause: 'pause',
          topPlay: 'play',
          topPlaying: 'playing',
          topProgress: 'progress',
          topRateChange: 'ratechange',
          topScroll: 'scroll',
          topSeeked: 'seeked',
          topSeeking: 'seeking',
          topSelectionChange: 'selectionchange',
          topStalled: 'stalled',
          topSuspend: 'suspend',
          topTextInput: 'textInput',
          topTimeUpdate: 'timeupdate',
          topToggle: 'toggle',
          topTouchCancel: 'touchcancel',
          topTouchEnd: 'touchend',
          topTouchMove: 'touchmove',
          topTouchStart: 'touchstart',
          topTransitionEnd: Cd('transitionend') || 'transitionend',
          topVolumeChange: 'volumechange',
          topWaiting: 'waiting',
          topWheel: 'wheel',
        },
        Ed = {},
        Fd = 0,
        Gd = '_reactListenersID' + ('' + Math.random()).slice(2);
      function Hd(a) {
        Object.prototype.hasOwnProperty.call(a, Gd) ||
          ((a[Gd] = Fd++), (Ed[a[Gd]] = {}));
        return Ed[a[Gd]];
      }
      function Id(a) {
        for (; a && a.firstChild; ) a = a.firstChild;
        return a;
      }
      function Jd(a, b) {
        var c = Id(a);
        a = 0;
        for (var d; c; ) {
          if (3 === c.nodeType) {
            d = a + c.textContent.length;
            if (a <= b && d >= b) return { node: c, offset: b - a };
            a = d;
          }
          a: {
            for (; c; ) {
              if (c.nextSibling) {
                c = c.nextSibling;
                break a;
              }
              c = c.parentNode;
            }
            c = void 0;
          }
          c = Id(c);
        }
      }
      function Kd(a) {
        var b = a && a.nodeName && a.nodeName.toLowerCase();
        return (
          b &&
          (('input' === b && 'text' === a.type) ||
            'textarea' === b ||
            'true' === a.contentEditable)
        );
      }
      var Ld =
          l.canUseDOM &&
          'documentMode' in document &&
          11 >= document.documentMode,
        Md = {
          select: {
            phasedRegistrationNames: {
              bubbled: 'onSelect',
              captured: 'onSelectCapture',
            },
            dependencies: 'topBlur topContextMenu topFocus topKeyDown topKeyUp topMouseDown topMouseUp topSelectionChange'.split(
              ' '
            ),
          },
        },
        Nd = null,
        Od = null,
        Pd = null,
        Qd = !1;
      function Rd(a, b) {
        if (Qd || null == Nd || Nd !== da()) return null;
        var c = Nd;
        'selectionStart' in c && Kd(c)
          ? (c = { start: c.selectionStart, end: c.selectionEnd })
          : window.getSelection
            ? ((c = window.getSelection()),
              (c = {
                anchorNode: c.anchorNode,
                anchorOffset: c.anchorOffset,
                focusNode: c.focusNode,
                focusOffset: c.focusOffset,
              }))
            : (c = void 0);
        return Pd && ea(Pd, c)
          ? null
          : ((Pd = c),
            (a = T.getPooled(Md.select, Od, a, b)),
            (a.type = 'select'),
            (a.target = Nd),
            Ab(a),
            a);
      }
      var Sd = {
        eventTypes: Md,
        extractEvents: function(a, b, c, d) {
          var e =
              d.window === d
                ? d.document
                : 9 === d.nodeType ? d : d.ownerDocument,
            f;
          if (!(f = !e)) {
            a: {
              e = Hd(e);
              f = Sa.onSelect;
              for (var g = 0; g < f.length; g++) {
                var h = f[g];
                if (!e.hasOwnProperty(h) || !e[h]) {
                  e = !1;
                  break a;
                }
              }
              e = !0;
            }
            f = !e;
          }
          if (f) return null;
          e = b ? qb(b) : window;
          switch (a) {
            case 'topFocus':
              if (vc(e) || 'true' === e.contentEditable)
                (Nd = e), (Od = b), (Pd = null);
              break;
            case 'topBlur':
              Pd = Od = Nd = null;
              break;
            case 'topMouseDown':
              Qd = !0;
              break;
            case 'topContextMenu':
            case 'topMouseUp':
              return (Qd = !1), Rd(c, d);
            case 'topSelectionChange':
              if (Ld) break;
            case 'topKeyDown':
            case 'topKeyUp':
              return Rd(c, d);
          }
          return null;
        },
      };
      function Td(a, b, c, d) {
        return T.call(this, a, b, c, d);
      }
      T.augmentClass(Td, {
        animationName: null,
        elapsedTime: null,
        pseudoElement: null,
      });
      function Ud(a, b, c, d) {
        return T.call(this, a, b, c, d);
      }
      T.augmentClass(Ud, {
        clipboardData: function(a) {
          return 'clipboardData' in a ? a.clipboardData : window.clipboardData;
        },
      });
      function Vd(a, b, c, d) {
        return T.call(this, a, b, c, d);
      }
      bd.augmentClass(Vd, { relatedTarget: null });
      function Wd(a) {
        var b = a.keyCode;
        'charCode' in a
          ? ((a = a.charCode), 0 === a && 13 === b && (a = 13))
          : (a = b);
        return 32 <= a || 13 === a ? a : 0;
      }
      var Xd = {
          Esc: 'Escape',
          Spacebar: ' ',
          Left: 'ArrowLeft',
          Up: 'ArrowUp',
          Right: 'ArrowRight',
          Down: 'ArrowDown',
          Del: 'Delete',
          Win: 'OS',
          Menu: 'ContextMenu',
          Apps: 'ContextMenu',
          Scroll: 'ScrollLock',
          MozPrintableKey: 'Unidentified',
        },
        Yd = {
          8: 'Backspace',
          9: 'Tab',
          12: 'Clear',
          13: 'Enter',
          16: 'Shift',
          17: 'Control',
          18: 'Alt',
          19: 'Pause',
          20: 'CapsLock',
          27: 'Escape',
          32: ' ',
          33: 'PageUp',
          34: 'PageDown',
          35: 'End',
          36: 'Home',
          37: 'ArrowLeft',
          38: 'ArrowUp',
          39: 'ArrowRight',
          40: 'ArrowDown',
          45: 'Insert',
          46: 'Delete',
          112: 'F1',
          113: 'F2',
          114: 'F3',
          115: 'F4',
          116: 'F5',
          117: 'F6',
          118: 'F7',
          119: 'F8',
          120: 'F9',
          121: 'F10',
          122: 'F11',
          123: 'F12',
          144: 'NumLock',
          145: 'ScrollLock',
          224: 'Meta',
        };
      function Zd(a, b, c, d) {
        return T.call(this, a, b, c, d);
      }
      bd.augmentClass(Zd, {
        key: function(a) {
          if (a.key) {
            var b = Xd[a.key] || a.key;
            if ('Unidentified' !== b) return b;
          }
          return 'keypress' === a.type
            ? ((a = Wd(a)), 13 === a ? 'Enter' : String.fromCharCode(a))
            : 'keydown' === a.type || 'keyup' === a.type
              ? Yd[a.keyCode] || 'Unidentified'
              : '';
        },
        location: null,
        ctrlKey: null,
        shiftKey: null,
        altKey: null,
        metaKey: null,
        repeat: null,
        locale: null,
        getModifierState: ed,
        charCode: function(a) {
          return 'keypress' === a.type ? Wd(a) : 0;
        },
        keyCode: function(a) {
          return 'keydown' === a.type || 'keyup' === a.type ? a.keyCode : 0;
        },
        which: function(a) {
          return 'keypress' === a.type
            ? Wd(a)
            : 'keydown' === a.type || 'keyup' === a.type ? a.keyCode : 0;
        },
      });
      function $d(a, b, c, d) {
        return T.call(this, a, b, c, d);
      }
      fd.augmentClass($d, { dataTransfer: null });
      function ae(a, b, c, d) {
        return T.call(this, a, b, c, d);
      }
      bd.augmentClass(ae, {
        touches: null,
        targetTouches: null,
        changedTouches: null,
        altKey: null,
        metaKey: null,
        ctrlKey: null,
        shiftKey: null,
        getModifierState: ed,
      });
      function be(a, b, c, d) {
        return T.call(this, a, b, c, d);
      }
      T.augmentClass(be, {
        propertyName: null,
        elapsedTime: null,
        pseudoElement: null,
      });
      function ce(a, b, c, d) {
        return T.call(this, a, b, c, d);
      }
      fd.augmentClass(ce, {
        deltaX: function(a) {
          return 'deltaX' in a
            ? a.deltaX
            : 'wheelDeltaX' in a ? -a.wheelDeltaX : 0;
        },
        deltaY: function(a) {
          return 'deltaY' in a
            ? a.deltaY
            : 'wheelDeltaY' in a
              ? -a.wheelDeltaY
              : 'wheelDelta' in a ? -a.wheelDelta : 0;
        },
        deltaZ: null,
        deltaMode: null,
      });
      var de = {},
        ee = {};
      'abort animationEnd animationIteration animationStart blur cancel canPlay canPlayThrough click close contextMenu copy cut doubleClick drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error focus input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing progress rateChange reset scroll seeked seeking stalled submit suspend timeUpdate toggle touchCancel touchEnd touchMove touchStart transitionEnd volumeChange waiting wheel'
        .split(' ')
        .forEach(function(a) {
          var b = a[0].toUpperCase() + a.slice(1),
            c = 'on' + b;
          b = 'top' + b;
          c = {
            phasedRegistrationNames: { bubbled: c, captured: c + 'Capture' },
            dependencies: [b],
          };
          de[a] = c;
          ee[b] = c;
        });
      var fe = {
        eventTypes: de,
        extractEvents: function(a, b, c, d) {
          var e = ee[a];
          if (!e) return null;
          switch (a) {
            case 'topKeyPress':
              if (0 === Wd(c)) return null;
            case 'topKeyDown':
            case 'topKeyUp':
              a = Zd;
              break;
            case 'topBlur':
            case 'topFocus':
              a = Vd;
              break;
            case 'topClick':
              if (2 === c.button) return null;
            case 'topDoubleClick':
            case 'topMouseDown':
            case 'topMouseMove':
            case 'topMouseUp':
            case 'topMouseOut':
            case 'topMouseOver':
            case 'topContextMenu':
              a = fd;
              break;
            case 'topDrag':
            case 'topDragEnd':
            case 'topDragEnter':
            case 'topDragExit':
            case 'topDragLeave':
            case 'topDragOver':
            case 'topDragStart':
            case 'topDrop':
              a = $d;
              break;
            case 'topTouchCancel':
            case 'topTouchEnd':
            case 'topTouchMove':
            case 'topTouchStart':
              a = ae;
              break;
            case 'topAnimationEnd':
            case 'topAnimationIteration':
            case 'topAnimationStart':
              a = Td;
              break;
            case 'topTransitionEnd':
              a = be;
              break;
            case 'topScroll':
              a = bd;
              break;
            case 'topWheel':
              a = ce;
              break;
            case 'topCopy':
            case 'topCut':
            case 'topPaste':
              a = Ud;
              break;
            default:
              a = T;
          }
          b = a.getPooled(e, b, c, d);
          Ab(b);
          return b;
        },
      };
      sd = function(a, b, c, d) {
        a = jb(a, b, c, d);
        kb(a);
        lb(!1);
      };
      hb.injectEventPluginOrder(
        'ResponderEventPlugin SimpleEventPlugin TapEventPlugin EnterLeaveEventPlugin ChangeEventPlugin SelectEventPlugin BeforeInputEventPlugin'.split(
          ' '
        )
      );
      Wa = sb.getFiberCurrentPropsFromNode;
      Xa = sb.getInstanceFromNode;
      Ya = sb.getNodeFromInstance;
      hb.injectEventPluginsByName({
        SimpleEventPlugin: fe,
        EnterLeaveEventPlugin: hd,
        ChangeEventPlugin: ad,
        SelectEventPlugin: Sd,
        BeforeInputEventPlugin: ic,
      });
      var ge = [],
        he = -1;
      function V(a) {
        0 > he || ((a.current = ge[he]), (ge[he] = null), he--);
      }
      function W(a, b) {
        he++;
        ge[he] = a.current;
        a.current = b;
      }
      new Set();
      var ie = { current: D },
        X = { current: !1 },
        je = D;
      function ke(a) {
        return le(a) ? je : ie.current;
      }
      function me(a, b) {
        var c = a.type.contextTypes;
        if (!c) return D;
        var d = a.stateNode;
        if (d && d.__reactInternalMemoizedUnmaskedChildContext === b)
          return d.__reactInternalMemoizedMaskedChildContext;
        var e = {},
          f;
        for (f in c) e[f] = b[f];
        d &&
          ((a = a.stateNode),
          (a.__reactInternalMemoizedUnmaskedChildContext = b),
          (a.__reactInternalMemoizedMaskedChildContext = e));
        return e;
      }
      function le(a) {
        return 2 === a.tag && null != a.type.childContextTypes;
      }
      function ne(a) {
        le(a) && (V(X, a), V(ie, a));
      }
      function oe(a, b, c) {
        null != ie.cursor ? E('168') : void 0;
        W(ie, b, a);
        W(X, c, a);
      }
      function pe(a, b) {
        var c = a.stateNode,
          d = a.type.childContextTypes;
        if ('function' !== typeof c.getChildContext) return b;
        c = c.getChildContext();
        for (var e in c) e in d ? void 0 : E('108', jd(a) || 'Unknown', e);
        return B({}, b, c);
      }
      function qe(a) {
        if (!le(a)) return !1;
        var b = a.stateNode;
        b = (b && b.__reactInternalMemoizedMergedChildContext) || D;
        je = ie.current;
        W(ie, b, a);
        W(X, X.current, a);
        return !0;
      }
      function re(a, b) {
        var c = a.stateNode;
        c ? void 0 : E('169');
        if (b) {
          var d = pe(a, je);
          c.__reactInternalMemoizedMergedChildContext = d;
          V(X, a);
          V(ie, a);
          W(ie, d, a);
        } else V(X, a);
        W(X, b, a);
      }
      function Y(a, b, c) {
        this.tag = a;
        this.key = b;
        this.stateNode = this.type = null;
        this.sibling = this.child = this['return'] = null;
        this.index = 0;
        this.memoizedState = this.updateQueue = this.memoizedProps = this.pendingProps = this.ref = null;
        this.internalContextTag = c;
        this.effectTag = 0;
        this.lastEffect = this.firstEffect = this.nextEffect = null;
        this.expirationTime = 0;
        this.alternate = null;
      }
      function se(a, b, c) {
        var d = a.alternate;
        null === d
          ? ((d = new Y(a.tag, a.key, a.internalContextTag)),
            (d.type = a.type),
            (d.stateNode = a.stateNode),
            (d.alternate = a),
            (a.alternate = d))
          : ((d.effectTag = 0),
            (d.nextEffect = null),
            (d.firstEffect = null),
            (d.lastEffect = null));
        d.expirationTime = c;
        d.pendingProps = b;
        d.child = a.child;
        d.memoizedProps = a.memoizedProps;
        d.memoizedState = a.memoizedState;
        d.updateQueue = a.updateQueue;
        d.sibling = a.sibling;
        d.index = a.index;
        d.ref = a.ref;
        return d;
      }
      function te(a, b, c) {
        var d = void 0,
          e = a.type,
          f = a.key;
        'function' === typeof e
          ? ((d =
              e.prototype && e.prototype.isReactComponent
                ? new Y(2, f, b)
                : new Y(0, f, b)),
            (d.type = e),
            (d.pendingProps = a.props))
          : 'string' === typeof e
            ? ((d = new Y(5, f, b)), (d.type = e), (d.pendingProps = a.props))
            : 'object' === typeof e && null !== e && 'number' === typeof e.tag
              ? ((d = e), (d.pendingProps = a.props))
              : E('130', null == e ? e : typeof e, '');
        d.expirationTime = c;
        return d;
      }
      function ue(a, b, c, d) {
        b = new Y(10, d, b);
        b.pendingProps = a;
        b.expirationTime = c;
        return b;
      }
      function ve(a, b, c) {
        b = new Y(6, null, b);
        b.pendingProps = a;
        b.expirationTime = c;
        return b;
      }
      function we(a, b, c) {
        b = new Y(7, a.key, b);
        b.type = a.handler;
        b.pendingProps = a;
        b.expirationTime = c;
        return b;
      }
      function xe(a, b, c) {
        a = new Y(9, null, b);
        a.expirationTime = c;
        return a;
      }
      function ye(a, b, c) {
        b = new Y(4, a.key, b);
        b.pendingProps = a.children || [];
        b.expirationTime = c;
        b.stateNode = {
          containerInfo: a.containerInfo,
          pendingChildren: null,
          implementation: a.implementation,
        };
        return b;
      }
      var ze = null,
        Ae = null;
      function Be(a) {
        return function(b) {
          try {
            return a(b);
          } catch (c) {}
        };
      }
      function Ce(a) {
        if ('undefined' === typeof {}) return !1;
        var b = {};
        if (b.isDisabled || !b.supportsFiber) return !0;
        try {
          var c = b.inject(a);
          ze = Be(function(a) {
            return b.onCommitFiberRoot(c, a);
          });
          Ae = Be(function(a) {
            return b.onCommitFiberUnmount(c, a);
          });
        } catch (d) {}
        return !0;
      }
      function De(a) {
        'function' === typeof ze && ze(a);
      }
      function Ee(a) {
        'function' === typeof Ae && Ae(a);
      }
      function Fe(a) {
        return {
          baseState: a,
          expirationTime: 0,
          first: null,
          last: null,
          callbackList: null,
          hasForceUpdate: !1,
          isInitialized: !1,
        };
      }
      function Ge(a, b) {
        null === a.last
          ? (a.first = a.last = b)
          : ((a.last.next = b), (a.last = b));
        if (0 === a.expirationTime || a.expirationTime > b.expirationTime)
          a.expirationTime = b.expirationTime;
      }
      function He(a, b) {
        var c = a.alternate,
          d = a.updateQueue;
        null === d && (d = a.updateQueue = Fe(null));
        null !== c
          ? ((a = c.updateQueue), null === a && (a = c.updateQueue = Fe(null)))
          : (a = null);
        a = a !== d ? a : null;
        null === a
          ? Ge(d, b)
          : null === d.last || null === a.last
            ? (Ge(d, b), Ge(a, b))
            : (Ge(d, b), (a.last = b));
      }
      function Ie(a, b, c, d) {
        a = a.partialState;
        return 'function' === typeof a ? a.call(b, c, d) : a;
      }
      function Je(a, b, c, d, e, f) {
        null !== a &&
          a.updateQueue === c &&
          (c = b.updateQueue = {
            baseState: c.baseState,
            expirationTime: c.expirationTime,
            first: c.first,
            last: c.last,
            isInitialized: c.isInitialized,
            callbackList: null,
            hasForceUpdate: !1,
          });
        c.expirationTime = 0;
        c.isInitialized
          ? (a = c.baseState)
          : ((a = c.baseState = b.memoizedState), (c.isInitialized = !0));
        for (var g = !0, h = c.first, k = !1; null !== h; ) {
          var q = h.expirationTime;
          if (q > f) {
            var v = c.expirationTime;
            if (0 === v || v > q) c.expirationTime = q;
            k || ((k = !0), (c.baseState = a));
          } else {
            k || ((c.first = h.next), null === c.first && (c.last = null));
            if (h.isReplace) (a = Ie(h, d, a, e)), (g = !0);
            else if ((q = Ie(h, d, a, e)))
              (a = g ? B({}, a, q) : B(a, q)), (g = !1);
            h.isForced && (c.hasForceUpdate = !0);
            null !== h.callback &&
              ((q = c.callbackList),
              null === q && (q = c.callbackList = []),
              q.push(h));
          }
          h = h.next;
        }
        null !== c.callbackList
          ? (b.effectTag |= 32)
          : null !== c.first || c.hasForceUpdate || (b.updateQueue = null);
        k || (c.baseState = a);
        return a;
      }
      function Ke(a, b) {
        var c = a.callbackList;
        if (null !== c)
          for (a.callbackList = null, a = 0; a < c.length; a++) {
            var d = c[a],
              e = d.callback;
            d.callback = null;
            'function' !== typeof e ? E('191', e) : void 0;
            e.call(b);
          }
      }
      function Le(a, b, c, d) {
        function e(a, b) {
          b.updater = f;
          a.stateNode = b;
          b._reactInternalFiber = a;
        }
        var f = {
          isMounted: ld,
          enqueueSetState: function(c, d, e) {
            c = c._reactInternalFiber;
            e = void 0 === e ? null : e;
            var g = b(c);
            He(c, {
              expirationTime: g,
              partialState: d,
              callback: e,
              isReplace: !1,
              isForced: !1,
              nextCallback: null,
              next: null,
            });
            a(c, g);
          },
          enqueueReplaceState: function(c, d, e) {
            c = c._reactInternalFiber;
            e = void 0 === e ? null : e;
            var g = b(c);
            He(c, {
              expirationTime: g,
              partialState: d,
              callback: e,
              isReplace: !0,
              isForced: !1,
              nextCallback: null,
              next: null,
            });
            a(c, g);
          },
          enqueueForceUpdate: function(c, d) {
            c = c._reactInternalFiber;
            d = void 0 === d ? null : d;
            var e = b(c);
            He(c, {
              expirationTime: e,
              partialState: null,
              callback: d,
              isReplace: !1,
              isForced: !0,
              nextCallback: null,
              next: null,
            });
            a(c, e);
          },
        };
        return {
          adoptClassInstance: e,
          constructClassInstance: function(a, b) {
            var c = a.type,
              d = ke(a),
              f = 2 === a.tag && null != a.type.contextTypes,
              g = f ? me(a, d) : D;
            b = new c(b, g);
            e(a, b);
            f &&
              ((a = a.stateNode),
              (a.__reactInternalMemoizedUnmaskedChildContext = d),
              (a.__reactInternalMemoizedMaskedChildContext = g));
            return b;
          },
          mountClassInstance: function(a, b) {
            var c = a.alternate,
              d = a.stateNode,
              e = d.state || null,
              g = a.pendingProps;
            g ? void 0 : E('158');
            var h = ke(a);
            d.props = g;
            d.state = a.memoizedState = e;
            d.refs = D;
            d.context = me(a, h);
            null != a.type &&
              null != a.type.prototype &&
              !0 === a.type.prototype.unstable_isAsyncReactComponent &&
              (a.internalContextTag |= 1);
            'function' === typeof d.componentWillMount &&
              ((e = d.state),
              d.componentWillMount(),
              e !== d.state && f.enqueueReplaceState(d, d.state, null),
              (e = a.updateQueue),
              null !== e && (d.state = Je(c, a, e, d, g, b)));
            'function' === typeof d.componentDidMount && (a.effectTag |= 4);
          },
          updateClassInstance: function(a, b, e) {
            var g = b.stateNode;
            g.props = b.memoizedProps;
            g.state = b.memoizedState;
            var h = b.memoizedProps,
              k = b.pendingProps;
            k || ((k = h), null == k ? E('159') : void 0);
            var u = g.context,
              z = ke(b);
            z = me(b, z);
            'function' !== typeof g.componentWillReceiveProps ||
              (h === k && u === z) ||
              ((u = g.state),
              g.componentWillReceiveProps(k, z),
              g.state !== u && f.enqueueReplaceState(g, g.state, null));
            u = b.memoizedState;
            e = null !== b.updateQueue ? Je(a, b, b.updateQueue, g, k, e) : u;
            if (
              !(
                h !== k ||
                u !== e ||
                X.current ||
                (null !== b.updateQueue && b.updateQueue.hasForceUpdate)
              )
            )
              return (
                'function' !== typeof g.componentDidUpdate ||
                  (h === a.memoizedProps && u === a.memoizedState) ||
                  (b.effectTag |= 4),
                !1
              );
            var G = k;
            if (
              null === h ||
              (null !== b.updateQueue && b.updateQueue.hasForceUpdate)
            )
              G = !0;
            else {
              var I = b.stateNode,
                L = b.type;
              G =
                'function' === typeof I.shouldComponentUpdate
                  ? I.shouldComponentUpdate(G, e, z)
                  : L.prototype && L.prototype.isPureReactComponent
                    ? !ea(h, G) || !ea(u, e)
                    : !0;
            }
            G
              ? ('function' === typeof g.componentWillUpdate &&
                  g.componentWillUpdate(k, e, z),
                'function' === typeof g.componentDidUpdate &&
                  (b.effectTag |= 4))
              : ('function' !== typeof g.componentDidUpdate ||
                  (h === a.memoizedProps && u === a.memoizedState) ||
                  (b.effectTag |= 4),
                c(b, k),
                d(b, e));
            g.props = k;
            g.state = e;
            g.context = z;
            return G;
          },
        };
      }
      var Qe = 'function' === typeof Symbol && Symbol['for'],
        Re = Qe ? Symbol['for']('react.element') : 60103,
        Se = Qe ? Symbol['for']('react.call') : 60104,
        Te = Qe ? Symbol['for']('react.return') : 60105,
        Ue = Qe ? Symbol['for']('react.portal') : 60106,
        Ve = Qe ? Symbol['for']('react.fragment') : 60107,
        We = 'function' === typeof Symbol && Symbol.iterator;
      function Xe(a) {
        if (null === a || 'undefined' === typeof a) return null;
        a = (We && a[We]) || a['@@iterator'];
        return 'function' === typeof a ? a : null;
      }
      var Ye = Array.isArray;
      function Ze(a, b) {
        var c = b.ref;
        if (null !== c && 'function' !== typeof c) {
          if (b._owner) {
            b = b._owner;
            var d = void 0;
            b && (2 !== b.tag ? E('110') : void 0, (d = b.stateNode));
            d ? void 0 : E('147', c);
            var e = '' + c;
            if (null !== a && null !== a.ref && a.ref._stringRef === e)
              return a.ref;
            a = function(a) {
              var b = d.refs === D ? (d.refs = {}) : d.refs;
              null === a ? delete b[e] : (b[e] = a);
            };
            a._stringRef = e;
            return a;
          }
          'string' !== typeof c ? E('148') : void 0;
          b._owner ? void 0 : E('149', c);
        }
        return c;
      }
      function $e(a, b) {
        'textarea' !== a.type &&
          E(
            '31',
            '[object Object]' === Object.prototype.toString.call(b)
              ? 'object with keys {' + Object.keys(b).join(', ') + '}'
              : b,
            ''
          );
      }
      function af(a) {
        function b(b, c) {
          if (a) {
            var d = b.lastEffect;
            null !== d
              ? ((d.nextEffect = c), (b.lastEffect = c))
              : (b.firstEffect = b.lastEffect = c);
            c.nextEffect = null;
            c.effectTag = 8;
          }
        }
        function c(c, d) {
          if (!a) return null;
          for (; null !== d; ) b(c, d), (d = d.sibling);
          return null;
        }
        function d(a, b) {
          for (a = new Map(); null !== b; )
            null !== b.key ? a.set(b.key, b) : a.set(b.index, b),
              (b = b.sibling);
          return a;
        }
        function e(a, b, c) {
          a = se(a, b, c);
          a.index = 0;
          a.sibling = null;
          return a;
        }
        function f(b, c, d) {
          b.index = d;
          if (!a) return c;
          d = b.alternate;
          if (null !== d)
            return (d = d.index), d < c ? ((b.effectTag = 2), c) : d;
          b.effectTag = 2;
          return c;
        }
        function g(b) {
          a && null === b.alternate && (b.effectTag = 2);
          return b;
        }
        function h(a, b, c, d) {
          if (null === b || 6 !== b.tag)
            return (b = ve(c, a.internalContextTag, d)), (b['return'] = a), b;
          b = e(b, c, d);
          b['return'] = a;
          return b;
        }
        function k(a, b, c, d) {
          if (null !== b && b.type === c.type)
            return (
              (d = e(b, c.props, d)), (d.ref = Ze(b, c)), (d['return'] = a), d
            );
          d = te(c, a.internalContextTag, d);
          d.ref = Ze(b, c);
          d['return'] = a;
          return d;
        }
        function q(a, b, c, d) {
          if (null === b || 7 !== b.tag)
            return (b = we(c, a.internalContextTag, d)), (b['return'] = a), b;
          b = e(b, c, d);
          b['return'] = a;
          return b;
        }
        function v(a, b, c, d) {
          if (null === b || 9 !== b.tag)
            return (
              (b = xe(c, a.internalContextTag, d)),
              (b.type = c.value),
              (b['return'] = a),
              b
            );
          b = e(b, null, d);
          b.type = c.value;
          b['return'] = a;
          return b;
        }
        function y(a, b, c, d) {
          if (
            null === b ||
            4 !== b.tag ||
            b.stateNode.containerInfo !== c.containerInfo ||
            b.stateNode.implementation !== c.implementation
          )
            return (b = ye(c, a.internalContextTag, d)), (b['return'] = a), b;
          b = e(b, c.children || [], d);
          b['return'] = a;
          return b;
        }
        function u(a, b, c, d, f) {
          if (null === b || 10 !== b.tag)
            return (
              (b = ue(c, a.internalContextTag, d, f)), (b['return'] = a), b
            );
          b = e(b, c, d);
          b['return'] = a;
          return b;
        }
        function z(a, b, c) {
          if ('string' === typeof b || 'number' === typeof b)
            return (
              (b = ve('' + b, a.internalContextTag, c)), (b['return'] = a), b
            );
          if ('object' === typeof b && null !== b) {
            switch (b.$$typeof) {
              case Re:
                if (b.type === Ve)
                  return (
                    (b = ue(b.props.children, a.internalContextTag, c, b.key)),
                    (b['return'] = a),
                    b
                  );
                c = te(b, a.internalContextTag, c);
                c.ref = Ze(null, b);
                c['return'] = a;
                return c;
              case Se:
                return (
                  (b = we(b, a.internalContextTag, c)), (b['return'] = a), b
                );
              case Te:
                return (
                  (c = xe(b, a.internalContextTag, c)),
                  (c.type = b.value),
                  (c['return'] = a),
                  c
                );
              case Ue:
                return (
                  (b = ye(b, a.internalContextTag, c)), (b['return'] = a), b
                );
            }
            if (Ye(b) || Xe(b))
              return (
                (b = ue(b, a.internalContextTag, c, null)), (b['return'] = a), b
              );
            $e(a, b);
          }
          return null;
        }
        function G(a, b, c, d) {
          var e = null !== b ? b.key : null;
          if ('string' === typeof c || 'number' === typeof c)
            return null !== e ? null : h(a, b, '' + c, d);
          if ('object' === typeof c && null !== c) {
            switch (c.$$typeof) {
              case Re:
                return c.key === e
                  ? c.type === Ve
                    ? u(a, b, c.props.children, d, e)
                    : k(a, b, c, d)
                  : null;
              case Se:
                return c.key === e ? q(a, b, c, d) : null;
              case Te:
                return null === e ? v(a, b, c, d) : null;
              case Ue:
                return c.key === e ? y(a, b, c, d) : null;
            }
            if (Ye(c) || Xe(c)) return null !== e ? null : u(a, b, c, d, null);
            $e(a, c);
          }
          return null;
        }
        function I(a, b, c, d, e) {
          if ('string' === typeof d || 'number' === typeof d)
            return (a = a.get(c) || null), h(b, a, '' + d, e);
          if ('object' === typeof d && null !== d) {
            switch (d.$$typeof) {
              case Re:
                return (
                  (a = a.get(null === d.key ? c : d.key) || null),
                  d.type === Ve
                    ? u(b, a, d.props.children, e, d.key)
                    : k(b, a, d, e)
                );
              case Se:
                return (
                  (a = a.get(null === d.key ? c : d.key) || null), q(b, a, d, e)
                );
              case Te:
                return (a = a.get(c) || null), v(b, a, d, e);
              case Ue:
                return (
                  (a = a.get(null === d.key ? c : d.key) || null), y(b, a, d, e)
                );
            }
            if (Ye(d) || Xe(d))
              return (a = a.get(c) || null), u(b, a, d, e, null);
            $e(b, d);
          }
          return null;
        }
        function L(e, g, m, A) {
          for (
            var h = null, r = null, n = g, w = (g = 0), k = null;
            null !== n && w < m.length;
            w++
          ) {
            n.index > w ? ((k = n), (n = null)) : (k = n.sibling);
            var x = G(e, n, m[w], A);
            if (null === x) {
              null === n && (n = k);
              break;
            }
            a && n && null === x.alternate && b(e, n);
            g = f(x, g, w);
            null === r ? (h = x) : (r.sibling = x);
            r = x;
            n = k;
          }
          if (w === m.length) return c(e, n), h;
          if (null === n) {
            for (; w < m.length; w++)
              if ((n = z(e, m[w], A)))
                (g = f(n, g, w)),
                  null === r ? (h = n) : (r.sibling = n),
                  (r = n);
            return h;
          }
          for (n = d(e, n); w < m.length; w++)
            if ((k = I(n, e, w, m[w], A))) {
              if (a && null !== k.alternate)
                n['delete'](null === k.key ? w : k.key);
              g = f(k, g, w);
              null === r ? (h = k) : (r.sibling = k);
              r = k;
            }
          a &&
            n.forEach(function(a) {
              return b(e, a);
            });
          return h;
        }
        function N(e, g, m, A) {
          var h = Xe(m);
          'function' !== typeof h ? E('150') : void 0;
          m = h.call(m);
          null == m ? E('151') : void 0;
          for (
            var r = (h = null), n = g, w = (g = 0), k = null, x = m.next();
            null !== n && !x.done;
            w++, x = m.next()
          ) {
            n.index > w ? ((k = n), (n = null)) : (k = n.sibling);
            var J = G(e, n, x.value, A);
            if (null === J) {
              n || (n = k);
              break;
            }
            a && n && null === J.alternate && b(e, n);
            g = f(J, g, w);
            null === r ? (h = J) : (r.sibling = J);
            r = J;
            n = k;
          }
          if (x.done) return c(e, n), h;
          if (null === n) {
            for (; !x.done; w++, x = m.next())
              (x = z(e, x.value, A)),
                null !== x &&
                  ((g = f(x, g, w)),
                  null === r ? (h = x) : (r.sibling = x),
                  (r = x));
            return h;
          }
          for (n = d(e, n); !x.done; w++, x = m.next())
            if (((x = I(n, e, w, x.value, A)), null !== x)) {
              if (a && null !== x.alternate)
                n['delete'](null === x.key ? w : x.key);
              g = f(x, g, w);
              null === r ? (h = x) : (r.sibling = x);
              r = x;
            }
          a &&
            n.forEach(function(a) {
              return b(e, a);
            });
          return h;
        }
        return function(a, d, f, h) {
          'object' === typeof f &&
            null !== f &&
            f.type === Ve &&
            null === f.key &&
            (f = f.props.children);
          var m = 'object' === typeof f && null !== f;
          if (m)
            switch (f.$$typeof) {
              case Re:
                a: {
                  var r = f.key;
                  for (m = d; null !== m; ) {
                    if (m.key === r)
                      if (10 === m.tag ? f.type === Ve : m.type === f.type) {
                        c(a, m.sibling);
                        d = e(m, f.type === Ve ? f.props.children : f.props, h);
                        d.ref = Ze(m, f);
                        d['return'] = a;
                        a = d;
                        break a;
                      } else {
                        c(a, m);
                        break;
                      }
                    else b(a, m);
                    m = m.sibling;
                  }
                  f.type === Ve
                    ? ((d = ue(
                        f.props.children,
                        a.internalContextTag,
                        h,
                        f.key
                      )),
                      (d['return'] = a),
                      (a = d))
                    : ((h = te(f, a.internalContextTag, h)),
                      (h.ref = Ze(d, f)),
                      (h['return'] = a),
                      (a = h));
                }
                return g(a);
              case Se:
                a: {
                  for (m = f.key; null !== d; ) {
                    if (d.key === m)
                      if (7 === d.tag) {
                        c(a, d.sibling);
                        d = e(d, f, h);
                        d['return'] = a;
                        a = d;
                        break a;
                      } else {
                        c(a, d);
                        break;
                      }
                    else b(a, d);
                    d = d.sibling;
                  }
                  d = we(f, a.internalContextTag, h);
                  d['return'] = a;
                  a = d;
                }
                return g(a);
              case Te:
                a: {
                  if (null !== d)
                    if (9 === d.tag) {
                      c(a, d.sibling);
                      d = e(d, null, h);
                      d.type = f.value;
                      d['return'] = a;
                      a = d;
                      break a;
                    } else c(a, d);
                  d = xe(f, a.internalContextTag, h);
                  d.type = f.value;
                  d['return'] = a;
                  a = d;
                }
                return g(a);
              case Ue:
                a: {
                  for (m = f.key; null !== d; ) {
                    if (d.key === m)
                      if (
                        4 === d.tag &&
                        d.stateNode.containerInfo === f.containerInfo &&
                        d.stateNode.implementation === f.implementation
                      ) {
                        c(a, d.sibling);
                        d = e(d, f.children || [], h);
                        d['return'] = a;
                        a = d;
                        break a;
                      } else {
                        c(a, d);
                        break;
                      }
                    else b(a, d);
                    d = d.sibling;
                  }
                  d = ye(f, a.internalContextTag, h);
                  d['return'] = a;
                  a = d;
                }
                return g(a);
            }
          if ('string' === typeof f || 'number' === typeof f)
            return (
              (f = '' + f),
              null !== d && 6 === d.tag
                ? (c(a, d.sibling), (d = e(d, f, h)))
                : (c(a, d), (d = ve(f, a.internalContextTag, h))),
              (d['return'] = a),
              (a = d),
              g(a)
            );
          if (Ye(f)) return L(a, d, f, h);
          if (Xe(f)) return N(a, d, f, h);
          m && $e(a, f);
          if ('undefined' === typeof f)
            switch (a.tag) {
              case 2:
              case 1:
                (h = a.type), E('152', h.displayName || h.name || 'Component');
            }
          return c(a, d);
        };
      }
      var bf = af(!0),
        cf = af(!1);
      function df(a, b, c, d, e) {
        function f(a, b, c) {
          var d = b.expirationTime;
          b.child = null === a ? cf(b, null, c, d) : bf(b, a.child, c, d);
        }
        function g(a, b) {
          var c = b.ref;
          null === c || (a && a.ref === c) || (b.effectTag |= 128);
        }
        function h(a, b, c, d) {
          g(a, b);
          if (!c) return d && re(b, !1), q(a, b);
          c = b.stateNode;
          id.current = b;
          var e = c.render();
          b.effectTag |= 1;
          f(a, b, e);
          b.memoizedState = c.state;
          b.memoizedProps = c.props;
          d && re(b, !0);
          return b.child;
        }
        function k(a) {
          var b = a.stateNode;
          b.pendingContext
            ? oe(a, b.pendingContext, b.pendingContext !== b.context)
            : b.context && oe(a, b.context, !1);
          I(a, b.containerInfo);
        }
        function q(a, b) {
          null !== a && b.child !== a.child ? E('153') : void 0;
          if (null !== b.child) {
            a = b.child;
            var c = se(a, a.pendingProps, a.expirationTime);
            b.child = c;
            for (c['return'] = b; null !== a.sibling; )
              (a = a.sibling),
                (c = c.sibling = se(a, a.pendingProps, a.expirationTime)),
                (c['return'] = b);
            c.sibling = null;
          }
          return b.child;
        }
        function v(a, b) {
          switch (b.tag) {
            case 3:
              k(b);
              break;
            case 2:
              qe(b);
              break;
            case 4:
              I(b, b.stateNode.containerInfo);
          }
          return null;
        }
        var y = a.shouldSetTextContent,
          u = a.useSyncScheduling,
          z = a.shouldDeprioritizeSubtree,
          G = b.pushHostContext,
          I = b.pushHostContainer,
          L = c.enterHydrationState,
          N = c.resetHydrationState,
          J = c.tryToClaimNextHydratableInstance;
        a = Le(
          d,
          e,
          function(a, b) {
            a.memoizedProps = b;
          },
          function(a, b) {
            a.memoizedState = b;
          }
        );
        var w = a.adoptClassInstance,
          m = a.constructClassInstance,
          A = a.mountClassInstance,
          Ob = a.updateClassInstance;
        return {
          beginWork: function(a, b, c) {
            if (0 === b.expirationTime || b.expirationTime > c) return v(a, b);
            switch (b.tag) {
              case 0:
                null !== a ? E('155') : void 0;
                var d = b.type,
                  e = b.pendingProps,
                  r = ke(b);
                r = me(b, r);
                d = d(e, r);
                b.effectTag |= 1;
                'object' === typeof d &&
                null !== d &&
                'function' === typeof d.render
                  ? ((b.tag = 2),
                    (e = qe(b)),
                    w(b, d),
                    A(b, c),
                    (b = h(a, b, !0, e)))
                  : ((b.tag = 1),
                    f(a, b, d),
                    (b.memoizedProps = e),
                    (b = b.child));
                return b;
              case 1:
                a: {
                  e = b.type;
                  c = b.pendingProps;
                  d = b.memoizedProps;
                  if (X.current) null === c && (c = d);
                  else if (null === c || d === c) {
                    b = q(a, b);
                    break a;
                  }
                  d = ke(b);
                  d = me(b, d);
                  e = e(c, d);
                  b.effectTag |= 1;
                  f(a, b, e);
                  b.memoizedProps = c;
                  b = b.child;
                }
                return b;
              case 2:
                return (
                  (e = qe(b)),
                  (d = void 0),
                  null === a
                    ? b.stateNode
                      ? E('153')
                      : (m(b, b.pendingProps), A(b, c), (d = !0))
                    : (d = Ob(a, b, c)),
                  h(a, b, d, e)
                );
              case 3:
                return (
                  k(b),
                  (e = b.updateQueue),
                  null !== e
                    ? ((d = b.memoizedState),
                      (e = Je(a, b, e, null, null, c)),
                      d === e
                        ? (N(), (b = q(a, b)))
                        : ((d = e.element),
                          (r = b.stateNode),
                          (null === a || null === a.child) && r.hydrate && L(b)
                            ? ((b.effectTag |= 2),
                              (b.child = cf(b, null, d, c)))
                            : (N(), f(a, b, d)),
                          (b.memoizedState = e),
                          (b = b.child)))
                    : (N(), (b = q(a, b))),
                  b
                );
              case 5:
                G(b);
                null === a && J(b);
                e = b.type;
                var n = b.memoizedProps;
                d = b.pendingProps;
                null === d && ((d = n), null === d ? E('154') : void 0);
                r = null !== a ? a.memoizedProps : null;
                X.current || (null !== d && n !== d)
                  ? ((n = d.children),
                    y(e, d) ? (n = null) : r && y(e, r) && (b.effectTag |= 16),
                    g(a, b),
                    2147483647 !== c && !u && z(e, d)
                      ? ((b.expirationTime = 2147483647), (b = null))
                      : (f(a, b, n), (b.memoizedProps = d), (b = b.child)))
                  : (b = q(a, b));
                return b;
              case 6:
                return (
                  null === a && J(b),
                  (a = b.pendingProps),
                  null === a && (a = b.memoizedProps),
                  (b.memoizedProps = a),
                  null
                );
              case 8:
                b.tag = 7;
              case 7:
                e = b.pendingProps;
                if (X.current)
                  null === e &&
                    ((e = a && a.memoizedProps),
                    null === e ? E('154') : void 0);
                else if (null === e || b.memoizedProps === e)
                  e = b.memoizedProps;
                d = e.children;
                b.stateNode =
                  null === a
                    ? cf(b, b.stateNode, d, c)
                    : bf(b, b.stateNode, d, c);
                b.memoizedProps = e;
                return b.stateNode;
              case 9:
                return null;
              case 4:
                a: {
                  I(b, b.stateNode.containerInfo);
                  e = b.pendingProps;
                  if (X.current)
                    null === e &&
                      ((e = a && a.memoizedProps),
                      null == e ? E('154') : void 0);
                  else if (null === e || b.memoizedProps === e) {
                    b = q(a, b);
                    break a;
                  }
                  null === a ? (b.child = bf(b, null, e, c)) : f(a, b, e);
                  b.memoizedProps = e;
                  b = b.child;
                }
                return b;
              case 10:
                a: {
                  c = b.pendingProps;
                  if (X.current) null === c && (c = b.memoizedProps);
                  else if (null === c || b.memoizedProps === c) {
                    b = q(a, b);
                    break a;
                  }
                  f(a, b, c);
                  b.memoizedProps = c;
                  b = b.child;
                }
                return b;
              default:
                E('156');
            }
          },
          beginFailedWork: function(a, b, c) {
            switch (b.tag) {
              case 2:
                qe(b);
                break;
              case 3:
                k(b);
                break;
              default:
                E('157');
            }
            b.effectTag |= 64;
            null === a
              ? (b.child = null)
              : b.child !== a.child && (b.child = a.child);
            if (0 === b.expirationTime || b.expirationTime > c) return v(a, b);
            b.firstEffect = null;
            b.lastEffect = null;
            b.child =
              null === a ? cf(b, null, null, c) : bf(b, a.child, null, c);
            2 === b.tag &&
              ((a = b.stateNode),
              (b.memoizedProps = a.props),
              (b.memoizedState = a.state));
            return b.child;
          },
        };
      }
      function ef(a, b, c) {
        function d(a) {
          a.effectTag |= 4;
        }
        var e = a.createInstance,
          f = a.createTextInstance,
          g = a.appendInitialChild,
          h = a.finalizeInitialChildren,
          k = a.prepareUpdate,
          q = a.persistence,
          v = b.getRootHostContainer,
          y = b.popHostContext,
          u = b.getHostContext,
          z = b.popHostContainer,
          G = c.prepareToHydrateHostInstance,
          I = c.prepareToHydrateHostTextInstance,
          L = c.popHydrationState,
          N = void 0,
          J = void 0,
          w = void 0;
        a.mutation
          ? ((N = function() {}),
            (J = function(a, b, c) {
              (b.updateQueue = c) && d(b);
            }),
            (w = function(a, b, c, e) {
              c !== e && d(b);
            }))
          : q ? E('235') : E('236');
        return {
          completeWork: function(a, b, c) {
            var m = b.pendingProps;
            if (null === m) m = b.memoizedProps;
            else if (2147483647 !== b.expirationTime || 2147483647 === c)
              b.pendingProps = null;
            switch (b.tag) {
              case 1:
                return null;
              case 2:
                return ne(b), null;
              case 3:
                z(b);
                V(X, b);
                V(ie, b);
                m = b.stateNode;
                m.pendingContext &&
                  ((m.context = m.pendingContext), (m.pendingContext = null));
                if (null === a || null === a.child) L(b), (b.effectTag &= -3);
                N(b);
                return null;
              case 5:
                y(b);
                c = v();
                var A = b.type;
                if (null !== a && null != b.stateNode) {
                  var p = a.memoizedProps,
                    q = b.stateNode,
                    x = u();
                  q = k(q, A, p, m, c, x);
                  J(a, b, q, A, p, m, c);
                  a.ref !== b.ref && (b.effectTag |= 128);
                } else {
                  if (!m) return null === b.stateNode ? E('166') : void 0, null;
                  a = u();
                  if (L(b)) G(b, c, a) && d(b);
                  else {
                    a = e(A, m, c, a, b);
                    a: for (p = b.child; null !== p; ) {
                      if (5 === p.tag || 6 === p.tag) g(a, p.stateNode);
                      else if (4 !== p.tag && null !== p.child) {
                        p.child['return'] = p;
                        p = p.child;
                        continue;
                      }
                      if (p === b) break;
                      for (; null === p.sibling; ) {
                        if (null === p['return'] || p['return'] === b) break a;
                        p = p['return'];
                      }
                      p.sibling['return'] = p['return'];
                      p = p.sibling;
                    }
                    h(a, A, m, c) && d(b);
                    b.stateNode = a;
                  }
                  null !== b.ref && (b.effectTag |= 128);
                }
                return null;
              case 6:
                if (a && null != b.stateNode) w(a, b, a.memoizedProps, m);
                else {
                  if ('string' !== typeof m)
                    return null === b.stateNode ? E('166') : void 0, null;
                  a = v();
                  c = u();
                  L(b) ? I(b) && d(b) : (b.stateNode = f(m, a, c, b));
                }
                return null;
              case 7:
                (m = b.memoizedProps) ? void 0 : E('165');
                b.tag = 8;
                A = [];
                a: for ((p = b.stateNode) && (p['return'] = b); null !== p; ) {
                  if (5 === p.tag || 6 === p.tag || 4 === p.tag) E('247');
                  else if (9 === p.tag) A.push(p.type);
                  else if (null !== p.child) {
                    p.child['return'] = p;
                    p = p.child;
                    continue;
                  }
                  for (; null === p.sibling; ) {
                    if (null === p['return'] || p['return'] === b) break a;
                    p = p['return'];
                  }
                  p.sibling['return'] = p['return'];
                  p = p.sibling;
                }
                p = m.handler;
                m = p(m.props, A);
                b.child = bf(b, null !== a ? a.child : null, m, c);
                return b.child;
              case 8:
                return (b.tag = 7), null;
              case 9:
                return null;
              case 10:
                return null;
              case 4:
                return z(b), N(b), null;
              case 0:
                E('167');
              default:
                E('156');
            }
          },
        };
      }
      function ff(a, b) {
        function c(a) {
          var c = a.ref;
          if (null !== c)
            try {
              c(null);
            } catch (A) {
              b(a, A);
            }
        }
        function d(a) {
          'function' === typeof Ee && Ee(a);
          switch (a.tag) {
            case 2:
              c(a);
              var d = a.stateNode;
              if ('function' === typeof d.componentWillUnmount)
                try {
                  (d.props = a.memoizedProps),
                    (d.state = a.memoizedState),
                    d.componentWillUnmount();
                } catch (A) {
                  b(a, A);
                }
              break;
            case 5:
              c(a);
              break;
            case 7:
              e(a.stateNode);
              break;
            case 4:
              k && g(a);
          }
        }
        function e(a) {
          for (var b = a; ; )
            if ((d(b), null === b.child || (k && 4 === b.tag))) {
              if (b === a) break;
              for (; null === b.sibling; ) {
                if (null === b['return'] || b['return'] === a) return;
                b = b['return'];
              }
              b.sibling['return'] = b['return'];
              b = b.sibling;
            } else (b.child['return'] = b), (b = b.child);
        }
        function f(a) {
          return 5 === a.tag || 3 === a.tag || 4 === a.tag;
        }
        function g(a) {
          for (var b = a, c = !1, f = void 0, g = void 0; ; ) {
            if (!c) {
              c = b['return'];
              a: for (;;) {
                null === c ? E('160') : void 0;
                switch (c.tag) {
                  case 5:
                    f = c.stateNode;
                    g = !1;
                    break a;
                  case 3:
                    f = c.stateNode.containerInfo;
                    g = !0;
                    break a;
                  case 4:
                    f = c.stateNode.containerInfo;
                    g = !0;
                    break a;
                }
                c = c['return'];
              }
              c = !0;
            }
            if (5 === b.tag || 6 === b.tag)
              e(b), g ? J(f, b.stateNode) : N(f, b.stateNode);
            else if (
              (4 === b.tag ? (f = b.stateNode.containerInfo) : d(b),
              null !== b.child)
            ) {
              b.child['return'] = b;
              b = b.child;
              continue;
            }
            if (b === a) break;
            for (; null === b.sibling; ) {
              if (null === b['return'] || b['return'] === a) return;
              b = b['return'];
              4 === b.tag && (c = !1);
            }
            b.sibling['return'] = b['return'];
            b = b.sibling;
          }
        }
        var h = a.getPublicInstance,
          k = a.mutation;
        a = a.persistence;
        k || (a ? E('235') : E('236'));
        var q = k.commitMount,
          v = k.commitUpdate,
          y = k.resetTextContent,
          u = k.commitTextUpdate,
          z = k.appendChild,
          G = k.appendChildToContainer,
          I = k.insertBefore,
          L = k.insertInContainerBefore,
          N = k.removeChild,
          J = k.removeChildFromContainer;
        return {
          commitResetTextContent: function(a) {
            y(a.stateNode);
          },
          commitPlacement: function(a) {
            a: {
              for (var b = a['return']; null !== b; ) {
                if (f(b)) {
                  var c = b;
                  break a;
                }
                b = b['return'];
              }
              E('160');
              c = void 0;
            }
            var d = (b = void 0);
            switch (c.tag) {
              case 5:
                b = c.stateNode;
                d = !1;
                break;
              case 3:
                b = c.stateNode.containerInfo;
                d = !0;
                break;
              case 4:
                b = c.stateNode.containerInfo;
                d = !0;
                break;
              default:
                E('161');
            }
            c.effectTag & 16 && (y(b), (c.effectTag &= -17));
            a: b: for (c = a; ; ) {
              for (; null === c.sibling; ) {
                if (null === c['return'] || f(c['return'])) {
                  c = null;
                  break a;
                }
                c = c['return'];
              }
              c.sibling['return'] = c['return'];
              for (c = c.sibling; 5 !== c.tag && 6 !== c.tag; ) {
                if (c.effectTag & 2) continue b;
                if (null === c.child || 4 === c.tag) continue b;
                else (c.child['return'] = c), (c = c.child);
              }
              if (!(c.effectTag & 2)) {
                c = c.stateNode;
                break a;
              }
            }
            for (var e = a; ; ) {
              if (5 === e.tag || 6 === e.tag)
                c
                  ? d ? L(b, e.stateNode, c) : I(b, e.stateNode, c)
                  : d ? G(b, e.stateNode) : z(b, e.stateNode);
              else if (4 !== e.tag && null !== e.child) {
                e.child['return'] = e;
                e = e.child;
                continue;
              }
              if (e === a) break;
              for (; null === e.sibling; ) {
                if (null === e['return'] || e['return'] === a) return;
                e = e['return'];
              }
              e.sibling['return'] = e['return'];
              e = e.sibling;
            }
          },
          commitDeletion: function(a) {
            g(a);
            a['return'] = null;
            a.child = null;
            a.alternate &&
              ((a.alternate.child = null), (a.alternate['return'] = null));
          },
          commitWork: function(a, b) {
            switch (b.tag) {
              case 2:
                break;
              case 5:
                var c = b.stateNode;
                if (null != c) {
                  var d = b.memoizedProps;
                  a = null !== a ? a.memoizedProps : d;
                  var e = b.type,
                    f = b.updateQueue;
                  b.updateQueue = null;
                  null !== f && v(c, f, e, a, d, b);
                }
                break;
              case 6:
                null === b.stateNode ? E('162') : void 0;
                c = b.memoizedProps;
                u(b.stateNode, null !== a ? a.memoizedProps : c, c);
                break;
              case 3:
                break;
              default:
                E('163');
            }
          },
          commitLifeCycles: function(a, b) {
            switch (b.tag) {
              case 2:
                var c = b.stateNode;
                if (b.effectTag & 4)
                  if (null === a)
                    (c.props = b.memoizedProps),
                      (c.state = b.memoizedState),
                      c.componentDidMount();
                  else {
                    var d = a.memoizedProps;
                    a = a.memoizedState;
                    c.props = b.memoizedProps;
                    c.state = b.memoizedState;
                    c.componentDidUpdate(d, a);
                  }
                b = b.updateQueue;
                null !== b && Ke(b, c);
                break;
              case 3:
                c = b.updateQueue;
                null !== c &&
                  Ke(c, null !== b.child ? b.child.stateNode : null);
                break;
              case 5:
                c = b.stateNode;
                null === a &&
                  b.effectTag & 4 &&
                  q(c, b.type, b.memoizedProps, b);
                break;
              case 6:
                break;
              case 4:
                break;
              default:
                E('163');
            }
          },
          commitAttachRef: function(a) {
            var b = a.ref;
            if (null !== b) {
              var c = a.stateNode;
              switch (a.tag) {
                case 5:
                  b(h(c));
                  break;
                default:
                  b(c);
              }
            }
          },
          commitDetachRef: function(a) {
            a = a.ref;
            null !== a && a(null);
          },
        };
      }
      var gf = {};
      function hf(a) {
        function b(a) {
          a === gf ? E('174') : void 0;
          return a;
        }
        var c = a.getChildHostContext,
          d = a.getRootHostContext,
          e = { current: gf },
          f = { current: gf },
          g = { current: gf };
        return {
          getHostContext: function() {
            return b(e.current);
          },
          getRootHostContainer: function() {
            return b(g.current);
          },
          popHostContainer: function(a) {
            V(e, a);
            V(f, a);
            V(g, a);
          },
          popHostContext: function(a) {
            f.current === a && (V(e, a), V(f, a));
          },
          pushHostContainer: function(a, b) {
            W(g, b, a);
            b = d(b);
            W(f, a, a);
            W(e, b, a);
          },
          pushHostContext: function(a) {
            var d = b(g.current),
              h = b(e.current);
            d = c(h, a.type, d);
            h !== d && (W(f, a, a), W(e, d, a));
          },
          resetHostContainer: function() {
            e.current = gf;
            g.current = gf;
          },
        };
      }
      function jf(a) {
        function b(a, b) {
          var c = new Y(5, null, 0);
          c.type = 'DELETED';
          c.stateNode = b;
          c['return'] = a;
          c.effectTag = 8;
          null !== a.lastEffect
            ? ((a.lastEffect.nextEffect = c), (a.lastEffect = c))
            : (a.firstEffect = a.lastEffect = c);
        }
        function c(a, b) {
          switch (a.tag) {
            case 5:
              return (
                (b = f(b, a.type, a.pendingProps)),
                null !== b ? ((a.stateNode = b), !0) : !1
              );
            case 6:
              return (
                (b = g(b, a.pendingProps)),
                null !== b ? ((a.stateNode = b), !0) : !1
              );
            default:
              return !1;
          }
        }
        function d(a) {
          for (a = a['return']; null !== a && 5 !== a.tag && 3 !== a.tag; )
            a = a['return'];
          y = a;
        }
        var e = a.shouldSetTextContent;
        a = a.hydration;
        if (!a)
          return {
            enterHydrationState: function() {
              return !1;
            },
            resetHydrationState: function() {},
            tryToClaimNextHydratableInstance: function() {},
            prepareToHydrateHostInstance: function() {
              E('175');
            },
            prepareToHydrateHostTextInstance: function() {
              E('176');
            },
            popHydrationState: function() {
              return !1;
            },
          };
        var f = a.canHydrateInstance,
          g = a.canHydrateTextInstance,
          h = a.getNextHydratableSibling,
          k = a.getFirstHydratableChild,
          q = a.hydrateInstance,
          v = a.hydrateTextInstance,
          y = null,
          u = null,
          z = !1;
        return {
          enterHydrationState: function(a) {
            u = k(a.stateNode.containerInfo);
            y = a;
            return (z = !0);
          },
          resetHydrationState: function() {
            u = y = null;
            z = !1;
          },
          tryToClaimNextHydratableInstance: function(a) {
            if (z) {
              var d = u;
              if (d) {
                if (!c(a, d)) {
                  d = h(d);
                  if (!d || !c(a, d)) {
                    a.effectTag |= 2;
                    z = !1;
                    y = a;
                    return;
                  }
                  b(y, u);
                }
                y = a;
                u = k(d);
              } else (a.effectTag |= 2), (z = !1), (y = a);
            }
          },
          prepareToHydrateHostInstance: function(a, b, c) {
            b = q(a.stateNode, a.type, a.memoizedProps, b, c, a);
            a.updateQueue = b;
            return null !== b ? !0 : !1;
          },
          prepareToHydrateHostTextInstance: function(a) {
            return v(a.stateNode, a.memoizedProps, a);
          },
          popHydrationState: function(a) {
            if (a !== y) return !1;
            if (!z) return d(a), (z = !0), !1;
            var c = a.type;
            if (
              5 !== a.tag ||
              ('head' !== c && 'body' !== c && !e(c, a.memoizedProps))
            )
              for (c = u; c; ) b(a, c), (c = h(c));
            d(a);
            u = y ? h(a.stateNode) : null;
            return !0;
          },
        };
      }
      function kf(a) {
        function b(a) {
          Qb = ja = !0;
          var b = a.stateNode;
          b.current === a ? E('177') : void 0;
          b.isReadyForCommit = !1;
          id.current = null;
          if (1 < a.effectTag)
            if (null !== a.lastEffect) {
              a.lastEffect.nextEffect = a;
              var c = a.firstEffect;
            } else c = a;
          else c = a.firstEffect;
          yg();
          for (t = c; null !== t; ) {
            var d = !1,
              e = void 0;
            try {
              for (; null !== t; ) {
                var f = t.effectTag;
                f & 16 && zg(t);
                if (f & 128) {
                  var g = t.alternate;
                  null !== g && Ag(g);
                }
                switch (f & -242) {
                  case 2:
                    Ne(t);
                    t.effectTag &= -3;
                    break;
                  case 6:
                    Ne(t);
                    t.effectTag &= -3;
                    Oe(t.alternate, t);
                    break;
                  case 4:
                    Oe(t.alternate, t);
                    break;
                  case 8:
                    (Sc = !0), Bg(t), (Sc = !1);
                }
                t = t.nextEffect;
              }
            } catch (Tc) {
              (d = !0), (e = Tc);
            }
            d &&
              (null === t ? E('178') : void 0,
              h(t, e),
              null !== t && (t = t.nextEffect));
          }
          Cg();
          b.current = a;
          for (t = c; null !== t; ) {
            c = !1;
            d = void 0;
            try {
              for (; null !== t; ) {
                var k = t.effectTag;
                k & 36 && Dg(t.alternate, t);
                k & 128 && Eg(t);
                if (k & 64)
                  switch (((e = t),
                  (f = void 0),
                  null !== R &&
                    ((f = R.get(e)),
                    R['delete'](e),
                    null == f &&
                      null !== e.alternate &&
                      ((e = e.alternate), (f = R.get(e)), R['delete'](e))),
                  null == f ? E('184') : void 0,
                  e.tag)) {
                    case 2:
                      e.stateNode.componentDidCatch(f.error, {
                        componentStack: f.componentStack,
                      });
                      break;
                    case 3:
                      null === ca && (ca = f.error);
                      break;
                    default:
                      E('157');
                  }
                var Qc = t.nextEffect;
                t.nextEffect = null;
                t = Qc;
              }
            } catch (Tc) {
              (c = !0), (d = Tc);
            }
            c &&
              (null === t ? E('178') : void 0,
              h(t, d),
              null !== t && (t = t.nextEffect));
          }
          ja = Qb = !1;
          'function' === typeof De && De(a.stateNode);
          ha && (ha.forEach(G), (ha = null));
          null !== ca && ((a = ca), (ca = null), Ob(a));
          b = b.current.expirationTime;
          0 === b && (qa = R = null);
          return b;
        }
        function c(a) {
          for (;;) {
            var b = Fg(a.alternate, a, H),
              c = a['return'],
              d = a.sibling;
            var e = a;
            if (2147483647 === H || 2147483647 !== e.expirationTime) {
              if (2 !== e.tag && 3 !== e.tag) var f = 0;
              else (f = e.updateQueue), (f = null === f ? 0 : f.expirationTime);
              for (var g = e.child; null !== g; )
                0 !== g.expirationTime &&
                  (0 === f || f > g.expirationTime) &&
                  (f = g.expirationTime),
                  (g = g.sibling);
              e.expirationTime = f;
            }
            if (null !== b) return b;
            null !== c &&
              (null === c.firstEffect && (c.firstEffect = a.firstEffect),
              null !== a.lastEffect &&
                (null !== c.lastEffect &&
                  (c.lastEffect.nextEffect = a.firstEffect),
                (c.lastEffect = a.lastEffect)),
              1 < a.effectTag &&
                (null !== c.lastEffect
                  ? (c.lastEffect.nextEffect = a)
                  : (c.firstEffect = a),
                (c.lastEffect = a)));
            if (null !== d) return d;
            if (null !== c) a = c;
            else {
              a.stateNode.isReadyForCommit = !0;
              break;
            }
          }
          return null;
        }
        function d(a) {
          var b = rg(a.alternate, a, H);
          null === b && (b = c(a));
          id.current = null;
          return b;
        }
        function e(a) {
          var b = Gg(a.alternate, a, H);
          null === b && (b = c(a));
          id.current = null;
          return b;
        }
        function f(a) {
          if (null !== R) {
            if (!(0 === H || H > a))
              if (H <= Uc) for (; null !== F; ) F = k(F) ? e(F) : d(F);
              else for (; null !== F && !A(); ) F = k(F) ? e(F) : d(F);
          } else if (!(0 === H || H > a))
            if (H <= Uc) for (; null !== F; ) F = d(F);
            else for (; null !== F && !A(); ) F = d(F);
        }
        function g(a, b) {
          ja ? E('243') : void 0;
          ja = !0;
          a.isReadyForCommit = !1;
          if (a !== ra || b !== H || null === F) {
            for (; -1 < he; ) (ge[he] = null), he--;
            je = D;
            ie.current = D;
            X.current = !1;
            x();
            ra = a;
            H = b;
            F = se(ra.current, null, b);
          }
          var c = !1,
            d = null;
          try {
            f(b);
          } catch (Rc) {
            (c = !0), (d = Rc);
          }
          for (; c; ) {
            if (eb) {
              ca = d;
              break;
            }
            var g = F;
            if (null === g) eb = !0;
            else {
              var k = h(g, d);
              null === k ? E('183') : void 0;
              if (!eb) {
                try {
                  c = k;
                  d = b;
                  for (k = c; null !== g; ) {
                    switch (g.tag) {
                      case 2:
                        ne(g);
                        break;
                      case 5:
                        qg(g);
                        break;
                      case 3:
                        p(g);
                        break;
                      case 4:
                        p(g);
                    }
                    if (g === k || g.alternate === k) break;
                    g = g['return'];
                  }
                  F = e(c);
                  f(d);
                } catch (Rc) {
                  c = !0;
                  d = Rc;
                  continue;
                }
                break;
              }
            }
          }
          b = ca;
          eb = ja = !1;
          ca = null;
          null !== b && Ob(b);
          return a.isReadyForCommit ? a.current.alternate : null;
        }
        function h(a, b) {
          var c = (id.current = null),
            d = !1,
            e = !1,
            f = null;
          if (3 === a.tag) (c = a), q(a) && (eb = !0);
          else
            for (var g = a['return']; null !== g && null === c; ) {
              2 === g.tag
                ? 'function' === typeof g.stateNode.componentDidCatch &&
                  ((d = !0), (f = jd(g)), (c = g), (e = !0))
                : 3 === g.tag && (c = g);
              if (q(g)) {
                if (
                  Sc ||
                  (null !== ha &&
                    (ha.has(g) ||
                      (null !== g.alternate && ha.has(g.alternate))))
                )
                  return null;
                c = null;
                e = !1;
              }
              g = g['return'];
            }
          if (null !== c) {
            null === qa && (qa = new Set());
            qa.add(c);
            var h = '';
            g = a;
            do {
              a: switch (g.tag) {
                case 0:
                case 1:
                case 2:
                case 5:
                  var k = g._debugOwner,
                    Qc = g._debugSource;
                  var m = jd(g);
                  var n = null;
                  k && (n = jd(k));
                  k = Qc;
                  m =
                    '\n    in ' +
                    (m || 'Unknown') +
                    (k
                      ? ' (at ' +
                        k.fileName.replace(/^.*[\\\/]/, '') +
                        ':' +
                        k.lineNumber +
                        ')'
                      : n ? ' (created by ' + n + ')' : '');
                  break a;
                default:
                  m = '';
              }
              h += m;
              g = g['return'];
            } while (g);
            g = h;
            a = jd(a);
            null === R && (R = new Map());
            b = {
              componentName: a,
              componentStack: g,
              error: b,
              errorBoundary: d ? c.stateNode : null,
              errorBoundaryFound: d,
              errorBoundaryName: f,
              willRetry: e,
            };
            R.set(c, b);
            try {
              var p = b.error;
              (p && p.suppressReactErrorLogging) || console.error(p);
            } catch (Vc) {
              (Vc && Vc.suppressReactErrorLogging) || console.error(Vc);
            }
            Qb ? (null === ha && (ha = new Set()), ha.add(c)) : G(c);
            return c;
          }
          null === ca && (ca = b);
          return null;
        }
        function k(a) {
          return (
            null !== R &&
            (R.has(a) || (null !== a.alternate && R.has(a.alternate)))
          );
        }
        function q(a) {
          return (
            null !== qa &&
            (qa.has(a) || (null !== a.alternate && qa.has(a.alternate)))
          );
        }
        function v() {
          return 20 * ((((I() + 100) / 20) | 0) + 1);
        }
        function y(a) {
          return 0 !== ka
            ? ka
            : ja ? (Qb ? 1 : H) : !Hg || a.internalContextTag & 1 ? v() : 1;
        }
        function u(a, b) {
          return z(a, b, !1);
        }
        function z(a, b) {
          for (; null !== a; ) {
            if (0 === a.expirationTime || a.expirationTime > b)
              a.expirationTime = b;
            null !== a.alternate &&
              (0 === a.alternate.expirationTime ||
                a.alternate.expirationTime > b) &&
              (a.alternate.expirationTime = b);
            if (null === a['return'])
              if (3 === a.tag) {
                var c = a.stateNode;
                !ja && c === ra && b < H && ((F = ra = null), (H = 0));
                var d = c,
                  e = b;
                Rb > Ig && E('185');
                if (null === d.nextScheduledRoot)
                  (d.remainingExpirationTime = e),
                    null === O
                      ? ((sa = O = d), (d.nextScheduledRoot = d))
                      : ((O = O.nextScheduledRoot = d),
                        (O.nextScheduledRoot = sa));
                else {
                  var f = d.remainingExpirationTime;
                  if (0 === f || e < f) d.remainingExpirationTime = e;
                }
                Fa ||
                  (la
                    ? Sb && ((ma = d), (na = 1), m(ma, na))
                    : 1 === e ? w(1, null) : L(e));
                !ja && c === ra && b < H && ((F = ra = null), (H = 0));
              } else break;
            a = a['return'];
          }
        }
        function G(a) {
          z(a, 1, !0);
        }
        function I() {
          return (Uc = (((Wc() - Pe) / 10) | 0) + 2);
        }
        function L(a) {
          if (0 !== Tb) {
            if (a > Tb) return;
            Jg(Xc);
          }
          var b = Wc() - Pe;
          Tb = a;
          Xc = Kg(J, { timeout: 10 * (a - 2) - b });
        }
        function N() {
          var a = 0,
            b = null;
          if (null !== O)
            for (var c = O, d = sa; null !== d; ) {
              var e = d.remainingExpirationTime;
              if (0 === e) {
                null === c || null === O ? E('244') : void 0;
                if (d === d.nextScheduledRoot) {
                  sa = O = d.nextScheduledRoot = null;
                  break;
                } else if (d === sa)
                  (sa = e = d.nextScheduledRoot),
                    (O.nextScheduledRoot = e),
                    (d.nextScheduledRoot = null);
                else if (d === O) {
                  O = c;
                  O.nextScheduledRoot = sa;
                  d.nextScheduledRoot = null;
                  break;
                } else
                  (c.nextScheduledRoot = d.nextScheduledRoot),
                    (d.nextScheduledRoot = null);
                d = c.nextScheduledRoot;
              } else {
                if (0 === a || e < a) (a = e), (b = d);
                if (d === O) break;
                c = d;
                d = d.nextScheduledRoot;
              }
            }
          c = ma;
          null !== c && c === b ? Rb++ : (Rb = 0);
          ma = b;
          na = a;
        }
        function J(a) {
          w(0, a);
        }
        function w(a, b) {
          fb = b;
          for (N(); null !== ma && 0 !== na && (0 === a || na <= a) && !Yc; )
            m(ma, na), N();
          null !== fb && ((Tb = 0), (Xc = -1));
          0 !== na && L(na);
          fb = null;
          Yc = !1;
          Rb = 0;
          if (Ub) throw ((a = Zc), (Zc = null), (Ub = !1), a);
        }
        function m(a, c) {
          Fa ? E('245') : void 0;
          Fa = !0;
          if (c <= I()) {
            var d = a.finishedWork;
            null !== d
              ? ((a.finishedWork = null), (a.remainingExpirationTime = b(d)))
              : ((a.finishedWork = null),
                (d = g(a, c)),
                null !== d && (a.remainingExpirationTime = b(d)));
          } else
            (d = a.finishedWork),
              null !== d
                ? ((a.finishedWork = null), (a.remainingExpirationTime = b(d)))
                : ((a.finishedWork = null),
                  (d = g(a, c)),
                  null !== d &&
                    (A()
                      ? (a.finishedWork = d)
                      : (a.remainingExpirationTime = b(d))));
          Fa = !1;
        }
        function A() {
          return null === fb || fb.timeRemaining() > Lg ? !1 : (Yc = !0);
        }
        function Ob(a) {
          null === ma ? E('246') : void 0;
          ma.remainingExpirationTime = 0;
          Ub || ((Ub = !0), (Zc = a));
        }
        var r = hf(a),
          n = jf(a),
          p = r.popHostContainer,
          qg = r.popHostContext,
          x = r.resetHostContainer,
          Me = df(a, r, n, u, y),
          rg = Me.beginWork,
          Gg = Me.beginFailedWork,
          Fg = ef(a, r, n).completeWork;
        r = ff(a, h);
        var zg = r.commitResetTextContent,
          Ne = r.commitPlacement,
          Bg = r.commitDeletion,
          Oe = r.commitWork,
          Dg = r.commitLifeCycles,
          Eg = r.commitAttachRef,
          Ag = r.commitDetachRef,
          Wc = a.now,
          Kg = a.scheduleDeferredCallback,
          Jg = a.cancelDeferredCallback,
          Hg = a.useSyncScheduling,
          yg = a.prepareForCommit,
          Cg = a.resetAfterCommit,
          Pe = Wc(),
          Uc = 2,
          ka = 0,
          ja = !1,
          F = null,
          ra = null,
          H = 0,
          t = null,
          R = null,
          qa = null,
          ha = null,
          ca = null,
          eb = !1,
          Qb = !1,
          Sc = !1,
          sa = null,
          O = null,
          Tb = 0,
          Xc = -1,
          Fa = !1,
          ma = null,
          na = 0,
          Yc = !1,
          Ub = !1,
          Zc = null,
          fb = null,
          la = !1,
          Sb = !1,
          Ig = 1e3,
          Rb = 0,
          Lg = 1;
        return {
          computeAsyncExpiration: v,
          computeExpirationForFiber: y,
          scheduleWork: u,
          batchedUpdates: function(a, b) {
            var c = la;
            la = !0;
            try {
              return a(b);
            } finally {
              (la = c) || Fa || w(1, null);
            }
          },
          unbatchedUpdates: function(a) {
            if (la && !Sb) {
              Sb = !0;
              try {
                return a();
              } finally {
                Sb = !1;
              }
            }
            return a();
          },
          flushSync: function(a) {
            var b = la;
            la = !0;
            try {
              a: {
                var c = ka;
                ka = 1;
                try {
                  var d = a();
                  break a;
                } finally {
                  ka = c;
                }
                d = void 0;
              }
              return d;
            } finally {
              (la = b), Fa ? E('187') : void 0, w(1, null);
            }
          },
          deferredUpdates: function(a) {
            var b = ka;
            ka = v();
            try {
              return a();
            } finally {
              ka = b;
            }
          },
        };
      }
      function lf(a) {
        function b(a) {
          a = od(a);
          return null === a ? null : a.stateNode;
        }
        var c = a.getPublicInstance;
        a = kf(a);
        var d = a.computeAsyncExpiration,
          e = a.computeExpirationForFiber,
          f = a.scheduleWork;
        return {
          createContainer: function(a, b) {
            var c = new Y(3, null, 0);
            a = {
              current: c,
              containerInfo: a,
              pendingChildren: null,
              remainingExpirationTime: 0,
              isReadyForCommit: !1,
              finishedWork: null,
              context: null,
              pendingContext: null,
              hydrate: b,
              nextScheduledRoot: null,
            };
            return (c.stateNode = a);
          },
          updateContainer: function(a, b, c, q) {
            var g = b.current;
            if (c) {
              c = c._reactInternalFiber;
              var h;
              b: {
                2 === kd(c) && 2 === c.tag ? void 0 : E('170');
                for (h = c; 3 !== h.tag; ) {
                  if (le(h)) {
                    h = h.stateNode.__reactInternalMemoizedMergedChildContext;
                    break b;
                  }
                  (h = h['return']) ? void 0 : E('171');
                }
                h = h.stateNode.context;
              }
              c = le(c) ? pe(c, h) : h;
            } else c = D;
            null === b.context ? (b.context = c) : (b.pendingContext = c);
            b = q;
            b = void 0 === b ? null : b;
            q =
              null != a &&
              null != a.type &&
              null != a.type.prototype &&
              !0 === a.type.prototype.unstable_isAsyncReactComponent
                ? d()
                : e(g);
            He(g, {
              expirationTime: q,
              partialState: { element: a },
              callback: b,
              isReplace: !1,
              isForced: !1,
              nextCallback: null,
              next: null,
            });
            f(g, q);
          },
          batchedUpdates: a.batchedUpdates,
          unbatchedUpdates: a.unbatchedUpdates,
          deferredUpdates: a.deferredUpdates,
          flushSync: a.flushSync,
          getPublicRootInstance: function(a) {
            a = a.current;
            if (!a.child) return null;
            switch (a.child.tag) {
              case 5:
                return c(a.child.stateNode);
              default:
                return a.child.stateNode;
            }
          },
          findHostInstance: b,
          findHostInstanceWithNoPortals: function(a) {
            a = pd(a);
            return null === a ? null : a.stateNode;
          },
          injectIntoDevTools: function(a) {
            var c = a.findFiberByHostInstance;
            return Ce(
              B({}, a, {
                findHostInstanceByFiber: function(a) {
                  return b(a);
                },
                findFiberByHostInstance: function(a) {
                  return c ? c(a) : null;
                },
              })
            );
          },
        };
      }
      var mf = Object.freeze({ default: lf }),
        nf = (mf && lf) || mf,
        of = nf['default'] ? nf['default'] : nf;
      function pf(a, b, c) {
        var d =
          3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
        return {
          $$typeof: Ue,
          key: null == d ? null : '' + d,
          children: a,
          containerInfo: b,
          implementation: c,
        };
      }
      var qf =
          'object' === typeof performance &&
          'function' === typeof performance.now,
        rf = void 0;
      rf = qf
        ? function() {
            return performance.now();
          }
        : function() {
            return Date.now();
          };
      var sf = void 0,
        tf = void 0;
      if (l.canUseDOM)
        if (
          'function' !== typeof requestIdleCallback ||
          'function' !== typeof cancelIdleCallback
        ) {
          var uf = null,
            vf = !1,
            wf = -1,
            xf = !1,
            yf = 0,
            zf = 33,
            Af = 33,
            Bf;
          Bf = qf
            ? {
                didTimeout: !1,
                timeRemaining: function() {
                  var a = yf - performance.now();
                  return 0 < a ? a : 0;
                },
              }
            : {
                didTimeout: !1,
                timeRemaining: function() {
                  var a = yf - Date.now();
                  return 0 < a ? a : 0;
                },
              };
          var Cf =
            '__reactIdleCallback$' +
            Math.random()
              .toString(36)
              .slice(2);
          window.addEventListener(
            'message',
            function(a) {
              if (a.source === window && a.data === Cf) {
                vf = !1;
                a = rf();
                if (0 >= yf - a)
                  if (-1 !== wf && wf <= a) Bf.didTimeout = !0;
                  else {
                    xf || ((xf = !0), requestAnimationFrame(Df));
                    return;
                  }
                else Bf.didTimeout = !1;
                wf = -1;
                a = uf;
                uf = null;
                null !== a && a(Bf);
              }
            },
            !1
          );
          var Df = function(a) {
            xf = !1;
            var b = a - yf + Af;
            b < Af && zf < Af
              ? (8 > b && (b = 8), (Af = b < zf ? zf : b))
              : (zf = b);
            yf = a + Af;
            vf || ((vf = !0), window.postMessage(Cf, '*'));
          };
          sf = function(a, b) {
            uf = a;
            null != b &&
              'number' === typeof b.timeout &&
              (wf = rf() + b.timeout);
            xf || ((xf = !0), requestAnimationFrame(Df));
            return 0;
          };
          tf = function() {
            uf = null;
            vf = !1;
            wf = -1;
          };
        } else
          (sf = window.requestIdleCallback), (tf = window.cancelIdleCallback);
      else
        (sf = function(a) {
          return setTimeout(function() {
            a({
              timeRemaining: function() {
                return Infinity;
              },
            });
          });
        }),
          (tf = function(a) {
            clearTimeout(a);
          });
      var Ef = /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,
        Ff = {},
        Gf = {};
      function Hf(a) {
        if (Gf.hasOwnProperty(a)) return !0;
        if (Ff.hasOwnProperty(a)) return !1;
        if (Ef.test(a)) return (Gf[a] = !0);
        Ff[a] = !0;
        return !1;
      }
      function If(a, b, c) {
        var d = wa(b);
        if (d && va(b, c)) {
          var e = d.mutationMethod;
          e
            ? e(a, c)
            : null == c ||
              (d.hasBooleanValue && !c) ||
              (d.hasNumericValue && isNaN(c)) ||
              (d.hasPositiveNumericValue && 1 > c) ||
              (d.hasOverloadedBooleanValue && !1 === c)
              ? Jf(a, b)
              : d.mustUseProperty
                ? (a[d.propertyName] = c)
                : ((b = d.attributeName),
                  (e = d.attributeNamespace)
                    ? a.setAttributeNS(e, b, '' + c)
                    : d.hasBooleanValue ||
                      (d.hasOverloadedBooleanValue && !0 === c)
                      ? a.setAttribute(b, '')
                      : a.setAttribute(b, '' + c));
        } else Kf(a, b, va(b, c) ? c : null);
      }
      function Kf(a, b, c) {
        Hf(b) && (null == c ? a.removeAttribute(b) : a.setAttribute(b, '' + c));
      }
      function Jf(a, b) {
        var c = wa(b);
        c
          ? (b = c.mutationMethod)
            ? b(a, void 0)
            : c.mustUseProperty
              ? (a[c.propertyName] = c.hasBooleanValue ? !1 : '')
              : a.removeAttribute(c.attributeName)
          : a.removeAttribute(b);
      }
      function Lf(a, b) {
        var c = b.value,
          d = b.checked;
        return B({ type: void 0, step: void 0, min: void 0, max: void 0 }, b, {
          defaultChecked: void 0,
          defaultValue: void 0,
          value: null != c ? c : a._wrapperState.initialValue,
          checked: null != d ? d : a._wrapperState.initialChecked,
        });
      }
      function Mf(a, b) {
        var c = b.defaultValue;
        a._wrapperState = {
          initialChecked: null != b.checked ? b.checked : b.defaultChecked,
          initialValue: null != b.value ? b.value : c,
          controlled:
            'checkbox' === b.type || 'radio' === b.type
              ? null != b.checked
              : null != b.value,
        };
      }
      function Nf(a, b) {
        b = b.checked;
        null != b && If(a, 'checked', b);
      }
      function Of(a, b) {
        Nf(a, b);
        var c = b.value;
        if (null != c)
          if (0 === c && '' === a.value) a.value = '0';
          else if ('number' === b.type) {
            if (
              ((b = parseFloat(a.value) || 0),
              c != b || (c == b && a.value != c))
            )
              a.value = '' + c;
          } else a.value !== '' + c && (a.value = '' + c);
        else
          null == b.value &&
            null != b.defaultValue &&
            a.defaultValue !== '' + b.defaultValue &&
            (a.defaultValue = '' + b.defaultValue),
            null == b.checked &&
              null != b.defaultChecked &&
              (a.defaultChecked = !!b.defaultChecked);
      }
      function Pf(a, b) {
        switch (b.type) {
          case 'submit':
          case 'reset':
            break;
          case 'color':
          case 'date':
          case 'datetime':
          case 'datetime-local':
          case 'month':
          case 'time':
          case 'week':
            a.value = '';
            a.value = a.defaultValue;
            break;
          default:
            a.value = a.value;
        }
        b = a.name;
        '' !== b && (a.name = '');
        a.defaultChecked = !a.defaultChecked;
        a.defaultChecked = !a.defaultChecked;
        '' !== b && (a.name = b);
      }
      function Qf(a) {
        var b = '';
        aa.Children.forEach(a, function(a) {
          null == a ||
            ('string' !== typeof a && 'number' !== typeof a) ||
            (b += a);
        });
        return b;
      }
      function Rf(a, b) {
        a = B({ children: void 0 }, b);
        if ((b = Qf(b.children))) a.children = b;
        return a;
      }
      function Sf(a, b, c, d) {
        a = a.options;
        if (b) {
          b = {};
          for (var e = 0; e < c.length; e++) b['$' + c[e]] = !0;
          for (c = 0; c < a.length; c++)
            (e = b.hasOwnProperty('$' + a[c].value)),
              a[c].selected !== e && (a[c].selected = e),
              e && d && (a[c].defaultSelected = !0);
        } else {
          c = '' + c;
          b = null;
          for (e = 0; e < a.length; e++) {
            if (a[e].value === c) {
              a[e].selected = !0;
              d && (a[e].defaultSelected = !0);
              return;
            }
            null !== b || a[e].disabled || (b = a[e]);
          }
          null !== b && (b.selected = !0);
        }
      }
      function Tf(a, b) {
        var c = b.value;
        a._wrapperState = {
          initialValue: null != c ? c : b.defaultValue,
          wasMultiple: !!b.multiple,
        };
      }
      function Uf(a, b) {
        null != b.dangerouslySetInnerHTML ? E('91') : void 0;
        return B({}, b, {
          value: void 0,
          defaultValue: void 0,
          children: '' + a._wrapperState.initialValue,
        });
      }
      function Vf(a, b) {
        var c = b.value;
        null == c &&
          ((c = b.defaultValue),
          (b = b.children),
          null != b &&
            (null != c ? E('92') : void 0,
            Array.isArray(b) && (1 >= b.length ? void 0 : E('93'), (b = b[0])),
            (c = '' + b)),
          null == c && (c = ''));
        a._wrapperState = { initialValue: '' + c };
      }
      function Wf(a, b) {
        var c = b.value;
        null != c &&
          ((c = '' + c),
          c !== a.value && (a.value = c),
          null == b.defaultValue && (a.defaultValue = c));
        null != b.defaultValue && (a.defaultValue = b.defaultValue);
      }
      function Xf(a) {
        var b = a.textContent;
        b === a._wrapperState.initialValue && (a.value = b);
      }
      var Yf = {
        html: 'http://www.w3.org/1999/xhtml',
        mathml: 'http://www.w3.org/1998/Math/MathML',
        svg: 'http://www.w3.org/2000/svg',
      };
      function Zf(a) {
        switch (a) {
          case 'svg':
            return 'http://www.w3.org/2000/svg';
          case 'math':
            return 'http://www.w3.org/1998/Math/MathML';
          default:
            return 'http://www.w3.org/1999/xhtml';
        }
      }
      function $f(a, b) {
        return null == a || 'http://www.w3.org/1999/xhtml' === a
          ? Zf(b)
          : 'http://www.w3.org/2000/svg' === a && 'foreignObject' === b
            ? 'http://www.w3.org/1999/xhtml'
            : a;
      }
      var ag = void 0,
        bg = (function(a) {
          return 'undefined' !== typeof MSApp && MSApp.execUnsafeLocalFunction
            ? function(b, c, d, e) {
                MSApp.execUnsafeLocalFunction(function() {
                  return a(b, c, d, e);
                });
              }
            : a;
        })(function(a, b) {
          if (a.namespaceURI !== Yf.svg || 'innerHTML' in a) a.innerHTML = b;
          else {
            ag = ag || document.createElement('div');
            ag.innerHTML = '\x3csvg\x3e' + b + '\x3c/svg\x3e';
            for (b = ag.firstChild; a.firstChild; ) a.removeChild(a.firstChild);
            for (; b.firstChild; ) a.appendChild(b.firstChild);
          }
        });
      function cg(a, b) {
        if (b) {
          var c = a.firstChild;
          if (c && c === a.lastChild && 3 === c.nodeType) {
            c.nodeValue = b;
            return;
          }
        }
        a.textContent = b;
      }
      var dg = {
          animationIterationCount: !0,
          borderImageOutset: !0,
          borderImageSlice: !0,
          borderImageWidth: !0,
          boxFlex: !0,
          boxFlexGroup: !0,
          boxOrdinalGroup: !0,
          columnCount: !0,
          columns: !0,
          flex: !0,
          flexGrow: !0,
          flexPositive: !0,
          flexShrink: !0,
          flexNegative: !0,
          flexOrder: !0,
          gridRow: !0,
          gridRowEnd: !0,
          gridRowSpan: !0,
          gridRowStart: !0,
          gridColumn: !0,
          gridColumnEnd: !0,
          gridColumnSpan: !0,
          gridColumnStart: !0,
          fontWeight: !0,
          lineClamp: !0,
          lineHeight: !0,
          opacity: !0,
          order: !0,
          orphans: !0,
          tabSize: !0,
          widows: !0,
          zIndex: !0,
          zoom: !0,
          fillOpacity: !0,
          floodOpacity: !0,
          stopOpacity: !0,
          strokeDasharray: !0,
          strokeDashoffset: !0,
          strokeMiterlimit: !0,
          strokeOpacity: !0,
          strokeWidth: !0,
        },
        eg = ['Webkit', 'ms', 'Moz', 'O'];
      Object.keys(dg).forEach(function(a) {
        eg.forEach(function(b) {
          b = b + a.charAt(0).toUpperCase() + a.substring(1);
          dg[b] = dg[a];
        });
      });
      function fg(a, b) {
        a = a.style;
        for (var c in b)
          if (b.hasOwnProperty(c)) {
            var d = 0 === c.indexOf('--');
            var e = c;
            var f = b[c];
            e =
              null == f || 'boolean' === typeof f || '' === f
                ? ''
                : d ||
                  'number' !== typeof f ||
                  0 === f ||
                  (dg.hasOwnProperty(e) && dg[e])
                  ? ('' + f).trim()
                  : f + 'px';
            'float' === c && (c = 'cssFloat');
            d ? a.setProperty(c, e) : (a[c] = e);
          }
      }
      var gg = B(
        { menuitem: !0 },
        {
          area: !0,
          base: !0,
          br: !0,
          col: !0,
          embed: !0,
          hr: !0,
          img: !0,
          input: !0,
          keygen: !0,
          link: !0,
          meta: !0,
          param: !0,
          source: !0,
          track: !0,
          wbr: !0,
        }
      );
      function hg(a, b, c) {
        b &&
          (gg[a] &&
            (null != b.children || null != b.dangerouslySetInnerHTML
              ? E('137', a, c())
              : void 0),
          null != b.dangerouslySetInnerHTML &&
            (null != b.children ? E('60') : void 0,
            'object' === typeof b.dangerouslySetInnerHTML &&
            '__html' in b.dangerouslySetInnerHTML
              ? void 0
              : E('61')),
          null != b.style && 'object' !== typeof b.style
            ? E('62', c())
            : void 0);
      }
      function ig(a, b) {
        if (-1 === a.indexOf('-')) return 'string' === typeof b.is;
        switch (a) {
          case 'annotation-xml':
          case 'color-profile':
          case 'font-face':
          case 'font-face-src':
          case 'font-face-uri':
          case 'font-face-format':
          case 'font-face-name':
          case 'missing-glyph':
            return !1;
          default:
            return !0;
        }
      }
      var jg = Yf.html,
        kg = C.thatReturns('');
      function lg(a, b) {
        a = 9 === a.nodeType || 11 === a.nodeType ? a : a.ownerDocument;
        var c = Hd(a);
        b = Sa[b];
        for (var d = 0; d < b.length; d++) {
          var e = b[d];
          (c.hasOwnProperty(e) && c[e]) ||
            ('topScroll' === e
              ? wd('topScroll', 'scroll', a)
              : 'topFocus' === e || 'topBlur' === e
                ? (wd('topFocus', 'focus', a),
                  wd('topBlur', 'blur', a),
                  (c.topBlur = !0),
                  (c.topFocus = !0))
                : 'topCancel' === e
                  ? (yc('cancel', !0) && wd('topCancel', 'cancel', a),
                    (c.topCancel = !0))
                  : 'topClose' === e
                    ? (yc('close', !0) && wd('topClose', 'close', a),
                      (c.topClose = !0))
                    : Dd.hasOwnProperty(e) && U(e, Dd[e], a),
            (c[e] = !0));
        }
      }
      var mg = {
        topAbort: 'abort',
        topCanPlay: 'canplay',
        topCanPlayThrough: 'canplaythrough',
        topDurationChange: 'durationchange',
        topEmptied: 'emptied',
        topEncrypted: 'encrypted',
        topEnded: 'ended',
        topError: 'error',
        topLoadedData: 'loadeddata',
        topLoadedMetadata: 'loadedmetadata',
        topLoadStart: 'loadstart',
        topPause: 'pause',
        topPlay: 'play',
        topPlaying: 'playing',
        topProgress: 'progress',
        topRateChange: 'ratechange',
        topSeeked: 'seeked',
        topSeeking: 'seeking',
        topStalled: 'stalled',
        topSuspend: 'suspend',
        topTimeUpdate: 'timeupdate',
        topVolumeChange: 'volumechange',
        topWaiting: 'waiting',
      };
      function ng(a, b, c, d) {
        c = 9 === c.nodeType ? c : c.ownerDocument;
        d === jg && (d = Zf(a));
        d === jg
          ? 'script' === a
            ? ((a = c.createElement('div')),
              (a.innerHTML = '\x3cscript\x3e\x3c/script\x3e'),
              (a = a.removeChild(a.firstChild)))
            : (a =
                'string' === typeof b.is
                  ? c.createElement(a, { is: b.is })
                  : c.createElement(a))
          : (a = c.createElementNS(d, a));
        return a;
      }
      function og(a, b) {
        return (9 === b.nodeType ? b : b.ownerDocument).createTextNode(a);
      }
      function pg(a, b, c, d) {
        var e = ig(b, c);
        switch (b) {
          case 'iframe':
          case 'object':
            U('topLoad', 'load', a);
            var f = c;
            break;
          case 'video':
          case 'audio':
            for (f in mg) mg.hasOwnProperty(f) && U(f, mg[f], a);
            f = c;
            break;
          case 'source':
            U('topError', 'error', a);
            f = c;
            break;
          case 'img':
          case 'image':
            U('topError', 'error', a);
            U('topLoad', 'load', a);
            f = c;
            break;
          case 'form':
            U('topReset', 'reset', a);
            U('topSubmit', 'submit', a);
            f = c;
            break;
          case 'details':
            U('topToggle', 'toggle', a);
            f = c;
            break;
          case 'input':
            Mf(a, c);
            f = Lf(a, c);
            U('topInvalid', 'invalid', a);
            lg(d, 'onChange');
            break;
          case 'option':
            f = Rf(a, c);
            break;
          case 'select':
            Tf(a, c);
            f = B({}, c, { value: void 0 });
            U('topInvalid', 'invalid', a);
            lg(d, 'onChange');
            break;
          case 'textarea':
            Vf(a, c);
            f = Uf(a, c);
            U('topInvalid', 'invalid', a);
            lg(d, 'onChange');
            break;
          default:
            f = c;
        }
        hg(b, f, kg);
        var g = f,
          h;
        for (h in g)
          if (g.hasOwnProperty(h)) {
            var k = g[h];
            'style' === h
              ? fg(a, k, kg)
              : 'dangerouslySetInnerHTML' === h
                ? ((k = k ? k.__html : void 0), null != k && bg(a, k))
                : 'children' === h
                  ? 'string' === typeof k
                    ? ('textarea' !== b || '' !== k) && cg(a, k)
                    : 'number' === typeof k && cg(a, '' + k)
                  : 'suppressContentEditableWarning' !== h &&
                    'suppressHydrationWarning' !== h &&
                    'autoFocus' !== h &&
                    (Ra.hasOwnProperty(h)
                      ? null != k && lg(d, h)
                      : e ? Kf(a, h, k) : null != k && If(a, h, k));
          }
        switch (b) {
          case 'input':
            Bc(a);
            Pf(a, c);
            break;
          case 'textarea':
            Bc(a);
            Xf(a, c);
            break;
          case 'option':
            null != c.value && a.setAttribute('value', c.value);
            break;
          case 'select':
            a.multiple = !!c.multiple;
            b = c.value;
            null != b
              ? Sf(a, !!c.multiple, b, !1)
              : null != c.defaultValue &&
                Sf(a, !!c.multiple, c.defaultValue, !0);
            break;
          default:
            'function' === typeof f.onClick && (a.onclick = C);
        }
      }
      function sg(a, b, c, d, e) {
        var f = null;
        switch (b) {
          case 'input':
            c = Lf(a, c);
            d = Lf(a, d);
            f = [];
            break;
          case 'option':
            c = Rf(a, c);
            d = Rf(a, d);
            f = [];
            break;
          case 'select':
            c = B({}, c, { value: void 0 });
            d = B({}, d, { value: void 0 });
            f = [];
            break;
          case 'textarea':
            c = Uf(a, c);
            d = Uf(a, d);
            f = [];
            break;
          default:
            'function' !== typeof c.onClick &&
              'function' === typeof d.onClick &&
              (a.onclick = C);
        }
        hg(b, d, kg);
        var g, h;
        a = null;
        for (g in c)
          if (!d.hasOwnProperty(g) && c.hasOwnProperty(g) && null != c[g])
            if ('style' === g)
              for (h in ((b = c[g]), b))
                b.hasOwnProperty(h) && (a || (a = {}), (a[h] = ''));
            else
              'dangerouslySetInnerHTML' !== g &&
                'children' !== g &&
                'suppressContentEditableWarning' !== g &&
                'suppressHydrationWarning' !== g &&
                'autoFocus' !== g &&
                (Ra.hasOwnProperty(g)
                  ? f || (f = [])
                  : (f = f || []).push(g, null));
        for (g in d) {
          var k = d[g];
          b = null != c ? c[g] : void 0;
          if (d.hasOwnProperty(g) && k !== b && (null != k || null != b))
            if ('style' === g)
              if (b) {
                for (h in b)
                  !b.hasOwnProperty(h) ||
                    (k && k.hasOwnProperty(h)) ||
                    (a || (a = {}), (a[h] = ''));
                for (h in k)
                  k.hasOwnProperty(h) &&
                    b[h] !== k[h] &&
                    (a || (a = {}), (a[h] = k[h]));
              } else a || (f || (f = []), f.push(g, a)), (a = k);
            else
              'dangerouslySetInnerHTML' === g
                ? ((k = k ? k.__html : void 0),
                  (b = b ? b.__html : void 0),
                  null != k && b !== k && (f = f || []).push(g, '' + k))
                : 'children' === g
                  ? b === k ||
                    ('string' !== typeof k && 'number' !== typeof k) ||
                    (f = f || []).push(g, '' + k)
                  : 'suppressContentEditableWarning' !== g &&
                    'suppressHydrationWarning' !== g &&
                    (Ra.hasOwnProperty(g)
                      ? (null != k && lg(e, g), f || b === k || (f = []))
                      : (f = f || []).push(g, k));
        }
        a && (f = f || []).push('style', a);
        return f;
      }
      function tg(a, b, c, d, e) {
        'input' === c && 'radio' === e.type && null != e.name && Nf(a, e);
        ig(c, d);
        d = ig(c, e);
        for (var f = 0; f < b.length; f += 2) {
          var g = b[f],
            h = b[f + 1];
          'style' === g
            ? fg(a, h, kg)
            : 'dangerouslySetInnerHTML' === g
              ? bg(a, h)
              : 'children' === g
                ? cg(a, h)
                : d
                  ? null != h ? Kf(a, g, h) : a.removeAttribute(g)
                  : null != h ? If(a, g, h) : Jf(a, g);
        }
        switch (c) {
          case 'input':
            Of(a, e);
            break;
          case 'textarea':
            Wf(a, e);
            break;
          case 'select':
            (a._wrapperState.initialValue = void 0),
              (b = a._wrapperState.wasMultiple),
              (a._wrapperState.wasMultiple = !!e.multiple),
              (c = e.value),
              null != c
                ? Sf(a, !!e.multiple, c, !1)
                : b !== !!e.multiple &&
                  (null != e.defaultValue
                    ? Sf(a, !!e.multiple, e.defaultValue, !0)
                    : Sf(a, !!e.multiple, e.multiple ? [] : '', !1));
        }
      }
      function ug(a, b, c, d, e) {
        switch (b) {
          case 'iframe':
          case 'object':
            U('topLoad', 'load', a);
            break;
          case 'video':
          case 'audio':
            for (var f in mg) mg.hasOwnProperty(f) && U(f, mg[f], a);
            break;
          case 'source':
            U('topError', 'error', a);
            break;
          case 'img':
          case 'image':
            U('topError', 'error', a);
            U('topLoad', 'load', a);
            break;
          case 'form':
            U('topReset', 'reset', a);
            U('topSubmit', 'submit', a);
            break;
          case 'details':
            U('topToggle', 'toggle', a);
            break;
          case 'input':
            Mf(a, c);
            U('topInvalid', 'invalid', a);
            lg(e, 'onChange');
            break;
          case 'select':
            Tf(a, c);
            U('topInvalid', 'invalid', a);
            lg(e, 'onChange');
            break;
          case 'textarea':
            Vf(a, c), U('topInvalid', 'invalid', a), lg(e, 'onChange');
        }
        hg(b, c, kg);
        d = null;
        for (var g in c)
          c.hasOwnProperty(g) &&
            ((f = c[g]),
            'children' === g
              ? 'string' === typeof f
                ? a.textContent !== f && (d = ['children', f])
                : 'number' === typeof f &&
                  a.textContent !== '' + f &&
                  (d = ['children', '' + f])
              : Ra.hasOwnProperty(g) && null != f && lg(e, g));
        switch (b) {
          case 'input':
            Bc(a);
            Pf(a, c);
            break;
          case 'textarea':
            Bc(a);
            Xf(a, c);
            break;
          case 'select':
          case 'option':
            break;
          default:
            'function' === typeof c.onClick && (a.onclick = C);
        }
        return d;
      }
      function vg(a, b) {
        return a.nodeValue !== b;
      }
      var wg = Object.freeze({
        createElement: ng,
        createTextNode: og,
        setInitialProperties: pg,
        diffProperties: sg,
        updateProperties: tg,
        diffHydratedProperties: ug,
        diffHydratedText: vg,
        warnForUnmatchedText: function() {},
        warnForDeletedHydratableElement: function() {},
        warnForDeletedHydratableText: function() {},
        warnForInsertedHydratedElement: function() {},
        warnForInsertedHydratedText: function() {},
        restoreControlledState: function(a, b, c) {
          switch (b) {
            case 'input':
              Of(a, c);
              b = c.name;
              if ('radio' === c.type && null != b) {
                for (c = a; c.parentNode; ) c = c.parentNode;
                c = c.querySelectorAll(
                  'input[name\x3d' +
                    JSON.stringify('' + b) +
                    '][type\x3d"radio"]'
                );
                for (b = 0; b < c.length; b++) {
                  var d = c[b];
                  if (d !== a && d.form === a.form) {
                    var e = rb(d);
                    e ? void 0 : E('90');
                    Cc(d);
                    Of(d, e);
                  }
                }
              }
              break;
            case 'textarea':
              Wf(a, c);
              break;
            case 'select':
              (b = c.value), null != b && Sf(a, !!c.multiple, b, !1);
          }
        },
      });
      nc.injectFiberControlledHostComponent(wg);
      var xg = null,
        Mg = null;
      function Ng(a) {
        return !(
          !a ||
          (1 !== a.nodeType &&
            9 !== a.nodeType &&
            11 !== a.nodeType &&
            (8 !== a.nodeType ||
              ' react-mount-point-unstable ' !== a.nodeValue))
        );
      }
      function Og(a) {
        a = a ? (9 === a.nodeType ? a.documentElement : a.firstChild) : null;
        return !(!a || 1 !== a.nodeType || !a.hasAttribute('data-reactroot'));
      }
      var Z = of({
        getRootHostContext: function(a) {
          var b = a.nodeType;
          switch (b) {
            case 9:
            case 11:
              a = (a = a.documentElement) ? a.namespaceURI : $f(null, '');
              break;
            default:
              (b = 8 === b ? a.parentNode : a),
                (a = b.namespaceURI || null),
                (b = b.tagName),
                (a = $f(a, b));
          }
          return a;
        },
        getChildHostContext: function(a, b) {
          return $f(a, b);
        },
        getPublicInstance: function(a) {
          return a;
        },
        prepareForCommit: function() {
          xg = td;
          var a = da();
          if (Kd(a)) {
            if ('selectionStart' in a)
              var b = { start: a.selectionStart, end: a.selectionEnd };
            else
              a: {
                var c = window.getSelection && window.getSelection();
                if (c && 0 !== c.rangeCount) {
                  b = c.anchorNode;
                  var d = c.anchorOffset,
                    e = c.focusNode;
                  c = c.focusOffset;
                  try {
                    b.nodeType, e.nodeType;
                  } catch (z) {
                    b = null;
                    break a;
                  }
                  var f = 0,
                    g = -1,
                    h = -1,
                    k = 0,
                    q = 0,
                    v = a,
                    y = null;
                  b: for (;;) {
                    for (var u; ; ) {
                      v !== b || (0 !== d && 3 !== v.nodeType) || (g = f + d);
                      v !== e || (0 !== c && 3 !== v.nodeType) || (h = f + c);
                      3 === v.nodeType && (f += v.nodeValue.length);
                      if (null === (u = v.firstChild)) break;
                      y = v;
                      v = u;
                    }
                    for (;;) {
                      if (v === a) break b;
                      y === b && ++k === d && (g = f);
                      y === e && ++q === c && (h = f);
                      if (null !== (u = v.nextSibling)) break;
                      v = y;
                      y = v.parentNode;
                    }
                    v = u;
                  }
                  b = -1 === g || -1 === h ? null : { start: g, end: h };
                } else b = null;
              }
            b = b || { start: 0, end: 0 };
          } else b = null;
          Mg = { focusedElem: a, selectionRange: b };
          ud(!1);
        },
        resetAfterCommit: function() {
          var a = Mg,
            b = da(),
            c = a.focusedElem,
            d = a.selectionRange;
          if (b !== c && fa(document.documentElement, c)) {
            if (Kd(c))
              if (
                ((b = d.start),
                (a = d.end),
                void 0 === a && (a = b),
                'selectionStart' in c)
              )
                (c.selectionStart = b),
                  (c.selectionEnd = Math.min(a, c.value.length));
              else if (window.getSelection) {
                b = window.getSelection();
                var e = c[Eb()].length;
                a = Math.min(d.start, e);
                d = void 0 === d.end ? a : Math.min(d.end, e);
                !b.extend && a > d && ((e = d), (d = a), (a = e));
                e = Jd(c, a);
                var f = Jd(c, d);
                if (
                  e &&
                  f &&
                  (1 !== b.rangeCount ||
                    b.anchorNode !== e.node ||
                    b.anchorOffset !== e.offset ||
                    b.focusNode !== f.node ||
                    b.focusOffset !== f.offset)
                ) {
                  var g = document.createRange();
                  g.setStart(e.node, e.offset);
                  b.removeAllRanges();
                  a > d
                    ? (b.addRange(g), b.extend(f.node, f.offset))
                    : (g.setEnd(f.node, f.offset), b.addRange(g));
                }
              }
            b = [];
            for (a = c; (a = a.parentNode); )
              1 === a.nodeType &&
                b.push({ element: a, left: a.scrollLeft, top: a.scrollTop });
            ia(c);
            for (c = 0; c < b.length; c++)
              (a = b[c]),
                (a.element.scrollLeft = a.left),
                (a.element.scrollTop = a.top);
          }
          Mg = null;
          ud(xg);
          xg = null;
        },
        createInstance: function(a, b, c, d, e) {
          a = ng(a, b, c, d);
          a[Q] = e;
          a[ob] = b;
          return a;
        },
        appendInitialChild: function(a, b) {
          a.appendChild(b);
        },
        finalizeInitialChildren: function(a, b, c, d) {
          pg(a, b, c, d);
          a: {
            switch (b) {
              case 'button':
              case 'input':
              case 'select':
              case 'textarea':
                a = !!c.autoFocus;
                break a;
            }
            a = !1;
          }
          return a;
        },
        prepareUpdate: function(a, b, c, d, e) {
          return sg(a, b, c, d, e);
        },
        shouldSetTextContent: function(a, b) {
          return (
            'textarea' === a ||
            'string' === typeof b.children ||
            'number' === typeof b.children ||
            ('object' === typeof b.dangerouslySetInnerHTML &&
              null !== b.dangerouslySetInnerHTML &&
              'string' === typeof b.dangerouslySetInnerHTML.__html)
          );
        },
        shouldDeprioritizeSubtree: function(a, b) {
          return !!b.hidden;
        },
        createTextInstance: function(a, b, c, d) {
          a = og(a, b);
          a[Q] = d;
          return a;
        },
        now: rf,
        mutation: {
          commitMount: function(a) {
            a.focus();
          },
          commitUpdate: function(a, b, c, d, e) {
            a[ob] = e;
            tg(a, b, c, d, e);
          },
          resetTextContent: function(a) {
            a.textContent = '';
          },
          commitTextUpdate: function(a, b, c) {
            a.nodeValue = c;
          },
          appendChild: function(a, b) {
            a.appendChild(b);
          },
          appendChildToContainer: function(a, b) {
            8 === a.nodeType
              ? a.parentNode.insertBefore(b, a)
              : a.appendChild(b);
          },
          insertBefore: function(a, b, c) {
            a.insertBefore(b, c);
          },
          insertInContainerBefore: function(a, b, c) {
            8 === a.nodeType
              ? a.parentNode.insertBefore(b, c)
              : a.insertBefore(b, c);
          },
          removeChild: function(a, b) {
            a.removeChild(b);
          },
          removeChildFromContainer: function(a, b) {
            8 === a.nodeType ? a.parentNode.removeChild(b) : a.removeChild(b);
          },
        },
        hydration: {
          canHydrateInstance: function(a, b) {
            return 1 !== a.nodeType ||
            b.toLowerCase() !== a.nodeName.toLowerCase()
              ? null
              : a;
          },
          canHydrateTextInstance: function(a, b) {
            return '' === b || 3 !== a.nodeType ? null : a;
          },
          getNextHydratableSibling: function(a) {
            for (a = a.nextSibling; a && 1 !== a.nodeType && 3 !== a.nodeType; )
              a = a.nextSibling;
            return a;
          },
          getFirstHydratableChild: function(a) {
            for (a = a.firstChild; a && 1 !== a.nodeType && 3 !== a.nodeType; )
              a = a.nextSibling;
            return a;
          },
          hydrateInstance: function(a, b, c, d, e, f) {
            a[Q] = f;
            a[ob] = c;
            return ug(a, b, c, e, d);
          },
          hydrateTextInstance: function(a, b, c) {
            a[Q] = c;
            return vg(a, b);
          },
          didNotMatchHydratedContainerTextInstance: function() {},
          didNotMatchHydratedTextInstance: function() {},
          didNotHydrateContainerInstance: function() {},
          didNotHydrateInstance: function() {},
          didNotFindHydratableContainerInstance: function() {},
          didNotFindHydratableContainerTextInstance: function() {},
          didNotFindHydratableInstance: function() {},
          didNotFindHydratableTextInstance: function() {},
        },
        scheduleDeferredCallback: sf,
        cancelDeferredCallback: tf,
        useSyncScheduling: !0,
      });
      rc = Z.batchedUpdates;
      function Pg(a, b, c, d, e) {
        Ng(c) ? void 0 : E('200');
        var f = c._reactRootContainer;
        if (f) Z.updateContainer(b, f, a, e);
        else {
          d = d || Og(c);
          if (!d) for (f = void 0; (f = c.lastChild); ) c.removeChild(f);
          var g = Z.createContainer(c, d);
          f = c._reactRootContainer = g;
          Z.unbatchedUpdates(function() {
            Z.updateContainer(b, g, a, e);
          });
        }
        return Z.getPublicRootInstance(f);
      }
      function Qg(a, b) {
        var c =
          2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
        Ng(b) ? void 0 : E('200');
        return pf(a, b, null, c);
      }
      function Rg(a, b) {
        this._reactRootContainer = Z.createContainer(a, b);
      }
      Rg.prototype.render = function(a, b) {
        Z.updateContainer(a, this._reactRootContainer, null, b);
      };
      Rg.prototype.unmount = function(a) {
        Z.updateContainer(null, this._reactRootContainer, null, a);
      };
      var Sg = {
        createPortal: Qg,
        findDOMNode: function(a) {
          if (null == a) return null;
          if (1 === a.nodeType) return a;
          var b = a._reactInternalFiber;
          if (b) return Z.findHostInstance(b);
          'function' === typeof a.render ? E('188') : E('213', Object.keys(a));
        },
        hydrate: function(a, b, c) {
          return Pg(null, a, b, !0, c);
        },
        render: function(a, b, c) {
          return Pg(null, a, b, !1, c);
        },
        unstable_renderSubtreeIntoContainer: function(a, b, c, d) {
          null == a || void 0 === a._reactInternalFiber ? E('38') : void 0;
          return Pg(a, b, c, !1, d);
        },
        unmountComponentAtNode: function(a) {
          Ng(a) ? void 0 : E('40');
          return a._reactRootContainer
            ? (Z.unbatchedUpdates(function() {
                Pg(null, null, a, !1, function() {
                  a._reactRootContainer = null;
                });
              }),
              !0)
            : !1;
        },
        unstable_createPortal: Qg,
        unstable_batchedUpdates: tc,
        unstable_deferredUpdates: Z.deferredUpdates,
        flushSync: Z.flushSync,
        __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
          EventPluginHub: mb,
          EventPluginRegistry: Va,
          EventPropagators: Cb,
          ReactControlledComponent: qc,
          ReactDOMComponentTree: sb,
          ReactDOMEventListener: xd,
        },
      };
      Z.injectIntoDevTools({
        findFiberByHostInstance: pb,
        bundleType: 0,
        version: '16.2.0',
        rendererPackageName: 'react-dom',
      });
      var Tg = Object.freeze({ default: Sg }),
        Ug = (Tg && Sg) || Tg;
      module.exports = Ug['default'] ? Ug['default'] : Ug;

      /***/
    },
    /* 26 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';
      /**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

      var canUseDOM = !!(
        typeof window !== 'undefined' &&
        window.document &&
        window.document.createElement
      );

      /**
 * Simple, lightweight module assisting with the detection and context of
 * Worker. Helps avoid circular dependencies and allows code to reason about
 * whether or not they are in a Worker, even if they never include the main
 * `ReactWorker` dependency.
 */
      var ExecutionEnvironment = {
        canUseDOM: canUseDOM,

        canUseWorkers: typeof Worker !== 'undefined',

        canUseEventListeners:
          canUseDOM && !!(window.addEventListener || window.attachEvent),

        canUseViewport: canUseDOM && !!window.screen,

        isInWorker: !canUseDOM, // For now, this is true - might change in the future.
      };

      module.exports = ExecutionEnvironment;

      /***/
    },
    /* 27 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      /**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @typechecks
 */

      var emptyFunction = __webpack_require__(3);

      /**
 * Upstream version of event listener. Does not take into account specific
 * nature of platform.
 */
      var EventListener = {
        /**
   * Listen to DOM events during the bubble phase.
   *
   * @param {DOMEventTarget} target DOM element to register listener on.
   * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.
   * @param {function} callback Callback function.
   * @return {object} Object with a `remove` method.
   */
        listen: function listen(target, eventType, callback) {
          if (target.addEventListener) {
            target.addEventListener(eventType, callback, false);
            return {
              remove: function remove() {
                target.removeEventListener(eventType, callback, false);
              },
            };
          } else if (target.attachEvent) {
            target.attachEvent('on' + eventType, callback);
            return {
              remove: function remove() {
                target.detachEvent('on' + eventType, callback);
              },
            };
          }
        },

        /**
   * Listen to DOM events during the capture phase.
   *
   * @param {DOMEventTarget} target DOM element to register listener on.
   * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.
   * @param {function} callback Callback function.
   * @return {object} Object with a `remove` method.
   */
        capture: function capture(target, eventType, callback) {
          if (target.addEventListener) {
            target.addEventListener(eventType, callback, true);
            return {
              remove: function remove() {
                target.removeEventListener(eventType, callback, true);
              },
            };
          } else {
            if (false) {
              console.error(
                'Attempted to listen to events during the capture phase on a ' +
                  'browser that does not support the capture phase. Your application ' +
                  'will not receive some events.'
              );
            }
            return {
              remove: emptyFunction,
            };
          }
        },

        registerDefault: function registerDefault() {},
      };

      module.exports = EventListener;

      /***/
    },
    /* 28 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      /**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @typechecks
 */

      /* eslint-disable fb-www/typeof-undefined */

      /**
 * Same as document.activeElement but wraps in a try-catch block. In IE it is
 * not safe to call document.activeElement if there is nothing focused.
 *
 * The activeElement will be null only if the document or document body is not
 * yet defined.
 *
 * @param {?DOMDocument} doc Defaults to current document.
 * @return {?DOMElement}
 */
      function getActiveElement(doc) /*?DOMElement*/ {
        doc = doc || (typeof document !== 'undefined' ? document : undefined);
        if (typeof doc === 'undefined') {
          return null;
        }
        try {
          return doc.activeElement || doc.body;
        } catch (e) {
          return doc.body;
        }
      }

      module.exports = getActiveElement;

      /***/
    },
    /* 29 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';
      /**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @typechecks
 * 
 */

      /*eslint-disable no-self-compare */

      var hasOwnProperty = Object.prototype.hasOwnProperty;

      /**
 * inlined Object.is polyfill to avoid requiring consumers ship their own
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
 */
      function is(x, y) {
        // SameValue algorithm
        if (x === y) {
          // Steps 1-5, 7-10
          // Steps 6.b-6.e: +0 != -0
          // Added the nonzero y check to make Flow happy, but it is redundant
          return x !== 0 || y !== 0 || 1 / x === 1 / y;
        } else {
          // Step 6.a: NaN == NaN
          return x !== x && y !== y;
        }
      }

      /**
 * Performs equality by iterating through keys on an object and returning false
 * when any key has values which are not strictly equal between the arguments.
 * Returns true when the values of all keys are strictly equal.
 */
      function shallowEqual(objA, objB) {
        if (is(objA, objB)) {
          return true;
        }

        if (
          typeof objA !== 'object' ||
          objA === null ||
          typeof objB !== 'object' ||
          objB === null
        ) {
          return false;
        }

        var keysA = Object.keys(objA);
        var keysB = Object.keys(objB);

        if (keysA.length !== keysB.length) {
          return false;
        }

        // Test for A's keys different from B.
        for (var i = 0; i < keysA.length; i++) {
          if (
            !hasOwnProperty.call(objB, keysA[i]) ||
            !is(objA[keysA[i]], objB[keysA[i]])
          ) {
            return false;
          }
        }

        return true;
      }

      module.exports = shallowEqual;

      /***/
    },
    /* 30 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      /**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 */

      var isTextNode = __webpack_require__(31);

      /*eslint-disable no-bitwise */

      /**
 * Checks if a given DOM node contains or is another DOM node.
 */
      function containsNode(outerNode, innerNode) {
        if (!outerNode || !innerNode) {
          return false;
        } else if (outerNode === innerNode) {
          return true;
        } else if (isTextNode(outerNode)) {
          return false;
        } else if (isTextNode(innerNode)) {
          return containsNode(outerNode, innerNode.parentNode);
        } else if ('contains' in outerNode) {
          return outerNode.contains(innerNode);
        } else if (outerNode.compareDocumentPosition) {
          return !!(outerNode.compareDocumentPosition(innerNode) & 16);
        } else {
          return false;
        }
      }

      module.exports = containsNode;

      /***/
    },
    /* 31 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      /**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @typechecks
 */

      var isNode = __webpack_require__(32);

      /**
 * @param {*} object The object to check.
 * @return {boolean} Whether or not the object is a DOM text node.
 */
      function isTextNode(object) {
        return isNode(object) && object.nodeType == 3;
      }

      module.exports = isTextNode;

      /***/
    },
    /* 32 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      /**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @typechecks
 */

      /**
 * @param {*} object The object to check.
 * @return {boolean} Whether or not the object is a DOM node.
 */
      function isNode(object) {
        var doc = object ? object.ownerDocument || object : document;
        var defaultView = doc.defaultView || window;
        return !!(
          object &&
          (typeof defaultView.Node === 'function'
            ? object instanceof defaultView.Node
            : typeof object === 'object' &&
              typeof object.nodeType === 'number' &&
              typeof object.nodeName === 'string')
        );
      }

      module.exports = isNode;

      /***/
    },
    /* 33 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';
      /**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

      /**
 * @param {DOMElement} node input/textarea to focus
 */

      function focusNode(node) {
        // IE8 can throw "Can't move focus to the control because it is invisible,
        // not enabled, or of a type that does not accept the focus." for all kinds of
        // reasons that are too expensive and fragile to test.
        try {
          node.focus();
        } catch (e) {}
      }

      module.exports = focusNode;

      /***/
    },
    /* 34 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireWildcard(__webpack_require__(0));

      var _ErrorOverlay = _interopRequireDefault(__webpack_require__(6));

      var _Footer = _interopRequireDefault(__webpack_require__(7));

      var _Header = _interopRequireDefault(__webpack_require__(8));

      var _CodeBlock = _interopRequireDefault(__webpack_require__(9));

      var _generateAnsiHTML = _interopRequireDefault(__webpack_require__(10));

      var _parseCompileError = _interopRequireDefault(__webpack_require__(38));

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/containers/CompileErrorContainer.js';

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      function _interopRequireWildcard(obj) {
        if (obj && obj.__esModule) {
          return obj;
        } else {
          var newObj = {};
          if (obj != null) {
            for (var key in obj) {
              if (Object.prototype.hasOwnProperty.call(obj, key))
                newObj[key] = obj[key];
            }
          }
          newObj.default = obj;
          return newObj;
        }
      }

      function _typeof(obj) {
        if (
          typeof Symbol === 'function' &&
          typeof Symbol.iterator === 'symbol'
        ) {
          _typeof = function _typeof(obj) {
            return typeof obj;
          };
        } else {
          _typeof = function _typeof(obj) {
            return obj &&
            typeof Symbol === 'function' &&
            obj.constructor === Symbol &&
            obj !== Symbol.prototype
              ? 'symbol'
              : typeof obj;
          };
        }
        return _typeof(obj);
      }

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError('Cannot call a class as a function');
        }
      }

      function _defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ('value' in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }

      function _createClass(Constructor, protoProps, staticProps) {
        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
        if (staticProps) _defineProperties(Constructor, staticProps);
        return Constructor;
      }

      function _possibleConstructorReturn(self, call) {
        if (
          call &&
          (_typeof(call) === 'object' || typeof call === 'function')
        ) {
          return call;
        }
        if (!self) {
          throw new ReferenceError(
            "this hasn't been initialised - super() hasn't been called"
          );
        }
        return self;
      }

      function _inherits(subClass, superClass) {
        if (typeof superClass !== 'function' && superClass !== null) {
          throw new TypeError(
            'Super expression must either be null or a function'
          );
        }
        subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
            value: subClass,
            enumerable: false,
            writable: true,
            configurable: true,
          },
        });
        if (superClass)
          Object.setPrototypeOf
            ? Object.setPrototypeOf(subClass, superClass)
            : (subClass.__proto__ = superClass);
      }

      var codeAnchorStyle = {
        cursor: 'pointer',
      };

      var CompileErrorContainer =
        /*#__PURE__*/
        (function(_PureComponent) {
          _inherits(CompileErrorContainer, _PureComponent);

          function CompileErrorContainer() {
            _classCallCheck(this, CompileErrorContainer);

            return _possibleConstructorReturn(
              this,
              (CompileErrorContainer.__proto__ ||
                Object.getPrototypeOf(CompileErrorContainer))
                .apply(this, arguments)
            );
          }

          _createClass(CompileErrorContainer, [
            {
              key: 'render',
              value: function render() {
                var _props = this.props,
                  error = _props.error,
                  editorHandler = _props.editorHandler;
                var errLoc = (0, _parseCompileError.default)(error);
                var canOpenInEditor = errLoc !== null && editorHandler !== null;
                return _react.default.createElement(
                  _ErrorOverlay.default,
                  {
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 33,
                    },
                    __self: this,
                  },
                  _react.default.createElement(_Header.default, {
                    headerText: 'Failed to compile',
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 34,
                    },
                    __self: this,
                  }),
                  _react.default.createElement(
                    'a',
                    {
                      onClick:
                        canOpenInEditor && errLoc
                          ? function() {
                              return editorHandler(errLoc);
                            }
                          : null,
                      style: canOpenInEditor ? codeAnchorStyle : null,
                      __source: {
                        fileName: _jsxFileName,
                        lineNumber: 35,
                      },
                      __self: this,
                    },
                    _react.default.createElement(_CodeBlock.default, {
                      main: true,
                      codeHTML: (0, _generateAnsiHTML.default)(error),
                      __source: {
                        fileName: _jsxFileName,
                        lineNumber: 41,
                      },
                      __self: this,
                    })
                  ),
                  _react.default.createElement(_Footer.default, {
                    line1:
                      'This error occurred during the build time and cannot be dismissed.',
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 43,
                    },
                    __self: this,
                  })
                );
              },
            },
          ]);

          return CompileErrorContainer;
        })(_react.PureComponent);

      var _default = CompileErrorContainer;
      exports.default = _default;

      /***/
    },
    /* 35 */
    /***/ function(module, exports, __webpack_require__) {
      module.exports = {
        XmlEntities: __webpack_require__(36),
        Html4Entities: __webpack_require__(37),
        Html5Entities: __webpack_require__(12),
        AllHtmlEntities: __webpack_require__(12),
      };

      /***/
    },
    /* 36 */
    /***/ function(module, exports) {
      var ALPHA_INDEX = {
        '&lt': '<',
        '&gt': '>',
        '&quot': '"',
        '&apos': "'",
        '&amp': '&',
        '&lt;': '<',
        '&gt;': '>',
        '&quot;': '"',
        '&apos;': "'",
        '&amp;': '&',
      };

      var CHAR_INDEX = {
        60: 'lt',
        62: 'gt',
        34: 'quot',
        39: 'apos',
        38: 'amp',
      };

      var CHAR_S_INDEX = {
        '<': '&lt;',
        '>': '&gt;',
        '"': '&quot;',
        "'": '&apos;',
        '&': '&amp;',
      };

      /**
 * @constructor
 */
      function XmlEntities() {}

      /**
 * @param {String} str
 * @returns {String}
 */
      XmlEntities.prototype.encode = function(str) {
        if (!str || !str.length) {
          return '';
        }
        return str.replace(/<|>|"|'|&/g, function(s) {
          return CHAR_S_INDEX[s];
        });
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      XmlEntities.encode = function(str) {
        return new XmlEntities().encode(str);
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      XmlEntities.prototype.decode = function(str) {
        if (!str || !str.length) {
          return '';
        }
        return str.replace(/&#?[0-9a-zA-Z]+;?/g, function(s) {
          if (s.charAt(1) === '#') {
            var code =
              s.charAt(2).toLowerCase() === 'x'
                ? parseInt(s.substr(3), 16)
                : parseInt(s.substr(2));

            if (isNaN(code) || code < -32768 || code > 65535) {
              return '';
            }
            return String.fromCharCode(code);
          }
          return ALPHA_INDEX[s] || s;
        });
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      XmlEntities.decode = function(str) {
        return new XmlEntities().decode(str);
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      XmlEntities.prototype.encodeNonUTF = function(str) {
        if (!str || !str.length) {
          return '';
        }
        var strLength = str.length;
        var result = '';
        var i = 0;
        while (i < strLength) {
          var c = str.charCodeAt(i);
          var alpha = CHAR_INDEX[c];
          if (alpha) {
            result += '&' + alpha + ';';
            i++;
            continue;
          }
          if (c < 32 || c > 126) {
            result += '&#' + c + ';';
          } else {
            result += str.charAt(i);
          }
          i++;
        }
        return result;
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      XmlEntities.encodeNonUTF = function(str) {
        return new XmlEntities().encodeNonUTF(str);
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      XmlEntities.prototype.encodeNonASCII = function(str) {
        if (!str || !str.length) {
          return '';
        }
        var strLenght = str.length;
        var result = '';
        var i = 0;
        while (i < strLenght) {
          var c = str.charCodeAt(i);
          if (c <= 255) {
            result += str[i++];
            continue;
          }
          result += '&#' + c + ';';
          i++;
        }
        return result;
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      XmlEntities.encodeNonASCII = function(str) {
        return new XmlEntities().encodeNonASCII(str);
      };

      module.exports = XmlEntities;

      /***/
    },
    /* 37 */
    /***/ function(module, exports) {
      var HTML_ALPHA = [
        'apos',
        'nbsp',
        'iexcl',
        'cent',
        'pound',
        'curren',
        'yen',
        'brvbar',
        'sect',
        'uml',
        'copy',
        'ordf',
        'laquo',
        'not',
        'shy',
        'reg',
        'macr',
        'deg',
        'plusmn',
        'sup2',
        'sup3',
        'acute',
        'micro',
        'para',
        'middot',
        'cedil',
        'sup1',
        'ordm',
        'raquo',
        'frac14',
        'frac12',
        'frac34',
        'iquest',
        'Agrave',
        'Aacute',
        'Acirc',
        'Atilde',
        'Auml',
        'Aring',
        'Aelig',
        'Ccedil',
        'Egrave',
        'Eacute',
        'Ecirc',
        'Euml',
        'Igrave',
        'Iacute',
        'Icirc',
        'Iuml',
        'ETH',
        'Ntilde',
        'Ograve',
        'Oacute',
        'Ocirc',
        'Otilde',
        'Ouml',
        'times',
        'Oslash',
        'Ugrave',
        'Uacute',
        'Ucirc',
        'Uuml',
        'Yacute',
        'THORN',
        'szlig',
        'agrave',
        'aacute',
        'acirc',
        'atilde',
        'auml',
        'aring',
        'aelig',
        'ccedil',
        'egrave',
        'eacute',
        'ecirc',
        'euml',
        'igrave',
        'iacute',
        'icirc',
        'iuml',
        'eth',
        'ntilde',
        'ograve',
        'oacute',
        'ocirc',
        'otilde',
        'ouml',
        'divide',
        'oslash',
        'ugrave',
        'uacute',
        'ucirc',
        'uuml',
        'yacute',
        'thorn',
        'yuml',
        'quot',
        'amp',
        'lt',
        'gt',
        'OElig',
        'oelig',
        'Scaron',
        'scaron',
        'Yuml',
        'circ',
        'tilde',
        'ensp',
        'emsp',
        'thinsp',
        'zwnj',
        'zwj',
        'lrm',
        'rlm',
        'ndash',
        'mdash',
        'lsquo',
        'rsquo',
        'sbquo',
        'ldquo',
        'rdquo',
        'bdquo',
        'dagger',
        'Dagger',
        'permil',
        'lsaquo',
        'rsaquo',
        'euro',
        'fnof',
        'Alpha',
        'Beta',
        'Gamma',
        'Delta',
        'Epsilon',
        'Zeta',
        'Eta',
        'Theta',
        'Iota',
        'Kappa',
        'Lambda',
        'Mu',
        'Nu',
        'Xi',
        'Omicron',
        'Pi',
        'Rho',
        'Sigma',
        'Tau',
        'Upsilon',
        'Phi',
        'Chi',
        'Psi',
        'Omega',
        'alpha',
        'beta',
        'gamma',
        'delta',
        'epsilon',
        'zeta',
        'eta',
        'theta',
        'iota',
        'kappa',
        'lambda',
        'mu',
        'nu',
        'xi',
        'omicron',
        'pi',
        'rho',
        'sigmaf',
        'sigma',
        'tau',
        'upsilon',
        'phi',
        'chi',
        'psi',
        'omega',
        'thetasym',
        'upsih',
        'piv',
        'bull',
        'hellip',
        'prime',
        'Prime',
        'oline',
        'frasl',
        'weierp',
        'image',
        'real',
        'trade',
        'alefsym',
        'larr',
        'uarr',
        'rarr',
        'darr',
        'harr',
        'crarr',
        'lArr',
        'uArr',
        'rArr',
        'dArr',
        'hArr',
        'forall',
        'part',
        'exist',
        'empty',
        'nabla',
        'isin',
        'notin',
        'ni',
        'prod',
        'sum',
        'minus',
        'lowast',
        'radic',
        'prop',
        'infin',
        'ang',
        'and',
        'or',
        'cap',
        'cup',
        'int',
        'there4',
        'sim',
        'cong',
        'asymp',
        'ne',
        'equiv',
        'le',
        'ge',
        'sub',
        'sup',
        'nsub',
        'sube',
        'supe',
        'oplus',
        'otimes',
        'perp',
        'sdot',
        'lceil',
        'rceil',
        'lfloor',
        'rfloor',
        'lang',
        'rang',
        'loz',
        'spades',
        'clubs',
        'hearts',
        'diams',
      ];
      var HTML_CODES = [
        39,
        160,
        161,
        162,
        163,
        164,
        165,
        166,
        167,
        168,
        169,
        170,
        171,
        172,
        173,
        174,
        175,
        176,
        177,
        178,
        179,
        180,
        181,
        182,
        183,
        184,
        185,
        186,
        187,
        188,
        189,
        190,
        191,
        192,
        193,
        194,
        195,
        196,
        197,
        198,
        199,
        200,
        201,
        202,
        203,
        204,
        205,
        206,
        207,
        208,
        209,
        210,
        211,
        212,
        213,
        214,
        215,
        216,
        217,
        218,
        219,
        220,
        221,
        222,
        223,
        224,
        225,
        226,
        227,
        228,
        229,
        230,
        231,
        232,
        233,
        234,
        235,
        236,
        237,
        238,
        239,
        240,
        241,
        242,
        243,
        244,
        245,
        246,
        247,
        248,
        249,
        250,
        251,
        252,
        253,
        254,
        255,
        34,
        38,
        60,
        62,
        338,
        339,
        352,
        353,
        376,
        710,
        732,
        8194,
        8195,
        8201,
        8204,
        8205,
        8206,
        8207,
        8211,
        8212,
        8216,
        8217,
        8218,
        8220,
        8221,
        8222,
        8224,
        8225,
        8240,
        8249,
        8250,
        8364,
        402,
        913,
        914,
        915,
        916,
        917,
        918,
        919,
        920,
        921,
        922,
        923,
        924,
        925,
        926,
        927,
        928,
        929,
        931,
        932,
        933,
        934,
        935,
        936,
        937,
        945,
        946,
        947,
        948,
        949,
        950,
        951,
        952,
        953,
        954,
        955,
        956,
        957,
        958,
        959,
        960,
        961,
        962,
        963,
        964,
        965,
        966,
        967,
        968,
        969,
        977,
        978,
        982,
        8226,
        8230,
        8242,
        8243,
        8254,
        8260,
        8472,
        8465,
        8476,
        8482,
        8501,
        8592,
        8593,
        8594,
        8595,
        8596,
        8629,
        8656,
        8657,
        8658,
        8659,
        8660,
        8704,
        8706,
        8707,
        8709,
        8711,
        8712,
        8713,
        8715,
        8719,
        8721,
        8722,
        8727,
        8730,
        8733,
        8734,
        8736,
        8743,
        8744,
        8745,
        8746,
        8747,
        8756,
        8764,
        8773,
        8776,
        8800,
        8801,
        8804,
        8805,
        8834,
        8835,
        8836,
        8838,
        8839,
        8853,
        8855,
        8869,
        8901,
        8968,
        8969,
        8970,
        8971,
        9001,
        9002,
        9674,
        9824,
        9827,
        9829,
        9830,
      ];

      var alphaIndex = {};
      var numIndex = {};

      var i = 0;
      var length = HTML_ALPHA.length;
      while (i < length) {
        var a = HTML_ALPHA[i];
        var c = HTML_CODES[i];
        alphaIndex[a] = String.fromCharCode(c);
        numIndex[c] = a;
        i++;
      }

      /**
 * @constructor
 */
      function Html4Entities() {}

      /**
 * @param {String} str
 * @returns {String}
 */
      Html4Entities.prototype.decode = function(str) {
        if (!str || !str.length) {
          return '';
        }
        return str.replace(/&(#?[\w\d]+);?/g, function(s, entity) {
          var chr;
          if (entity.charAt(0) === '#') {
            var code =
              entity.charAt(1).toLowerCase() === 'x'
                ? parseInt(entity.substr(2), 16)
                : parseInt(entity.substr(1));

            if (!(isNaN(code) || code < -32768 || code > 65535)) {
              chr = String.fromCharCode(code);
            }
          } else {
            chr = alphaIndex[entity];
          }
          return chr || s;
        });
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html4Entities.decode = function(str) {
        return new Html4Entities().decode(str);
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html4Entities.prototype.encode = function(str) {
        if (!str || !str.length) {
          return '';
        }
        var strLength = str.length;
        var result = '';
        var i = 0;
        while (i < strLength) {
          var alpha = numIndex[str.charCodeAt(i)];
          result += alpha ? '&' + alpha + ';' : str.charAt(i);
          i++;
        }
        return result;
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html4Entities.encode = function(str) {
        return new Html4Entities().encode(str);
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html4Entities.prototype.encodeNonUTF = function(str) {
        if (!str || !str.length) {
          return '';
        }
        var strLength = str.length;
        var result = '';
        var i = 0;
        while (i < strLength) {
          var cc = str.charCodeAt(i);
          var alpha = numIndex[cc];
          if (alpha) {
            result += '&' + alpha + ';';
          } else if (cc < 32 || cc > 126) {
            result += '&#' + cc + ';';
          } else {
            result += str.charAt(i);
          }
          i++;
        }
        return result;
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html4Entities.encodeNonUTF = function(str) {
        return new Html4Entities().encodeNonUTF(str);
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html4Entities.prototype.encodeNonASCII = function(str) {
        if (!str || !str.length) {
          return '';
        }
        var strLength = str.length;
        var result = '';
        var i = 0;
        while (i < strLength) {
          var c = str.charCodeAt(i);
          if (c <= 255) {
            result += str[i++];
            continue;
          }
          result += '&#' + c + ';';
          i++;
        }
        return result;
      };

      /**
 * @param {String} str
 * @returns {String}
 */
      Html4Entities.encodeNonASCII = function(str) {
        return new Html4Entities().encodeNonASCII(str);
      };

      module.exports = Html4Entities;

      /***/
    },
    /* 38 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _anser = _interopRequireDefault(__webpack_require__(11));

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      var filePathRegex = /^\.(\/[^/\n ]+)+\.[^/\n ]+$/;
      var lineNumberRegexes = [
        // Babel syntax errors
        // Based on syntax error formating of babylon parser
        // https://github.com/babel/babylon/blob/v7.0.0-beta.22/src/parser/location.js#L19
        /^.*\((\d+):(\d+)\)$/, // ESLint errors
        // Based on eslintFormatter in react-dev-utils
        /^Line (\d+):.+$/,
      ]; // Based on error formatting of webpack
      // https://github.com/webpack/webpack/blob/v3.5.5/lib/Stats.js#L183-L217

      function parseCompileError(message) {
        var lines = message.split('\n');
        var fileName = '';
        var lineNumber = 0;

        for (var i = 0; i < lines.length; i++) {
          var line = _anser.default.ansiToText(lines[i]).trim();

          if (!line) {
            continue;
          }

          if (!fileName && line.match(filePathRegex)) {
            fileName = line;
          }

          var k = 0;

          while (k < lineNumberRegexes.length) {
            var match = line.match(lineNumberRegexes[k]);

            if (match) {
              lineNumber = parseInt(match[1], 10);
              break;
            }

            k++;
          }

          if (fileName && lineNumber) {
            break;
          }
        }

        return fileName && lineNumber
          ? {
              fileName: fileName,
              lineNumber: lineNumber,
            }
          : null;
      }

      var _default = parseCompileError;
      exports.default = _default;

      /***/
    },
    /* 39 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireWildcard(__webpack_require__(0));

      var _ErrorOverlay = _interopRequireDefault(__webpack_require__(6));

      var _CloseButton = _interopRequireDefault(__webpack_require__(40));

      var _NavigationBar = _interopRequireDefault(__webpack_require__(41));

      var _RuntimeError = _interopRequireDefault(__webpack_require__(42));

      var _Footer = _interopRequireDefault(__webpack_require__(7));

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/containers/RuntimeErrorContainer.js';

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      function _interopRequireWildcard(obj) {
        if (obj && obj.__esModule) {
          return obj;
        } else {
          var newObj = {};
          if (obj != null) {
            for (var key in obj) {
              if (Object.prototype.hasOwnProperty.call(obj, key))
                newObj[key] = obj[key];
            }
          }
          newObj.default = obj;
          return newObj;
        }
      }

      function _typeof(obj) {
        if (
          typeof Symbol === 'function' &&
          typeof Symbol.iterator === 'symbol'
        ) {
          _typeof = function _typeof(obj) {
            return typeof obj;
          };
        } else {
          _typeof = function _typeof(obj) {
            return obj &&
            typeof Symbol === 'function' &&
            obj.constructor === Symbol &&
            obj !== Symbol.prototype
              ? 'symbol'
              : typeof obj;
          };
        }
        return _typeof(obj);
      }

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError('Cannot call a class as a function');
        }
      }

      function _defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ('value' in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }

      function _createClass(Constructor, protoProps, staticProps) {
        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
        if (staticProps) _defineProperties(Constructor, staticProps);
        return Constructor;
      }

      function _possibleConstructorReturn(self, call) {
        if (
          call &&
          (_typeof(call) === 'object' || typeof call === 'function')
        ) {
          return call;
        }
        if (!self) {
          throw new ReferenceError(
            "this hasn't been initialised - super() hasn't been called"
          );
        }
        return self;
      }

      function _inherits(subClass, superClass) {
        if (typeof superClass !== 'function' && superClass !== null) {
          throw new TypeError(
            'Super expression must either be null or a function'
          );
        }
        subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
            value: subClass,
            enumerable: false,
            writable: true,
            configurable: true,
          },
        });
        if (superClass)
          Object.setPrototypeOf
            ? Object.setPrototypeOf(subClass, superClass)
            : (subClass.__proto__ = superClass);
      }

      var RuntimeErrorContainer =
        /*#__PURE__*/
        (function(_PureComponent) {
          _inherits(RuntimeErrorContainer, _PureComponent);

          function RuntimeErrorContainer() {
            var _ref;

            var _temp, _this;

            _classCallCheck(this, RuntimeErrorContainer);

            for (
              var _len = arguments.length, args = new Array(_len), _key = 0;
              _key < _len;
              _key++
            ) {
              args[_key] = arguments[_key];
            }

            return _possibleConstructorReturn(
              _this,
              ((_temp = _this = _possibleConstructorReturn(
                this,
                (_ref =
                  RuntimeErrorContainer.__proto__ ||
                  Object.getPrototypeOf(RuntimeErrorContainer)).call.apply(
                  _ref,
                  [this].concat(args)
                )
              )),
              Object.defineProperty(_this, 'state', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: {
                  currentIndex: 0,
                },
              }),
              Object.defineProperty(_this, 'previous', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: function value() {
                  _this.setState(function(state, props) {
                    return {
                      currentIndex:
                        state.currentIndex > 0
                          ? state.currentIndex - 1
                          : props.errorRecords.length - 1,
                    };
                  });
                },
              }),
              Object.defineProperty(_this, 'next', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: function value() {
                  _this.setState(function(state, props) {
                    return {
                      currentIndex:
                        state.currentIndex < props.errorRecords.length - 1
                          ? state.currentIndex + 1
                          : 0,
                    };
                  });
                },
              }),
              Object.defineProperty(_this, 'shortcutHandler', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: function value(key) {
                  if (key === 'Escape') {
                    _this.props.close();
                  } else if (key === 'ArrowLeft') {
                    _this.previous();
                  } else if (key === 'ArrowRight') {
                    _this.next();
                  }
                },
              }),
              _temp)
            );
          }

          _createClass(RuntimeErrorContainer, [
            {
              key: 'render',
              value: function render() {
                var _props = this.props,
                  errorRecords = _props.errorRecords,
                  close = _props.close;
                var totalErrors = errorRecords.length;
                return _react.default.createElement(
                  _ErrorOverlay.default,
                  {
                    shortcutHandler: this.shortcutHandler,
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 66,
                    },
                    __self: this,
                  },
                  _react.default.createElement(_CloseButton.default, {
                    close: close,
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 67,
                    },
                    __self: this,
                  }),
                  totalErrors > 1 &&
                    _react.default.createElement(_NavigationBar.default, {
                      currentError: this.state.currentIndex + 1,
                      totalErrors: totalErrors,
                      previous: this.previous,
                      next: this.next,
                      __source: {
                        fileName: _jsxFileName,
                        lineNumber: 69,
                      },
                      __self: this,
                    }),
                  _react.default.createElement(_RuntimeError.default, {
                    errorRecord: errorRecords[this.state.currentIndex],
                    editorHandler: this.props.editorHandler,
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 76,
                    },
                    __self: this,
                  }),
                  _react.default.createElement(_Footer.default, {
                    line1:
                      'This screen is visible only in development. It will not appear if the app crashes in production.',
                    line2:
                      'Open your browser\u2019s developer console to further inspect this error.',
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 80,
                    },
                    __self: this,
                  })
                );
              },
            },
          ]);

          return RuntimeErrorContainer;
        })(_react.PureComponent);

      var _default = RuntimeErrorContainer;
      exports.default = _default;

      /***/
    },
    /* 40 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireDefault(__webpack_require__(0));

      var _styles = __webpack_require__(1);

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/components/CloseButton.js';

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      var closeButtonStyle = {
        color: _styles.black,
        lineHeight: '1rem',
        fontSize: '1.5rem',
        padding: '1rem',
        cursor: 'pointer',
        position: 'absolute',
        right: 0,
        top: 0,
      };

      function CloseButton(_ref) {
        var close = _ref.close;
        return _react.default.createElement(
          'span',
          {
            title: 'Click or press Escape to dismiss.',
            onClick: close,
            style: closeButtonStyle,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 26,
            },
            __self: this,
          },
          '\xD7'
        );
      }

      var _default = CloseButton;
      exports.default = _default;

      /***/
    },
    /* 41 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireDefault(__webpack_require__(0));

      var _styles = __webpack_require__(1);

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/components/NavigationBar.js';

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      function _extends() {
        _extends =
          Object.assign ||
          function(target) {
            for (var i = 1; i < arguments.length; i++) {
              var source = arguments[i];
              for (var key in source) {
                if (Object.prototype.hasOwnProperty.call(source, key)) {
                  target[key] = source[key];
                }
              }
            }
            return target;
          };
        return _extends.apply(this, arguments);
      }

      var navigationBarStyle = {
        marginBottom: '0.5rem',
      };
      var buttonContainerStyle = {
        marginRight: '1em',
      };
      var _navButtonStyle = {
        backgroundColor: _styles.redTransparent,
        color: _styles.red,
        border: 'none',
        borderRadius: '4px',
        padding: '3px 6px',
        cursor: 'pointer',
      };

      var leftButtonStyle = _extends({}, _navButtonStyle, {
        borderTopRightRadius: '0px',
        borderBottomRightRadius: '0px',
        marginRight: '1px',
      });

      var rightButtonStyle = _extends({}, _navButtonStyle, {
        borderTopLeftRadius: '0px',
        borderBottomLeftRadius: '0px',
      });

      function NavigationBar(props) {
        var currentError = props.currentError,
          totalErrors = props.totalErrors,
          previous = props.previous,
          next = props.next;
        return _react.default.createElement(
          'div',
          {
            style: navigationBarStyle,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 54,
            },
            __self: this,
          },
          _react.default.createElement(
            'span',
            {
              style: buttonContainerStyle,
              __source: {
                fileName: _jsxFileName,
                lineNumber: 55,
              },
              __self: this,
            },
            _react.default.createElement(
              'button',
              {
                onClick: previous,
                style: leftButtonStyle,
                __source: {
                  fileName: _jsxFileName,
                  lineNumber: 56,
                },
                __self: this,
              },
              '\u2190'
            ),
            _react.default.createElement(
              'button',
              {
                onClick: next,
                style: rightButtonStyle,
                __source: {
                  fileName: _jsxFileName,
                  lineNumber: 59,
                },
                __self: this,
              },
              '\u2192'
            )
          ),
          ''
            .concat(currentError, ' of ')
            .concat(totalErrors, ' errors on the page')
        );
      }

      var _default = NavigationBar;
      exports.default = _default;

      /***/
    },
    /* 42 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireDefault(__webpack_require__(0));

      var _Header = _interopRequireDefault(__webpack_require__(8));

      var _StackTrace = _interopRequireDefault(__webpack_require__(43));

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/containers/RuntimeError.js';

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      var wrapperStyle = {
        display: 'flex',
        flexDirection: 'column',
      };

      function RuntimeError(_ref) {
        var errorRecord = _ref.errorRecord,
          editorHandler = _ref.editorHandler;
        var error = errorRecord.error,
          unhandledRejection = errorRecord.unhandledRejection,
          contextSize = errorRecord.contextSize,
          stackFrames = errorRecord.stackFrames;
        var errorName = unhandledRejection
          ? 'Unhandled Rejection (' + error.name + ')'
          : error.name; // Make header prettier

        var message = error.message;
        var headerText =
          message.match(/^\w*:/) || !errorName
            ? message
            : errorName + ': ' + message;
        headerText = headerText // TODO: maybe remove this prefix from fbjs?
          // It's just scaring people
          .replace(/^Invariant Violation:\s*/, '') // This is not helpful either:
          .replace(/^Warning:\s*/, '') // Break the actionable part to the next line.
          // AFAIK React 16+ should already do this.
          .replace(' Check the render method', '\n\nCheck the render method')
          .replace(' Check your code at', '\n\nCheck your code at');
        return _react.default.createElement(
          'div',
          {
            style: wrapperStyle,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 56,
            },
            __self: this,
          },
          _react.default.createElement(_Header.default, {
            headerText: headerText,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 57,
            },
            __self: this,
          }),
          _react.default.createElement(_StackTrace.default, {
            stackFrames: stackFrames,
            errorName: errorName,
            contextSize: contextSize,
            editorHandler: editorHandler,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 58,
            },
            __self: this,
          })
        );
      }

      var _default = RuntimeError;
      exports.default = _default;

      /***/
    },
    /* 43 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireWildcard(__webpack_require__(0));

      var _StackFrame = _interopRequireDefault(__webpack_require__(44));

      var _Collapsible = _interopRequireDefault(__webpack_require__(62));

      var _isInternalFile = __webpack_require__(63);

      var _isBultinErrorName = __webpack_require__(64);

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/containers/StackTrace.js';

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      function _interopRequireWildcard(obj) {
        if (obj && obj.__esModule) {
          return obj;
        } else {
          var newObj = {};
          if (obj != null) {
            for (var key in obj) {
              if (Object.prototype.hasOwnProperty.call(obj, key))
                newObj[key] = obj[key];
            }
          }
          newObj.default = obj;
          return newObj;
        }
      }

      function _typeof(obj) {
        if (
          typeof Symbol === 'function' &&
          typeof Symbol.iterator === 'symbol'
        ) {
          _typeof = function _typeof(obj) {
            return typeof obj;
          };
        } else {
          _typeof = function _typeof(obj) {
            return obj &&
            typeof Symbol === 'function' &&
            obj.constructor === Symbol &&
            obj !== Symbol.prototype
              ? 'symbol'
              : typeof obj;
          };
        }
        return _typeof(obj);
      }

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError('Cannot call a class as a function');
        }
      }

      function _defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ('value' in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }

      function _createClass(Constructor, protoProps, staticProps) {
        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
        if (staticProps) _defineProperties(Constructor, staticProps);
        return Constructor;
      }

      function _possibleConstructorReturn(self, call) {
        if (
          call &&
          (_typeof(call) === 'object' || typeof call === 'function')
        ) {
          return call;
        }
        if (!self) {
          throw new ReferenceError(
            "this hasn't been initialised - super() hasn't been called"
          );
        }
        return self;
      }

      function _inherits(subClass, superClass) {
        if (typeof superClass !== 'function' && superClass !== null) {
          throw new TypeError(
            'Super expression must either be null or a function'
          );
        }
        subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
            value: subClass,
            enumerable: false,
            writable: true,
            configurable: true,
          },
        });
        if (superClass)
          Object.setPrototypeOf
            ? Object.setPrototypeOf(subClass, superClass)
            : (subClass.__proto__ = superClass);
      }

      var traceStyle = {
        fontSize: '1em',
        flex: '0 1 auto',
        minHeight: '0px',
        overflow: 'auto',
      };

      var StackTrace =
        /*#__PURE__*/
        (function(_Component) {
          _inherits(StackTrace, _Component);

          function StackTrace() {
            _classCallCheck(this, StackTrace);

            return _possibleConstructorReturn(
              this,
              (StackTrace.__proto__ || Object.getPrototypeOf(StackTrace))
                .apply(this, arguments)
            );
          }

          _createClass(StackTrace, [
            {
              key: 'renderFrames',
              value: function renderFrames() {
                var _props = this.props,
                  stackFrames = _props.stackFrames,
                  errorName = _props.errorName,
                  contextSize = _props.contextSize,
                  editorHandler = _props.editorHandler;
                var renderedFrames = [];
                var hasReachedAppCode = false,
                  currentBundle = [],
                  bundleCount = 0;
                stackFrames.forEach(function(frame, index) {
                  var fileName = frame.fileName,
                    sourceFileName = frame._originalFileName;
                  var isInternalUrl = (0, _isInternalFile.isInternalFile)(
                    sourceFileName,
                    fileName
                  );
                  var isThrownIntentionally = !(0,
                  _isBultinErrorName.isBultinErrorName)(errorName);
                  var shouldCollapse =
                    isInternalUrl &&
                    (isThrownIntentionally || hasReachedAppCode);

                  if (!isInternalUrl) {
                    hasReachedAppCode = true;
                  }

                  var frameEle = _react.default.createElement(
                    _StackFrame.default,
                    {
                      key: 'frame-' + index,
                      frame: frame,
                      contextSize: contextSize,
                      critical: index === 0,
                      showCode: !shouldCollapse,
                      editorHandler: editorHandler,
                      __source: {
                        fileName: _jsxFileName,
                        lineNumber: 52,
                      },
                      __self: this,
                    }
                  );

                  var lastElement = index === stackFrames.length - 1;

                  if (shouldCollapse) {
                    currentBundle.push(frameEle);
                  }

                  if (!shouldCollapse || lastElement) {
                    if (currentBundle.length === 1) {
                      renderedFrames.push(currentBundle[0]);
                    } else if (currentBundle.length > 1) {
                      bundleCount++;
                      renderedFrames.push(
                        _react.default.createElement(
                          _Collapsible.default,
                          {
                            key: 'bundle-' + bundleCount,
                            __source: {
                              fileName: _jsxFileName,
                              lineNumber: 73,
                            },
                            __self: this,
                          },
                          currentBundle
                        )
                      );
                    }

                    currentBundle = [];
                  }

                  if (!shouldCollapse) {
                    renderedFrames.push(frameEle);
                  }
                });
                return renderedFrames;
              },
            },
            {
              key: 'render',
              value: function render() {
                return _react.default.createElement(
                  'div',
                  {
                    style: traceStyle,
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 90,
                    },
                    __self: this,
                  },
                  this.renderFrames()
                );
              },
            },
          ]);

          return StackTrace;
        })(_react.Component);

      var _default = StackTrace;
      exports.default = _default;

      /***/
    },
    /* 44 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireWildcard(__webpack_require__(0));

      var _StackFrameCodeBlock = _interopRequireDefault(
        __webpack_require__(45)
      );

      var _getPrettyURL = __webpack_require__(61);

      var _styles = __webpack_require__(1);

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/containers/StackFrame.js';

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      function _interopRequireWildcard(obj) {
        if (obj && obj.__esModule) {
          return obj;
        } else {
          var newObj = {};
          if (obj != null) {
            for (var key in obj) {
              if (Object.prototype.hasOwnProperty.call(obj, key))
                newObj[key] = obj[key];
            }
          }
          newObj.default = obj;
          return newObj;
        }
      }

      function _typeof(obj) {
        if (
          typeof Symbol === 'function' &&
          typeof Symbol.iterator === 'symbol'
        ) {
          _typeof = function _typeof(obj) {
            return typeof obj;
          };
        } else {
          _typeof = function _typeof(obj) {
            return obj &&
            typeof Symbol === 'function' &&
            obj.constructor === Symbol &&
            obj !== Symbol.prototype
              ? 'symbol'
              : typeof obj;
          };
        }
        return _typeof(obj);
      }

      function _extends() {
        _extends =
          Object.assign ||
          function(target) {
            for (var i = 1; i < arguments.length; i++) {
              var source = arguments[i];
              for (var key in source) {
                if (Object.prototype.hasOwnProperty.call(source, key)) {
                  target[key] = source[key];
                }
              }
            }
            return target;
          };
        return _extends.apply(this, arguments);
      }

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError('Cannot call a class as a function');
        }
      }

      function _defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ('value' in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }

      function _createClass(Constructor, protoProps, staticProps) {
        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
        if (staticProps) _defineProperties(Constructor, staticProps);
        return Constructor;
      }

      function _possibleConstructorReturn(self, call) {
        if (
          call &&
          (_typeof(call) === 'object' || typeof call === 'function')
        ) {
          return call;
        }
        if (!self) {
          throw new ReferenceError(
            "this hasn't been initialised - super() hasn't been called"
          );
        }
        return self;
      }

      function _inherits(subClass, superClass) {
        if (typeof superClass !== 'function' && superClass !== null) {
          throw new TypeError(
            'Super expression must either be null or a function'
          );
        }
        subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
            value: subClass,
            enumerable: false,
            writable: true,
            configurable: true,
          },
        });
        if (superClass)
          Object.setPrototypeOf
            ? Object.setPrototypeOf(subClass, superClass)
            : (subClass.__proto__ = superClass);
      }

      var linkStyle = {
        fontSize: '0.9em',
        marginBottom: '0.9em',
      };
      var anchorStyle = {
        textDecoration: 'none',
        color: _styles.darkGray,
        cursor: 'pointer',
      };
      var codeAnchorStyle = {
        cursor: 'pointer',
      };
      var toggleStyle = {
        marginBottom: '1.5em',
        color: _styles.darkGray,
        cursor: 'pointer',
        border: 'none',
        display: 'block',
        width: '100%',
        textAlign: 'left',
        background: '#fff',
        fontFamily: 'Consolas, Menlo, monospace',
        fontSize: '1em',
        padding: '0px',
        lineHeight: '1.5',
      };

      var StackFrame =
        /*#__PURE__*/
        (function(_Component) {
          _inherits(StackFrame, _Component);

          function StackFrame() {
            var _ref;

            var _temp, _this;

            _classCallCheck(this, StackFrame);

            for (
              var _len = arguments.length, args = new Array(_len), _key = 0;
              _key < _len;
              _key++
            ) {
              args[_key] = arguments[_key];
            }

            return _possibleConstructorReturn(
              _this,
              ((_temp = _this = _possibleConstructorReturn(
                this,
                (_ref =
                  StackFrame.__proto__ ||
                  Object.getPrototypeOf(StackFrame)).call.apply(
                  _ref,
                  [this].concat(args)
                )
              )),
              Object.defineProperty(_this, 'state', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: {
                  compiled: false,
                },
              }),
              Object.defineProperty(_this, 'toggleCompiled', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: function value() {
                  _this.setState(function(state) {
                    return {
                      compiled: !state.compiled,
                    };
                  });
                },
              }),
              Object.defineProperty(_this, 'editorHandler', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: function value() {
                  var errorLoc = _this.getErrorLocation();

                  if (!errorLoc) {
                    return;
                  }

                  _this.props.editorHandler(errorLoc);
                },
              }),
              Object.defineProperty(_this, 'onKeyDown', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: function value(e) {
                  if (e.key === 'Enter') {
                    _this.editorHandler();
                  }
                },
              }),
              _temp)
            );
          }

          _createClass(StackFrame, [
            {
              key: 'getErrorLocation',
              value: function getErrorLocation() {
                var _props$frame = this.props.frame,
                  fileName = _props$frame._originalFileName,
                  lineNumber = _props$frame._originalLineNumber; // Unknown file

                if (!fileName) {
                  return null;
                } // e.g. "/path-to-my-app/webpack/bootstrap eaddeb46b67d75e4dfc1"

                var isInternalWebpackBootstrapCode =
                  fileName.trim().indexOf(' ') !== -1;

                if (isInternalWebpackBootstrapCode) {
                  return null;
                } // Code is in a real file

                return {
                  fileName: fileName,
                  lineNumber: lineNumber || 1,
                };
              },
            },
            {
              key: 'render',
              value: function render() {
                var _props = this.props,
                  frame = _props.frame,
                  contextSize = _props.contextSize,
                  critical = _props.critical,
                  showCode = _props.showCode;
                var fileName = frame.fileName,
                  lineNumber = frame.lineNumber,
                  columnNumber = frame.columnNumber,
                  scriptLines = frame._scriptCode,
                  sourceFileName = frame._originalFileName,
                  sourceLineNumber = frame._originalLineNumber,
                  sourceColumnNumber = frame._originalColumnNumber,
                  sourceLines = frame._originalScriptCode;
                var functionName = frame.getFunctionName();
                var compiled = this.state.compiled;
                var url = (0, _getPrettyURL.getPrettyURL)(
                  sourceFileName,
                  sourceLineNumber,
                  sourceColumnNumber,
                  fileName,
                  lineNumber,
                  columnNumber,
                  compiled
                );
                var codeBlockProps = null;

                if (showCode) {
                  if (
                    compiled &&
                    scriptLines &&
                    scriptLines.length !== 0 &&
                    lineNumber != null
                  ) {
                    codeBlockProps = {
                      lines: scriptLines,
                      lineNum: lineNumber,
                      columnNum: columnNumber,
                      contextSize: contextSize,
                      main: critical,
                    };
                  } else if (
                    !compiled &&
                    sourceLines &&
                    sourceLines.length !== 0 &&
                    sourceLineNumber != null
                  ) {
                    codeBlockProps = {
                      lines: sourceLines,
                      lineNum: sourceLineNumber,
                      columnNum: sourceColumnNumber,
                      contextSize: contextSize,
                      main: critical,
                    };
                  }
                }

                var canOpenInEditor =
                  this.getErrorLocation() !== null &&
                  this.props.editorHandler !== null;
                return _react.default.createElement(
                  'div',
                  {
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 161,
                    },
                    __self: this,
                  },
                  _react.default.createElement(
                    'div',
                    {
                      __source: {
                        fileName: _jsxFileName,
                        lineNumber: 162,
                      },
                      __self: this,
                    },
                    functionName
                  ),
                  _react.default.createElement(
                    'div',
                    {
                      style: linkStyle,
                      __source: {
                        fileName: _jsxFileName,
                        lineNumber: 163,
                      },
                      __self: this,
                    },
                    _react.default.createElement(
                      'a',
                      {
                        style: canOpenInEditor ? anchorStyle : null,
                        onClick: canOpenInEditor ? this.editorHandler : null,
                        onKeyDown: canOpenInEditor ? this.onKeyDown : null,
                        tabIndex: canOpenInEditor ? '0' : null,
                        __source: {
                          fileName: _jsxFileName,
                          lineNumber: 164,
                        },
                        __self: this,
                      },
                      url
                    )
                  ),
                  codeBlockProps &&
                    _react.default.createElement(
                      'span',
                      {
                        __source: {
                          fileName: _jsxFileName,
                          lineNumber: 174,
                        },
                        __self: this,
                      },
                      _react.default.createElement(
                        'a',
                        {
                          onClick: canOpenInEditor ? this.editorHandler : null,
                          style: canOpenInEditor ? codeAnchorStyle : null,
                          __source: {
                            fileName: _jsxFileName,
                            lineNumber: 175,
                          },
                          __self: this,
                        },
                        _react.default.createElement(
                          _StackFrameCodeBlock.default,
                          _extends({}, codeBlockProps, {
                            __source: {
                              fileName: _jsxFileName,
                              lineNumber: 179,
                            },
                            __self: this,
                          })
                        )
                      ),
                      _react.default.createElement(
                        'button',
                        {
                          style: toggleStyle,
                          onClick: this.toggleCompiled,
                          __source: {
                            fileName: _jsxFileName,
                            lineNumber: 181,
                          },
                          __self: this,
                        },
                        'View ' + (compiled ? 'source' : 'compiled')
                      )
                    )
                );
              },
            },
          ]);

          return StackFrame;
        })(_react.Component);

      var _default = StackFrame;
      exports.default = _default;

      /***/
    },
    /* 45 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireDefault(__webpack_require__(0));

      var _CodeBlock = _interopRequireDefault(__webpack_require__(9));

      var _css = __webpack_require__(13);

      var _absolutifyCaret = __webpack_require__(46);

      var _styles = __webpack_require__(1);

      var _generateAnsiHTML = _interopRequireDefault(__webpack_require__(10));

      var _codeFrame = _interopRequireDefault(__webpack_require__(47));

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/containers/StackFrameCodeBlock.js';

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      function StackFrameCodeBlock(props) {
        var lines = props.lines,
          lineNum = props.lineNum,
          columnNum = props.columnNum,
          contextSize = props.contextSize,
          main = props.main;
        var sourceCode = [];
        var whiteSpace = Infinity;
        lines.forEach(function(e) {
          var text = e.content;
          var m = text.match(/^\s*/);

          if (text === '') {
            return;
          }

          if (m && m[0]) {
            whiteSpace = Math.min(whiteSpace, m[0].length);
          } else {
            whiteSpace = 0;
          }
        });
        lines.forEach(function(e) {
          var text = e.content;
          var line = e.lineNumber;

          if (isFinite(whiteSpace)) {
            text = text.substring(whiteSpace);
          }

          sourceCode[line - 1] = text;
        });
        var ansiHighlight = (0, _codeFrame.default)(
          sourceCode.join('\n'),
          {
            start: {
              line: lineNum,
              column:
                columnNum == null
                  ? 0
                  : columnNum - (isFinite(whiteSpace) ? whiteSpace : 0),
            },
          },
          {
            forceColor: true,
            linesAbove: contextSize,
            linesBelow: contextSize,
          }
        );
        var htmlHighlight = (0, _generateAnsiHTML.default)(ansiHighlight);
        var code = document.createElement('code');
        code.innerHTML = htmlHighlight;
        (0, _absolutifyCaret.absolutifyCaret)(code);
        var ccn = code.childNodes; // eslint-disable-next-line

        oLoop: for (var index = 0; index < ccn.length; ++index) {
          var node = ccn[index];
          var ccn2 = node.childNodes;

          for (var index2 = 0; index2 < ccn2.length; ++index2) {
            var lineNode = ccn2[index2];
            var text = lineNode.innerText;

            if (text == null) {
              continue;
            }

            if (text.indexOf(' ' + lineNum + ' |') === -1) {
              continue;
            } // $FlowFixMe

            (0, _css.applyStyles)(
              node,
              main ? _styles.primaryErrorStyle : _styles.secondaryErrorStyle
            ); // eslint-disable-next-line

            break oLoop;
          }
        }

        return _react.default.createElement(_CodeBlock.default, {
          main: main,
          codeHTML: code.innerHTML,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 96,
          },
          __self: this,
        });
      }

      var _default = StackFrameCodeBlock;
      exports.default = _default;

      /***/
    },
    /* 46 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.absolutifyCaret = absolutifyCaret;

      /**
 * Copyright (c) 2015-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
      function removeNextBr(parent, component) {
        while (component != null && component.tagName.toLowerCase() !== 'br') {
          component = component.nextElementSibling;
        }

        if (component != null) {
          parent.removeChild(component);
        }
      }

      function absolutifyCaret(component) {
        var ccn = component.childNodes;

        for (var index = 0; index < ccn.length; ++index) {
          var c = ccn[index]; // $FlowFixMe

          if (c.tagName.toLowerCase() !== 'span') {
            continue;
          }

          var _text = c.innerText;

          if (_text == null) {
            continue;
          }

          var text = _text.replace(/\s/g, '');

          if (text !== '|^') {
            continue;
          } // $FlowFixMe

          c.style.position = 'absolute'; // $FlowFixMe

          removeNextBr(component, c);
        }
      }

      /***/
    },
    /* 47 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';
      /* WEBPACK VAR INJECTION */ (function(process) {
        exports.__esModule = true;
        exports.codeFrameColumns = codeFrameColumns;
        exports.default = _default;

        var _jsTokens = _interopRequireWildcard(__webpack_require__(48));

        var _esutils = _interopRequireDefault(__webpack_require__(49));

        var _chalk = _interopRequireDefault(__webpack_require__(52));

        function _interopRequireDefault(obj) {
          return obj && obj.__esModule ? obj : { default: obj };
        }

        function _interopRequireWildcard(obj) {
          if (obj && obj.__esModule) {
            return obj;
          } else {
            var newObj = {};
            if (obj != null) {
              for (var key in obj) {
                if (Object.prototype.hasOwnProperty.call(obj, key))
                  newObj[key] = obj[key];
              }
            }
            newObj.default = obj;
            return newObj;
          }
        }

        var deprecationWarningShown = false;

        function getDefs(chalk) {
          return {
            keyword: chalk.cyan,
            capitalized: chalk.yellow,
            jsx_tag: chalk.yellow,
            punctuator: chalk.yellow,
            number: chalk.magenta,
            string: chalk.green,
            regex: chalk.magenta,
            comment: chalk.grey,
            invalid: chalk.white.bgRed.bold,
            gutter: chalk.grey,
            marker: chalk.red.bold,
          };
        }

        var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
        var JSX_TAG = /^[a-z][\w-]*$/i;
        var BRACKET = /^[()[\]{}]$/;

        function getTokenType(match) {
          var _match$slice = match.slice(-2),
            offset = _match$slice[0],
            text = _match$slice[1];

          var token = (0, _jsTokens.matchToToken)(match);

          if (token.type === 'name') {
            if (_esutils.default.keyword.isReservedWordES6(token.value)) {
              return 'keyword';
            }

            if (
              JSX_TAG.test(token.value) &&
              (text[offset - 1] === '<' || text.substr(offset - 2, 2) == '</')
            ) {
              return 'jsx_tag';
            }

            if (token.value[0] !== token.value[0].toLowerCase()) {
              return 'capitalized';
            }
          }

          if (token.type === 'punctuator' && BRACKET.test(token.value)) {
            return 'bracket';
          }

          if (
            token.type === 'invalid' &&
            (token.value === '@' || token.value === '#')
          ) {
            return 'punctuator';
          }

          return token.type;
        }

        function highlight(defs, text) {
          return text.replace(_jsTokens.default, function() {
            for (
              var _len = arguments.length, args = new Array(_len), _key = 0;
              _key < _len;
              _key++
            ) {
              args[_key] = arguments[_key];
            }

            var type = getTokenType(args);
            var colorize = defs[type];

            if (colorize) {
              return args[0]
                .split(NEWLINE)
                .map(function(str) {
                  return colorize(str);
                })
                .join('\n');
            } else {
              return args[0];
            }
          });
        }

        function getMarkerLines(loc, source, opts) {
          var startLoc = Object.assign(
            {},
            {
              column: 0,
              line: -1,
            },
            loc.start
          );
          var endLoc = Object.assign({}, startLoc, loc.end);
          var linesAbove = opts.linesAbove || 2;
          var linesBelow = opts.linesBelow || 3;
          var startLine = startLoc.line;
          var startColumn = startLoc.column;
          var endLine = endLoc.line;
          var endColumn = endLoc.column;
          var start = Math.max(startLine - (linesAbove + 1), 0);
          var end = Math.min(source.length, endLine + linesBelow);

          if (startLine === -1) {
            start = 0;
          }

          if (endLine === -1) {
            end = source.length;
          }

          var lineDiff = endLine - startLine;
          var markerLines = {};

          if (lineDiff) {
            for (var i = 0; i <= lineDiff; i++) {
              var lineNumber = i + startLine;

              if (!startColumn) {
                markerLines[lineNumber] = true;
              } else if (i === 0) {
                var sourceLength = source[lineNumber - 1].length;
                markerLines[lineNumber] = [
                  startColumn,
                  sourceLength - startColumn,
                ];
              } else if (i === lineDiff) {
                markerLines[lineNumber] = [0, endColumn];
              } else {
                var _sourceLength = source[lineNumber - i].length;
                markerLines[lineNumber] = [0, _sourceLength];
              }
            }
          } else {
            if (startColumn === endColumn) {
              if (startColumn) {
                markerLines[startLine] = [startColumn, 0];
              } else {
                markerLines[startLine] = true;
              }
            } else {
              markerLines[startLine] = [startColumn, endColumn - startColumn];
            }
          }

          return {
            start: start,
            end: end,
            markerLines: markerLines,
          };
        }

        function codeFrameColumns(rawLines, loc, opts) {
          if (opts === void 0) {
            opts = {};
          }

          var highlighted =
            (opts.highlightCode && _chalk.default.supportsColor) ||
            opts.forceColor;
          var chalk = _chalk.default;

          if (opts.forceColor) {
            chalk = new _chalk.default.constructor({
              enabled: true,
            });
          }

          var maybeHighlight = function maybeHighlight(chalkFn, string) {
            return highlighted ? chalkFn(string) : string;
          };

          var defs = getDefs(chalk);
          if (highlighted) rawLines = highlight(defs, rawLines);
          var lines = rawLines.split(NEWLINE);

          var _getMarkerLines = getMarkerLines(loc, lines, opts),
            start = _getMarkerLines.start,
            end = _getMarkerLines.end,
            markerLines = _getMarkerLines.markerLines;

          var numberMaxWidth = String(end).length;
          var frame = lines
            .slice(start, end)
            .map(function(line, index) {
              var number = start + 1 + index;
              var paddedNumber = (' ' + number).slice(-numberMaxWidth);
              var gutter = ' ' + paddedNumber + ' | ';
              var hasMarker = markerLines[number];

              if (hasMarker) {
                var markerLine = '';

                if (Array.isArray(hasMarker)) {
                  var markerSpacing = line
                    .slice(0, Math.max(hasMarker[0] - 1, 0))
                    .replace(/[^\t]/g, ' ');
                  var numberOfMarkers = hasMarker[1] || 1;
                  markerLine = [
                    '\n ',
                    maybeHighlight(defs.gutter, gutter.replace(/\d/g, ' ')),
                    markerSpacing,
                    maybeHighlight(defs.marker, '^').repeat(numberOfMarkers),
                  ].join('');
                }

                return [
                  maybeHighlight(defs.marker, '>'),
                  maybeHighlight(defs.gutter, gutter),
                  line,
                  markerLine,
                ].join('');
              } else {
                return ' ' + maybeHighlight(defs.gutter, gutter) + line;
              }
            })
            .join('\n');

          if (highlighted) {
            return chalk.reset(frame);
          } else {
            return frame;
          }
        }

        function _default(rawLines, lineNumber, colNumber, opts) {
          if (opts === void 0) {
            opts = {};
          }

          if (!deprecationWarningShown) {
            deprecationWarningShown = true;
            var deprecationError = new Error(
              'Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.'
            );
            deprecationError.name = 'DeprecationWarning';

            if (process.emitWarning) {
              process.emitWarning(deprecationError);
            } else {
              console.warn(deprecationError);
            }
          }

          colNumber = Math.max(colNumber, 0);
          var location = {
            start: {
              column: colNumber,
              line: lineNumber,
            },
          };
          return codeFrameColumns(rawLines, location, opts);
        }
        /* WEBPACK VAR INJECTION */
      }.call(exports, __webpack_require__(14)));

      /***/
    },
    /* 48 */
    /***/ function(module, exports) {
      // Copyright 2014, 2015, 2016, 2017 Simon Lydell
      // License: MIT. (See LICENSE.)

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });

      // This regex comes from regex.coffee, and is inserted here by generate-index.js
      // (run `npm run build`).
      exports.default = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyu]{1,5}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g;

      exports.matchToToken = function(match) {
        var token = { type: 'invalid', value: match[0] };
        if (match[1])
          (token.type = 'string'), (token.closed = !!(match[3] || match[4]));
        else if (match[5]) token.type = 'comment';
        else if (match[6])
          (token.type = 'comment'), (token.closed = !!match[7]);
        else if (match[8]) token.type = 'regex';
        else if (match[9]) token.type = 'number';
        else if (match[10]) token.type = 'name';
        else if (match[11]) token.type = 'punctuator';
        else if (match[12]) token.type = 'whitespace';
        return token;
      };

      /***/
    },
    /* 49 */
    /***/ function(module, exports, __webpack_require__) {
      /*
  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

      (function() {
        'use strict';

        exports.ast = __webpack_require__(50);
        exports.code = __webpack_require__(15);
        exports.keyword = __webpack_require__(51);
      })();
      /* vim: set sw=4 ts=4 et tw=80 : */

      /***/
    },
    /* 50 */
    /***/ function(module, exports) {
      /*
  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

      (function() {
        'use strict';

        function isExpression(node) {
          if (node == null) {
            return false;
          }
          switch (node.type) {
            case 'ArrayExpression':
            case 'AssignmentExpression':
            case 'BinaryExpression':
            case 'CallExpression':
            case 'ConditionalExpression':
            case 'FunctionExpression':
            case 'Identifier':
            case 'Literal':
            case 'LogicalExpression':
            case 'MemberExpression':
            case 'NewExpression':
            case 'ObjectExpression':
            case 'SequenceExpression':
            case 'ThisExpression':
            case 'UnaryExpression':
            case 'UpdateExpression':
              return true;
          }
          return false;
        }

        function isIterationStatement(node) {
          if (node == null) {
            return false;
          }
          switch (node.type) {
            case 'DoWhileStatement':
            case 'ForInStatement':
            case 'ForStatement':
            case 'WhileStatement':
              return true;
          }
          return false;
        }

        function isStatement(node) {
          if (node == null) {
            return false;
          }
          switch (node.type) {
            case 'BlockStatement':
            case 'BreakStatement':
            case 'ContinueStatement':
            case 'DebuggerStatement':
            case 'DoWhileStatement':
            case 'EmptyStatement':
            case 'ExpressionStatement':
            case 'ForInStatement':
            case 'ForStatement':
            case 'IfStatement':
            case 'LabeledStatement':
            case 'ReturnStatement':
            case 'SwitchStatement':
            case 'ThrowStatement':
            case 'TryStatement':
            case 'VariableDeclaration':
            case 'WhileStatement':
            case 'WithStatement':
              return true;
          }
          return false;
        }

        function isSourceElement(node) {
          return (
            isStatement(node) ||
            (node != null && node.type === 'FunctionDeclaration')
          );
        }

        function trailingStatement(node) {
          switch (node.type) {
            case 'IfStatement':
              if (node.alternate != null) {
                return node.alternate;
              }
              return node.consequent;

            case 'LabeledStatement':
            case 'ForStatement':
            case 'ForInStatement':
            case 'WhileStatement':
            case 'WithStatement':
              return node.body;
          }
          return null;
        }

        function isProblematicIfStatement(node) {
          var current;

          if (node.type !== 'IfStatement') {
            return false;
          }
          if (node.alternate == null) {
            return false;
          }
          current = node.consequent;
          do {
            if (current.type === 'IfStatement') {
              if (current.alternate == null) {
                return true;
              }
            }
            current = trailingStatement(current);
          } while (current);

          return false;
        }

        module.exports = {
          isExpression: isExpression,
          isStatement: isStatement,
          isIterationStatement: isIterationStatement,
          isSourceElement: isSourceElement,
          isProblematicIfStatement: isProblematicIfStatement,

          trailingStatement: trailingStatement,
        };
      })();
      /* vim: set sw=4 ts=4 et tw=80 : */

      /***/
    },
    /* 51 */
    /***/ function(module, exports, __webpack_require__) {
      /*
  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

      (function() {
        'use strict';

        var code = __webpack_require__(15);

        function isStrictModeReservedWordES6(id) {
          switch (id) {
            case 'implements':
            case 'interface':
            case 'package':
            case 'private':
            case 'protected':
            case 'public':
            case 'static':
            case 'let':
              return true;
            default:
              return false;
          }
        }

        function isKeywordES5(id, strict) {
          // yield should not be treated as keyword under non-strict mode.
          if (!strict && id === 'yield') {
            return false;
          }
          return isKeywordES6(id, strict);
        }

        function isKeywordES6(id, strict) {
          if (strict && isStrictModeReservedWordES6(id)) {
            return true;
          }

          switch (id.length) {
            case 2:
              return id === 'if' || id === 'in' || id === 'do';
            case 3:
              return (
                id === 'var' || id === 'for' || id === 'new' || id === 'try'
              );
            case 4:
              return (
                id === 'this' ||
                id === 'else' ||
                id === 'case' ||
                id === 'void' ||
                id === 'with' ||
                id === 'enum'
              );
            case 5:
              return (
                id === 'while' ||
                id === 'break' ||
                id === 'catch' ||
                id === 'throw' ||
                id === 'const' ||
                id === 'yield' ||
                id === 'class' ||
                id === 'super'
              );
            case 6:
              return (
                id === 'return' ||
                id === 'typeof' ||
                id === 'delete' ||
                id === 'switch' ||
                id === 'export' ||
                id === 'import'
              );
            case 7:
              return id === 'default' || id === 'finally' || id === 'extends';
            case 8:
              return (
                id === 'function' || id === 'continue' || id === 'debugger'
              );
            case 10:
              return id === 'instanceof';
            default:
              return false;
          }
        }

        function isReservedWordES5(id, strict) {
          return (
            id === 'null' ||
            id === 'true' ||
            id === 'false' ||
            isKeywordES5(id, strict)
          );
        }

        function isReservedWordES6(id, strict) {
          return (
            id === 'null' ||
            id === 'true' ||
            id === 'false' ||
            isKeywordES6(id, strict)
          );
        }

        function isRestrictedWord(id) {
          return id === 'eval' || id === 'arguments';
        }

        function isIdentifierNameES5(id) {
          var i, iz, ch;

          if (id.length === 0) {
            return false;
          }

          ch = id.charCodeAt(0);
          if (!code.isIdentifierStartES5(ch)) {
            return false;
          }

          for (i = 1, iz = id.length; i < iz; ++i) {
            ch = id.charCodeAt(i);
            if (!code.isIdentifierPartES5(ch)) {
              return false;
            }
          }
          return true;
        }

        function decodeUtf16(lead, trail) {
          return (lead - 0xd800) * 0x400 + (trail - 0xdc00) + 0x10000;
        }

        function isIdentifierNameES6(id) {
          var i, iz, ch, lowCh, check;

          if (id.length === 0) {
            return false;
          }

          check = code.isIdentifierStartES6;
          for (i = 0, iz = id.length; i < iz; ++i) {
            ch = id.charCodeAt(i);
            if (0xd800 <= ch && ch <= 0xdbff) {
              ++i;
              if (i >= iz) {
                return false;
              }
              lowCh = id.charCodeAt(i);
              if (!(0xdc00 <= lowCh && lowCh <= 0xdfff)) {
                return false;
              }
              ch = decodeUtf16(ch, lowCh);
            }
            if (!check(ch)) {
              return false;
            }
            check = code.isIdentifierPartES6;
          }
          return true;
        }

        function isIdentifierES5(id, strict) {
          return isIdentifierNameES5(id) && !isReservedWordES5(id, strict);
        }

        function isIdentifierES6(id, strict) {
          return isIdentifierNameES6(id) && !isReservedWordES6(id, strict);
        }

        module.exports = {
          isKeywordES5: isKeywordES5,
          isKeywordES6: isKeywordES6,
          isReservedWordES5: isReservedWordES5,
          isReservedWordES6: isReservedWordES6,
          isRestrictedWord: isRestrictedWord,
          isIdentifierNameES5: isIdentifierNameES5,
          isIdentifierNameES6: isIdentifierNameES6,
          isIdentifierES5: isIdentifierES5,
          isIdentifierES6: isIdentifierES6,
        };
      })();
      /* vim: set sw=4 ts=4 et tw=80 : */

      /***/
    },
    /* 52 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';
      /* WEBPACK VAR INJECTION */ (function(process) {
        const escapeStringRegexp = __webpack_require__(53);
        const ansiStyles = __webpack_require__(54);
        const supportsColor = __webpack_require__(59);

        const template = __webpack_require__(60);

        const isSimpleWindowsTerm =
          process.platform === 'win32' &&
          !(Object({ NODE_ENV: 'production' }).TERM || '')
            .toLowerCase()
            .startsWith('xterm');

        // `supportsColor.level` → `ansiStyles.color[name]` mapping
        const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];

        // `color-convert` models to exclude from the Chalk API due to conflicts and such
        const skipModels = new Set(['gray']);

        const styles = Object.create(null);

        function applyOptions(obj, options) {
          options = options || {};

          // Detect level if not set manually
          const scLevel = supportsColor ? supportsColor.level : 0;
          obj.level = options.level === undefined ? scLevel : options.level;
          obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
        }

        function Chalk(options) {
          // We check for this.template here since calling `chalk.constructor()`
          // by itself will have a `this` of a previously constructed chalk object
          if (!this || !(this instanceof Chalk) || this.template) {
            const chalk = {};
            applyOptions(chalk, options);

            chalk.template = function() {
              const args = [].slice.call(arguments);
              return chalkTag.apply(null, [chalk.template].concat(args));
            };

            Object.setPrototypeOf(chalk, Chalk.prototype);
            Object.setPrototypeOf(chalk.template, chalk);

            chalk.template.constructor = Chalk;

            return chalk.template;
          }

          applyOptions(this, options);
        }

        // Use bright blue on Windows as the normal blue color is illegible
        if (isSimpleWindowsTerm) {
          ansiStyles.blue.open = '\u001B[94m';
        }

        for (const key of Object.keys(ansiStyles)) {
          ansiStyles[key].closeRe = new RegExp(
            escapeStringRegexp(ansiStyles[key].close),
            'g'
          );

          styles[key] = {
            get() {
              const codes = ansiStyles[key];
              return build.call(
                this,
                this._styles ? this._styles.concat(codes) : [codes],
                this._empty,
                key
              );
            },
          };
        }

        styles.visible = {
          get() {
            return build.call(this, this._styles || [], true, 'visible');
          },
        };

        ansiStyles.color.closeRe = new RegExp(
          escapeStringRegexp(ansiStyles.color.close),
          'g'
        );
        for (const model of Object.keys(ansiStyles.color.ansi)) {
          if (skipModels.has(model)) {
            continue;
          }

          styles[model] = {
            get() {
              const level = this.level;
              return function() {
                const open = ansiStyles.color[levelMapping[level]][model].apply(
                  null,
                  arguments
                );
                const codes = {
                  open,
                  close: ansiStyles.color.close,
                  closeRe: ansiStyles.color.closeRe,
                };
                return build.call(
                  this,
                  this._styles ? this._styles.concat(codes) : [codes],
                  this._empty,
                  model
                );
              };
            },
          };
        }

        ansiStyles.bgColor.closeRe = new RegExp(
          escapeStringRegexp(ansiStyles.bgColor.close),
          'g'
        );
        for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
          if (skipModels.has(model)) {
            continue;
          }

          const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
          styles[bgModel] = {
            get() {
              const level = this.level;
              return function() {
                const open = ansiStyles.bgColor[levelMapping[level]][
                  model
                ].apply(null, arguments);
                const codes = {
                  open,
                  close: ansiStyles.bgColor.close,
                  closeRe: ansiStyles.bgColor.closeRe,
                };
                return build.call(
                  this,
                  this._styles ? this._styles.concat(codes) : [codes],
                  this._empty,
                  model
                );
              };
            },
          };
        }

        const proto = Object.defineProperties(() => {}, styles);

        function build(_styles, _empty, key) {
          const builder = function() {
            return applyStyle.apply(builder, arguments);
          };

          builder._styles = _styles;
          builder._empty = _empty;

          const self = this;

          Object.defineProperty(builder, 'level', {
            enumerable: true,
            get() {
              return self.level;
            },
            set(level) {
              self.level = level;
            },
          });

          Object.defineProperty(builder, 'enabled', {
            enumerable: true,
            get() {
              return self.enabled;
            },
            set(enabled) {
              self.enabled = enabled;
            },
          });

          // See below for fix regarding invisible grey/dim combination on Windows
          builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';

          // `__proto__` is used because we must return a function, but there is
          // no way to create a function with a different prototype
          builder.__proto__ = proto; // eslint-disable-line no-proto

          return builder;
        }

        function applyStyle() {
          // Support varags, but simply cast to string in case there's only one arg
          const args = arguments;
          const argsLen = args.length;
          let str = String(arguments[0]);

          if (argsLen === 0) {
            return '';
          }

          if (argsLen > 1) {
            // Don't slice `arguments`, it prevents V8 optimizations
            for (let a = 1; a < argsLen; a++) {
              str += ' ' + args[a];
            }
          }

          if (!this.enabled || this.level <= 0 || !str) {
            return this._empty ? '' : str;
          }

          // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
          // see https://github.com/chalk/chalk/issues/58
          // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
          const originalDim = ansiStyles.dim.open;
          if (isSimpleWindowsTerm && this.hasGrey) {
            ansiStyles.dim.open = '';
          }

          for (const code of this._styles.slice().reverse()) {
            // Replace any instances already present with a re-opening code
            // otherwise only the part of the string until said closing code
            // will be colored, and the rest will simply be 'plain'.
            str = code.open + str.replace(code.closeRe, code.open) + code.close;

            // Close the styling before a linebreak and reopen
            // after next line to fix a bleed issue on macOS
            // https://github.com/chalk/chalk/pull/92
            str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
          }

          // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
          ansiStyles.dim.open = originalDim;

          return str;
        }

        function chalkTag(chalk, strings) {
          if (!Array.isArray(strings)) {
            // If chalk() was called by itself or with a string,
            // return the string itself as a string.
            return [].slice.call(arguments, 1).join(' ');
          }

          const args = [].slice.call(arguments, 2);
          const parts = [strings.raw[0]];

          for (let i = 1; i < strings.length; i++) {
            parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
            parts.push(String(strings.raw[i]));
          }

          return template(chalk, parts.join(''));
        }

        Object.defineProperties(Chalk.prototype, styles);

        module.exports = Chalk(); // eslint-disable-line new-cap
        module.exports.supportsColor = supportsColor;
        module.exports.default = module.exports; // For TypeScript

        /* WEBPACK VAR INJECTION */
      }.call(exports, __webpack_require__(14)));

      /***/
    },
    /* 53 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;

      module.exports = function(str) {
        if (typeof str !== 'string') {
          throw new TypeError('Expected a string');
        }

        return str.replace(matchOperatorsRe, '\\$&');
      };

      /***/
    },
    /* 54 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';
      /* WEBPACK VAR INJECTION */ (function(module) {
        const colorConvert = __webpack_require__(56);

        const wrapAnsi16 = (fn, offset) =>
          function() {
            const code = fn.apply(colorConvert, arguments);
            return `\u001B[${code + offset}m`;
          };

        const wrapAnsi256 = (fn, offset) =>
          function() {
            const code = fn.apply(colorConvert, arguments);
            return `\u001B[${38 + offset};5;${code}m`;
          };

        const wrapAnsi16m = (fn, offset) =>
          function() {
            const rgb = fn.apply(colorConvert, arguments);
            return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
          };

        function assembleStyles() {
          const codes = new Map();
          const styles = {
            modifier: {
              reset: [0, 0],
              // 21 isn't widely supported and 22 does the same thing
              bold: [1, 22],
              dim: [2, 22],
              italic: [3, 23],
              underline: [4, 24],
              inverse: [7, 27],
              hidden: [8, 28],
              strikethrough: [9, 29],
            },
            color: {
              black: [30, 39],
              red: [31, 39],
              green: [32, 39],
              yellow: [33, 39],
              blue: [34, 39],
              magenta: [35, 39],
              cyan: [36, 39],
              white: [37, 39],
              gray: [90, 39],

              // Bright color
              redBright: [91, 39],
              greenBright: [92, 39],
              yellowBright: [93, 39],
              blueBright: [94, 39],
              magentaBright: [95, 39],
              cyanBright: [96, 39],
              whiteBright: [97, 39],
            },
            bgColor: {
              bgBlack: [40, 49],
              bgRed: [41, 49],
              bgGreen: [42, 49],
              bgYellow: [43, 49],
              bgBlue: [44, 49],
              bgMagenta: [45, 49],
              bgCyan: [46, 49],
              bgWhite: [47, 49],

              // Bright color
              bgBlackBright: [100, 49],
              bgRedBright: [101, 49],
              bgGreenBright: [102, 49],
              bgYellowBright: [103, 49],
              bgBlueBright: [104, 49],
              bgMagentaBright: [105, 49],
              bgCyanBright: [106, 49],
              bgWhiteBright: [107, 49],
            },
          };

          // Fix humans
          styles.color.grey = styles.color.gray;

          for (const groupName of Object.keys(styles)) {
            const group = styles[groupName];

            for (const styleName of Object.keys(group)) {
              const style = group[styleName];

              styles[styleName] = {
                open: `\u001B[${style[0]}m`,
                close: `\u001B[${style[1]}m`,
              };

              group[styleName] = styles[styleName];

              codes.set(style[0], style[1]);
            }

            Object.defineProperty(styles, groupName, {
              value: group,
              enumerable: false,
            });

            Object.defineProperty(styles, 'codes', {
              value: codes,
              enumerable: false,
            });
          }

          const rgb2rgb = (r, g, b) => [r, g, b];

          styles.color.close = '\u001B[39m';
          styles.bgColor.close = '\u001B[49m';

          styles.color.ansi = {};
          styles.color.ansi256 = {};
          styles.color.ansi16m = {
            rgb: wrapAnsi16m(rgb2rgb, 0),
          };

          styles.bgColor.ansi = {};
          styles.bgColor.ansi256 = {};
          styles.bgColor.ansi16m = {
            rgb: wrapAnsi16m(rgb2rgb, 10),
          };

          for (const key of Object.keys(colorConvert)) {
            if (typeof colorConvert[key] !== 'object') {
              continue;
            }

            const suite = colorConvert[key];

            if ('ansi16' in suite) {
              styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
              styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
            }

            if ('ansi256' in suite) {
              styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
              styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
            }

            if ('rgb' in suite) {
              styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
              styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
            }
          }

          return styles;
        }

        // Make the export immutable
        Object.defineProperty(module, 'exports', {
          enumerable: true,
          get: assembleStyles,
        });

        /* WEBPACK VAR INJECTION */
      }.call(exports, __webpack_require__(55)(module)));

      /***/
    },
    /* 55 */
    /***/ function(module, exports) {
      module.exports = function(module) {
        if (!module.webpackPolyfill) {
          module.deprecate = function() {};
          module.paths = [];
          // module.parent = undefined by default
          if (!module.children) module.children = [];
          Object.defineProperty(module, 'loaded', {
            enumerable: true,
            get: function() {
              return module.l;
            },
          });
          Object.defineProperty(module, 'id', {
            enumerable: true,
            get: function() {
              return module.i;
            },
          });
          module.webpackPolyfill = 1;
        }
        return module;
      };

      /***/
    },
    /* 56 */
    /***/ function(module, exports, __webpack_require__) {
      var conversions = __webpack_require__(16);
      var route = __webpack_require__(58);

      var convert = {};

      var models = Object.keys(conversions);

      function wrapRaw(fn) {
        var wrappedFn = function(args) {
          if (args === undefined || args === null) {
            return args;
          }

          if (arguments.length > 1) {
            args = Array.prototype.slice.call(arguments);
          }

          return fn(args);
        };

        // preserve .conversion property if there is one
        if ('conversion' in fn) {
          wrappedFn.conversion = fn.conversion;
        }

        return wrappedFn;
      }

      function wrapRounded(fn) {
        var wrappedFn = function(args) {
          if (args === undefined || args === null) {
            return args;
          }

          if (arguments.length > 1) {
            args = Array.prototype.slice.call(arguments);
          }

          var result = fn(args);

          // we're assuming the result is an array here.
          // see notice in conversions.js; don't use box types
          // in conversion functions.
          if (typeof result === 'object') {
            for (var len = result.length, i = 0; i < len; i++) {
              result[i] = Math.round(result[i]);
            }
          }

          return result;
        };

        // preserve .conversion property if there is one
        if ('conversion' in fn) {
          wrappedFn.conversion = fn.conversion;
        }

        return wrappedFn;
      }

      models.forEach(function(fromModel) {
        convert[fromModel] = {};

        Object.defineProperty(convert[fromModel], 'channels', {
          value: conversions[fromModel].channels,
        });
        Object.defineProperty(convert[fromModel], 'labels', {
          value: conversions[fromModel].labels,
        });

        var routes = route(fromModel);
        var routeModels = Object.keys(routes);

        routeModels.forEach(function(toModel) {
          var fn = routes[toModel];

          convert[fromModel][toModel] = wrapRounded(fn);
          convert[fromModel][toModel].raw = wrapRaw(fn);
        });
      });

      module.exports = convert;

      /***/
    },
    /* 57 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      module.exports = {
        aliceblue: [240, 248, 255],
        antiquewhite: [250, 235, 215],
        aqua: [0, 255, 255],
        aquamarine: [127, 255, 212],
        azure: [240, 255, 255],
        beige: [245, 245, 220],
        bisque: [255, 228, 196],
        black: [0, 0, 0],
        blanchedalmond: [255, 235, 205],
        blue: [0, 0, 255],
        blueviolet: [138, 43, 226],
        brown: [165, 42, 42],
        burlywood: [222, 184, 135],
        cadetblue: [95, 158, 160],
        chartreuse: [127, 255, 0],
        chocolate: [210, 105, 30],
        coral: [255, 127, 80],
        cornflowerblue: [100, 149, 237],
        cornsilk: [255, 248, 220],
        crimson: [220, 20, 60],
        cyan: [0, 255, 255],
        darkblue: [0, 0, 139],
        darkcyan: [0, 139, 139],
        darkgoldenrod: [184, 134, 11],
        darkgray: [169, 169, 169],
        darkgreen: [0, 100, 0],
        darkgrey: [169, 169, 169],
        darkkhaki: [189, 183, 107],
        darkmagenta: [139, 0, 139],
        darkolivegreen: [85, 107, 47],
        darkorange: [255, 140, 0],
        darkorchid: [153, 50, 204],
        darkred: [139, 0, 0],
        darksalmon: [233, 150, 122],
        darkseagreen: [143, 188, 143],
        darkslateblue: [72, 61, 139],
        darkslategray: [47, 79, 79],
        darkslategrey: [47, 79, 79],
        darkturquoise: [0, 206, 209],
        darkviolet: [148, 0, 211],
        deeppink: [255, 20, 147],
        deepskyblue: [0, 191, 255],
        dimgray: [105, 105, 105],
        dimgrey: [105, 105, 105],
        dodgerblue: [30, 144, 255],
        firebrick: [178, 34, 34],
        floralwhite: [255, 250, 240],
        forestgreen: [34, 139, 34],
        fuchsia: [255, 0, 255],
        gainsboro: [220, 220, 220],
        ghostwhite: [248, 248, 255],
        gold: [255, 215, 0],
        goldenrod: [218, 165, 32],
        gray: [128, 128, 128],
        green: [0, 128, 0],
        greenyellow: [173, 255, 47],
        grey: [128, 128, 128],
        honeydew: [240, 255, 240],
        hotpink: [255, 105, 180],
        indianred: [205, 92, 92],
        indigo: [75, 0, 130],
        ivory: [255, 255, 240],
        khaki: [240, 230, 140],
        lavender: [230, 230, 250],
        lavenderblush: [255, 240, 245],
        lawngreen: [124, 252, 0],
        lemonchiffon: [255, 250, 205],
        lightblue: [173, 216, 230],
        lightcoral: [240, 128, 128],
        lightcyan: [224, 255, 255],
        lightgoldenrodyellow: [250, 250, 210],
        lightgray: [211, 211, 211],
        lightgreen: [144, 238, 144],
        lightgrey: [211, 211, 211],
        lightpink: [255, 182, 193],
        lightsalmon: [255, 160, 122],
        lightseagreen: [32, 178, 170],
        lightskyblue: [135, 206, 250],
        lightslategray: [119, 136, 153],
        lightslategrey: [119, 136, 153],
        lightsteelblue: [176, 196, 222],
        lightyellow: [255, 255, 224],
        lime: [0, 255, 0],
        limegreen: [50, 205, 50],
        linen: [250, 240, 230],
        magenta: [255, 0, 255],
        maroon: [128, 0, 0],
        mediumaquamarine: [102, 205, 170],
        mediumblue: [0, 0, 205],
        mediumorchid: [186, 85, 211],
        mediumpurple: [147, 112, 219],
        mediumseagreen: [60, 179, 113],
        mediumslateblue: [123, 104, 238],
        mediumspringgreen: [0, 250, 154],
        mediumturquoise: [72, 209, 204],
        mediumvioletred: [199, 21, 133],
        midnightblue: [25, 25, 112],
        mintcream: [245, 255, 250],
        mistyrose: [255, 228, 225],
        moccasin: [255, 228, 181],
        navajowhite: [255, 222, 173],
        navy: [0, 0, 128],
        oldlace: [253, 245, 230],
        olive: [128, 128, 0],
        olivedrab: [107, 142, 35],
        orange: [255, 165, 0],
        orangered: [255, 69, 0],
        orchid: [218, 112, 214],
        palegoldenrod: [238, 232, 170],
        palegreen: [152, 251, 152],
        paleturquoise: [175, 238, 238],
        palevioletred: [219, 112, 147],
        papayawhip: [255, 239, 213],
        peachpuff: [255, 218, 185],
        peru: [205, 133, 63],
        pink: [255, 192, 203],
        plum: [221, 160, 221],
        powderblue: [176, 224, 230],
        purple: [128, 0, 128],
        rebeccapurple: [102, 51, 153],
        red: [255, 0, 0],
        rosybrown: [188, 143, 143],
        royalblue: [65, 105, 225],
        saddlebrown: [139, 69, 19],
        salmon: [250, 128, 114],
        sandybrown: [244, 164, 96],
        seagreen: [46, 139, 87],
        seashell: [255, 245, 238],
        sienna: [160, 82, 45],
        silver: [192, 192, 192],
        skyblue: [135, 206, 235],
        slateblue: [106, 90, 205],
        slategray: [112, 128, 144],
        slategrey: [112, 128, 144],
        snow: [255, 250, 250],
        springgreen: [0, 255, 127],
        steelblue: [70, 130, 180],
        tan: [210, 180, 140],
        teal: [0, 128, 128],
        thistle: [216, 191, 216],
        tomato: [255, 99, 71],
        turquoise: [64, 224, 208],
        violet: [238, 130, 238],
        wheat: [245, 222, 179],
        white: [255, 255, 255],
        whitesmoke: [245, 245, 245],
        yellow: [255, 255, 0],
        yellowgreen: [154, 205, 50],
      };

      /***/
    },
    /* 58 */
    /***/ function(module, exports, __webpack_require__) {
      var conversions = __webpack_require__(16);

      /*
	this function routes a model to all other models.

	all functions that are routed have a property `.conversion` attached
	to the returned synthetic function. This property is an array
	of strings, each with the steps in between the 'from' and 'to'
	color models (inclusive).

	conversions that are not possible simply are not included.
*/

      function buildGraph() {
        var graph = {};
        // https://jsperf.com/object-keys-vs-for-in-with-closure/3
        var models = Object.keys(conversions);

        for (var len = models.length, i = 0; i < len; i++) {
          graph[models[i]] = {
            // http://jsperf.com/1-vs-infinity
            // micro-opt, but this is simple.
            distance: -1,
            parent: null,
          };
        }

        return graph;
      }

      // https://en.wikipedia.org/wiki/Breadth-first_search
      function deriveBFS(fromModel) {
        var graph = buildGraph();
        var queue = [fromModel]; // unshift -> queue -> pop

        graph[fromModel].distance = 0;

        while (queue.length) {
          var current = queue.pop();
          var adjacents = Object.keys(conversions[current]);

          for (var len = adjacents.length, i = 0; i < len; i++) {
            var adjacent = adjacents[i];
            var node = graph[adjacent];

            if (node.distance === -1) {
              node.distance = graph[current].distance + 1;
              node.parent = current;
              queue.unshift(adjacent);
            }
          }
        }

        return graph;
      }

      function link(from, to) {
        return function(args) {
          return to(from(args));
        };
      }

      function wrapConversion(toModel, graph) {
        var path = [graph[toModel].parent, toModel];
        var fn = conversions[graph[toModel].parent][toModel];

        var cur = graph[toModel].parent;
        while (graph[cur].parent) {
          path.unshift(graph[cur].parent);
          fn = link(conversions[graph[cur].parent][cur], fn);
          cur = graph[cur].parent;
        }

        fn.conversion = path;
        return fn;
      }

      module.exports = function(fromModel) {
        var graph = deriveBFS(fromModel);
        var conversion = {};

        var models = Object.keys(graph);
        for (var len = models.length, i = 0; i < len; i++) {
          var toModel = models[i];
          var node = graph[toModel];

          if (node.parent === null) {
            // no possible conversion, or this node is the source model.
            continue;
          }

          conversion[toModel] = wrapConversion(toModel, graph);
        }

        return conversion;
      };

      /***/
    },
    /* 59 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      module.exports = false;

      /***/
    },
    /* 60 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
      const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
      const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
      const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;

      const ESCAPES = new Map([
        ['n', '\n'],
        ['r', '\r'],
        ['t', '\t'],
        ['b', '\b'],
        ['f', '\f'],
        ['v', '\v'],
        ['0', '\0'],
        ['\\', '\\'],
        ['e', '\u001B'],
        ['a', '\u0007'],
      ]);

      function unescape(c) {
        if (
          (c[0] === 'u' && c.length === 5) ||
          (c[0] === 'x' && c.length === 3)
        ) {
          return String.fromCharCode(parseInt(c.slice(1), 16));
        }

        return ESCAPES.get(c) || c;
      }

      function parseArguments(name, args) {
        const results = [];
        const chunks = args.trim().split(/\s*,\s*/g);
        let matches;

        for (const chunk of chunks) {
          if (!isNaN(chunk)) {
            results.push(Number(chunk));
          } else if ((matches = chunk.match(STRING_REGEX))) {
            results.push(
              matches[2].replace(
                ESCAPE_REGEX,
                (m, escape, chr) => (escape ? unescape(escape) : chr)
              )
            );
          } else {
            throw new Error(
              `Invalid Chalk template style argument: ${chunk} (in style '${name}')`
            );
          }
        }

        return results;
      }

      function parseStyle(style) {
        STYLE_REGEX.lastIndex = 0;

        const results = [];
        let matches;

        while ((matches = STYLE_REGEX.exec(style)) !== null) {
          const name = matches[1];

          if (matches[2]) {
            const args = parseArguments(name, matches[2]);
            results.push([name].concat(args));
          } else {
            results.push([name]);
          }
        }

        return results;
      }

      function buildStyle(chalk, styles) {
        const enabled = {};

        for (const layer of styles) {
          for (const style of layer.styles) {
            enabled[style[0]] = layer.inverse ? null : style.slice(1);
          }
        }

        let current = chalk;
        for (const styleName of Object.keys(enabled)) {
          if (Array.isArray(enabled[styleName])) {
            if (!(styleName in current)) {
              throw new Error(`Unknown Chalk style: ${styleName}`);
            }

            if (enabled[styleName].length > 0) {
              current = current[styleName].apply(current, enabled[styleName]);
            } else {
              current = current[styleName];
            }
          }
        }

        return current;
      }

      module.exports = (chalk, tmp) => {
        const styles = [];
        const chunks = [];
        let chunk = [];

        // eslint-disable-next-line max-params
        tmp.replace(
          TEMPLATE_REGEX,
          (m, escapeChar, inverse, style, close, chr) => {
            if (escapeChar) {
              chunk.push(unescape(escapeChar));
            } else if (style) {
              const str = chunk.join('');
              chunk = [];
              chunks.push(
                styles.length === 0 ? str : buildStyle(chalk, styles)(str)
              );
              styles.push({ inverse, styles: parseStyle(style) });
            } else if (close) {
              if (styles.length === 0) {
                throw new Error('Found extraneous } in Chalk template literal');
              }

              chunks.push(buildStyle(chalk, styles)(chunk.join('')));
              chunk = [];
              styles.pop();
            } else {
              chunk.push(chr);
            }
          }
        );

        chunks.push(chunk.join(''));

        if (styles.length > 0) {
          const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length ===
          1
            ? ''
            : 's'} (\`}\`)`;
          throw new Error(errMsg);
        }

        return chunks.join('');
      };

      /***/
    },
    /* 61 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.getPrettyURL = getPrettyURL;
      exports.default = void 0;

      /**
 * Copyright (c) 2015-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
      function getPrettyURL(
        sourceFileName,
        sourceLineNumber,
        sourceColumnNumber,
        fileName,
        lineNumber,
        columnNumber,
        compiled
      ) {
        var prettyURL;

        if (
          !compiled &&
          sourceFileName &&
          typeof sourceLineNumber === 'number'
        ) {
          // Remove everything up to the first /src/ or /node_modules/
          var trimMatch = /^[/|\\].*?[/|\\]((src|node_modules)[/|\\].*)/.exec(
            sourceFileName
          );

          if (trimMatch && trimMatch[1]) {
            prettyURL = trimMatch[1];
          } else {
            prettyURL = sourceFileName;
          }

          prettyURL += ':' + sourceLineNumber; // Note: we intentionally skip 0's because they're produced by cheap Webpack maps

          if (sourceColumnNumber) {
            prettyURL += ':' + sourceColumnNumber;
          }
        } else if (fileName && typeof lineNumber === 'number') {
          prettyURL = fileName + ':' + lineNumber; // Note: we intentionally skip 0's because they're produced by cheap Webpack maps

          if (columnNumber) {
            prettyURL += ':' + columnNumber;
          }
        } else {
          prettyURL = 'unknown';
        }

        return prettyURL.replace('webpack://', '.');
      }

      var _default = getPrettyURL;
      exports.default = _default;

      /***/
    },
    /* 62 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.default = void 0;

      var _react = _interopRequireWildcard(__webpack_require__(0));

      var _styles = __webpack_require__(1);

      var _jsxFileName =
        '/Users/clemmy/create-react-app/packages/react-error-overlay/src/components/Collapsible.js';

      function _interopRequireWildcard(obj) {
        if (obj && obj.__esModule) {
          return obj;
        } else {
          var newObj = {};
          if (obj != null) {
            for (var key in obj) {
              if (Object.prototype.hasOwnProperty.call(obj, key))
                newObj[key] = obj[key];
            }
          }
          newObj.default = obj;
          return newObj;
        }
      }

      function _typeof(obj) {
        if (
          typeof Symbol === 'function' &&
          typeof Symbol.iterator === 'symbol'
        ) {
          _typeof = function _typeof(obj) {
            return typeof obj;
          };
        } else {
          _typeof = function _typeof(obj) {
            return obj &&
            typeof Symbol === 'function' &&
            obj.constructor === Symbol &&
            obj !== Symbol.prototype
              ? 'symbol'
              : typeof obj;
          };
        }
        return _typeof(obj);
      }

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError('Cannot call a class as a function');
        }
      }

      function _defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ('value' in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }

      function _createClass(Constructor, protoProps, staticProps) {
        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
        if (staticProps) _defineProperties(Constructor, staticProps);
        return Constructor;
      }

      function _possibleConstructorReturn(self, call) {
        if (
          call &&
          (_typeof(call) === 'object' || typeof call === 'function')
        ) {
          return call;
        }
        if (!self) {
          throw new ReferenceError(
            "this hasn't been initialised - super() hasn't been called"
          );
        }
        return self;
      }

      function _inherits(subClass, superClass) {
        if (typeof superClass !== 'function' && superClass !== null) {
          throw new TypeError(
            'Super expression must either be null or a function'
          );
        }
        subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
            value: subClass,
            enumerable: false,
            writable: true,
            configurable: true,
          },
        });
        if (superClass)
          Object.setPrototypeOf
            ? Object.setPrototypeOf(subClass, superClass)
            : (subClass.__proto__ = superClass);
      }

      function _extends() {
        _extends =
          Object.assign ||
          function(target) {
            for (var i = 1; i < arguments.length; i++) {
              var source = arguments[i];
              for (var key in source) {
                if (Object.prototype.hasOwnProperty.call(source, key)) {
                  target[key] = source[key];
                }
              }
            }
            return target;
          };
        return _extends.apply(this, arguments);
      }

      var _collapsibleStyle = {
        color: _styles.black,
        cursor: 'pointer',
        border: 'none',
        display: 'block',
        width: '100%',
        textAlign: 'left',
        background: '#fff',
        fontFamily: 'Consolas, Menlo, monospace',
        fontSize: '1em',
        padding: '0px',
        lineHeight: '1.5',
      };

      var collapsibleCollapsedStyle = _extends({}, _collapsibleStyle, {
        marginBottom: '1.5em',
      });

      var collapsibleExpandedStyle = _extends({}, _collapsibleStyle, {
        marginBottom: '0.6em',
      });

      var Collapsible =
        /*#__PURE__*/
        (function(_Component) {
          _inherits(Collapsible, _Component);

          function Collapsible() {
            var _ref;

            var _temp, _this;

            _classCallCheck(this, Collapsible);

            for (
              var _len = arguments.length, args = new Array(_len), _key = 0;
              _key < _len;
              _key++
            ) {
              args[_key] = arguments[_key];
            }

            return _possibleConstructorReturn(
              _this,
              ((_temp = _this = _possibleConstructorReturn(
                this,
                (_ref =
                  Collapsible.__proto__ ||
                  Object.getPrototypeOf(Collapsible)).call.apply(
                  _ref,
                  [this].concat(args)
                )
              )),
              Object.defineProperty(_this, 'state', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: {
                  collapsed: true,
                },
              }),
              Object.defineProperty(_this, 'toggleCollaped', {
                configurable: true,
                enumerable: true,
                writable: true,
                value: function value() {
                  _this.setState(function(state) {
                    return {
                      collapsed: !state.collapsed,
                    };
                  });
                },
              }),
              _temp)
            );
          }

          _createClass(Collapsible, [
            {
              key: 'render',
              value: function render() {
                var count = this.props.children.length;
                var collapsed = this.state.collapsed;
                return _react.default.createElement(
                  'div',
                  {
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 61,
                    },
                    __self: this,
                  },
                  _react.default.createElement(
                    'button',
                    {
                      onClick: this.toggleCollaped,
                      style: collapsed
                        ? collapsibleCollapsedStyle
                        : collapsibleExpandedStyle,
                      __source: {
                        fileName: _jsxFileName,
                        lineNumber: 62,
                      },
                      __self: this,
                    },
                    (collapsed ? '▶' : '▼') +
                      ' '.concat(count, ' stack frames were ') +
                      (collapsed ? 'collapsed.' : 'expanded.')
                  ),
                  _react.default.createElement(
                    'div',
                    {
                      style: {
                        display: collapsed ? 'none' : 'block',
                      },
                      __source: {
                        fileName: _jsxFileName,
                        lineNumber: 72,
                      },
                      __self: this,
                    },
                    this.props.children,
                    _react.default.createElement(
                      'button',
                      {
                        onClick: this.toggleCollaped,
                        style: collapsibleExpandedStyle,
                        __source: {
                          fileName: _jsxFileName,
                          lineNumber: 74,
                        },
                        __self: this,
                      },
                      '\u25B2 '.concat(count, ' stack frames were expanded.')
                    )
                  )
                );
              },
            },
          ]);

          return Collapsible;
        })(_react.Component);

      var _default = Collapsible;
      exports.default = _default;

      /***/
    },
    /* 63 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.isInternalFile = isInternalFile;

      /**
 * Copyright (c) 2015-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
      function isInternalFile(sourceFileName, fileName) {
        return (
          sourceFileName == null ||
          sourceFileName === '' ||
          sourceFileName.indexOf('/~/') !== -1 ||
          sourceFileName.indexOf('/node_modules/') !== -1 ||
          sourceFileName.trim().indexOf(' ') !== -1 ||
          fileName == null ||
          fileName === ''
        );
      }

      /***/
    },
    /* 64 */
    /***/ function(module, exports, __webpack_require__) {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true,
      });
      exports.isBultinErrorName = isBultinErrorName;
      exports.default = void 0;

      /**
 * Copyright (c) 2015-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
      function isBultinErrorName(errorName) {
        switch (errorName) {
          case 'EvalError':
          case 'InternalError':
          case 'RangeError':
          case 'ReferenceError':
          case 'SyntaxError':
          case 'TypeError':
          case 'URIError':
            return true;

          default:
            return false;
        }
      }

      var _default = isBultinErrorName;
      exports.default = _default;

      /***/
    },
    /******/
  ]
);