{"version":3,"file":"static/js/main.01d95ded.js","mappings":"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","sources":["../node_modules/charenc/charenc.js","../node_modules/crypt/crypt.js","../node_modules/is-buffer/index.js","../node_modules/md5/md5.js","../node_modules/react-dom/client.js","../node_modules/react/cjs/react-jsx-runtime.production.min.js","../node_modules/react/jsx-runtime.js","../external var \"React\"","../external var \"ReactDOM\"","../webpack/bootstrap","../webpack/runtime/compat get default export","../webpack/runtime/define property getters","../webpack/runtime/hasOwnProperty shorthand","../webpack/runtime/publicPath","../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","../node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","../node_modules/@babel/runtime/helpers/esm/slicedToArray.js","../node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","../node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","../node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","../node_modules/@babel/runtime/helpers/esm/extends.js","../../packages/react-router/lib/context.ts","../../packages/react-router/lib/router.ts","../../packages/react-router/lib/hooks.tsx","../../packages/react-router/lib/components.tsx","../../packages/react-router-dom/index.tsx","../node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js","components/Header/index.js","components/Footer/index.js","assets/imgs/index.js","components/CharGrid/index.js","utils/index.js","components/WordList/index.js","components/PageTip/index.js","components/StarList/index.js","components/FilterButton/index.js","App.js","index.js"],"sourcesContent":["var charenc = {\n  // UTF-8 encoding\n  utf8: {\n    // Convert a string to a byte array\n    stringToBytes: function(str) {\n      return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));\n    },\n\n    // Convert a byte array to a string\n    bytesToString: function(bytes) {\n      return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));\n    }\n  },\n\n  // Binary encoding\n  bin: {\n    // Convert a string to a byte array\n    stringToBytes: function(str) {\n      for (var bytes = [], i = 0; i < str.length; i++)\n        bytes.push(str.charCodeAt(i) & 0xFF);\n      return bytes;\n    },\n\n    // Convert a byte array to a string\n    bytesToString: function(bytes) {\n      for (var str = [], i = 0; i < bytes.length; i++)\n        str.push(String.fromCharCode(bytes[i]));\n      return str.join('');\n    }\n  }\n};\n\nmodule.exports = charenc;\n","(function() {\n  var base64map\n      = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',\n\n  crypt = {\n    // Bit-wise rotation left\n    rotl: function(n, b) {\n      return (n << b) | (n >>> (32 - b));\n    },\n\n    // Bit-wise rotation right\n    rotr: function(n, b) {\n      return (n << (32 - b)) | (n >>> b);\n    },\n\n    // Swap big-endian to little-endian and vice versa\n    endian: function(n) {\n      // If number given, swap endian\n      if (n.constructor == Number) {\n        return crypt.rotl(n, 8) & 0x00FF00FF | crypt.rotl(n, 24) & 0xFF00FF00;\n      }\n\n      // Else, assume array and swap all items\n      for (var i = 0; i < n.length; i++)\n        n[i] = crypt.endian(n[i]);\n      return n;\n    },\n\n    // Generate an array of any length of random bytes\n    randomBytes: function(n) {\n      for (var bytes = []; n > 0; n--)\n        bytes.push(Math.floor(Math.random() * 256));\n      return bytes;\n    },\n\n    // Convert a byte array to big-endian 32-bit words\n    bytesToWords: function(bytes) {\n      for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8)\n        words[b >>> 5] |= bytes[i] << (24 - b % 32);\n      return words;\n    },\n\n    // Convert big-endian 32-bit words to a byte array\n    wordsToBytes: function(words) {\n      for (var bytes = [], b = 0; b < words.length * 32; b += 8)\n        bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);\n      return bytes;\n    },\n\n    // Convert a byte array to a hex string\n    bytesToHex: function(bytes) {\n      for (var hex = [], i = 0; i < bytes.length; i++) {\n        hex.push((bytes[i] >>> 4).toString(16));\n        hex.push((bytes[i] & 0xF).toString(16));\n      }\n      return hex.join('');\n    },\n\n    // Convert a hex string to a byte array\n    hexToBytes: function(hex) {\n      for (var bytes = [], c = 0; c < hex.length; c += 2)\n        bytes.push(parseInt(hex.substr(c, 2), 16));\n      return bytes;\n    },\n\n    // Convert a byte array to a base-64 string\n    bytesToBase64: function(bytes) {\n      for (var base64 = [], i = 0; i < bytes.length; i += 3) {\n        var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];\n        for (var j = 0; j < 4; j++)\n          if (i * 8 + j * 6 <= bytes.length * 8)\n            base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F));\n          else\n            base64.push('=');\n      }\n      return base64.join('');\n    },\n\n    // Convert a base-64 string to a byte array\n    base64ToBytes: function(base64) {\n      // Remove non-base-64 characters\n      base64 = base64.replace(/[^A-Z0-9+\\/]/ig, '');\n\n      for (var bytes = [], i = 0, imod4 = 0; i < base64.length;\n          imod4 = ++i % 4) {\n        if (imod4 == 0) continue;\n        bytes.push(((base64map.indexOf(base64.charAt(i - 1))\n            & (Math.pow(2, -2 * imod4 + 8) - 1)) << (imod4 * 2))\n            | (base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2)));\n      }\n      return bytes;\n    }\n  };\n\n  module.exports = crypt;\n})();\n","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\nmodule.exports = function (obj) {\n  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)\n}\n\nfunction isBuffer (obj) {\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n\n// For Node v0.10 support. Remove this eventually.\nfunction isSlowBuffer (obj) {\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))\n}\n","(function(){\r\n  var crypt = require('crypt'),\r\n      utf8 = require('charenc').utf8,\r\n      isBuffer = require('is-buffer'),\r\n      bin = require('charenc').bin,\r\n\r\n  // The core\r\n  md5 = function (message, options) {\r\n    // Convert to byte array\r\n    if (message.constructor == String)\r\n      if (options && options.encoding === 'binary')\r\n        message = bin.stringToBytes(message);\r\n      else\r\n        message = utf8.stringToBytes(message);\r\n    else if (isBuffer(message))\r\n      message = Array.prototype.slice.call(message, 0);\r\n    else if (!Array.isArray(message) && message.constructor !== Uint8Array)\r\n      message = message.toString();\r\n    // else, assume byte array already\r\n\r\n    var m = crypt.bytesToWords(message),\r\n        l = message.length * 8,\r\n        a =  1732584193,\r\n        b = -271733879,\r\n        c = -1732584194,\r\n        d =  271733878;\r\n\r\n    // Swap endian\r\n    for (var i = 0; i < m.length; i++) {\r\n      m[i] = ((m[i] <<  8) | (m[i] >>> 24)) & 0x00FF00FF |\r\n             ((m[i] << 24) | (m[i] >>>  8)) & 0xFF00FF00;\r\n    }\r\n\r\n    // Padding\r\n    m[l >>> 5] |= 0x80 << (l % 32);\r\n    m[(((l + 64) >>> 9) << 4) + 14] = l;\r\n\r\n    // Method shortcuts\r\n    var FF = md5._ff,\r\n        GG = md5._gg,\r\n        HH = md5._hh,\r\n        II = md5._ii;\r\n\r\n    for (var i = 0; i < m.length; i += 16) {\r\n\r\n      var aa = a,\r\n          bb = b,\r\n          cc = c,\r\n          dd = d;\r\n\r\n      a = FF(a, b, c, d, m[i+ 0],  7, -680876936);\r\n      d = FF(d, a, b, c, m[i+ 1], 12, -389564586);\r\n      c = FF(c, d, a, b, m[i+ 2], 17,  606105819);\r\n      b = FF(b, c, d, a, m[i+ 3], 22, -1044525330);\r\n      a = FF(a, b, c, d, m[i+ 4],  7, -176418897);\r\n      d = FF(d, a, b, c, m[i+ 5], 12,  1200080426);\r\n      c = FF(c, d, a, b, m[i+ 6], 17, -1473231341);\r\n      b = FF(b, c, d, a, m[i+ 7], 22, -45705983);\r\n      a = FF(a, b, c, d, m[i+ 8],  7,  1770035416);\r\n      d = FF(d, a, b, c, m[i+ 9], 12, -1958414417);\r\n      c = FF(c, d, a, b, m[i+10], 17, -42063);\r\n      b = FF(b, c, d, a, m[i+11], 22, -1990404162);\r\n      a = FF(a, b, c, d, m[i+12],  7,  1804603682);\r\n      d = FF(d, a, b, c, m[i+13], 12, -40341101);\r\n      c = FF(c, d, a, b, m[i+14], 17, -1502002290);\r\n      b = FF(b, c, d, a, m[i+15], 22,  1236535329);\r\n\r\n      a = GG(a, b, c, d, m[i+ 1],  5, -165796510);\r\n      d = GG(d, a, b, c, m[i+ 6],  9, -1069501632);\r\n      c = GG(c, d, a, b, m[i+11], 14,  643717713);\r\n      b = GG(b, c, d, a, m[i+ 0], 20, -373897302);\r\n      a = GG(a, b, c, d, m[i+ 5],  5, -701558691);\r\n      d = GG(d, a, b, c, m[i+10],  9,  38016083);\r\n      c = GG(c, d, a, b, m[i+15], 14, -660478335);\r\n      b = GG(b, c, d, a, m[i+ 4], 20, -405537848);\r\n      a = GG(a, b, c, d, m[i+ 9],  5,  568446438);\r\n      d = GG(d, a, b, c, m[i+14],  9, -1019803690);\r\n      c = GG(c, d, a, b, m[i+ 3], 14, -187363961);\r\n      b = GG(b, c, d, a, m[i+ 8], 20,  1163531501);\r\n      a = GG(a, b, c, d, m[i+13],  5, -1444681467);\r\n      d = GG(d, a, b, c, m[i+ 2],  9, -51403784);\r\n      c = GG(c, d, a, b, m[i+ 7], 14,  1735328473);\r\n      b = GG(b, c, d, a, m[i+12], 20, -1926607734);\r\n\r\n      a = HH(a, b, c, d, m[i+ 5],  4, -378558);\r\n      d = HH(d, a, b, c, m[i+ 8], 11, -2022574463);\r\n      c = HH(c, d, a, b, m[i+11], 16,  1839030562);\r\n      b = HH(b, c, d, a, m[i+14], 23, -35309556);\r\n      a = HH(a, b, c, d, m[i+ 1],  4, -1530992060);\r\n      d = HH(d, a, b, c, m[i+ 4], 11,  1272893353);\r\n      c = HH(c, d, a, b, m[i+ 7], 16, -155497632);\r\n      b = HH(b, c, d, a, m[i+10], 23, -1094730640);\r\n      a = HH(a, b, c, d, m[i+13],  4,  681279174);\r\n      d = HH(d, a, b, c, m[i+ 0], 11, -358537222);\r\n      c = HH(c, d, a, b, m[i+ 3], 16, -722521979);\r\n      b = HH(b, c, d, a, m[i+ 6], 23,  76029189);\r\n      a = HH(a, b, c, d, m[i+ 9],  4, -640364487);\r\n      d = HH(d, a, b, c, m[i+12], 11, -421815835);\r\n      c = HH(c, d, a, b, m[i+15], 16,  530742520);\r\n      b = HH(b, c, d, a, m[i+ 2], 23, -995338651);\r\n\r\n      a = II(a, b, c, d, m[i+ 0],  6, -198630844);\r\n      d = II(d, a, b, c, m[i+ 7], 10,  1126891415);\r\n      c = II(c, d, a, b, m[i+14], 15, -1416354905);\r\n      b = II(b, c, d, a, m[i+ 5], 21, -57434055);\r\n      a = II(a, b, c, d, m[i+12],  6,  1700485571);\r\n      d = II(d, a, b, c, m[i+ 3], 10, -1894986606);\r\n      c = II(c, d, a, b, m[i+10], 15, -1051523);\r\n      b = II(b, c, d, a, m[i+ 1], 21, -2054922799);\r\n      a = II(a, b, c, d, m[i+ 8],  6,  1873313359);\r\n      d = II(d, a, b, c, m[i+15], 10, -30611744);\r\n      c = II(c, d, a, b, m[i+ 6], 15, -1560198380);\r\n      b = II(b, c, d, a, m[i+13], 21,  1309151649);\r\n      a = II(a, b, c, d, m[i+ 4],  6, -145523070);\r\n      d = II(d, a, b, c, m[i+11], 10, -1120210379);\r\n      c = II(c, d, a, b, m[i+ 2], 15,  718787259);\r\n      b = II(b, c, d, a, m[i+ 9], 21, -343485551);\r\n\r\n      a = (a + aa) >>> 0;\r\n      b = (b + bb) >>> 0;\r\n      c = (c + cc) >>> 0;\r\n      d = (d + dd) >>> 0;\r\n    }\r\n\r\n    return crypt.endian([a, b, c, d]);\r\n  };\r\n\r\n  // Auxiliary functions\r\n  md5._ff  = function (a, b, c, d, x, s, t) {\r\n    var n = a + (b & c | ~b & d) + (x >>> 0) + t;\r\n    return ((n << s) | (n >>> (32 - s))) + b;\r\n  };\r\n  md5._gg  = function (a, b, c, d, x, s, t) {\r\n    var n = a + (b & d | c & ~d) + (x >>> 0) + t;\r\n    return ((n << s) | (n >>> (32 - s))) + b;\r\n  };\r\n  md5._hh  = function (a, b, c, d, x, s, t) {\r\n    var n = a + (b ^ c ^ d) + (x >>> 0) + t;\r\n    return ((n << s) | (n >>> (32 - s))) + b;\r\n  };\r\n  md5._ii  = function (a, b, c, d, x, s, t) {\r\n    var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;\r\n    return ((n << s) | (n >>> (32 - s))) + b;\r\n  };\r\n\r\n  // Package private blocksize\r\n  md5._blocksize = 16;\r\n  md5._digestsize = 16;\r\n\r\n  module.exports = function (message, options) {\r\n    if (message === undefined || message === null)\r\n      throw new Error('Illegal argument ' + message);\r\n\r\n    var digestbytes = crypt.wordsToBytes(md5(message, options));\r\n    return options && options.asBytes ? digestbytes :\r\n        options && options.asString ? bin.bytesToString(digestbytes) :\r\n        crypt.bytesToHex(digestbytes);\r\n  };\r\n\r\n})();\r\n","'use strict';\n\nvar m = require('react-dom');\nif (process.env.NODE_ENV === 'production') {\n  exports.createRoot = m.createRoot;\n  exports.hydrateRoot = m.hydrateRoot;\n} else {\n  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n  exports.createRoot = function(c, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.createRoot(c, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n  exports.hydrateRoot = function(c, h, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.hydrateRoot(c, h, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n}\n","/**\n * @license React\n * react-jsx-runtime.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var f=require(\"react\"),k=Symbol.for(\"react.element\"),l=Symbol.for(\"react.fragment\"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};\nfunction q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=\"\"+g);void 0!==a.key&&(e=\"\"+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-jsx-runtime.production.min.js');\n} else {\n  module.exports = require('./cjs/react-jsx-runtime.development.js');\n}\n","module.exports = React;","module.exports = ReactDOM;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = function(module) {\n\tvar getter = module && module.__esModule ?\n\t\tfunction() { return module['default']; } :\n\t\tfunction() { return module; };\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = function(exports, definition) {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","__webpack_require__.p = \"/\";","export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _iterableToArrayLimit(arr, i) {\n  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n\n  var _s, _e;\n\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","export default function _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}","import * as React from \"react\";\nimport type { History, Location } from \"history\";\nimport { Action as NavigationType } from \"history\";\n\nimport type { RouteMatch } from \"./router\";\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level <Router> API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\nexport type Navigator = Pick<History, \"go\" | \"push\" | \"replace\" | \"createHref\">;\n\ninterface NavigationContextObject {\n  basename: string;\n  navigator: Navigator;\n  static: boolean;\n}\n\nexport const NavigationContext = React.createContext<NavigationContextObject>(\n  null!\n);\n\nif (__DEV__) {\n  NavigationContext.displayName = \"Navigation\";\n}\n\ninterface LocationContextObject {\n  location: Location;\n  navigationType: NavigationType;\n}\n\nexport const LocationContext = React.createContext<LocationContextObject>(\n  null!\n);\n\nif (__DEV__) {\n  LocationContext.displayName = \"Location\";\n}\n\ninterface RouteContextObject {\n  outlet: React.ReactElement | null;\n  matches: RouteMatch[];\n}\n\nexport const RouteContext = React.createContext<RouteContextObject>({\n  outlet: null,\n  matches: [],\n});\n\nif (__DEV__) {\n  RouteContext.displayName = \"Route\";\n}\n","import type { Location, Path, To } from \"history\";\nimport { parsePath } from \"history\";\n\nexport function invariant(cond: any, message: string): asserts cond {\n  if (!cond) throw new Error(message);\n}\n\nexport function warning(cond: any, message: string): void {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n\n    try {\n      // Welcome to debugging React Router!\n      //\n      // This error is thrown as a convenience so you can more easily\n      // find the source for a warning that appears in the console by\n      // enabling \"pause on exceptions\" in your JavaScript debugger.\n      throw new Error(message);\n      // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\n\nconst alreadyWarned: Record<string, boolean> = {};\nexport function warningOnce(key: string, cond: boolean, message: string) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    warning(false, message);\n  }\n}\n\ntype ParamParseFailed = { failed: true };\n\ntype ParamParseSegment<Segment extends string> =\n  // Check here if there exists a forward slash in the string.\n  Segment extends `${infer LeftSegment}/${infer RightSegment}`\n    ? // If there is a forward slash, then attempt to parse each side of the\n      // forward slash.\n      ParamParseSegment<LeftSegment> extends infer LeftResult\n      ? ParamParseSegment<RightSegment> extends infer RightResult\n        ? LeftResult extends string\n          ? // If the left side is successfully parsed as a param, then check if\n            // the right side can be successfully parsed as well. If both sides\n            // can be parsed, then the result is a union of the two sides\n            // (read: \"foo\" | \"bar\").\n            RightResult extends string\n            ? LeftResult | RightResult\n            : LeftResult\n          : // If the left side is not successfully parsed as a param, then check\n          // if only the right side can be successfully parse as a param. If it\n          // can, then the result is just right, else it's a failure.\n          RightResult extends string\n          ? RightResult\n          : ParamParseFailed\n        : ParamParseFailed\n      : // If the left side didn't parse into a param, then just check the right\n      // side.\n      ParamParseSegment<RightSegment> extends infer RightResult\n      ? RightResult extends string\n        ? RightResult\n        : ParamParseFailed\n      : ParamParseFailed\n    : // If there's no forward slash, then check if this segment starts with a\n    // colon. If it does, then this is a dynamic segment, so the result is\n    // just the remainder of the string. Otherwise, it's a failure.\n    Segment extends `:${infer Remaining}`\n    ? Remaining\n    : ParamParseFailed;\n\n// Attempt to parse the given string segment. If it fails, then just return the\n// plain string type as a default fallback. Otherwise return the union of the\n// parsed string literals that were referenced as dynamic segments in the route.\nexport type ParamParseKey<Segment extends string> =\n  ParamParseSegment<Segment> extends string\n    ? ParamParseSegment<Segment>\n    : string;\n\n/**\n * The parameters that were parsed from the URL path.\n */\nexport type Params<Key extends string = string> = {\n  readonly [key in Key]: string | undefined;\n};\n\n/**\n * A route object represents a logical route, with (optionally) its child\n * routes organized in a tree-like structure.\n */\nexport interface RouteObject {\n  caseSensitive?: boolean;\n  children?: RouteObject[];\n  element?: React.ReactNode;\n  index?: boolean;\n  path?: string;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/docs/en/v6/api#generatepath\n */\nexport function generatePath(path: string, params: Params = {}): string {\n  return path\n    .replace(/:(\\w+)/g, (_, key) => {\n      invariant(params[key] != null, `Missing \":${key}\" param`);\n      return params[key]!;\n    })\n    .replace(/\\/*\\*$/, (_) =>\n      params[\"*\"] == null ? \"\" : params[\"*\"].replace(/^\\/*/, \"/\")\n    );\n}\n\n/**\n * A RouteMatch contains info about how a route matched a URL.\n */\nexport interface RouteMatch<ParamKey extends string = string> {\n  /**\n   * The names and values of dynamic parameters in the URL.\n   */\n  params: Params<ParamKey>;\n  /**\n   * The portion of the URL pathname that was matched.\n   */\n  pathname: string;\n  /**\n   * The portion of the URL pathname that was matched before child routes.\n   */\n  pathnameBase: string;\n  /**\n   * The route object that was used to match.\n   */\n  route: RouteObject;\n}\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchroutes\n */\nexport function matchRoutes(\n  routes: RouteObject[],\n  locationArg: Partial<Location> | string,\n  basename = \"/\"\n): RouteMatch[] | null {\n  let location =\n    typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n\n  if (pathname == null) {\n    return null;\n  }\n\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n\n  let matches = null;\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    matches = matchRouteBranch(branches[i], pathname);\n  }\n\n  return matches;\n}\n\ninterface RouteMeta {\n  relativePath: string;\n  caseSensitive: boolean;\n  childrenIndex: number;\n  route: RouteObject;\n}\n\ninterface RouteBranch {\n  path: string;\n  score: number;\n  routesMeta: RouteMeta[];\n}\n\nfunction flattenRoutes(\n  routes: RouteObject[],\n  branches: RouteBranch[] = [],\n  parentsMeta: RouteMeta[] = [],\n  parentPath = \"\"\n): RouteBranch[] {\n  routes.forEach((route, index) => {\n    let meta: RouteMeta = {\n      relativePath: route.path || \"\",\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route,\n    };\n\n    if (meta.relativePath.startsWith(\"/\")) {\n      invariant(\n        meta.relativePath.startsWith(parentPath),\n        `Absolute route path \"${meta.relativePath}\" nested under path ` +\n          `\"${parentPath}\" is not valid. An absolute child route path ` +\n          `must start with the combined path of all its parent routes.`\n      );\n\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta);\n\n    // Add the children before adding this route to the array so we traverse the\n    // route tree depth-first and child routes appear before their parents in\n    // the \"flattened\" version.\n    if (route.children && route.children.length > 0) {\n      invariant(\n        route.index !== true,\n        `Index routes must not have child routes. Please remove ` +\n          `all child routes from route path \"${path}\".`\n      );\n\n      flattenRoutes(route.children, branches, routesMeta, path);\n    }\n\n    // Routes without a path shouldn't ever match by themselves unless they are\n    // index routes, so don't add them to the list of possible branches.\n    if (route.path == null && !route.index) {\n      return;\n    }\n\n    branches.push({ path, score: computeScore(path, route.index), routesMeta });\n  });\n\n  return branches;\n}\n\nfunction rankRouteBranches(branches: RouteBranch[]): void {\n  branches.sort((a, b) =>\n    a.score !== b.score\n      ? b.score - a.score // Higher score first\n      : compareIndexes(\n          a.routesMeta.map((meta) => meta.childrenIndex),\n          b.routesMeta.map((meta) => meta.childrenIndex)\n        )\n  );\n}\n\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = (s: string) => s === \"*\";\n\nfunction computeScore(path: string, index: boolean | undefined): number {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n\n  return segments\n    .filter((s) => !isSplat(s))\n    .reduce(\n      (score, segment) =>\n        score +\n        (paramRe.test(segment)\n          ? dynamicSegmentValue\n          : segment === \"\"\n          ? emptySegmentValue\n          : staticSegmentValue),\n      initialScore\n    );\n}\n\nfunction compareIndexes(a: number[], b: number[]): number {\n  let siblings =\n    a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n\n  return siblings\n    ? // If two routes are siblings, we should try to match the earlier sibling\n      // first. This allows people to have fine-grained control over the matching\n      // behavior by simply putting routes with identical paths in the order they\n      // want them tried.\n      a[a.length - 1] - b[b.length - 1]\n    : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n      // so they sort equally.\n      0;\n}\n\nfunction matchRouteBranch<ParamKey extends string = string>(\n  branch: RouteBranch,\n  pathname: string\n): RouteMatch<ParamKey>[] | null {\n  let { routesMeta } = branch;\n\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches: RouteMatch[] = [];\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname =\n      matchedPathname === \"/\"\n        ? pathname\n        : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath(\n      { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },\n      remainingPathname\n    );\n\n    if (!match) return null;\n\n    Object.assign(matchedParams, match.params);\n\n    let route = meta.route;\n\n    matches.push({\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(\n        joinPaths([matchedPathname, match.pathnameBase])\n      ),\n      route,\n    });\n\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n\n/**\n * A PathPattern is used to match on some portion of a URL pathname.\n */\nexport interface PathPattern<Path extends string = string> {\n  /**\n   * A string to match against a URL pathname. May contain `:id`-style segments\n   * to indicate placeholders for dynamic parameters. May also end with `/*` to\n   * indicate matching the rest of the URL pathname.\n   */\n  path: Path;\n  /**\n   * Should be `true` if the static portions of the `path` should be matched in\n   * the same case.\n   */\n  caseSensitive?: boolean;\n  /**\n   * Should be `true` if this pattern should match the entire URL pathname.\n   */\n  end?: boolean;\n}\n\n/**\n * A PathMatch contains info about how a PathPattern matched on a URL pathname.\n */\nexport interface PathMatch<ParamKey extends string = string> {\n  /**\n   * The names and values of dynamic parameters in the URL.\n   */\n  params: Params<ParamKey>;\n  /**\n   * The portion of the URL pathname that was matched.\n   */\n  pathname: string;\n  /**\n   * The portion of the URL pathname that was matched before child routes.\n   */\n  pathnameBase: string;\n  /**\n   * The pattern that was used to match.\n   */\n  pattern: PathPattern;\n}\n\ntype Mutable<T> = {\n  -readonly [P in keyof T]: T[P];\n};\n\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchpath\n */\nexport function matchPath<\n  ParamKey extends ParamParseKey<Path>,\n  Path extends string\n>(\n  pattern: PathPattern<Path> | Path,\n  pathname: string\n): PathMatch<ParamKey> | null {\n  if (typeof pattern === \"string\") {\n    pattern = { path: pattern, caseSensitive: false, end: true };\n  }\n\n  let [matcher, paramNames] = compilePath(\n    pattern.path,\n    pattern.caseSensitive,\n    pattern.end\n  );\n\n  let match = pathname.match(matcher);\n  if (!match) return null;\n\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params: Params = paramNames.reduce<Mutable<Params>>(\n    (memo, paramName, index) => {\n      // We need to compute the pathnameBase here using the raw splat value\n      // instead of using params[\"*\"] later because it will be decoded then\n      if (paramName === \"*\") {\n        let splatValue = captureGroups[index] || \"\";\n        pathnameBase = matchedPathname\n          .slice(0, matchedPathname.length - splatValue.length)\n          .replace(/(.)\\/+$/, \"$1\");\n      }\n\n      memo[paramName] = safelyDecodeURIComponent(\n        captureGroups[index] || \"\",\n        paramName\n      );\n      return memo;\n    },\n    {}\n  );\n\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern,\n  };\n}\n\nfunction compilePath(\n  path: string,\n  caseSensitive = false,\n  end = true\n): [RegExp, string[]] {\n  warning(\n    path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"),\n    `Route path \"${path}\" will be treated as if it were ` +\n      `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n      `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n      `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n  );\n\n  let paramNames: string[] = [];\n  let regexpSource =\n    \"^\" +\n    path\n      .replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n      .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n      .replace(/[\\\\.*+^$?{}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n      .replace(/:(\\w+)/g, (_: string, paramName: string) => {\n        paramNames.push(paramName);\n        return \"([^\\\\/]+)\";\n      });\n\n  if (path.endsWith(\"*\")) {\n    paramNames.push(\"*\");\n    regexpSource +=\n      path === \"*\" || path === \"/*\"\n        ? \"(.*)$\" // Already matched the initial /, just match the rest\n        : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else {\n    regexpSource += end\n      ? \"\\\\/*$\" // When matching to the end, ignore trailing slashes\n      : // Otherwise, match a word boundary or a proceeding /. The word boundary restricts\n        // parent routes to matching only their own words and nothing more, e.g. parent\n        // route \"/home\" should not match \"/home2\".\n        // Additionally, allow paths starting with `.`, `-`, `~`, and url-encoded entities,\n        // but do not consume the character in the matched path so they can match against\n        // nested paths.\n        \"(?:(?=[.~-]|%[0-9A-F]{2})|\\\\b|\\\\/|$)\";\n  }\n\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n\n  return [matcher, paramNames];\n}\n\nfunction safelyDecodeURIComponent(value: string, paramName: string) {\n  try {\n    return decodeURIComponent(value);\n  } catch (error) {\n    warning(\n      false,\n      `The value for the URL param \"${paramName}\" will not be decoded because` +\n        ` the string \"${value}\" is a malformed URL segment. This is probably` +\n        ` due to a bad percent encoding (${error}).`\n    );\n\n    return value;\n  }\n}\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/docs/en/v6/api#resolvepath\n */\nexport function resolvePath(to: To, fromPathname = \"/\"): Path {\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\",\n  } = typeof to === \"string\" ? parsePath(to) : to;\n\n  let pathname = toPathname\n    ? toPathname.startsWith(\"/\")\n      ? toPathname\n      : resolvePathname(toPathname, fromPathname)\n    : fromPathname;\n\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash),\n  };\n}\n\nfunction resolvePathname(relativePath: string, fromPathname: string): string {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\n\n  relativeSegments.forEach((segment) => {\n    if (segment === \"..\") {\n      // Keep the root \"\" segment so the pathname starts at /\n      if (segments.length > 1) segments.pop();\n    } else if (segment !== \".\") {\n      segments.push(segment);\n    }\n  });\n\n  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\n\nexport function resolveTo(\n  toArg: To,\n  routePathnames: string[],\n  locationPathname: string\n): Path {\n  let to = typeof toArg === \"string\" ? parsePath(toArg) : toArg;\n  let toPathname = toArg === \"\" || to.pathname === \"\" ? \"/\" : to.pathname;\n\n  // If a pathname is explicitly provided in `to`, it should be relative to the\n  // route context. This is explained in `Note on `<Link to>` values` in our\n  // migration guide from v5 as a means of disambiguation between `to` values\n  // that begin with `/` and those that do not. However, this is problematic for\n  // `to` values that do not provide a pathname. `to` can simply be a search or\n  // hash string, in which case we should assume that the navigation is relative\n  // to the current location's pathname and *not* the route pathname.\n  let from: string;\n  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    if (toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n\n      // Each leading .. segment means \"go up one route\" instead of \"go up one\n      // URL segment\".  This is a key difference from how <a href> works and a\n      // major reason we call this a \"to\" value instead of a \"href\".\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    }\n\n    // If there are more \"..\" segments than parent routes, resolve relative to\n    // the root / URL.\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n\n  let path = resolvePath(to, from);\n\n  // Ensure the pathname has a trailing slash if the original to value had one.\n  if (\n    toPathname &&\n    toPathname !== \"/\" &&\n    toPathname.endsWith(\"/\") &&\n    !path.pathname.endsWith(\"/\")\n  ) {\n    path.pathname += \"/\";\n  }\n\n  return path;\n}\n\nexport function getToPathname(to: To): string | undefined {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || (to as Path).pathname === \"\"\n    ? \"/\"\n    : typeof to === \"string\"\n    ? parsePath(to).pathname\n    : to.pathname;\n}\n\nexport function stripBasename(\n  pathname: string,\n  basename: string\n): string | null {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n\n  let nextChar = pathname.charAt(basename.length);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(basename.length) || \"/\";\n}\n\nexport const joinPaths = (paths: string[]): string =>\n  paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\nexport const normalizePathname = (pathname: string): string =>\n  pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\nconst normalizeSearch = (search: string): string =>\n  !search || search === \"?\"\n    ? \"\"\n    : search.startsWith(\"?\")\n    ? search\n    : \"?\" + search;\n\nconst normalizeHash = (hash: string): string =>\n  !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n","import * as React from \"react\";\nimport type { Location, Path, To } from \"history\";\nimport { Action as NavigationType, parsePath } from \"history\";\n\nimport { LocationContext, NavigationContext, RouteContext } from \"./context\";\nimport type {\n  ParamParseKey,\n  Params,\n  PathMatch,\n  PathPattern,\n  RouteMatch,\n  RouteObject,\n} from \"./router\";\nimport {\n  getToPathname,\n  invariant,\n  joinPaths,\n  matchPath,\n  matchRoutes,\n  resolveTo,\n  warning,\n  warningOnce,\n} from \"./router\";\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usehref\n */\nexport function useHref(to: To): string {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useHref() may be used only in the context of a <Router> component.`\n  );\n\n  let { basename, navigator } = React.useContext(NavigationContext);\n  let { hash, pathname, search } = useResolvedPath(to);\n\n  let joinedPathname = pathname;\n  if (basename !== \"/\") {\n    let toPathname = getToPathname(to);\n    let endsWithSlash = toPathname != null && toPathname.endsWith(\"/\");\n    joinedPathname =\n      pathname === \"/\"\n        ? basename + (endsWithSlash ? \"/\" : \"\")\n        : joinPaths([basename, pathname]);\n  }\n\n  return navigator.createHref({ pathname: joinedPathname, search, hash });\n}\n\n/**\n * Returns true if this component is a descendant of a <Router>.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useinroutercontext\n */\nexport function useInRouterContext(): boolean {\n  return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/docs/en/v6/api#uselocation\n */\nexport function useLocation(): Location {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useLocation() may be used only in the context of a <Router> component.`\n  );\n\n  return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usenavigationtype\n */\nexport function useNavigationType(): NavigationType {\n  return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns true if the URL for the given \"to\" value matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * <NavLink>.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usematch\n */\nexport function useMatch<\n  ParamKey extends ParamParseKey<Path>,\n  Path extends string\n>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useMatch() may be used only in the context of a <Router> component.`\n  );\n\n  let { pathname } = useLocation();\n  return React.useMemo(\n    () => matchPath<ParamKey, Path>(pattern, pathname),\n    [pathname, pattern]\n  );\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\nexport interface NavigateFunction {\n  (to: To, options?: NavigateOptions): void;\n  (delta: number): void;\n}\n\nexport interface NavigateOptions {\n  replace?: boolean;\n  state?: any;\n}\n\n/**\n * Returns an imperative method for changing the location. Used by <Link>s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usenavigate\n */\nexport function useNavigate(): NavigateFunction {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useNavigate() may be used only in the context of a <Router> component.`\n  );\n\n  let { basename, navigator } = React.useContext(NavigationContext);\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n\n  let routePathnamesJson = JSON.stringify(\n    matches.map((match) => match.pathnameBase)\n  );\n\n  let activeRef = React.useRef(false);\n  React.useEffect(() => {\n    activeRef.current = true;\n  });\n\n  let navigate: NavigateFunction = React.useCallback(\n    (to: To | number, options: NavigateOptions = {}) => {\n      warning(\n        activeRef.current,\n        `You should call navigate() in a React.useEffect(), not when ` +\n          `your component is first rendered.`\n      );\n\n      if (!activeRef.current) return;\n\n      if (typeof to === \"number\") {\n        navigator.go(to);\n        return;\n      }\n\n      let path = resolveTo(\n        to,\n        JSON.parse(routePathnamesJson),\n        locationPathname\n      );\n\n      if (basename !== \"/\") {\n        path.pathname = joinPaths([basename, path.pathname]);\n      }\n\n      (!!options.replace ? navigator.replace : navigator.push)(\n        path,\n        options.state\n      );\n    },\n    [basename, navigator, routePathnamesJson, locationPathname]\n  );\n\n  return navigate;\n}\n\nconst OutletContext = React.createContext<unknown>(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/docs/en/v6/api#useoutletcontext\n */\nexport function useOutletContext<Context = unknown>(): Context {\n  return React.useContext(OutletContext) as Context;\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by <Outlet> to render child routes.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useoutlet\n */\nexport function useOutlet(context?: unknown): React.ReactElement | null {\n  let outlet = React.useContext(RouteContext).outlet;\n  if (outlet) {\n    return (\n      <OutletContext.Provider value={context}>{outlet}</OutletContext.Provider>\n    );\n  }\n  return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useparams\n */\nexport function useParams<\n  ParamsOrKey extends string | Record<string, string | undefined> = string\n>(): Readonly<\n  [ParamsOrKey] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>\n> {\n  let { matches } = React.useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? (routeMatch.params as any) : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useresolvedpath\n */\nexport function useResolvedPath(to: To): Path {\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n\n  let routePathnamesJson = JSON.stringify(\n    matches.map((match) => match.pathnameBase)\n  );\n\n  return React.useMemo(\n    () => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname),\n    [to, routePathnamesJson, locationPathname]\n  );\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an <Outlet> to render their child route's\n * element.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useroutes\n */\nexport function useRoutes(\n  routes: RouteObject[],\n  locationArg?: Partial<Location> | string\n): React.ReactElement | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useRoutes() may be used only in the context of a <Router> component.`\n  );\n\n  let { matches: parentMatches } = React.useContext(RouteContext);\n  let routeMatch = parentMatches[parentMatches.length - 1];\n  let parentParams = routeMatch ? routeMatch.params : {};\n  let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n  let parentRoute = routeMatch && routeMatch.route;\n\n  if (__DEV__) {\n    // You won't get a warning about 2 different <Routes> under a <Route>\n    // without a trailing *, but this is a best-effort warning anyway since we\n    // cannot even give the warning unless they land at the parent route.\n    //\n    // Example:\n    //\n    // <Routes>\n    //   {/* This route path MUST end with /* because otherwise\n    //       it will never match /blog/post/123 */}\n    //   <Route path=\"blog\" element={<Blog />} />\n    //   <Route path=\"blog/feed\" element={<BlogFeed />} />\n    // </Routes>\n    //\n    // function Blog() {\n    //   return (\n    //     <Routes>\n    //       <Route path=\"post/:id\" element={<Post />} />\n    //     </Routes>\n    //   );\n    // }\n    let parentPath = (parentRoute && parentRoute.path) || \"\";\n    warningOnce(\n      parentPathname,\n      !parentRoute || parentPath.endsWith(\"*\"),\n      `You rendered descendant <Routes> (or called \\`useRoutes()\\`) at ` +\n        `\"${parentPathname}\" (under <Route path=\"${parentPath}\">) but the ` +\n        `parent route path has no trailing \"*\". This means if you navigate ` +\n        `deeper, the parent won't match anymore and therefore the child ` +\n        `routes will never render.\\n\\n` +\n        `Please change the parent <Route path=\"${parentPath}\"> to <Route ` +\n        `path=\"${parentPath === \"/\" ? \"*\" : `${parentPath}/*`}\">.`\n    );\n  }\n\n  let locationFromContext = useLocation();\n\n  let location;\n  if (locationArg) {\n    let parsedLocationArg =\n      typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n    invariant(\n      parentPathnameBase === \"/\" ||\n        parsedLocationArg.pathname?.startsWith(parentPathnameBase),\n      `When overriding the location using \\`<Routes location>\\` or \\`useRoutes(routes, location)\\`, ` +\n        `the location pathname must begin with the portion of the URL pathname that was ` +\n        `matched by all parent routes. The current pathname base is \"${parentPathnameBase}\" ` +\n        `but pathname \"${parsedLocationArg.pathname}\" was given in the \\`location\\` prop.`\n    );\n\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n\n  let pathname = location.pathname || \"/\";\n  let remainingPathname =\n    parentPathnameBase === \"/\"\n      ? pathname\n      : pathname.slice(parentPathnameBase.length) || \"/\";\n  let matches = matchRoutes(routes, { pathname: remainingPathname });\n\n  if (__DEV__) {\n    warning(\n      parentRoute || matches != null,\n      `No routes matched location \"${location.pathname}${location.search}${location.hash}\" `\n    );\n\n    warning(\n      matches == null ||\n        matches[matches.length - 1].route.element !== undefined,\n      `Matched leaf route at location \"${location.pathname}${location.search}${location.hash}\" does not have an element. ` +\n        `This means it will render an <Outlet /> with a null value by default resulting in an \"empty\" page.`\n    );\n  }\n\n  return _renderMatches(\n    matches &&\n      matches.map((match) =>\n        Object.assign({}, match, {\n          params: Object.assign({}, parentParams, match.params),\n          pathname: joinPaths([parentPathnameBase, match.pathname]),\n          pathnameBase:\n            match.pathnameBase === \"/\"\n              ? parentPathnameBase\n              : joinPaths([parentPathnameBase, match.pathnameBase]),\n        })\n      ),\n    parentMatches\n  );\n}\n\nexport function _renderMatches(\n  matches: RouteMatch[] | null,\n  parentMatches: RouteMatch[] = []\n): React.ReactElement | null {\n  if (matches == null) return null;\n\n  return matches.reduceRight((outlet, match, index) => {\n    return (\n      <RouteContext.Provider\n        children={\n          match.route.element !== undefined ? match.route.element : outlet\n        }\n        value={{\n          outlet,\n          matches: parentMatches.concat(matches.slice(0, index + 1)),\n        }}\n      />\n    );\n  }, null as React.ReactElement | null);\n}\n","import * as React from \"react\";\nimport type { InitialEntry, Location, MemoryHistory, To } from \"history\";\nimport {\n  Action as NavigationType,\n  createMemoryHistory,\n  parsePath,\n} from \"history\";\n\nimport { LocationContext, NavigationContext, Navigator } from \"./context\";\nimport {\n  useInRouterContext,\n  useNavigate,\n  useOutlet,\n  useRoutes,\n  _renderMatches,\n} from \"./hooks\";\nimport type { RouteMatch, RouteObject } from \"./router\";\nimport { invariant, normalizePathname, stripBasename, warning } from \"./router\";\n\nexport interface MemoryRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n}\n\n/**\n * A <Router> that stores all entries in memory.\n *\n * @see https://reactrouter.com/docs/en/v6/api#memoryrouter\n */\nexport function MemoryRouter({\n  basename,\n  children,\n  initialEntries,\n  initialIndex,\n}: MemoryRouterProps): React.ReactElement {\n  let historyRef = React.useRef<MemoryHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({ initialEntries, initialIndex });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n\n  React.useLayoutEffect(() => history.listen(setState), [history]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nexport interface NavigateProps {\n  to: To;\n  replace?: boolean;\n  state?: any;\n}\n\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/docs/en/v6/api#navigate\n */\nexport function Navigate({ to, replace, state }: NavigateProps): null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of\n    // the router loaded. We can help them understand how to avoid that.\n    `<Navigate> may be used only in the context of a <Router> component.`\n  );\n\n  warning(\n    !React.useContext(NavigationContext).static,\n    `<Navigate> must not be used on the initial render in a <StaticRouter>. ` +\n      `This is a no-op, but you should modify your code so the <Navigate> is ` +\n      `only ever rendered in response to some user interaction or state change.`\n  );\n\n  let navigate = useNavigate();\n  React.useEffect(() => {\n    navigate(to, { replace, state });\n  });\n\n  return null;\n}\n\nexport interface OutletProps {\n  context?: unknown;\n}\n\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/docs/en/v6/api#outlet\n */\nexport function Outlet(props: OutletProps): React.ReactElement | null {\n  return useOutlet(props.context);\n}\n\nexport interface RouteProps {\n  caseSensitive?: boolean;\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n  index?: boolean;\n  path?: string;\n}\n\nexport interface PathRouteProps {\n  caseSensitive?: boolean;\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n  index?: false;\n  path: string;\n}\n\nexport interface LayoutRouteProps {\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n}\n\nexport interface IndexRouteProps {\n  element?: React.ReactNode | null;\n  index: true;\n}\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/docs/en/v6/api#route\n */\nexport function Route(\n  _props: PathRouteProps | LayoutRouteProps | IndexRouteProps\n): React.ReactElement | null {\n  invariant(\n    false,\n    `A <Route> is only ever to be used as the child of <Routes> element, ` +\n      `never rendered directly. Please wrap your <Route> in a <Routes>.`\n  );\n}\n\nexport interface RouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  location: Partial<Location> | string;\n  navigationType?: NavigationType;\n  navigator: Navigator;\n  static?: boolean;\n}\n\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a <Router> directly. Instead, you'll render a\n * router that is more specific to your environment such as a <BrowserRouter>\n * in web browsers or a <StaticRouter> for server rendering.\n *\n * @see https://reactrouter.com/docs/en/v6/api#router\n */\nexport function Router({\n  basename: basenameProp = \"/\",\n  children = null,\n  location: locationProp,\n  navigationType = NavigationType.Pop,\n  navigator,\n  static: staticProp = false,\n}: RouterProps): React.ReactElement | null {\n  invariant(\n    !useInRouterContext(),\n    `You cannot render a <Router> inside another <Router>.` +\n      ` You should never have more than one in your app.`\n  );\n\n  let basename = normalizePathname(basenameProp);\n  let navigationContext = React.useMemo(\n    () => ({ basename, navigator, static: staticProp }),\n    [basename, navigator, staticProp]\n  );\n\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\",\n  } = locationProp;\n\n  let location = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n\n    if (trailingPathname == null) {\n      return null;\n    }\n\n    return {\n      pathname: trailingPathname,\n      search,\n      hash,\n      state,\n      key,\n    };\n  }, [basename, pathname, search, hash, state, key]);\n\n  warning(\n    location != null,\n    `<Router basename=\"${basename}\"> is not able to match the URL ` +\n      `\"${pathname}${search}${hash}\" because it does not start with the ` +\n      `basename, so the <Router> won't render anything.`\n  );\n\n  if (location == null) {\n    return null;\n  }\n\n  return (\n    <NavigationContext.Provider value={navigationContext}>\n      <LocationContext.Provider\n        children={children}\n        value={{ location, navigationType }}\n      />\n    </NavigationContext.Provider>\n  );\n}\n\nexport interface RoutesProps {\n  children?: React.ReactNode;\n  location?: Partial<Location> | string;\n}\n\n/**\n * A container for a nested tree of <Route> elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#routes\n */\nexport function Routes({\n  children,\n  location,\n}: RoutesProps): React.ReactElement | null {\n  return useRoutes(createRoutesFromChildren(children), location);\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/docs/en/v6/api#createroutesfromchildren\n */\nexport function createRoutesFromChildren(\n  children: React.ReactNode\n): RouteObject[] {\n  let routes: RouteObject[] = [];\n\n  React.Children.forEach(children, (element) => {\n    if (!React.isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(\n        routes,\n        createRoutesFromChildren(element.props.children)\n      );\n      return;\n    }\n\n    invariant(\n      element.type === Route,\n      `[${\n        typeof element.type === \"string\" ? element.type : element.type.name\n      }] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>`\n    );\n\n    let route: RouteObject = {\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      index: element.props.index,\n      path: element.props.path,\n    };\n\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(element.props.children);\n    }\n\n    routes.push(route);\n  });\n\n  return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nexport function renderMatches(\n  matches: RouteMatch[] | null\n): React.ReactElement | null {\n  return _renderMatches(matches);\n}\n","/**\n * NOTE: If you refactor this to split up the modules into separate files,\n * you'll need to update the rollup config for react-router-dom-v5-compat.\n */\nimport * as React from \"react\";\nimport type { BrowserHistory, HashHistory, History } from \"history\";\nimport { createBrowserHistory, createHashHistory } from \"history\";\nimport {\n  MemoryRouter,\n  Navigate,\n  Outlet,\n  Route,\n  Router,\n  Routes,\n  createRoutesFromChildren,\n  generatePath,\n  matchRoutes,\n  matchPath,\n  createPath,\n  parsePath,\n  resolvePath,\n  renderMatches,\n  useHref,\n  useInRouterContext,\n  useLocation,\n  useMatch,\n  useNavigate,\n  useNavigationType,\n  useOutlet,\n  useParams,\n  useResolvedPath,\n  useRoutes,\n  useOutletContext,\n} from \"react-router\";\nimport type { To } from \"react-router\";\n\nfunction warning(cond: boolean, message: string): void {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n\n    try {\n      // Welcome to debugging React Router!\n      //\n      // This error is thrown as a convenience so you can more easily\n      // find the source for a warning that appears in the console by\n      // enabling \"pause on exceptions\" in your JavaScript debugger.\n      throw new Error(message);\n      // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// RE-EXPORTS\n////////////////////////////////////////////////////////////////////////////////\n\n// Note: Keep in sync with react-router exports!\nexport {\n  MemoryRouter,\n  Navigate,\n  Outlet,\n  Route,\n  Router,\n  Routes,\n  createRoutesFromChildren,\n  generatePath,\n  matchRoutes,\n  matchPath,\n  createPath,\n  parsePath,\n  renderMatches,\n  resolvePath,\n  useHref,\n  useInRouterContext,\n  useLocation,\n  useMatch,\n  useNavigate,\n  useNavigationType,\n  useOutlet,\n  useParams,\n  useResolvedPath,\n  useRoutes,\n  useOutletContext,\n};\n\nexport { NavigationType } from \"react-router\";\nexport type {\n  Hash,\n  Location,\n  Path,\n  To,\n  MemoryRouterProps,\n  NavigateFunction,\n  NavigateOptions,\n  NavigateProps,\n  Navigator,\n  OutletProps,\n  Params,\n  PathMatch,\n  RouteMatch,\n  RouteObject,\n  RouteProps,\n  PathRouteProps,\n  LayoutRouteProps,\n  IndexRouteProps,\n  RouterProps,\n  Pathname,\n  Search,\n  RoutesProps,\n} from \"react-router\";\n\n///////////////////////////////////////////////////////////////////////////////\n// DANGER! PLEASE READ ME!\n// We provide these exports as an escape hatch in the event that you need any\n// routing data that we don't provide an explicit API for. With that said, we\n// want to cover your use case if we can, so if you feel the need to use these\n// we want to hear from you. Let us know what you're building and we'll do our\n// best to make sure we can support you!\n//\n// We consider these exports an implementation detail and do not guarantee\n// against any breaking changes, regardless of the semver release. Use with\n// extreme caution and only if you understand the consequences. Godspeed.\n///////////////////////////////////////////////////////////////////////////////\n\n/** @internal */\nexport {\n  UNSAFE_NavigationContext,\n  UNSAFE_LocationContext,\n  UNSAFE_RouteContext,\n} from \"react-router\";\n\n////////////////////////////////////////////////////////////////////////////////\n// COMPONENTS\n////////////////////////////////////////////////////////////////////////////////\n\nexport interface BrowserRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  window?: Window;\n}\n\n/**\n * A `<Router>` for use in web browsers. Provides the cleanest URLs.\n */\nexport function BrowserRouter({\n  basename,\n  children,\n  window,\n}: BrowserRouterProps) {\n  let historyRef = React.useRef<BrowserHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createBrowserHistory({ window });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n\n  React.useLayoutEffect(() => history.listen(setState), [history]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nexport interface HashRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  window?: Window;\n}\n\n/**\n * A `<Router>` for use in web browsers. Stores the location in the hash\n * portion of the URL so it is not sent to the server.\n */\nexport function HashRouter({ basename, children, window }: HashRouterProps) {\n  let historyRef = React.useRef<HashHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createHashHistory({ window });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n\n  React.useLayoutEffect(() => history.listen(setState), [history]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nexport interface HistoryRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  history: History;\n}\n\n/**\n * A `<Router>` that accepts a pre-instantiated history object. It's important\n * to note that using your own history object is highly discouraged and may add\n * two versions of the history library to your bundles unless you use the same\n * version of the history library that React Router uses internally.\n */\nfunction HistoryRouter({ basename, children, history }: HistoryRouterProps) {\n  const [state, setState] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n\n  React.useLayoutEffect(() => history.listen(setState), [history]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nif (__DEV__) {\n  HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\n\nexport { HistoryRouter as unstable_HistoryRouter };\n\nfunction isModifiedEvent(event: React.MouseEvent) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\n\nexport interface LinkProps\n  extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, \"href\"> {\n  reloadDocument?: boolean;\n  replace?: boolean;\n  state?: any;\n  to: To;\n}\n\n/**\n * The public API for rendering a history-aware <a>.\n */\nexport const Link = React.forwardRef<HTMLAnchorElement, LinkProps>(\n  function LinkWithRef(\n    { onClick, reloadDocument, replace = false, state, target, to, ...rest },\n    ref\n  ) {\n    let href = useHref(to);\n    let internalOnClick = useLinkClickHandler(to, { replace, state, target });\n    function handleClick(\n      event: React.MouseEvent<HTMLAnchorElement, MouseEvent>\n    ) {\n      if (onClick) onClick(event);\n      if (!event.defaultPrevented && !reloadDocument) {\n        internalOnClick(event);\n      }\n    }\n\n    return (\n      // eslint-disable-next-line jsx-a11y/anchor-has-content\n      <a\n        {...rest}\n        href={href}\n        onClick={handleClick}\n        ref={ref}\n        target={target}\n      />\n    );\n  }\n);\n\nif (__DEV__) {\n  Link.displayName = \"Link\";\n}\n\nexport interface NavLinkProps\n  extends Omit<LinkProps, \"className\" | \"style\" | \"children\"> {\n  children?:\n    | React.ReactNode\n    | ((props: { isActive: boolean }) => React.ReactNode);\n  caseSensitive?: boolean;\n  className?: string | ((props: { isActive: boolean }) => string | undefined);\n  end?: boolean;\n  style?:\n    | React.CSSProperties\n    | ((props: { isActive: boolean }) => React.CSSProperties);\n}\n\n/**\n * A <Link> wrapper that knows if it's \"active\" or not.\n */\nexport const NavLink = React.forwardRef<HTMLAnchorElement, NavLinkProps>(\n  function NavLinkWithRef(\n    {\n      \"aria-current\": ariaCurrentProp = \"page\",\n      caseSensitive = false,\n      className: classNameProp = \"\",\n      end = false,\n      style: styleProp,\n      to,\n      children,\n      ...rest\n    },\n    ref\n  ) {\n    let location = useLocation();\n    let path = useResolvedPath(to);\n\n    let locationPathname = location.pathname;\n    let toPathname = path.pathname;\n    if (!caseSensitive) {\n      locationPathname = locationPathname.toLowerCase();\n      toPathname = toPathname.toLowerCase();\n    }\n\n    let isActive =\n      locationPathname === toPathname ||\n      (!end &&\n        locationPathname.startsWith(toPathname) &&\n        locationPathname.charAt(toPathname.length) === \"/\");\n\n    let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n\n    let className: string | undefined;\n    if (typeof classNameProp === \"function\") {\n      className = classNameProp({ isActive });\n    } else {\n      // If the className prop is not a function, we use a default `active`\n      // class for <NavLink />s that are active. In v5 `active` was the default\n      // value for `activeClassName`, but we are removing that API and can still\n      // use the old default behavior for a cleaner upgrade path and keep the\n      // simple styling rules working as they currently do.\n      className = [classNameProp, isActive ? \"active\" : null]\n        .filter(Boolean)\n        .join(\" \");\n    }\n\n    let style =\n      typeof styleProp === \"function\" ? styleProp({ isActive }) : styleProp;\n\n    return (\n      <Link\n        {...rest}\n        aria-current={ariaCurrent}\n        className={className}\n        ref={ref}\n        style={style}\n        to={to}\n      >\n        {typeof children === \"function\" ? children({ isActive }) : children}\n      </Link>\n    );\n  }\n);\n\nif (__DEV__) {\n  NavLink.displayName = \"NavLink\";\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// HOOKS\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Handles the click behavior for router `<Link>` components. This is useful if\n * you need to create custom `<Link>` components with the same click behavior we\n * use in our exported `<Link>`.\n */\nexport function useLinkClickHandler<E extends Element = HTMLAnchorElement>(\n  to: To,\n  {\n    target,\n    replace: replaceProp,\n    state,\n  }: {\n    target?: React.HTMLAttributeAnchorTarget;\n    replace?: boolean;\n    state?: any;\n  } = {}\n): (event: React.MouseEvent<E, MouseEvent>) => void {\n  let navigate = useNavigate();\n  let location = useLocation();\n  let path = useResolvedPath(to);\n\n  return React.useCallback(\n    (event: React.MouseEvent<E, MouseEvent>) => {\n      if (\n        event.button === 0 && // Ignore everything but left clicks\n        (!target || target === \"_self\") && // Let browser handle \"target=_blank\" etc.\n        !isModifiedEvent(event) // Ignore clicks with modifier keys\n      ) {\n        event.preventDefault();\n\n        // If the URL hasn't changed, a regular <a> will do a replace instead of\n        // a push, so do the same here.\n        let replace =\n          !!replaceProp || createPath(location) === createPath(path);\n\n        navigate(to, { replace, state });\n      }\n    },\n    [location, navigate, path, replaceProp, state, target, to]\n  );\n}\n\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\nexport function useSearchParams(defaultInit?: URLSearchParamsInit) {\n  warning(\n    typeof URLSearchParams !== \"undefined\",\n    `You cannot use the \\`useSearchParams\\` hook in a browser that does not ` +\n      `support the URLSearchParams API. If you need to support Internet ` +\n      `Explorer 11, we recommend you load a polyfill such as ` +\n      `https://github.com/ungap/url-search-params\\n\\n` +\n      `If you're unsure how to load polyfills, we recommend you check out ` +\n      `https://polyfill.io/v3/ which provides some recommendations about how ` +\n      `to load polyfills only for users that need them, instead of for every ` +\n      `user.`\n  );\n\n  let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));\n\n  let location = useLocation();\n  let searchParams = React.useMemo(() => {\n    let searchParams = createSearchParams(location.search);\n\n    for (let key of defaultSearchParamsRef.current.keys()) {\n      if (!searchParams.has(key)) {\n        defaultSearchParamsRef.current.getAll(key).forEach((value) => {\n          searchParams.append(key, value);\n        });\n      }\n    }\n\n    return searchParams;\n  }, [location.search]);\n\n  let navigate = useNavigate();\n  let setSearchParams = React.useCallback(\n    (\n      nextInit: URLSearchParamsInit,\n      navigateOptions?: { replace?: boolean; state?: any }\n    ) => {\n      navigate(\"?\" + createSearchParams(nextInit), navigateOptions);\n    },\n    [navigate]\n  );\n\n  return [searchParams, setSearchParams] as const;\n}\n\nexport type ParamKeyValuePair = [string, string];\n\nexport type URLSearchParamsInit =\n  | string\n  | ParamKeyValuePair[]\n  | Record<string, string | string[]>\n  | URLSearchParams;\n\n/**\n * Creates a URLSearchParams object using the given initializer.\n *\n * This is identical to `new URLSearchParams(init)` except it also\n * supports arrays as values in the object form of the initializer\n * instead of just strings. This is convenient when you need multiple\n * values for a given key, but don't want to use an array initializer.\n *\n * For example, instead of:\n *\n *   let searchParams = new URLSearchParams([\n *     ['sort', 'name'],\n *     ['sort', 'price']\n *   ]);\n *\n * you can do:\n *\n *   let searchParams = createSearchParams({\n *     sort: ['name', 'price']\n *   });\n */\nexport function createSearchParams(\n  init: URLSearchParamsInit = \"\"\n): URLSearchParams {\n  return new URLSearchParams(\n    typeof init === \"string\" ||\n    Array.isArray(init) ||\n    init instanceof URLSearchParams\n      ? init\n      : Object.keys(init).reduce((memo, key) => {\n          let value = init[key];\n          return memo.concat(\n            Array.isArray(value) ? value.map((v) => [key, v]) : [[key, value]]\n          );\n        }, [] as ParamKeyValuePair[])\n  );\n}\n","import unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nexport default function _createForOfIteratorHelper(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n\n  if (!it) {\n    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n\n      var F = function F() {};\n\n      return {\n        s: F,\n        n: function n() {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function e(_e) {\n          throw _e;\n        },\n        f: F\n      };\n    }\n\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  var normalCompletion = true,\n      didErr = false,\n      err;\n  return {\n    s: function s() {\n      it = it.call(o);\n    },\n    n: function n() {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function e(_e2) {\n      didErr = true;\n      err = _e2;\n    },\n    f: function f() {\n      try {\n        if (!normalCompletion && it[\"return\"] != null) it[\"return\"]();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}","import logo from \"./logo.png\";\nimport { useNavigate } from \"react-router-dom\";\nimport \"./index.css\";\n\nexport default function Header() {\n  const navigate = useNavigate();\n\n  return (\n    <header className=\"header\">\n       <img src={logo} className=\"logo\" alt=\"logo\" onClick={() => {navigate(`/`)}}/>\n       <div className=\"title\">\n        <p>Englishi</p>\n        <p>longman 3000</p>\n      </div>\n    </header>\n  );\n}\n","import \"./index.css\";\n\nexport default function Footer() {\n  const now = new Date();\n  return (\n    <footer>\n      <div>©{now.getFullYear()} Englishi by Sediment</div>\n      <div className=\"social\">\n        <i className='bx bxl-instagram-alt bx-tada-hover'></i>\n        <i className='bx bxl-twitter bx-tada-hover'></i>\n        <i className='bx bxl-discord-alt bx-tada-hover'></i>\n      </div>\n    </footer>\n  );\n}\n","// import A from \"./a.png\";\n// import B from \"./b.png\";\n// import C from \"./c.png\";\n// import D from \"./d.png\";\n// import E from \"./e.png\";\n// import F from \"./f.png\";\n// import G from \"./g.png\";\n// import H from \"./h.png\";\n// import I from \"./i.png\";\n// import J from \"./j.png\";\n// import K from \"./k.png\";\n// import L from \"./l.png\";\n// import M from \"./m.png\";\n// import N from \"./n.png\";\n// import O from \"./o.png\";\n// import P from \"./p.png\";\n// import Q from \"./q.png\";\n// import R from \"./r.png\";\n// import S from \"./s.png\";\n// import T from \"./t.png\";\n// import U from \"./u.png\";\n// import V from \"./v.png\";\n// import W from \"./w.png\";\n// import X from \"./x.png\";\n// import Y from \"./y.png\";\n// import Z from \"./z.png\";\n\n//  const imgs = {\n//   A:\"https://imgtu.com/i/LoGrWt\",\n//   B:\"https://imgtu.com/i/LoGDJI\",\n//   C:\"https://imgtu.com/i/LoGBFA\",\n//   D:\"https://imgtu.com/i/LoGySP\",\n//   E:\"https://imgtu.com/i/LoG6Qf\",\n//   F:\"https://imgtu.com/i/LoGcy8\",\n//   G:\"https://imgtu.com/i/LoGgOS\",\n//   H:\"https://imgtu.com/i/LoGReg\",\n//   I:\"https://imgtu.com/i/LoGWwQ\",\n//   J:\"https://imgtu.com/i/LoGfoj\",\n//   K:\"https://imgtu.com/i/LoG4Fs\",\n//   L:\"https://imgtu.com/i/LoG5Yn\",\n//   M:\"https://imgtu.com/i/LoGIWq\",\n//   N:\"https://imgtu.com/i/LoGTS0\",\n//   O:\"https://imgtu.com/i/LoG7lV\",\n//   P:\"https://imgtu.com/i/LoGHyT\",\n//   Q:\"https://imgtu.com/i/LoGbOU\",\n//   R:\"https://imgtu.com/i/LoGLmF\",\n//   S:\"https://imgtu.com/i/LoGOw4\",\n//   T:\"https://imgtu.com/i/LoGXTJ\",\n//   U:\"https://imgtu.com/i/LoGvk9\",\n//   V:\"https://imgtu.com/i/LoGxYR\",\n//   W:\"https://imgtu.com/i/LoGzf1\",\n//   X:\"https://imgtu.com/i/LoJpSx\",\n//   Y:\"https://imgtu.com/i/LoJ9l6\",\n//   Z:\"https://imgtu.com/i/LoJC6K\",\n// };\n\n const imgs = {\n  A:\"https://s1.ax1x.com/2022/04/25/LoGrWt.png\",\n  B:\"https://s1.ax1x.com/2022/04/25/LoGDJI.png\",\n  C:\"https://s1.ax1x.com/2022/04/25/LoGBFA.png\",\n  D:\"https://s1.ax1x.com/2022/04/25/LoGySP.png\",\n  E:\"https://s1.ax1x.com/2022/04/25/LoG6Qf.png\",\n  F:\"https://s1.ax1x.com/2022/04/25/LoGcy8.png\",\n  G:\"https://s1.ax1x.com/2022/04/25/LoGgOS.png\",\n  H:\"https://s1.ax1x.com/2022/04/25/LoGReg.png\",\n  I:\"https://s1.ax1x.com/2022/04/25/LoGWwQ.png\",\n  J:\"https://s1.ax1x.com/2022/04/25/LoGfoj.png\",\n  K:\"https://s1.ax1x.com/2022/04/25/LoG4Fs.png\",\n  L:\"https://s1.ax1x.com/2022/04/25/LoG5Yn.png\",\n  M:\"https://s1.ax1x.com/2022/04/25/LoGIWq.png\",\n  N:\"https://s1.ax1x.com/2022/04/25/LoGTS0.png\",\n  O:\"https://s1.ax1x.com/2022/04/25/LoG7lV.png\",\n  P:\"https://s1.ax1x.com/2022/04/25/LoGHyT.png\",\n  Q:\"https://s1.ax1x.com/2022/04/25/LoGbOU.png\",\n  R:\"https://s1.ax1x.com/2022/04/25/LoGLmF.png\",\n  S:\"https://s1.ax1x.com/2022/04/25/LoGOw4.png\",\n  T:\"https://s1.ax1x.com/2022/04/25/LoGXTJ.png\",\n  U:\"https://s1.ax1x.com/2022/04/25/LoGvk9.png\",\n  V:\"https://s1.ax1x.com/2022/04/25/LoGxYR.png\",\n  W:\"https://s1.ax1x.com/2022/04/25/LoGzf1.png\",\n  X:\"https://s1.ax1x.com/2022/04/25/LoJpSx.png\",\n  Y:\"https://s1.ax1x.com/2022/04/25/LoJ9l6.png\",\n  Z:\"https://s1.ax1x.com/2022/04/25/LoJC6K.png\",\n};\nexport default  imgs\n","import { useNavigate } from \"react-router-dom\";\nimport imgs from \"./../../assets/imgs\";\nimport \"./index.css\";\n\nexport default function CharGrid({ map: dic }) {\n  const navigate = useNavigate();\n  const items = Object.entries(dic).map(([key, value]) => (\n    <div\n      className=\"item\"\n      key={key}\n      onClick={() => {\n        navigate(`/l?w=${key}`);\n      }}\n    >\n      <img className=\"word-img\" src={imgs[key]} alt=\"word img\"></img>\n      <div>{`${value} ${value > 1 ? \"words\" : \"word\"}`}</div>\n    </div>\n  ));\n\n  return <ul className=\"grid\">{items}</ul>;\n}\n","const storage = {\n\n    setArray : (key, value) => {\n        localStorage.setItem(key, JSON.stringify(value))\n    },\n    \n    getArray: (key) => {\n        const value = localStorage.getItem(key);\n        return JSON.parse(value) || []\n    }\n    \n}\n\nexport default storage","import React, { useRef } from \"react\";\nimport storage from \"../../utils\";\nimport \"./index.css\";\nimport md5 from \"md5\";\n\nexport default function WordList({ list, alpha = \"A\" }) {\n  const wordAudioRef = useRef(null);\n  const refList = useRef(null)\n\n  const onPlay = (word) => {\n    const wordMD5 = md5(word);\n    const one2two = wordMD5.slice(0, 2);\n    const three2four = wordMD5.slice(2, 4);\n    wordAudioRef.current.src = `http://res.iciba.com/resource/amp3/1/0/${one2two}/${three2four}/${wordMD5}.mp3`;\n    wordAudioRef.current.play();\n  };\n\n  const onStar = (word) => {\n    const map = {}\n    refList.current.childNodes.forEach(child => {\n      map[child.id] = child;\n    })\n    \n    const currentItem = map[word.id];\n    if(currentItem.firstChild.className === \"dark-star\") {\n      currentItem.firstChild.className = \"light-star\"\n    } else {\n      currentItem.firstChild.className = \"dark-star\"\n    }\n\n    let starWords = storage.getArray('starWords');\n    if(starWords.some(item => item.id === word.id)) {\n      const filterList = starWords.filter(item => item.id !== word.id);\n      storage.setArray('starWords', filterList)\n    } else {\n      starWords.push(word);\n      storage.setArray('starWords', starWords)\n\n    }\n  };\n\n  const starWordsIDs = storage.getArray('starWords').map(item => item.id)\n\n  const items = list[alpha].map((item) => {\n    return (\n      <div className=\"word-item\" key={item.id} id={item.id}>\n        <div\n          className={starWordsIDs.includes(item.id) ? 'light-star' : 'dark-star'}\n          onClick={() => {\n            onStar(item);\n          }}\n        >\n          <i className='bx bxs-star'></i>\n        </div>\n        <div className=\"word-text\">{item.w}</div>\n        <div className=\"type\">{item.t}</div>\n        <div\n          className=\"play-audio\"\n          onClick={() => {\n            onPlay(item.w);\n          }}\n        >\n          <i className='bx bxs-volume-full'></i>\n        </div>\n        <div className=\"search\">\n          <a\n            href={`https://www.ldoceonline.com/dictionary/${item.w}`}\n            target=\"_blank\"\n            rel=\"noopener noreferrer\"\n          >\n            <i className='bx bxs-send'></i>\n          </a>\n        </div>\n        <div className=\"level\">\n          <span>{item.l}</span>\n        </div>\n      </div>\n    );\n  });\n\n  return (\n    <div>\n      <ul className=\"word-list\" ref={refList}>{items}</ul>\n      <div></div>\n      <audio id=\"word-audio\" src=\"\" ref={wordAudioRef}></audio>\n    </div>\n  );\n}\n","import './index.css'\n\nexport default function PageTip({info}) {\n  return (\n    <div className='page-tip'>\n      <div className='page-title'>{info.title}</div>\n      <div className='page-text'>{info.tip}</div>\n    </div>\n  );\n}\n","import React, { useRef, useState } from \"react\";\nimport PageTip from \"../PageTip\";\nimport storage from \"../../utils\";\nimport \"./index.css\";\nimport md5 from \"md5\";\n\nexport default function WordList() {\n  const starWords = storage.getArray(\"starWords\")\n  const wordAudioRef = useRef(null);\n  const [list, setList] = useState(starWords);\n\n  const onPlay = (word) => {\n    const wordMD5 = md5(word);\n    const one2two = wordMD5.slice(0, 2);\n    const three2four = wordMD5.slice(2, 4);\n    wordAudioRef.current.src = `http://res.iciba.com/resource/amp3/1/0/${one2two}/${three2four}/${wordMD5}.mp3`;\n    wordAudioRef.current.play();\n  };\n\n  const onDelete = (id) => {\n    let filterList = list.filter(item => item.id !== id)\n    setList(filterList);\n    storage.setArray('starWords', filterList);\n  };\n\n  const items = list.length > 0 ? list.map((item) => {\n    return (\n      <div className=\"word-item\" key={item.id} id={item.id}>\n        <div\n          className=\"remove-star\"\n          onClick={() => {\n            onDelete(item.id);\n          }}\n        >\n          <i className='bx bxs-minus-circle'></i>\n        </div>\n        <div className=\"word-text\">{item.w}</div>\n        <div className=\"type\">{item.t}</div>\n        <div\n          className=\"play-audio\"\n          onClick={() => {\n            onPlay(item.w);\n          }}\n        >\n          <i className='bx bxs-volume-full'></i>\n        </div>\n        <div className=\"search\">\n          <a\n            href={`https://www.ldoceonline.com/dictionary/${item.w}`}\n            target=\"_blank\"\n            rel=\"noopener noreferrer\"\n          >\n            <i className='bx bxs-send'></i>\n          </a>\n        </div>\n        <div className=\"level\">\n          <span>{item.l}</span>\n        </div>\n      </div>\n    );\n  }) : (<PageTip info={{title: \"Woops!\", tip:'Nothing'}}></PageTip>);\n\n  return (\n    <div>\n      <ul className=\"word-list\">{items}</ul>\n      <div></div>\n      <audio id=\"word-audio\" src=\"\" ref={wordAudioRef}></audio>\n    </div>\n  );\n}\n","import './index.css';\nimport { useNavigate } from \"react-router-dom\";\n\nexport default function FilterButton() {\n    const navigate = useNavigate();\n\n    return (\n        <div className='filter' onClick={()=> {navigate(`/s`);}}>\n            <i className='bx bx-star bx-slg'></i>\n        </div>\n    )\n}","import \"./App.css\";\nimport { Routes, Route, useSearchParams, useLocation } from \"react-router-dom\";\n\nimport data from \"./data/data.json\";\n\nimport Header from \"./components/Header\";\nimport Footer from \"./components/Footer\";\nimport CharGrid from \"./components/CharGrid\";\nimport WordList from \"./components/WordList\";\nimport StarList from \"./components/StarList\";\nimport FilterButton from \"./components/FilterButton\";\nimport PageTip from \"./components/PageTip\";\n\nfunction App() {\n  let location = useLocation();\n  let [searchParams] = useSearchParams();\n  let alpha = \"\";\n  if (location.pathname === \"/l\") {\n    alpha = searchParams.get(\"w\") || \"A\";\n  }\n\n  return (\n    <div className=\"App\">\n      <Header></Header>\n      <main>\n        <Routes>\n          <Route path=\"/\" element={<CharGrid map={data.map}></CharGrid>} />\n          <Route\n            path=\"/l\"\n            element={<WordList alpha={alpha} list={data.list} />}\n          />\n          <Route\n            path=\"/s\"\n            element={<StarList list={data.list} />}\n          />\n          <Route path=\"*\" element={<PageTip info={{title: '404', tip:'What Are You Doing?'}} />} />\n        </Routes>\n      </main>\n      <FilterButton></FilterButton>\n      <Footer></Footer>\n    </div>\n  );\n}\n\nexport default App;\n","import React from \"react\";\nimport ReactDOM from \"react-dom/client\";\nimport { BrowserRouter } from \"react-router-dom\";\n\nimport \"./index.css\";\nimport App from \"./App\";\n// import reportWebVitals from \"./reportWebVitals\";\n\nconst root = ReactDOM.createRoot(document.getElementById(\"root\"));\nroot.render(\n  <React.StrictMode>\n    <BrowserRouter>\n      <App />\n    </BrowserRouter>\n  </React.StrictMode>\n);\n\n// If you want to start measuring performance in your app, pass a function\n// to log results (for example: reportWebVitals(console.log))\n// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals\n// reportWebVitals();\n"],"names":["charenc","utf8","stringToBytes","str","bin","unescape","encodeURIComponent","bytesToString","bytes","decodeURIComponent","escape","i","length","push","charCodeAt","String","fromCharCode","join","module","exports","base64map","crypt","rotl","n","b","rotr","endian","constructor","Number","randomBytes","Math","floor","random","bytesToWords","words","wordsToBytes","bytesToHex","hex","toString","hexToBytes","c","parseInt","substr","bytesToBase64","base64","triplet","j","charAt","base64ToBytes","replace","imod4","indexOf","pow","isBuffer","obj","readFloatLE","slice","isSlowBuffer","_isBuffer","require","md5","message","options","encoding","Array","prototype","call","isArray","Uint8Array","m","l","a","d","FF","_ff","GG","_gg","HH","_hh","II","_ii","aa","bb","cc","dd","x","s","t","_blocksize","_digestsize","undefined","Error","digestbytes","asBytes","asString","createRoot","hydrateRoot","f","k","Symbol","for","Object","hasOwnProperty","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","ReactCurrentOwner","p","key","ref","__self","__source","q","g","e","h","defaultProps","$$typeof","type","props","_owner","current","jsx","jsxs","React","ReactDOM","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","definition","o","defineProperty","enumerable","get","prop","_arrayLikeToArray","arr","len","arr2","_unsupportedIterableToArray","minLen","name","from","test","_i","iterator","_s","_e","_arr","_n","_d","next","done","value","err","TypeError","assign","target","arguments","source","apply","this","NavigationContext","LocationContext","RouteContext","outlet","matches","invariant","cond","matchRoutes","routes","locationArg","basename","pathname","stripBasename","parsePath","branches","flattenRoutes","sort","score","siblings","every","compareIndexes","routesMeta","map","meta","childrenIndex","rankRouteBranches","matchRouteBranch","parentsMeta","parentPath","forEach","route","index","relativePath","path","caseSensitive","startsWith","joinPaths","concat","children","computeScore","paramRe","isSplat","segments","split","initialScore","some","filter","reduce","segment","branch","matchedParams","matchedPathname","end","remainingPathname","match","matchPath","params","pathnameBase","normalizePathname","pattern","paramNames","regexpSource","_","paramName","endsWith","RegExp","compilePath","matcher","captureGroups","memo","splatValue","error","safelyDecodeURIComponent","resolveTo","toArg","routePathnames","locationPathname","to","toPathname","routePathnameIndex","toSegments","shift","fromPathname","search","hash","pop","resolvePathname","normalizeSearch","normalizeHash","resolvePath","toLowerCase","nextChar","paths","useInRouterContext","useLocation","location","useNavigate","navigator","routePathnamesJson","JSON","stringify","activeRef","parse","state","go","_renderMatches","parentMatches","reduceRight","React.createElement","Provider","element","Route","_props","Router","_ref3","basenameProp","locationProp","navigationType","NavigationType","static","staticProp","navigationContext","trailingPathname","Routes","_ref4","routeMatch","parentParams","parentPathnameBase","locationFromContext","parsedLocationArg","_parsedLocationArg$pa","useRoutes","createRoutesFromChildren","BrowserRouter","window","historyRef","createBrowserHistory","history","action","setState","listen","useSearchParams","defaultInit","defaultSearchParamsRef","createSearchParams","searchParams","allowArrayLike","it","F","normalCompletion","didErr","step","_e2","keys","has","getAll","append","navigate","nextInit","navigateOptions","init","URLSearchParams","v","Header","className","src","logo","alt","onClick","Footer","now","Date","getFullYear","A","B","C","D","E","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","CharGrid","dic","items","entries","imgs","setArray","localStorage","setItem","getArray","getItem","WordList","list","alpha","wordAudioRef","useRef","refList","starWordsIDs","storage","item","id","includes","word","childNodes","child","currentItem","firstChild","starWords","filterList","onStar","w","wordMD5","one2two","three2four","play","onPlay","href","rel","PageTip","info","title","tip","useState","setList","onDelete","FilterButton","data","document","getElementById","render"],"sourceRoot":""}