{"version":3,"file":"router.js","sources":["router.js"],"sourcesContent":["/**\n * @remix-run/router v1.0.3\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : 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  return _extends.apply(this, arguments);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Actions represent the type of change to a location value.\n */\nvar Action;\n\n(function (Action) {\n  /**\n   * A POP indicates a change to an arbitrary index in the history stack, such\n   * as a back or forward navigation. It does not describe the direction of the\n   * navigation, only that the current index changed.\n   *\n   * Note: This is the default action for newly created history objects.\n   */\n  Action[\"Pop\"] = \"POP\";\n  /**\n   * A PUSH indicates a new entry being added to the history stack, such as when\n   * a link is clicked and a new page loads. When this happens, all subsequent\n   * entries in the stack are lost.\n   */\n\n  Action[\"Push\"] = \"PUSH\";\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n\n  Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\n\nconst PopStateEventType = \"popstate\";\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\n\nfunction createMemoryHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  let {\n    initialEntries = [\"/\"],\n    initialIndex,\n    v5Compat = false\n  } = options;\n  let entries; // Declare so we can access from createMemoryLocation\n\n  entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === \"string\" ? null : entry.state, index === 0 ? \"default\" : undefined));\n  let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);\n  let action = Action.Pop;\n  let listener = null;\n\n  function clampIndex(n) {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n\n  function getCurrentLocation() {\n    return entries[index];\n  }\n\n  function createMemoryLocation(to, state, key) {\n    if (state === void 0) {\n      state = null;\n    }\n\n    let location = createLocation(entries ? getCurrentLocation().pathname : \"/\", to, state, key);\n    warning$1(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in memory history: \" + JSON.stringify(to));\n    return location;\n  }\n\n  let history = {\n    get index() {\n      return index;\n    },\n\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return getCurrentLocation();\n    },\n\n    createHref(to) {\n      return typeof to === \"string\" ? to : createPath(to);\n    },\n\n    encodeLocation(location) {\n      return location;\n    },\n\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation\n        });\n      }\n    },\n\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation\n        });\n      }\n    },\n\n    go(delta) {\n      action = Action.Pop;\n      index = clampIndex(index + delta);\n\n      if (listener) {\n        listener({\n          action,\n          location: getCurrentLocation()\n        });\n      }\n    },\n\n    listen(fn) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    }\n\n  };\n  return history;\n}\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\n\nfunction createBrowserHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  function createBrowserLocation(window, globalHistory) {\n    let {\n      pathname,\n      search,\n      hash\n    } = window.location;\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    }, // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n\n  function createBrowserHref(window, to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);\n}\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\n\nfunction createHashHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  function createHashLocation(window, globalHistory) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\"\n    } = parsePath(window.location.hash.substr(1));\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    }, // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n\n  function createHashHref(window, to) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n\n    if (base && base.getAttribute(\"href\")) {\n      let url = window.location.href;\n      let hashIndex = url.indexOf(\"#\");\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n\n  function validateHashLocation(location, to) {\n    warning$1(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\");\n  }\n\n  return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region UTILS\n////////////////////////////////////////////////////////////////////////////////\n\nfunction warning$1(cond, message) {\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 history!\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); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\n\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n/**\n * For browser-based histories, we combine the state and key into an object\n */\n\n\nfunction getHistoryState(location) {\n  return {\n    usr: location.state,\n    key: location.key\n  };\n}\n/**\n * Creates a Location object with a unique key from the given Path\n */\n\n\nfunction createLocation(current, to, state, key) {\n  if (state === void 0) {\n    state = null;\n  }\n\n  let location = _extends({\n    pathname: typeof current === \"string\" ? current : current.pathname,\n    search: \"\",\n    hash: \"\"\n  }, typeof to === \"string\" ? parsePath(to) : to, {\n    state,\n    // TODO: This could be cleaned up.  push/replace should probably just take\n    // full Locations now and avoid the need to run through this flow at all\n    // But that's a pretty big refactor to the current test suite so going to\n    // keep as is for the time being and just let any incoming keys take precedence\n    key: to && to.key || key || createKey()\n  });\n\n  return location;\n}\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\n\nfunction createPath(_ref) {\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\"\n  } = _ref;\n  if (search && search !== \"?\") pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\") pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\n\nfunction parsePath(path) {\n  let parsedPath = {};\n\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n\n    let searchIndex = path.indexOf(\"?\");\n\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n\n  return parsedPath;\n}\nfunction createURL(location) {\n  // window.location.origin is \"null\" (the literal string value) in Firefox\n  // under certain conditions, notably when serving from a local HTML file\n  // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n  let base = typeof window !== \"undefined\" && typeof window.location !== \"undefined\" && window.location.origin !== \"null\" ? window.location.origin : \"unknown://unknown\";\n  let href = typeof location === \"string\" ? location : createPath(location);\n  return new URL(href, base);\n}\n\nfunction getUrlBasedHistory(getLocation, createHref, validateLocation, options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  let {\n    window = document.defaultView,\n    v5Compat = false\n  } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener = null;\n\n  function handlePop() {\n    action = Action.Pop;\n\n    if (listener) {\n      listener({\n        action,\n        location: history.location\n      });\n    }\n  }\n\n  function push(to, state) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    let historyState = getHistoryState(location);\n    let url = history.createHref(location); // try...catch because iOS limits us to 100 pushState calls :/\n\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location\n      });\n    }\n  }\n\n  function replace(to, state) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    let historyState = getHistoryState(location);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location\n      });\n    }\n  }\n\n  let history = {\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n\n    listen(fn) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n\n    createHref(to) {\n      return createHref(window, to);\n    },\n\n    encodeLocation(location) {\n      // Encode a Location the same way window.location would\n      let url = createURL(createPath(location));\n      return _extends({}, location, {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash\n      });\n    },\n\n    push,\n    replace,\n\n    go(n) {\n      return globalHistory.go(n);\n    }\n\n  };\n  return history;\n} //#endregion\n\nvar ResultType;\n\n(function (ResultType) {\n  ResultType[\"data\"] = \"data\";\n  ResultType[\"deferred\"] = \"deferred\";\n  ResultType[\"redirect\"] = \"redirect\";\n  ResultType[\"error\"] = \"error\";\n})(ResultType || (ResultType = {}));\n\nfunction isIndexRoute(route) {\n  return route.index === true;\n} // Walk the route tree generating unique IDs where necessary so we are working\n// solely with AgnosticDataRouteObject's within the Router\n\n\nfunction convertRoutesToDataRoutes(routes, parentPath, allIds) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n\n  if (allIds === void 0) {\n    allIds = new Set();\n  }\n\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, index];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(route.index !== true || !route.children, \"Cannot specify children on an index route\");\n    invariant(!allIds.has(id), \"Found a route id collision on id \\\"\" + id + \"\\\".  Route \" + \"id's must be globally unique within Data Router usages\");\n    allIds.add(id);\n\n    if (isIndexRoute(route)) {\n      let indexRoute = _extends({}, route, {\n        id\n      });\n\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute = _extends({}, route, {\n        id,\n        children: route.children ? convertRoutesToDataRoutes(route.children, treePath, allIds) : undefined\n      });\n\n      return pathOrLayoutRoute;\n    }\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/utils/match-routes\n */\n\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n\n  let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\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  let matches = null;\n\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    matches = matchRouteBranch(branches[i], // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    safelyDecodeURI(pathname));\n  }\n\n  return matches;\n}\n\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n  if (branches === void 0) {\n    branches = [];\n  }\n\n  if (parentsMeta === void 0) {\n    parentsMeta = [];\n  }\n\n  if (parentPath === void 0) {\n    parentPath = \"\";\n  }\n\n  routes.forEach((route, index) => {\n    let meta = {\n      relativePath: route.path || \"\",\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\n\n    if (meta.relativePath.startsWith(\"/\")) {\n      invariant(meta.relativePath.startsWith(parentPath), \"Absolute route path \\\"\" + meta.relativePath + \"\\\" nested under path \" + (\"\\\"\" + parentPath + \"\\\" is not valid. An absolute child route path \") + \"must start with the combined path of all its parent routes.\");\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta); // 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\n    if (route.children && route.children.length > 0) {\n      invariant( // Our types know better, but runtime JS may not!\n      // @ts-expect-error\n      route.index !== true, \"Index routes must not have child routes. Please remove \" + (\"all child routes from route path \\\"\" + path + \"\\\".\"));\n      flattenRoutes(route.children, branches, routesMeta, path);\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\n\n    if (route.path == null && !route.index) {\n      return;\n    }\n\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta\n    });\n  });\n  return branches;\n}\n\nfunction rankRouteBranches(branches) {\n  branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first\n  : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));\n}\n\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\n\nconst isSplat = s => s === \"*\";\n\nfunction computeScore(path, index) {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n\n  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\n\nfunction compareIndexes(a, b) {\n  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n  return siblings ? // 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] : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n  // so they sort equally.\n  0;\n}\n\nfunction matchRouteBranch(branch, pathname) {\n  let {\n    routesMeta\n  } = branch;\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches = [];\n\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname = matchedPathname === \"/\" ? pathname : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath({\n      path: meta.relativePath,\n      caseSensitive: meta.caseSensitive,\n      end\n    }, remainingPathname);\n    if (!match) return null;\n    Object.assign(matchedParams, match.params);\n    let route = meta.route;\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),\n      route\n    });\n\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/docs/en/v6/utils/generate-path\n */\n\n\nfunction generatePath(path, params) {\n  if (params === void 0) {\n    params = {};\n  }\n\n  return path.replace(/:(\\w+)/g, (_, key) => {\n    invariant(params[key] != null, \"Missing \\\":\" + key + \"\\\" param\");\n    return params[key];\n  }).replace(/(\\/?)\\*/, (_, prefix, __, str) => {\n    const star = \"*\";\n\n    if (params[star] == null) {\n      // If no splat was provided, trim the trailing slash _unless_ it's\n      // the entire path\n      return str === \"/*\" ? \"/\" : \"\";\n    } // Apply the splat\n\n\n    return \"\" + prefix + params[star];\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/utils/match-path\n */\n\nfunction matchPath(pattern, pathname) {\n  if (typeof pattern === \"string\") {\n    pattern = {\n      path: pattern,\n      caseSensitive: false,\n      end: true\n    };\n  }\n\n  let [matcher, paramNames] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);\n  let match = pathname.match(matcher);\n  if (!match) return null;\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params = paramNames.reduce((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.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\\/+$/, \"$1\");\n    }\n\n    memo[paramName] = safelyDecodeURIComponent(captureGroups[index] || \"\", paramName);\n    return memo;\n  }, {});\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern\n  };\n}\n\nfunction compilePath(path, caseSensitive, end) {\n  if (caseSensitive === void 0) {\n    caseSensitive = false;\n  }\n\n  if (end === void 0) {\n    end = true;\n  }\n\n  warning(path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"), \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n  let paramNames = [];\n  let regexpSource = \"^\" + path.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, (_, paramName) => {\n    paramNames.push(paramName);\n    return \"([^\\\\/]+)\";\n  });\n\n  if (path.endsWith(\"*\")) {\n    paramNames.push(\"*\");\n    regexpSource += path === \"*\" || path === \"/*\" ? \"(.*)$\" // Already matched the initial /, just match the rest\n    : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else ;\n\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n  return [matcher, paramNames];\n}\n\nfunction safelyDecodeURI(value) {\n  try {\n    return decodeURI(value);\n  } catch (error) {\n    warning(false, \"The URL path \\\"\" + value + \"\\\" could not be decoded because it is is a \" + \"malformed URL segment. This is probably due to a bad percent \" + (\"encoding (\" + error + \").\"));\n    return value;\n  }\n}\n\nfunction safelyDecodeURIComponent(value, paramName) {\n  try {\n    return decodeURIComponent(value);\n  } catch (error) {\n    warning(false, \"The value for the URL param \\\"\" + paramName + \"\\\" will not be decoded because\" + (\" the string \\\"\" + value + \"\\\" is a malformed URL segment. This is probably\") + (\" due to a bad percent encoding (\" + error + \").\"));\n    return value;\n  }\n}\n/**\n * @private\n */\n\n\nfunction stripBasename(pathname, basename) {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  } // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n\n\n  let startIndex = basename.endsWith(\"/\") ? basename.length - 1 : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(startIndex) || \"/\";\n}\nfunction invariant(value, message) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\n/**\n * @private\n */\n\nfunction warning(cond, message) {\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); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/docs/en/v6/utils/resolve-path\n */\n\nfunction resolvePath(to, fromPathname) {\n  if (fromPathname === void 0) {\n    fromPathname = \"/\";\n  }\n\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\"\n  } = typeof to === \"string\" ? parsePath(to) : to;\n  let pathname = toPathname ? toPathname.startsWith(\"/\") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash)\n  };\n}\n\nfunction resolvePathname(relativePath, fromPathname) {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\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  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\n\nfunction getInvalidPathError(char, field, dest, path) {\n  return \"Cannot include a '\" + char + \"' character in a manually specified \" + (\"`to.\" + field + \"` field [\" + JSON.stringify(path) + \"].  Please separate it out to the \") + (\"`to.\" + dest + \"` field. Alternatively you may provide the full path as \") + \"a string in <Link to=\\\"...\\\"> and the router will parse it for you.\";\n}\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\n\n\nfunction getPathContributingMatches(matches) {\n  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);\n}\n/**\n * @private\n */\n\nfunction resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {\n  if (isPathRelative === void 0) {\n    isPathRelative = false;\n  }\n\n  let to;\n\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = _extends({}, toArg);\n    invariant(!to.pathname || !to.pathname.includes(\"?\"), getInvalidPathError(\"?\", \"pathname\", \"search\", to));\n    invariant(!to.pathname || !to.pathname.includes(\"#\"), getInvalidPathError(\"#\", \"pathname\", \"hash\", to));\n    invariant(!to.search || !to.search.includes(\"#\"), getInvalidPathError(\"#\", \"search\", \"hash\", to));\n  }\n\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n  let from; // Routing is relative to the current pathname if explicitly requested.\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\n  if (isPathRelative || toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    if (toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\"); // 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\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    } // If there are more \"..\" segments than parent routes, resolve relative to\n    // the root / URL.\n\n\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n\n  let path = resolvePath(to, from); // Ensure the pathname has a trailing slash if the original \"to\" had one\n\n  let hasExplicitTrailingSlash = toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\"); // Or if this was a link to the current path which has a trailing slash\n\n  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n\n  if (!path.pathname.endsWith(\"/\") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {\n    path.pathname += \"/\";\n  }\n\n  return path;\n}\n/**\n * @private\n */\n\nfunction getToPathname(to) {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || to.pathname === \"\" ? \"/\" : typeof to === \"string\" ? parsePath(to).pathname : to.pathname;\n}\n/**\n * @private\n */\n\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n/**\n * @private\n */\n\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n/**\n * @private\n */\n\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n/**\n * @private\n */\n\nconst normalizeHash = hash => !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n */\n\nconst json = function json(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  let headers = new Headers(responseInit.headers);\n\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n\n  return new Response(JSON.stringify(data), _extends({}, responseInit, {\n    headers\n  }));\n};\nclass AbortedDeferredError extends Error {}\nclass DeferredData {\n  constructor(data) {\n    this.pendingKeys = new Set();\n    this.subscriber = undefined;\n    invariant(data && typeof data === \"object\" && !Array.isArray(data), \"defer() only accepts plain objects\"); // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n\n    let reject;\n    this.abortPromise = new Promise((_, r) => reject = r);\n    this.controller = new AbortController();\n\n    let onAbort = () => reject(new AbortedDeferredError(\"Deferred data aborted\"));\n\n    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener(\"abort\", onAbort);\n\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n    this.data = Object.entries(data).reduce((acc, _ref) => {\n      let [key, value] = _ref;\n      return Object.assign(acc, {\n        [key]: this.trackPromise(key, value)\n      });\n    }, {});\n  }\n\n  trackPromise(key, value) {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n\n    this.pendingKeys.add(key); // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n\n    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, null, data), error => this.onSettle(promise, key, error)); // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n\n    promise.catch(() => {});\n    Object.defineProperty(promise, \"_tracked\", {\n      get: () => true\n    });\n    return promise;\n  }\n\n  onSettle(promise, key, error, data) {\n    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      return Promise.reject(error);\n    }\n\n    this.pendingKeys.delete(key);\n\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n\n    const subscriber = this.subscriber;\n\n    if (error) {\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      subscriber && subscriber(false);\n      return Promise.reject(error);\n    }\n\n    Object.defineProperty(promise, \"_data\", {\n      get: () => data\n    });\n    subscriber && subscriber(false);\n    return data;\n  }\n\n  subscribe(fn) {\n    this.subscriber = fn;\n  }\n\n  cancel() {\n    this.controller.abort();\n    this.pendingKeys.forEach((v, k) => this.pendingKeys.delete(k));\n    let subscriber = this.subscriber;\n    subscriber && subscriber(true);\n  }\n\n  async resolveData(signal) {\n    let aborted = false;\n\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise(resolve => {\n        this.subscribe(aborted => {\n          signal.removeEventListener(\"abort\", onAbort);\n\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n\n    return aborted;\n  }\n\n  get done() {\n    return this.pendingKeys.size === 0;\n  }\n\n  get unwrappedData() {\n    invariant(this.data !== null && this.done, \"Can only unwrap data on initialized and settled deferreds\");\n    return Object.entries(this.data).reduce((acc, _ref2) => {\n      let [key, value] = _ref2;\n      return Object.assign(acc, {\n        [key]: unwrapTrackedPromise(value)\n      });\n    }, {});\n  }\n\n}\n\nfunction isTrackedPromise(value) {\n  return value instanceof Promise && value._tracked === true;\n}\n\nfunction unwrapTrackedPromise(value) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n\n  if (value._error) {\n    throw value._error;\n  }\n\n  return value._data;\n}\n\nfunction defer(data) {\n  return new DeferredData(data);\n}\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\n\nconst redirect = function redirect(url, init) {\n  if (init === void 0) {\n    init = 302;\n  }\n\n  let responseInit = init;\n\n  if (typeof responseInit === \"number\") {\n    responseInit = {\n      status: responseInit\n    };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n  return new Response(null, _extends({}, responseInit, {\n    headers\n  }));\n};\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n */\n\nclass ErrorResponse {\n  constructor(status, statusText, data) {\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.data = data;\n  }\n\n}\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response throw from an action/loader\n */\n\nfunction isRouteErrorResponse(e) {\n  return e instanceof ErrorResponse;\n}\n\nconst IDLE_NAVIGATION = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined\n};\nconst IDLE_FETCHER = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined\n};\nconst isBrowser = typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\";\nconst isServer = !isBrowser; //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Create a router and listen to history POP navigations\n */\n\nfunction createRouter(init) {\n  invariant(init.routes.length > 0, \"You must provide a non-empty routes array to createRouter\");\n  let dataRoutes = convertRoutesToDataRoutes(init.routes); // Cleanup function for history\n\n  let unlistenHistory = null; // Externally-provided functions to call on all state changes\n\n  let subscribers = new Set(); // Externally-provided object to hold scroll restoration locations during routing\n\n  let savedScrollPositions = null; // Externally-provided function to get scroll restoration keys\n\n  let getScrollRestorationKey = null; // Externally-provided function to get current scroll position\n\n  let getScrollPosition = null; // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n\n  let initialScrollRestored = false;\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, init.basename);\n  let initialErrors = null;\n\n  if (initialMatches == null) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let {\n      matches,\n      route,\n      error\n    } = getNotFoundMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = {\n      [route.id]: error\n    };\n  }\n\n  let initialized = !initialMatches.some(m => m.route.loader) || init.hydrationData != null;\n  let router;\n  let state = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    restoreScrollPosition: null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: init.hydrationData && init.hydrationData.loaderData || {},\n    actionData: init.hydrationData && init.hydrationData.actionData || null,\n    errors: init.hydrationData && init.hydrationData.errors || initialErrors,\n    fetchers: new Map()\n  }; // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n\n  let pendingAction = Action.Pop; // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n\n  let pendingPreventScrollReset = false; // AbortController for the active navigation\n\n  let pendingNavigationController; // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n\n  let isUninterruptedRevalidation = false; // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidate()\n  //  - X-Remix-Revalidate (from redirect)\n\n  let isRevalidationRequired = false; // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n\n  let cancelledDeferredRoutes = []; // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n\n  let cancelledFetcherLoads = []; // AbortControllers for any in-flight fetchers\n\n  let fetchControllers = new Map(); // Track loads based on the order in which they started\n\n  let incrementingLoadId = 0; // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n\n  let pendingNavigationLoadId = -1; // Fetchers that triggered data reloads as a result of their actions\n\n  let fetchReloadIds = new Map(); // Fetchers that triggered redirect navigations from their actions\n\n  let fetchRedirectIds = new Set(); // Most recent href/match for fetcher.load calls for fetchers\n\n  let fetchLoadMatches = new Map(); // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n\n  let activeDeferreds = new Map(); // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(_ref => {\n      let {\n        action: historyAction,\n        location\n      } = _ref;\n      return startNavigation(historyAction, location);\n    }); // Kick off initial data load if needed.  Use Pop to avoid modifying history\n\n    if (!state.initialized) {\n      startNavigation(Action.Pop, state.location);\n    }\n\n    return router;\n  } // Clean up a router and it's side effects\n\n\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n  } // Subscribe to state updates for the router\n\n\n  function subscribe(fn) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  } // Update our state and notify the calling context of the change\n\n\n  function updateState(newState) {\n    state = _extends({}, state, newState);\n    subscribers.forEach(subscriber => subscriber(state));\n  } // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n\n\n  function completeNavigation(location, newState) {\n    var _state$navigation$for;\n\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a submission\n    // - We're past the submitting state and into the loading state\n    // - The location we've finished loading is different from the submission\n    //   location, indicating we redirected from the action (avoids false\n    //   positives for loading/submissionRedirect when actionData returned\n    //   on a prior submission)\n    let isActionReload = state.actionData != null && state.navigation.formMethod != null && state.navigation.state === \"loading\" && ((_state$navigation$for = state.navigation.formAction) == null ? void 0 : _state$navigation$for.split(\"?\")[0]) === location.pathname; // Always preserve any existing loaderData from re-used routes\n\n    let newLoaderData = newState.loaderData ? {\n      loaderData: mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [])\n    } : {};\n    updateState(_extends({}, isActionReload ? {} : {\n      actionData: null\n    }, newState, newLoaderData, {\n      historyAction: pendingAction,\n      location,\n      initialized: true,\n      navigation: IDLE_NAVIGATION,\n      revalidation: \"idle\",\n      // Don't restore on submission navigations\n      restoreScrollPosition: state.navigation.formData ? false : getSavedScrollPosition(location, newState.matches || state.matches),\n      preventScrollReset: pendingPreventScrollReset\n    }));\n\n    if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === Action.Replace) {\n      init.history.replace(location, location.state);\n    } // Reset stateful navigation vars\n\n\n    pendingAction = Action.Pop;\n    pendingPreventScrollReset = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n    cancelledFetcherLoads = [];\n  } // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n\n\n  async function navigate(to, opts) {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(to, opts);\n    let location = createLocation(state.location, path, opts && opts.state); // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n\n    location = init.history.encodeLocation(location);\n    let historyAction = (opts && opts.replace) === true || submission != null ? Action.Replace : Action.Push;\n    let preventScrollReset = opts && \"preventScrollReset\" in opts ? opts.preventScrollReset === true : undefined;\n    return await startNavigation(historyAction, location, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace\n    });\n  } // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n\n\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({\n      revalidation: \"loading\"\n    }); // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n\n    if (state.navigation.state === \"submitting\") {\n      return;\n    } // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n\n\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true\n      });\n      return;\n    } // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n\n\n    startNavigation(pendingAction || state.historyAction, state.navigation.location, {\n      overrideNavigation: state.navigation\n    });\n  } // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n\n\n  async function startNavigation(historyAction, location, opts) {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true; // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = matchRoutes(dataRoutes, location, init.basename); // Short circuit with a 404 on the root error boundary if we match nothing\n\n    if (!matches) {\n      let {\n        matches: notFoundMatches,\n        route,\n        error\n      } = getNotFoundMatches(dataRoutes); // Cancel all pending deferred on 404s since we don't keep any routes\n\n      cancelActiveDeferreds();\n      completeNavigation(location, {\n        matches: notFoundMatches,\n        loaderData: {},\n        errors: {\n          [route.id]: error\n        }\n      });\n      return;\n    } // Short circuit if it's only a hash change\n\n\n    if (isHashChangeOnly(state.location, location)) {\n      completeNavigation(location, {\n        matches\n      });\n      return;\n    } // Create a controller/Request for this navigation\n\n\n    pendingNavigationController = new AbortController();\n    let request = createRequest(location, pendingNavigationController.signal, opts && opts.submission);\n    let pendingActionData;\n    let pendingError;\n\n    if (opts && opts.pendingError) {\n      // If we have a pendingError, it means the user attempted a GET submission\n      // with binary FormData so assign here and skip to handleLoaders.  That\n      // way we handle calling loaders above the boundary etc.  It's not really\n      // different from an actionError in that sense.\n      pendingError = {\n        [findNearestBoundary(matches).route.id]: opts.pendingError\n      };\n    } else if (opts && opts.submission) {\n      // Call action if we received an action submission\n      let actionOutput = await handleAction(request, location, opts.submission, matches, {\n        replace: opts.replace\n      });\n\n      if (actionOutput.shortCircuited) {\n        return;\n      }\n\n      pendingActionData = actionOutput.pendingActionData;\n      pendingError = actionOutput.pendingActionError;\n\n      let navigation = _extends({\n        state: \"loading\",\n        location\n      }, opts.submission);\n\n      loadingNavigation = navigation;\n    } // Call loaders\n\n\n    let {\n      shortCircuited,\n      loaderData,\n      errors\n    } = await handleLoaders(request, location, matches, loadingNavigation, opts && opts.submission, opts && opts.replace, pendingActionData, pendingError);\n\n    if (shortCircuited) {\n      return;\n    } // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n\n\n    pendingNavigationController = null;\n    completeNavigation(location, {\n      matches,\n      loaderData,\n      errors\n    });\n  } // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n\n\n  async function handleAction(request, location, submission, matches, opts) {\n    interruptActiveLoads(); // Put us in a submitting state\n\n    let navigation = _extends({\n      state: \"submitting\",\n      location\n    }, submission);\n\n    updateState({\n      navigation\n    }); // Call our action and get the result\n\n    let result;\n    let actionMatch = getTargetMatch(matches, location);\n\n    if (!actionMatch.route.action) {\n      result = getMethodNotAllowedResult(location);\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, router.basename);\n\n      if (request.signal.aborted) {\n        return {\n          shortCircuited: true\n        };\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      let redirectNavigation = _extends({\n        state: \"loading\",\n        location: createLocation(state.location, result.location)\n      }, submission);\n\n      await startRedirectNavigation(result, redirectNavigation, opts && opts.replace);\n      return {\n        shortCircuited: true\n      };\n    }\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id); // By default, all submissions are REPLACE navigations, but if the\n      // action threw an error that'll be rendered in an errorElement, we fall\n      // back to PUSH so that the user can use the back button to get back to\n      // the pre-submission form location to try again\n\n      if ((opts && opts.replace) !== true) {\n        pendingAction = Action.Push;\n      }\n\n      return {\n        pendingActionError: {\n          [boundaryMatch.route.id]: result.error\n        }\n      };\n    }\n\n    if (isDeferredResult(result)) {\n      throw new Error(\"defer() is not supported in actions\");\n    }\n\n    return {\n      pendingActionData: {\n        [actionMatch.route.id]: result.data\n      }\n    };\n  } // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n\n\n  async function handleLoaders(request, location, matches, overrideNavigation, submission, replace, pendingActionData, pendingError) {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation = overrideNavigation;\n\n    if (!loadingNavigation) {\n      let navigation = {\n        state: \"loading\",\n        location,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      };\n      loadingNavigation = navigation;\n    }\n\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(state, matches, submission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, pendingActionData, pendingError, fetchLoadMatches); // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n\n    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId)); // Short circuit if we have no loaders to run\n\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      completeNavigation(location, {\n        matches,\n        loaderData: mergeLoaderData(state.loaderData, {}, matches),\n        // Commit pending error if we're short circuiting\n        errors: pendingError || null,\n        actionData: pendingActionData || null\n      });\n      return {\n        shortCircuited: true\n      };\n    } // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n\n\n    if (!isUninterruptedRevalidation) {\n      revalidatingFetchers.forEach(_ref2 => {\n        let [key] = _ref2;\n        let fetcher = state.fetchers.get(key);\n        let revalidatingFetcher = {\n          state: \"loading\",\n          data: fetcher && fetcher.data,\n          formMethod: undefined,\n          formAction: undefined,\n          formEncType: undefined,\n          formData: undefined\n        };\n        state.fetchers.set(key, revalidatingFetcher);\n      });\n      updateState(_extends({\n        navigation: loadingNavigation,\n        actionData: pendingActionData || state.actionData || null\n      }, revalidatingFetchers.length > 0 ? {\n        fetchers: new Map(state.fetchers)\n      } : {}));\n    }\n\n    pendingNavigationLoadId = ++incrementingLoadId;\n    revalidatingFetchers.forEach(_ref3 => {\n      let [key] = _ref3;\n      return fetchControllers.set(key, pendingNavigationController);\n    });\n    let {\n      results,\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);\n\n    if (request.signal.aborted) {\n      return {\n        shortCircuited: true\n      };\n    } // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n\n\n    revalidatingFetchers.forEach(_ref4 => {\n      let [key] = _ref4;\n      return fetchControllers.delete(key);\n    }); // If any loaders returned a redirect Response, start a new REPLACE navigation\n\n    let redirect = findRedirect(results);\n\n    if (redirect) {\n      let redirectNavigation = getLoaderRedirect(state, redirect);\n      await startRedirectNavigation(redirect, redirectNavigation, replace);\n      return {\n        shortCircuited: true\n      };\n    } // Process and commit output from loaders\n\n\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds); // Wire up subscribers to update loaderData as promises settle\n\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe(aborted => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n    markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    return _extends({\n      loaderData,\n      errors\n    }, didAbortFetchLoads || revalidatingFetchers.length > 0 ? {\n      fetchers: new Map(state.fetchers)\n    } : {});\n  }\n\n  function getFetcher(key) {\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  } // Trigger a fetcher load/submit for the given fetcher key\n\n\n  function fetch(key, routeId, href, opts) {\n    if (isServer) {\n      throw new Error(\"router.fetch() was called during the server render, but it shouldn't be. \" + \"You are likely calling a useFetcher() method in the body of your component. \" + \"Try moving it to a useEffect or a callback.\");\n    }\n\n    if (fetchControllers.has(key)) abortFetcher(key);\n    let matches = matchRoutes(dataRoutes, href, init.basename);\n\n    if (!matches) {\n      setFetcherError(key, routeId, new ErrorResponse(404, \"Not Found\", null));\n      return;\n    }\n\n    let {\n      path,\n      submission\n    } = normalizeNavigateOptions(href, opts, true);\n    let match = getTargetMatch(matches, path);\n\n    if (submission) {\n      handleFetcherAction(key, routeId, path, match, matches, submission);\n      return;\n    } // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n\n\n    fetchLoadMatches.set(key, [path, match, matches]);\n    handleFetcherLoader(key, routeId, path, match, matches);\n  } // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n\n\n  async function handleFetcherAction(key, routeId, path, match, requestMatches, submission) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n\n    if (!match.route.action) {\n      let {\n        error\n      } = getMethodNotAllowedResult(path);\n      setFetcherError(key, routeId, error);\n      return;\n    } // Put this fetcher into it's submitting state\n\n\n    let existingFetcher = state.fetchers.get(key);\n\n    let fetcher = _extends({\n      state: \"submitting\"\n    }, submission, {\n      data: existingFetcher && existingFetcher.data\n    });\n\n    state.fetchers.set(key, fetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }); // Call the action for the fetcher\n\n    let abortController = new AbortController();\n    let fetchRequest = createRequest(path, abortController.signal, submission);\n    fetchControllers.set(key, abortController);\n    let actionResult = await callLoaderOrAction(\"action\", fetchRequest, match, requestMatches, router.basename);\n\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by ou our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n\n      return;\n    }\n\n    if (isRedirectResult(actionResult)) {\n      fetchControllers.delete(key);\n      fetchRedirectIds.add(key);\n\n      let loadingFetcher = _extends({\n        state: \"loading\"\n      }, submission, {\n        data: undefined\n      });\n\n      state.fetchers.set(key, loadingFetcher);\n      updateState({\n        fetchers: new Map(state.fetchers)\n      });\n\n      let redirectNavigation = _extends({\n        state: \"loading\",\n        location: createLocation(state.location, actionResult.location)\n      }, submission);\n\n      await startRedirectNavigation(actionResult, redirectNavigation);\n      return;\n    } // Process any non-redirect errors thrown\n\n\n    if (isErrorResult(actionResult)) {\n      setFetcherError(key, routeId, actionResult.error);\n      return;\n    }\n\n    if (isDeferredResult(actionResult)) {\n      invariant(false, \"defer() is not supported in actions\");\n    } // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n\n\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createRequest(nextLocation, abortController.signal);\n    let matches = state.navigation.state !== \"idle\" ? matchRoutes(dataRoutes, state.navigation.location, init.basename) : state.matches;\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n\n    let loadFetcher = _extends({\n      state: \"loading\",\n      data: actionResult.data\n    }, submission);\n\n    state.fetchers.set(key, loadFetcher);\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(state, matches, submission, nextLocation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, {\n      [match.route.id]: actionResult.data\n    }, undefined, // No need to send through errors since we short circuit above\n    fetchLoadMatches); // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n\n    revalidatingFetchers.filter(_ref5 => {\n      let [staleKey] = _ref5;\n      return staleKey !== key;\n    }).forEach(_ref6 => {\n      let [staleKey] = _ref6;\n      let existingFetcher = state.fetchers.get(staleKey);\n      let revalidatingFetcher = {\n        state: \"loading\",\n        data: existingFetcher && existingFetcher.data,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      };\n      state.fetchers.set(staleKey, revalidatingFetcher);\n      fetchControllers.set(staleKey, abortController);\n    });\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n    let {\n      results,\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);\n\n    if (abortController.signal.aborted) {\n      return;\n    }\n\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach(_ref7 => {\n      let [staleKey] = _ref7;\n      return fetchControllers.delete(staleKey);\n    });\n    let redirect = findRedirect(results);\n\n    if (redirect) {\n      let redirectNavigation = getLoaderRedirect(state, redirect);\n      await startRedirectNavigation(redirect, redirectNavigation);\n      return;\n    } // Process and commit output from loaders\n\n\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, state.matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);\n    let doneFetcher = {\n      state: \"idle\",\n      data: actionResult.data,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined\n    };\n    state.fetchers.set(key, doneFetcher);\n    let didAbortFetchLoads = abortStaleFetchLoads(loadId); // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n\n    if (state.navigation.state === \"loading\" && loadId > pendingNavigationLoadId) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers)\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState(_extends({\n        errors,\n        loaderData: mergeLoaderData(state.loaderData, loaderData, matches)\n      }, didAbortFetchLoads ? {\n        fetchers: new Map(state.fetchers)\n      } : {}));\n      isRevalidationRequired = false;\n    }\n  } // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n\n\n  async function handleFetcherLoader(key, routeId, path, match, matches) {\n    let existingFetcher = state.fetchers.get(key); // Put this fetcher into it's loading state\n\n    let loadingFetcher = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      data: existingFetcher && existingFetcher.data\n    };\n    state.fetchers.set(key, loadingFetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }); // Call the loader for this fetcher route match\n\n    let abortController = new AbortController();\n    let fetchRequest = createRequest(path, abortController.signal);\n    fetchControllers.set(key, abortController);\n    let result = await callLoaderOrAction(\"loader\", fetchRequest, match, matches, router.basename); // Deferred isn't supported or fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n\n    if (isDeferredResult(result)) {\n      result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;\n    } // We can delete this so long as we weren't aborted by ou our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n\n\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n\n    if (fetchRequest.signal.aborted) {\n      return;\n    } // If the loader threw a redirect Response, start a new REPLACE navigation\n\n\n    if (isRedirectResult(result)) {\n      let redirectNavigation = getLoaderRedirect(state, result);\n      await startRedirectNavigation(result, redirectNavigation);\n      return;\n    } // Process any non-redirect errors thrown\n\n\n    if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, routeId);\n      state.fetchers.delete(key); // TODO: In remix, this would reset to IDLE_NAVIGATION if it was a catch -\n      // do we need to behave any differently with our non-redirect errors?\n      // What if it was a non-redirect Response?\n\n      updateState({\n        fetchers: new Map(state.fetchers),\n        errors: {\n          [boundaryMatch.route.id]: result.error\n        }\n      });\n      return;\n    }\n\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\"); // Put the fetcher back into an idle state\n\n    let doneFetcher = {\n      state: \"idle\",\n      data: result.data,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined\n    };\n    state.fetchers.set(key, doneFetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n  }\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n\n\n  async function startRedirectNavigation(redirect, navigation, replace) {\n    if (redirect.revalidate) {\n      isRevalidationRequired = true;\n    }\n\n    invariant(navigation.location, \"Expected a location on the redirect navigation\"); // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n\n    pendingNavigationController = null;\n    let redirectHistoryAction = replace === true ? Action.Replace : Action.Push;\n    await startNavigation(redirectHistoryAction, navigation.location, {\n      overrideNavigation: navigation\n    });\n  }\n\n  async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {\n    // Call all navigation loaders and revalidating fetcher loaders in parallel,\n    // then slice off the results into separate arrays so we can handle them\n    // accordingly\n    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction(\"loader\", request, match, matches, router.basename)), ...fetchersToLoad.map(_ref8 => {\n      let [, href, match, fetchMatches] = _ref8;\n      return callLoaderOrAction(\"loader\", createRequest(href, request.signal), match, fetchMatches, router.basename);\n    })]);\n    let loaderResults = results.slice(0, matchesToLoad.length);\n    let fetcherResults = results.slice(matchesToLoad.length);\n    await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, request.signal, false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(_ref9 => {\n      let [,, match] = _ref9;\n      return match;\n    }), fetcherResults, request.signal, true)]);\n    return {\n      results,\n      loaderResults,\n      fetcherResults\n    };\n  }\n\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true; // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds()); // Abort in-flight fetcher loads\n\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.push(key);\n        abortFetcher(key);\n      }\n    });\n  }\n\n  function setFetcherError(key, routeId, error) {\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState({\n      errors: {\n        [boundaryMatch.route.id]: error\n      },\n      fetchers: new Map(state.fetchers)\n    });\n  }\n\n  function deleteFetcher(key) {\n    if (fetchControllers.has(key)) abortFetcher(key);\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n    state.fetchers.delete(key);\n  }\n\n  function abortFetcher(key) {\n    let controller = fetchControllers.get(key);\n    invariant(controller, \"Expected fetch controller: \" + key);\n    controller.abort();\n    fetchControllers.delete(key);\n  }\n\n  function markFetchersDone(keys) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = {\n        state: \"idle\",\n        data: fetcher.data,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      };\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  function markFetchRedirectsDone() {\n    let doneKeys = [];\n\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, \"Expected fetcher: \" + key);\n\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n      }\n    }\n\n    markFetchersDone(doneKeys);\n  }\n\n  function abortStaleFetchLoads(landedId) {\n    let yeetedKeys = [];\n\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, \"Expected fetcher: \" + key);\n\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n\n  function cancelActiveDeferreds(predicate) {\n    let cancelledRouteIds = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  } // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n\n\n  function enableScrollRestoration(positions, getPosition, getKey) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n\n    getScrollRestorationKey = getKey || (location => location.key); // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n\n\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n\n      if (y != null) {\n        updateState({\n          restoreScrollPosition: y\n        });\n      }\n    }\n\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n\n  function saveScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollRestorationKey && getScrollPosition) {\n      let userMatches = matches.map(m => createUseMatchesMatch(m, state.loaderData));\n      let key = getScrollRestorationKey(location, userMatches) || location.key;\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n\n  function getSavedScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollRestorationKey && getScrollPosition) {\n      let userMatches = matches.map(m => createUseMatchesMatch(m, state.loaderData));\n      let key = getScrollRestorationKey(location, userMatches) || location.key;\n      let y = savedScrollPositions[key];\n\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n\n    return null;\n  }\n\n  router = {\n    get basename() {\n      return init.basename;\n    },\n\n    get state() {\n      return state;\n    },\n\n    get routes() {\n      return dataRoutes;\n    },\n\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: to => init.history.createHref(to),\n    getFetcher,\n    deleteFetcher,\n    dispose,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds\n  };\n  return router;\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\n\nconst validActionMethods = new Set([\"POST\", \"PUT\", \"PATCH\", \"DELETE\"]);\nconst validRequestMethods = new Set([\"GET\", \"HEAD\", ...validActionMethods]);\nfunction unstable_createStaticHandler(routes) {\n  invariant(routes.length > 0, \"You must provide a non-empty routes array to unstable_createStaticHandler\");\n  let dataRoutes = convertRoutesToDataRoutes(routes);\n  /**\n   * The query() method is intended for document requests, in which we want to\n   * call an optional action and potentially multiple loaders for all nested\n   * routes.  It returns a StaticHandlerContext object, which is very similar\n   * to the router state (location, loaderData, actionData, errors, etc.) and\n   * also adds SSR-specific information such as the statusCode and headers\n   * from action/loaders Responses.\n   *\n   * It _should_ never throw and should report all errors through the\n   * returned context.errors object, properly associating errors to their error\n   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be\n   * used to emulate React error boundaries during SSr by performing a second\n   * pass only down to the boundaryId.\n   *\n   * The one exception where we do not return a StaticHandlerContext is when a\n   * redirect response is returned or thrown from any action/loader.  We\n   * propagate that out and return the raw Response so the HTTP server can\n   * return it directly.\n   */\n\n  async function query(request) {\n    let url = new URL(request.url);\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location);\n\n    if (!validRequestMethods.has(request.method)) {\n      let {\n        matches: methodNotAllowedMatches,\n        route,\n        error\n      } = getMethodNotAllowedMatches(dataRoutes);\n      return {\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {}\n      };\n    } else if (!matches) {\n      let {\n        matches: notFoundMatches,\n        route,\n        error\n      } = getNotFoundMatches(dataRoutes);\n      return {\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {}\n      };\n    }\n\n    let result = await queryImpl(request, location, matches);\n\n    if (result instanceof Response) {\n      return result;\n    } // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n\n\n    return _extends({\n      location\n    }, result);\n  }\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated thrown Response (such as a\n   * 404 or 405) will have a custom X-Remix-Router-Error: \"yes\" header on it\n   * in order to differentiate from responses thrown from user actions/loaders.\n   */\n\n\n  async function queryRoute(request, routeId) {\n    let url = new URL(request.url);\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location);\n\n    if (!validRequestMethods.has(request.method)) {\n      throw createRouterErrorResponse(null, {\n        status: 405,\n        statusText: \"Method Not Allowed\"\n      });\n    } else if (!matches) {\n      throw createRouterErrorResponse(null, {\n        status: 404,\n        statusText: \"Not Found\"\n      });\n    }\n\n    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);\n\n    if (!match) {\n      throw createRouterErrorResponse(null, {\n        status: 404,\n        statusText: \"Not Found\"\n      });\n    }\n\n    let result = await queryImpl(request, location, matches, match);\n\n    if (result instanceof Response) {\n      return result;\n    }\n\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    } // Pick off the right state value to return\n\n\n    let routeData = [result.actionData, result.loaderData].find(v => v);\n    return Object.values(routeData || {})[0];\n  }\n\n  async function queryImpl(request, location, matches, routeMatch) {\n    invariant(request.signal, \"query()/queryRoute() requests must contain an AbortController signal\");\n\n    try {\n      if (validActionMethods.has(request.method)) {\n        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), routeMatch != null);\n        return result;\n      }\n\n      let result = await loadRouteData(request, matches, routeMatch);\n      return result instanceof Response ? result : _extends({}, result, {\n        actionData: null,\n        actionHeaders: {}\n      });\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction, we throw\n      // it to bail out and then return or throw here based on whether the user\n      // returned or threw\n      if (isQueryRouteResponse(e)) {\n        if (e.type === ResultType.error && !isRedirectResponse(e.response)) {\n          throw e.response;\n        }\n\n        return e.response;\n      } // Redirects are always returned since they don't propagate to catch\n      // boundaries\n\n\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n\n      throw e;\n    }\n  }\n\n  async function submit(request, matches, actionMatch, isRouteRequest) {\n    let result;\n\n    if (!actionMatch.route.action) {\n      if (isRouteRequest) {\n        throw createRouterErrorResponse(null, {\n          status: 405,\n          statusText: \"Method Not Allowed\"\n        });\n      }\n\n      result = getMethodNotAllowedResult(request.url);\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, undefined, // Basename not currently supported in static handlers\n      true, isRouteRequest);\n\n      if (request.signal.aborted) {\n        let method = isRouteRequest ? \"queryRoute\" : \"query\";\n        throw new Error(method + \"() call aborted\");\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      // Uhhhh - this should never happen, we should always throw these from\n      // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n      // can get back on the \"throw all redirect responses\" train here should\n      // this ever happen :/\n      throw new Response(null, {\n        status: result.status,\n        headers: {\n          Location: result.location\n        }\n      });\n    }\n\n    if (isDeferredResult(result)) {\n      throw new Error(\"defer() is not supported in actions\");\n    }\n\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n        return {\n          matches: [actionMatch],\n          loaderData: {},\n          actionData: null,\n          errors: {\n            [boundaryMatch.route.id]: result.error\n          },\n          // Note: statusCode + headers are unused here since queryRoute will\n          // return the raw Response or value\n          statusCode: 500,\n          loaderHeaders: {},\n          actionHeaders: {}\n        };\n      }\n\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: {\n          [actionMatch.route.id]: result.data\n        },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {}\n      };\n    }\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n      let context = await loadRouteData(request, matches, undefined, {\n        [boundaryMatch.route.id]: result.error\n      }); // action status codes take precedence over loader status codes\n\n      return _extends({}, context, {\n        statusCode: isRouteErrorResponse(result.error) ? result.error.status : 500,\n        actionData: null,\n        actionHeaders: _extends({}, result.headers ? {\n          [actionMatch.route.id]: result.headers\n        } : {})\n      });\n    }\n\n    let context = await loadRouteData(request, matches);\n    return _extends({}, context, result.statusCode ? {\n      statusCode: result.statusCode\n    } : {}, {\n      actionData: {\n        [actionMatch.route.id]: result.data\n      },\n      actionHeaders: _extends({}, result.headers ? {\n        [actionMatch.route.id]: result.headers\n      } : {})\n    });\n  }\n\n  async function loadRouteData(request, matches, routeMatch, pendingActionError) {\n    let isRouteRequest = routeMatch != null;\n    let requestMatches = routeMatch ? [routeMatch] : getLoaderMatchesUntilBoundary(matches, Object.keys(pendingActionError || {})[0]);\n    let matchesToLoad = requestMatches.filter(m => m.route.loader); // Short circuit if we have no loaders to run\n\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        loaderData: {},\n        errors: pendingActionError || null,\n        statusCode: 200,\n        loaderHeaders: {}\n      };\n    }\n\n    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction(\"loader\", request, match, matches, undefined, // Basename not currently supported in static handlers\n    true, isRouteRequest))]);\n\n    if (request.signal.aborted) {\n      let method = isRouteRequest ? \"queryRoute\" : \"query\";\n      throw new Error(method + \"() call aborted\");\n    } // Can't do anything with these without the Remix side of things, so just\n    // cancel them for now\n\n\n    results.forEach(result => {\n      if (isDeferredResult(result)) {\n        result.deferredData.cancel();\n      }\n    }); // Process and commit output from loaders\n\n    let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionError);\n    return _extends({}, context, {\n      matches\n    });\n  }\n\n  function createRouterErrorResponse(body, init) {\n    return new Response(body, _extends({}, init, {\n      headers: _extends({}, init.headers, {\n        \"X-Remix-Router-Error\": \"yes\"\n      })\n    }));\n  }\n\n  return {\n    dataRoutes,\n    query,\n    queryRoute\n  };\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\n\nfunction getStaticContextFromError(routes, context, error) {\n  let newContext = _extends({}, context, {\n    statusCode: 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error\n    }\n  });\n\n  return newContext;\n} // Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\n\nfunction normalizeNavigateOptions(to, opts, isFetcher) {\n  if (isFetcher === void 0) {\n    isFetcher = false;\n  }\n\n  let path = typeof to === \"string\" ? to : createPath(to); // Return location verbatim on non-submission navigations\n\n  if (!opts || !(\"formMethod\" in opts) && !(\"formData\" in opts)) {\n    return {\n      path\n    };\n  } // Create a Submission on non-GET navigations\n\n\n  if (opts.formMethod != null && opts.formMethod !== \"get\") {\n    return {\n      path,\n      submission: {\n        formMethod: opts.formMethod,\n        formAction: stripHashFromPath(path),\n        formEncType: opts && opts.formEncType || \"application/x-www-form-urlencoded\",\n        formData: opts.formData\n      }\n    };\n  } // No formData to flatten for GET submission\n\n\n  if (!opts.formData) {\n    return {\n      path\n    };\n  } // Flatten submission onto URLSearchParams for GET submissions\n\n\n  let parsedPath = parsePath(path);\n\n  try {\n    let searchParams = convertFormDataToSearchParams(opts.formData); // Since fetcher GET submissions only run a single loader (as opposed to\n    // navigation GET submissions which run all loaders), we need to preserve\n    // any incoming ?index params\n\n    if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n      searchParams.append(\"index\", \"\");\n    }\n\n    parsedPath.search = \"?\" + searchParams;\n  } catch (e) {\n    return {\n      path,\n      error: new ErrorResponse(400, \"Bad Request\", \"Cannot submit binary form data using GET\")\n    };\n  }\n\n  return {\n    path: createPath(parsedPath)\n  };\n}\n\nfunction getLoaderRedirect(state, redirect) {\n  let {\n    formMethod,\n    formAction,\n    formEncType,\n    formData\n  } = state.navigation;\n  let navigation = {\n    state: \"loading\",\n    location: createLocation(state.location, redirect.location),\n    formMethod: formMethod || undefined,\n    formAction: formAction || undefined,\n    formEncType: formEncType || undefined,\n    formData: formData || undefined\n  };\n  return navigation;\n} // Filter out all routes below any caught error as they aren't going to\n// render so we don't need to load them\n\n\nfunction getLoaderMatchesUntilBoundary(matches, boundaryId) {\n  let boundaryMatches = matches;\n\n  if (boundaryId) {\n    let index = matches.findIndex(m => m.route.id === boundaryId);\n\n    if (index >= 0) {\n      boundaryMatches = matches.slice(0, index);\n    }\n  }\n\n  return boundaryMatches;\n}\n\nfunction getMatchesToLoad(state, matches, submission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, pendingActionData, pendingError, fetchLoadMatches) {\n  let actionResult = pendingError ? Object.values(pendingError)[0] : pendingActionData ? Object.values(pendingActionData)[0] : null; // Pick navigation matches that are net-new or qualify for revalidation\n\n  let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;\n  let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);\n  let navigationMatches = boundaryMatches.filter((match, index) => match.route.loader != null && (isNewLoader(state.loaderData, state.matches[index], match) || // If this route had a pending deferred cancelled it must be revalidated\n  cancelledDeferredRoutes.some(id => id === match.route.id) || shouldRevalidateLoader(state.location, state.matches[index], submission, location, match, isRevalidationRequired, actionResult))); // Pick fetcher.loads that need to be revalidated\n\n  let revalidatingFetchers = [];\n  fetchLoadMatches && fetchLoadMatches.forEach((_ref10, key) => {\n    let [href, match, fetchMatches] = _ref10;\n\n    // This fetcher was cancelled from a prior action submission - force reload\n    if (cancelledFetcherLoads.includes(key)) {\n      revalidatingFetchers.push([key, href, match, fetchMatches]);\n    } else if (isRevalidationRequired) {\n      let shouldRevalidate = shouldRevalidateLoader(href, match, submission, href, match, isRevalidationRequired, actionResult);\n\n      if (shouldRevalidate) {\n        revalidatingFetchers.push([key, href, match, fetchMatches]);\n      }\n    }\n  });\n  return [navigationMatches, revalidatingFetchers];\n}\n\nfunction isNewLoader(currentLoaderData, currentMatch, match) {\n  let isNew = // [a] -> [a, b]\n  !currentMatch || // [a, b] -> [a, c]\n  match.route.id !== currentMatch.route.id; // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n\n  let isMissingData = currentLoaderData[match.route.id] === undefined; // Always load if this is a net-new route or we don't yet have data\n\n  return isNew || isMissingData;\n}\n\nfunction isNewRouteInstance(currentMatch, match) {\n  let currentPath = currentMatch.route.path;\n  return (// param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname || // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    currentPath && currentPath.endsWith(\"*\") && currentMatch.params[\"*\"] !== match.params[\"*\"]\n  );\n}\n\nfunction shouldRevalidateLoader(currentLocation, currentMatch, submission, location, match, isRevalidationRequired, actionResult) {\n  let currentUrl = createURL(currentLocation);\n  let currentParams = currentMatch.params;\n  let nextUrl = createURL(location);\n  let nextParams = match.params; // This is the default implementation as to when we revalidate.  If the route\n  // provides it's own implementation, then we give them full control but\n  // provide this value so they can leverage it if needed after they check\n  // their own specific use cases\n  // Note that fetchers always provide the same current/next locations so the\n  // URL-based checks here don't apply to fetcher shouldRevalidate calls\n\n  let defaultShouldRevalidate = isNewRouteInstance(currentMatch, match) || // Clicked the same link, resubmitted a GET form\n  currentUrl.toString() === nextUrl.toString() || // Search params affect all loaders\n  currentUrl.search !== nextUrl.search || // Forced revalidation due to submission, useRevalidate, or X-Remix-Revalidate\n  isRevalidationRequired;\n\n  if (match.route.shouldRevalidate) {\n    let routeChoice = match.route.shouldRevalidate(_extends({\n      currentUrl,\n      currentParams,\n      nextUrl,\n      nextParams\n    }, submission, {\n      actionResult,\n      defaultShouldRevalidate\n    }));\n\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n\n  return defaultShouldRevalidate;\n}\n\nasync function callLoaderOrAction(type, request, match, matches, basename, isStaticRequest, isRouteRequest) {\n  if (isStaticRequest === void 0) {\n    isStaticRequest = false;\n  }\n\n  if (isRouteRequest === void 0) {\n    isRouteRequest = false;\n  }\n\n  let resultType;\n  let result; // Setup a promise we can race against so that abort signals short circuit\n\n  let reject;\n  let abortPromise = new Promise((_, r) => reject = r);\n\n  let onReject = () => reject();\n\n  request.signal.addEventListener(\"abort\", onReject);\n\n  try {\n    let handler = match.route[type];\n    invariant(handler, \"Could not find the \" + type + \" to run on the \\\"\" + match.route.id + \"\\\" route\");\n    result = await Promise.race([handler({\n      request,\n      params: match.params\n    }), abortPromise]);\n  } catch (e) {\n    resultType = ResultType.error;\n    result = e;\n  } finally {\n    request.signal.removeEventListener(\"abort\", onReject);\n  }\n\n  if (result instanceof Response) {\n    let status = result.status; // Process redirects\n\n    if (status >= 300 && status <= 399) {\n      let location = result.headers.get(\"Location\");\n      invariant(location, \"Redirects returned/thrown from loaders/actions must have a Location header\"); // Support relative routing in redirects\n\n      let activeMatches = matches.slice(0, matches.indexOf(match) + 1);\n      let routePathnames = getPathContributingMatches(activeMatches).map(match => match.pathnameBase);\n      let requestPath = createURL(request.url).pathname;\n      let resolvedLocation = resolveTo(location, routePathnames, requestPath);\n      invariant(createPath(resolvedLocation), \"Unable to resolve redirect location: \" + result.headers.get(\"Location\")); // Prepend the basename to the redirect location if we have one\n\n      if (basename) {\n        let path = resolvedLocation.pathname;\n        resolvedLocation.pathname = path === \"/\" ? basename : joinPaths([basename, path]);\n      }\n\n      location = createPath(resolvedLocation); // Don't process redirects in the router during static requests requests.\n      // Instead, throw the Response and let the server handle it with an HTTP\n      // redirect.  We also update the Location header in place in this flow so\n      // basename and relative routing is taken into account\n\n      if (isStaticRequest) {\n        result.headers.set(\"Location\", location);\n        throw result;\n      }\n\n      return {\n        type: ResultType.redirect,\n        status,\n        location,\n        revalidate: result.headers.get(\"X-Remix-Revalidate\") !== null\n      };\n    } // For SSR single-route requests, we want to hand Responses back directly\n    // without unwrapping.  We do this with the QueryRouteResponse wrapper\n    // interface so we can know whether it was returned or thrown\n\n\n    if (isRouteRequest) {\n      // eslint-disable-next-line no-throw-literal\n      throw {\n        type: resultType || ResultType.data,\n        response: result\n      };\n    }\n\n    let data;\n    let contentType = result.headers.get(\"Content-Type\");\n\n    if (contentType && contentType.startsWith(\"application/json\")) {\n      data = await result.json();\n    } else {\n      data = await result.text();\n    }\n\n    if (resultType === ResultType.error) {\n      return {\n        type: resultType,\n        error: new ErrorResponse(status, result.statusText, data),\n        headers: result.headers\n      };\n    }\n\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers\n    };\n  }\n\n  if (resultType === ResultType.error) {\n    return {\n      type: resultType,\n      error: result\n    };\n  }\n\n  if (result instanceof DeferredData) {\n    return {\n      type: ResultType.deferred,\n      deferredData: result\n    };\n  }\n\n  return {\n    type: ResultType.data,\n    data: result\n  };\n}\n\nfunction createRequest(location, signal, submission) {\n  let url = createURL(stripHashFromPath(location)).toString();\n  let init = {\n    signal\n  };\n\n  if (submission) {\n    let {\n      formMethod,\n      formEncType,\n      formData\n    } = submission;\n    init.method = formMethod.toUpperCase();\n    init.body = formEncType === \"application/x-www-form-urlencoded\" ? convertFormDataToSearchParams(formData) : formData;\n  } // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n\n\n  return new Request(url, init);\n}\n\nfunction convertFormDataToSearchParams(formData) {\n  let searchParams = new URLSearchParams();\n\n  for (let [key, value] of formData.entries()) {\n    invariant(typeof value === \"string\", 'File inputs are not supported with encType \"application/x-www-form-urlencoded\", ' + 'please use \"multipart/form-data\" instead.');\n    searchParams.append(key, value);\n  }\n\n  return searchParams;\n}\n\nfunction processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds) {\n  // Fill in loaderData/errors from our loaders\n  let loaderData = {};\n  let errors = null;\n  let statusCode;\n  let foundError = false;\n  let loaderHeaders = {}; // Process loader results into state.loaderData/state.errors\n\n  results.forEach((result, index) => {\n    let id = matchesToLoad[index].route.id;\n    invariant(!isRedirectResult(result), \"Cannot handle redirect results in processLoaderData\");\n\n    if (isErrorResult(result)) {\n      // Look upwards from the matched route for the closest ancestor\n      // error boundary, defaulting to the root match\n      let boundaryMatch = findNearestBoundary(matches, id);\n      let error = result.error; // If we have a pending action error, we report it at the highest-route\n      // that throws a loader error, and then clear it out to indicate that\n      // it was consumed\n\n      if (pendingError) {\n        error = Object.values(pendingError)[0];\n        pendingError = undefined;\n      }\n\n      errors = Object.assign(errors || {}, {\n        [boundaryMatch.route.id]: error\n      }); // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;\n      }\n\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else if (isDeferredResult(result)) {\n      activeDeferreds && activeDeferreds.set(id, result.deferredData);\n      loaderData[id] = result.deferredData.data; // TODO: Add statusCode/headers once we wire up streaming in Remix\n    } else {\n      loaderData[id] = result.data; // Error status codes always override success status codes, but if all\n      // loaders are successful we take the deepest status code.\n\n      if (result.statusCode != null && result.statusCode !== 200 && !foundError) {\n        statusCode = result.statusCode;\n      }\n\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    }\n  }); // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here\n\n  if (pendingError) {\n    errors = pendingError;\n  }\n\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders\n  };\n}\n\nfunction processLoaderData(state, matches, matchesToLoad, results, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds) {\n  let {\n    loaderData,\n    errors\n  } = processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds); // Process results from our revalidating fetchers\n\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let [key,, match] = revalidatingFetchers[index];\n    invariant(fetcherResults !== undefined && fetcherResults[index] !== undefined, \"Did not find corresponding fetcher result\");\n    let result = fetcherResults[index]; // Process fetcher non-redirect errors\n\n    if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match.route.id);\n\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = _extends({}, errors, {\n          [boundaryMatch.route.id]: result.error\n        });\n      }\n\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      throw new Error(\"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      throw new Error(\"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = {\n        state: \"idle\",\n        data: result.data,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      };\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  return {\n    loaderData,\n    errors\n  };\n}\n\nfunction mergeLoaderData(loaderData, newLoaderData, matches) {\n  let mergedLoaderData = _extends({}, newLoaderData);\n\n  matches.forEach(match => {\n    let id = match.route.id;\n\n    if (newLoaderData[id] === undefined && loaderData[id] !== undefined) {\n      mergedLoaderData[id] = loaderData[id];\n    }\n  });\n  return mergedLoaderData;\n} // Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\n\n\nfunction findNearestBoundary(matches, routeId) {\n  let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];\n  return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];\n}\n\nfunction getShortCircuitMatches(routes, status, statusText) {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route = routes.find(r => r.index || !r.path || r.path === \"/\") || {\n    id: \"__shim-\" + status + \"-route__\"\n  };\n  return {\n    matches: [{\n      params: {},\n      pathname: \"\",\n      pathnameBase: \"\",\n      route\n    }],\n    route,\n    error: new ErrorResponse(status, statusText, null)\n  };\n}\n\nfunction getNotFoundMatches(routes) {\n  return getShortCircuitMatches(routes, 404, \"Not Found\");\n}\n\nfunction getMethodNotAllowedMatches(routes) {\n  return getShortCircuitMatches(routes, 405, \"Method Not Allowed\");\n}\n\nfunction getMethodNotAllowedResult(path) {\n  let href = typeof path === \"string\" ? path : createPath(path);\n  console.warn(\"You're trying to submit to a route that does not have an action.  To \" + \"fix this, please add an `action` function to the route for \" + (\"[\" + href + \"]\"));\n  return {\n    type: ResultType.error,\n    error: new ErrorResponse(405, \"Method Not Allowed\", \"\")\n  };\n} // Find any returned redirect errors, starting from the lowest match\n\n\nfunction findRedirect(results) {\n  for (let i = results.length - 1; i >= 0; i--) {\n    let result = results[i];\n\n    if (isRedirectResult(result)) {\n      return result;\n    }\n  }\n}\n\nfunction stripHashFromPath(path) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath(_extends({}, parsedPath, {\n    hash: \"\"\n  }));\n}\n\nfunction isHashChangeOnly(a, b) {\n  return a.pathname === b.pathname && a.search === b.search && a.hash !== b.hash;\n}\n\nfunction isDeferredResult(result) {\n  return result.type === ResultType.deferred;\n}\n\nfunction isErrorResult(result) {\n  return result.type === ResultType.error;\n}\n\nfunction isRedirectResult(result) {\n  return (result && result.type) === ResultType.redirect;\n}\n\nfunction isRedirectResponse(result) {\n  if (!(result instanceof Response)) {\n    return false;\n  }\n\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\n\nfunction isQueryRouteResponse(obj) {\n  return obj && obj.response instanceof Response && (obj.type === ResultType.data || ResultType.error);\n}\n\nasync function resolveDeferredResults(currentMatches, matchesToLoad, results, signal, isFetcher, currentLoaderData) {\n  for (let index = 0; index < results.length; index++) {\n    let result = results[index];\n    let match = matchesToLoad[index];\n    let currentMatch = currentMatches.find(m => m.route.id === match.route.id);\n    let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n\n    if (isDeferredResult(result) && (isFetcher || isRevalidatingLoader)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      await resolveDeferredData(result, signal, isFetcher).then(result => {\n        if (result) {\n          results[index] = result || results[index];\n        }\n      });\n    }\n  }\n}\n\nasync function resolveDeferredData(result, signal, unwrap) {\n  if (unwrap === void 0) {\n    unwrap = false;\n  }\n\n  let aborted = await result.deferredData.resolveData(signal);\n\n  if (aborted) {\n    return;\n  }\n\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n  }\n\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data\n  };\n}\n\nfunction hasNakedIndexQuery(search) {\n  return new URLSearchParams(search).getAll(\"index\").some(v => v === \"\");\n} // Note: This should match the format exported by useMatches, so if you change\n// this please also change that :)  Eventually we'll DRY this up\n\n\nfunction createUseMatchesMatch(match, loaderData) {\n  let {\n    route,\n    pathname,\n    params\n  } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle\n  };\n}\n\nfunction getTargetMatch(matches, location) {\n  let search = typeof location === \"string\" ? parsePath(location).search : location.search;\n\n  if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || \"\")) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  } // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n\n\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n} //#endregion\n\nexport { AbortedDeferredError, Action, ErrorResponse, IDLE_FETCHER, IDLE_NAVIGATION, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, getPathContributingMatches as UNSAFE_getPathContributingMatches, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, defer, generatePath, getStaticContextFromError, getToPathname, invariant, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, resolvePath, resolveTo, stripBasename, unstable_createStaticHandler, warning };\n//# sourceMappingURL=router.js.map\n"],"names":["_extends","target","i","source","key","Action","PopStateEventType","createMemoryHistory","options","initialEntries","initialIndex","v5Compat","entries","entry","index","createMemoryLocation","clampIndex","action","listener","n","getCurrentLocation","to","state","location","createLocation","warning$1","createPath","nextLocation","delta","fn","createBrowserHistory","createBrowserLocation","window","globalHistory","pathname","search","hash","createBrowserHref","getUrlBasedHistory","createHashHistory","createHashLocation","parsePath","createHashHref","base","href","url","hashIndex","validateHashLocation","cond","message","createKey","getHistoryState","current","_ref","path","parsedPath","searchIndex","createURL","getLocation","createHref","validateLocation","handlePop","history","push","historyState","replace","ResultType","isIndexRoute","route","convertRoutesToDataRoutes","routes","parentPath","allIds","treePath","id","invariant","matchRoutes","locationArg","basename","stripBasename","branches","flattenRoutes","rankRouteBranches","matches","matchRouteBranch","safelyDecodeURI","parentsMeta","meta","joinPaths","routesMeta","computeScore","a","b","compareIndexes","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","segments","initialScore","score","segment","branch","matchedParams","matchedPathname","end","remainingPathname","match","matchPath","normalizePathname","generatePath","params","_","prefix","__","str","star","pattern","matcher","paramNames","compilePath","pathnameBase","captureGroups","memo","paramName","splatValue","safelyDecodeURIComponent","caseSensitive","warning","regexpSource","value","error","startIndex","nextChar","resolvePath","fromPathname","toPathname","resolvePathname","normalizeSearch","normalizeHash","relativePath","getInvalidPathError","char","field","dest","getPathContributingMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","isEmptyPath","from","routePathnameIndex","toSegments","hasExplicitTrailingSlash","hasCurrentTrailingSlash","getToPathname","paths","json","data","init","responseInit","headers","AbortedDeferredError","DeferredData","reject","r","onAbort","acc","promise","subscriber","v","k","signal","aborted","resolve","_ref2","unwrapTrackedPromise","isTrackedPromise","defer","redirect","ErrorResponse","status","statusText","isRouteErrorResponse","IDLE_NAVIGATION","IDLE_FETCHER","isBrowser","isServer","createRouter","dataRoutes","unlistenHistory","subscribers","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","initialMatches","initialErrors","getNotFoundMatches","initialized","m","router","pendingAction","pendingPreventScrollReset","pendingNavigationController","isUninterruptedRevalidation","isRevalidationRequired","cancelledDeferredRoutes","cancelledFetcherLoads","fetchControllers","incrementingLoadId","pendingNavigationLoadId","fetchReloadIds","fetchRedirectIds","fetchLoadMatches","activeDeferreds","initialize","historyAction","startNavigation","dispose","deleteFetcher","subscribe","updateState","newState","completeNavigation","_state$navigation$for","isActionReload","newLoaderData","mergeLoaderData","getSavedScrollPosition","navigate","opts","submission","normalizeNavigateOptions","preventScrollReset","revalidate","interruptActiveLoads","saveScrollPosition","loadingNavigation","notFoundMatches","cancelActiveDeferreds","isHashChangeOnly","request","createRequest","pendingActionData","pendingError","findNearestBoundary","actionOutput","handleAction","shortCircuited","loaderData","errors","handleLoaders","navigation","result","actionMatch","getTargetMatch","getMethodNotAllowedResult","callLoaderOrAction","isRedirectResult","redirectNavigation","startRedirectNavigation","isErrorResult","boundaryMatch","isDeferredResult","overrideNavigation","matchesToLoad","revalidatingFetchers","getMatchesToLoad","routeId","fetcher","revalidatingFetcher","_ref3","results","loaderResults","fetcherResults","callLoadersAndMaybeResolveData","_ref4","findRedirect","getLoaderRedirect","processLoaderData","deferredData","markFetchRedirectsDone","didAbortFetchLoads","abortStaleFetchLoads","getFetcher","fetch","abortFetcher","setFetcherError","handleFetcherAction","handleFetcherLoader","requestMatches","existingFetcher","abortController","fetchRequest","actionResult","loadingFetcher","revalidationRequest","loadId","loadFetcher","_ref5","staleKey","_ref6","_ref7","doneFetcher","resolveDeferredData","redirectHistoryAction","currentMatches","fetchersToLoad","_ref8","fetchMatches","resolveDeferredResults","_ref9","controller","markFetchersDone","keys","doneKeys","landedId","yeetedKeys","predicate","cancelledRouteIds","dfd","enableScrollRestoration","positions","getPosition","getKey","y","userMatches","createUseMatchesMatch","validActionMethods","validRequestMethods","unstable_createStaticHandler","query","methodNotAllowedMatches","getMethodNotAllowedMatches","queryImpl","queryRoute","createRouterErrorResponse","routeData","routeMatch","submit","loadRouteData","e","isQueryRouteResponse","isRedirectResponse","isRouteRequest","method","context","pendingActionError","getLoaderMatchesUntilBoundary","processRouteLoaderData","body","getStaticContextFromError","isFetcher","stripHashFromPath","searchParams","convertFormDataToSearchParams","hasNakedIndexQuery","formMethod","formAction","formEncType","formData","boundaryId","boundaryMatches","navigationMatches","isNewLoader","shouldRevalidateLoader","_ref10","currentLoaderData","currentMatch","isNew","isMissingData","isNewRouteInstance","currentPath","currentLocation","currentUrl","currentParams","nextUrl","nextParams","defaultShouldRevalidate","routeChoice","type","isStaticRequest","resultType","abortPromise","onReject","handler","activeMatches","requestPath","resolvedLocation","contentType","statusCode","foundError","loaderHeaders","mergedLoaderData","getShortCircuitMatches","obj","isRevalidatingLoader","unwrap","pathMatches"],"mappings":"AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAUA,SAASA,GAAW,CAClB,OAAAA,EAAW,OAAO,OAAS,OAAO,OAAO,KAAI,EAAK,SAAUC,EAAQ,CAClE,QAASC,EAAI,EAAGA,EAAI,UAAU,OAAQA,IAAK,CACzC,IAAIC,EAAS,UAAUD,CAAC,EAExB,QAASE,KAAOD,EACV,OAAO,UAAU,eAAe,KAAKA,EAAQC,CAAG,IAClDH,EAAOG,CAAG,EAAID,EAAOC,CAAG,GAK9B,OAAOH,CACX,EACSD,EAAS,MAAM,KAAM,SAAS,CACvC,CASG,IAACK,GAEH,SAAUA,EAAQ,CAQjBA,EAAO,IAAS,MAOhBA,EAAO,KAAU,OAMjBA,EAAO,QAAa,SACtB,GAAGA,IAAWA,EAAS,CAAE,EAAC,EAE1B,MAAMC,GAAoB,WAM1B,SAASC,GAAoBC,EAAS,CAChCA,IAAY,SACdA,EAAU,CAAA,GAGZ,GAAI,CACF,eAAAC,EAAiB,CAAC,GAAG,EACrB,aAAAC,EACA,SAAAC,EAAW,EACZ,EAAGH,EACAI,EAEJA,EAAUH,EAAe,IAAI,CAACI,EAAOC,IAAUC,EAAqBF,EAAO,OAAOA,GAAU,SAAW,KAAOA,EAAM,MAAOC,IAAU,EAAI,UAAY,MAAS,CAAC,EAC/J,IAAIA,EAAQE,EAAWN,GAAuBE,EAAQ,OAAS,CAAgB,EAC3EK,EAASZ,EAAO,IAChBa,EAAW,KAEf,SAASF,EAAWG,EAAG,CACrB,OAAO,KAAK,IAAI,KAAK,IAAIA,EAAG,CAAC,EAAGP,EAAQ,OAAS,CAAC,CACnD,CAED,SAASQ,GAAqB,CAC5B,OAAOR,EAAQE,CAAK,CACrB,CAED,SAASC,EAAqBM,EAAIC,EAAOlB,EAAK,CACxCkB,IAAU,SACZA,EAAQ,MAGV,IAAIC,EAAWC,EAAeZ,EAAUQ,EAAoB,EAAC,SAAW,IAAKC,EAAIC,EAAOlB,CAAG,EAC3F,OAAAqB,GAAUF,EAAS,SAAS,OAAO,CAAC,IAAM,IAAK,2DAA6D,KAAK,UAAUF,CAAE,CAAC,EACvHE,CACR,CAsED,MApEc,CACZ,IAAI,OAAQ,CACV,OAAOT,CACR,EAED,IAAI,QAAS,CACX,OAAOG,CACR,EAED,IAAI,UAAW,CACb,OAAOG,EAAkB,CAC1B,EAED,WAAWC,EAAI,CACb,OAAO,OAAOA,GAAO,SAAWA,EAAKK,EAAWL,CAAE,CACnD,EAED,eAAeE,EAAU,CACvB,OAAOA,CACR,EAED,KAAKF,EAAIC,EAAO,CACdL,EAASZ,EAAO,KAChB,IAAIsB,EAAeZ,EAAqBM,EAAIC,CAAK,EACjDR,GAAS,EACTF,EAAQ,OAAOE,EAAOF,EAAQ,OAAQe,CAAY,EAE9ChB,GAAYO,GACdA,EAAS,CACP,OAAAD,EACA,SAAUU,CACpB,CAAS,CAEJ,EAED,QAAQN,EAAIC,EAAO,CACjBL,EAASZ,EAAO,QAChB,IAAIsB,EAAeZ,EAAqBM,EAAIC,CAAK,EACjDV,EAAQE,CAAK,EAAIa,EAEbhB,GAAYO,GACdA,EAAS,CACP,OAAAD,EACA,SAAUU,CACpB,CAAS,CAEJ,EAED,GAAGC,EAAO,CACRX,EAASZ,EAAO,IAChBS,EAAQE,EAAWF,EAAQc,CAAK,EAE5BV,GACFA,EAAS,CACP,OAAAD,EACA,SAAUG,EAAoB,CACxC,CAAS,CAEJ,EAED,OAAOS,EAAI,CACT,OAAAX,EAAWW,EACJ,IAAM,CACXX,EAAW,IACnB,CACK,CAEL,CAEA,CASA,SAASY,GAAqBtB,EAAS,CACjCA,IAAY,SACdA,EAAU,CAAA,GAGZ,SAASuB,EAAsBC,EAAQC,EAAe,CACpD,GAAI,CACF,SAAAC,EACA,OAAAC,EACA,KAAAC,CACN,EAAQJ,EAAO,SACX,OAAOR,EAAe,GAAI,CACxB,SAAAU,EACA,OAAAC,EACA,KAAAC,CACD,EACDH,EAAc,OAASA,EAAc,MAAM,KAAO,KAAMA,EAAc,OAASA,EAAc,MAAM,KAAO,SAAS,CACpH,CAED,SAASI,EAAkBL,EAAQX,EAAI,CACrC,OAAO,OAAOA,GAAO,SAAWA,EAAKK,EAAWL,CAAE,CACnD,CAED,OAAOiB,GAAmBP,EAAuBM,EAAmB,KAAM7B,CAAO,CACnF,CAUA,SAAS+B,GAAkB/B,EAAS,CAC9BA,IAAY,SACdA,EAAU,CAAA,GAGZ,SAASgC,EAAmBR,EAAQC,EAAe,CACjD,GAAI,CACF,SAAAC,EAAW,IACX,OAAAC,EAAS,GACT,KAAAC,EAAO,EACb,EAAQK,EAAUT,EAAO,SAAS,KAAK,OAAO,CAAC,CAAC,EAC5C,OAAOR,EAAe,GAAI,CACxB,SAAAU,EACA,OAAAC,EACA,KAAAC,CACD,EACDH,EAAc,OAASA,EAAc,MAAM,KAAO,KAAMA,EAAc,OAASA,EAAc,MAAM,KAAO,SAAS,CACpH,CAED,SAASS,EAAeV,EAAQX,EAAI,CAClC,IAAIsB,EAAOX,EAAO,SAAS,cAAc,MAAM,EAC3CY,EAAO,GAEX,GAAID,GAAQA,EAAK,aAAa,MAAM,EAAG,CACrC,IAAIE,EAAMb,EAAO,SAAS,KACtBc,EAAYD,EAAI,QAAQ,GAAG,EAC/BD,EAAOE,IAAc,GAAKD,EAAMA,EAAI,MAAM,EAAGC,CAAS,EAGxD,OAAOF,EAAO,KAAO,OAAOvB,GAAO,SAAWA,EAAKK,EAAWL,CAAE,EACjE,CAED,SAAS0B,EAAqBxB,EAAUF,EAAI,CAC1CI,GAAUF,EAAS,SAAS,OAAO,CAAC,IAAM,IAAK,6DAA+D,KAAK,UAAUF,CAAE,EAAI,GAAG,CACvI,CAED,OAAOiB,GAAmBE,EAAoBE,EAAgBK,EAAsBvC,CAAO,CAC7F,CAKA,SAASiB,GAAUuB,EAAMC,EAAS,CAChC,GAAI,CAACD,EAAM,CAEL,OAAO,QAAY,KAAa,QAAQ,KAAKC,CAAO,EAExD,GAAI,CAMF,MAAM,IAAI,MAAMA,CAAO,CAC7B,MAAM,CAAY,EAElB,CAEA,SAASC,IAAY,CACnB,OAAO,KAAK,OAAM,EAAG,SAAS,EAAE,EAAE,OAAO,EAAG,CAAC,CAC/C,CAMA,SAASC,GAAgB5B,EAAU,CACjC,MAAO,CACL,IAAKA,EAAS,MACd,IAAKA,EAAS,GAClB,CACA,CAMA,SAASC,EAAe4B,EAAS/B,EAAIC,EAAOlB,EAAK,CAC/C,OAAIkB,IAAU,SACZA,EAAQ,MAGKtB,EAAS,CACtB,SAAU,OAAOoD,GAAY,SAAWA,EAAUA,EAAQ,SAC1D,OAAQ,GACR,KAAM,EACV,EAAK,OAAO/B,GAAO,SAAWoB,EAAUpB,CAAE,EAAIA,EAAI,CAC9C,MAAAC,EAKA,IAAKD,GAAMA,EAAG,KAAOjB,GAAO8C,GAAW,CAC3C,CAAG,CAGH,CAKA,SAASxB,EAAW2B,EAAM,CACxB,GAAI,CACF,SAAAnB,EAAW,IACX,OAAAC,EAAS,GACT,KAAAC,EAAO,EACR,EAAGiB,EACJ,OAAIlB,GAAUA,IAAW,MAAKD,GAAYC,EAAO,OAAO,CAAC,IAAM,IAAMA,EAAS,IAAMA,GAChFC,GAAQA,IAAS,MAAKF,GAAYE,EAAK,OAAO,CAAC,IAAM,IAAMA,EAAO,IAAMA,GACrEF,CACT,CAKA,SAASO,EAAUa,EAAM,CACvB,IAAIC,EAAa,CAAA,EAEjB,GAAID,EAAM,CACR,IAAIR,EAAYQ,EAAK,QAAQ,GAAG,EAE5BR,GAAa,IACfS,EAAW,KAAOD,EAAK,OAAOR,CAAS,EACvCQ,EAAOA,EAAK,OAAO,EAAGR,CAAS,GAGjC,IAAIU,EAAcF,EAAK,QAAQ,GAAG,EAE9BE,GAAe,IACjBD,EAAW,OAASD,EAAK,OAAOE,CAAW,EAC3CF,EAAOA,EAAK,OAAO,EAAGE,CAAW,GAG/BF,IACFC,EAAW,SAAWD,GAI1B,OAAOC,CACT,CACA,SAASE,GAAUlC,EAAU,CAI3B,IAAIoB,EAAO,OAAO,OAAW,KAAe,OAAO,OAAO,SAAa,KAAe,OAAO,SAAS,SAAW,OAAS,OAAO,SAAS,OAAS,oBAC/IC,EAAO,OAAOrB,GAAa,SAAWA,EAAWG,EAAWH,CAAQ,EACxE,OAAO,IAAI,IAAIqB,EAAMD,CAAI,CAC3B,CAEA,SAASL,GAAmBoB,EAAaC,EAAYC,EAAkBpD,EAAS,CAC1EA,IAAY,SACdA,EAAU,CAAA,GAGZ,GAAI,CACF,OAAAwB,EAAS,SAAS,YAClB,SAAArB,EAAW,EACZ,EAAGH,EACAyB,EAAgBD,EAAO,QACvBf,EAASZ,EAAO,IAChBa,EAAW,KAEf,SAAS2C,GAAY,CACnB5C,EAASZ,EAAO,IAEZa,GACFA,EAAS,CACP,OAAAD,EACA,SAAU6C,EAAQ,QAC1B,CAAO,CAEJ,CAED,SAASC,EAAK1C,EAAIC,EAAO,CACvBL,EAASZ,EAAO,KAChB,IAAIkB,EAAWC,EAAesC,EAAQ,SAAUzC,EAAIC,CAAK,EACrDsC,GAAkBA,EAAiBrC,EAAUF,CAAE,EACnD,IAAI2C,EAAeb,GAAgB5B,CAAQ,EACvCsB,EAAMiB,EAAQ,WAAWvC,CAAQ,EAErC,GAAI,CACFU,EAAc,UAAU+B,EAAc,GAAInB,CAAG,CAC9C,MAAC,CAGAb,EAAO,SAAS,OAAOa,CAAG,CAC3B,CAEGlC,GAAYO,GACdA,EAAS,CACP,OAAAD,EACA,SAAU6C,EAAQ,QAC1B,CAAO,CAEJ,CAED,SAASG,EAAQ5C,EAAIC,EAAO,CAC1BL,EAASZ,EAAO,QAChB,IAAIkB,EAAWC,EAAesC,EAAQ,SAAUzC,EAAIC,CAAK,EACrDsC,GAAkBA,EAAiBrC,EAAUF,CAAE,EACnD,IAAI2C,EAAeb,GAAgB5B,CAAQ,EACvCsB,EAAMiB,EAAQ,WAAWvC,CAAQ,EACrCU,EAAc,aAAa+B,EAAc,GAAInB,CAAG,EAE5ClC,GAAYO,GACdA,EAAS,CACP,OAAAD,EACA,SAAU6C,EAAQ,QAC1B,CAAO,CAEJ,CAED,IAAIA,EAAU,CACZ,IAAI,QAAS,CACX,OAAO7C,CACR,EAED,IAAI,UAAW,CACb,OAAOyC,EAAY1B,EAAQC,CAAa,CACzC,EAED,OAAOJ,EAAI,CACT,GAAIX,EACF,MAAM,IAAI,MAAM,4CAA4C,EAG9D,OAAAc,EAAO,iBAAiB1B,GAAmBuD,CAAS,EACpD3C,EAAWW,EACJ,IAAM,CACXG,EAAO,oBAAoB1B,GAAmBuD,CAAS,EACvD3C,EAAW,IACnB,CACK,EAED,WAAWG,EAAI,CACb,OAAOsC,EAAW3B,EAAQX,CAAE,CAC7B,EAED,eAAeE,EAAU,CAEvB,IAAIsB,EAAMY,GAAU/B,EAAWH,CAAQ,CAAC,EACxC,OAAOvB,EAAS,CAAE,EAAEuB,EAAU,CAC5B,SAAUsB,EAAI,SACd,OAAQA,EAAI,OACZ,KAAMA,EAAI,IAClB,CAAO,CACF,EAED,KAAAkB,EACA,QAAAE,EAEA,GAAG9C,EAAG,CACJ,OAAOc,EAAc,GAAGd,CAAC,CAC1B,CAEL,EACE,OAAO2C,CACT,CAEA,IAAII,GAEH,SAAUA,EAAY,CACrBA,EAAW,KAAU,OACrBA,EAAW,SAAc,WACzBA,EAAW,SAAc,WACzBA,EAAW,MAAW,OACxB,GAAGA,IAAeA,EAAa,CAAE,EAAC,EAElC,SAASC,GAAaC,EAAO,CAC3B,OAAOA,EAAM,QAAU,EACzB,CAIA,SAASC,GAA0BC,EAAQC,EAAYC,EAAQ,CAC7D,OAAID,IAAe,SACjBA,EAAa,CAAA,GAGXC,IAAW,SACbA,EAAS,IAAI,KAGRF,EAAO,IAAI,CAACF,EAAOtD,IAAU,CAClC,IAAI2D,EAAW,CAAC,GAAGF,EAAYzD,CAAK,EAChC4D,EAAK,OAAON,EAAM,IAAO,SAAWA,EAAM,GAAKK,EAAS,KAAK,GAAG,EAKpE,OAJAE,EAAUP,EAAM,QAAU,IAAQ,CAACA,EAAM,SAAU,2CAA2C,EAC9FO,EAAU,CAACH,EAAO,IAAIE,CAAE,EAAG,qCAAwCA,EAAK,kEAAwE,EAChJF,EAAO,IAAIE,CAAE,EAETP,GAAaC,CAAK,EACHpE,EAAS,CAAE,EAAEoE,EAAO,CACnC,GAAAM,CACR,CAAO,EAIuB1E,EAAS,CAAE,EAAEoE,EAAO,CAC1C,GAAAM,EACA,SAAUN,EAAM,SAAWC,GAA0BD,EAAM,SAAUK,EAAUD,CAAM,EAAI,MACjG,CAAO,CAIP,CAAG,CACH,CAOA,SAASI,EAAYN,EAAQO,EAAaC,EAAU,CAC9CA,IAAa,SACfA,EAAW,KAGb,IAAIvD,EAAW,OAAOsD,GAAgB,SAAWpC,EAAUoC,CAAW,EAAIA,EACtE3C,EAAW6C,GAAcxD,EAAS,UAAY,IAAKuD,CAAQ,EAE/D,GAAI5C,GAAY,KACd,OAAO,KAGT,IAAI8C,EAAWC,GAAcX,CAAM,EACnCY,GAAkBF,CAAQ,EAC1B,IAAIG,EAAU,KAEd,QAASjF,EAAI,EAAGiF,GAAW,MAAQjF,EAAI8E,EAAS,OAAQ,EAAE9E,EACxDiF,EAAUC,GAAiBJ,EAAS9E,CAAC,EAMrCmF,GAAgBnD,CAAQ,CAAC,EAG3B,OAAOiD,CACT,CAEA,SAASF,GAAcX,EAAQU,EAAUM,EAAaf,EAAY,CAChE,OAAIS,IAAa,SACfA,EAAW,CAAA,GAGTM,IAAgB,SAClBA,EAAc,CAAA,GAGZf,IAAe,SACjBA,EAAa,IAGfD,EAAO,QAAQ,CAACF,EAAOtD,IAAU,CAC/B,IAAIyE,EAAO,CACT,aAAcnB,EAAM,MAAQ,GAC5B,cAAeA,EAAM,gBAAkB,GACvC,cAAetD,EACf,MAAAsD,CACN,EAEQmB,EAAK,aAAa,WAAW,GAAG,IAClCZ,EAAUY,EAAK,aAAa,WAAWhB,CAAU,EAAG,wBAA2BgB,EAAK,aAAe,wBAA2B,IAAOhB,EAAa,iDAAoD,6DAA6D,EACnQgB,EAAK,aAAeA,EAAK,aAAa,MAAMhB,EAAW,MAAM,GAG/D,IAAIjB,EAAOkC,GAAU,CAACjB,EAAYgB,EAAK,YAAY,CAAC,EAChDE,EAAaH,EAAY,OAAOC,CAAI,EAIpCnB,EAAM,UAAYA,EAAM,SAAS,OAAS,IAC5CO,EAEAP,EAAM,QAAU,GAAM,2DAA6D,qCAAwCd,EAAO,KAAM,EACxI2B,GAAcb,EAAM,SAAUY,EAAUS,EAAYnC,CAAI,GAKtD,EAAAc,EAAM,MAAQ,MAAQ,CAACA,EAAM,QAIjCY,EAAS,KAAK,CACZ,KAAA1B,EACA,MAAOoC,GAAapC,EAAMc,EAAM,KAAK,EACrC,WAAAqB,CACN,CAAK,CACL,CAAG,EACMT,CACT,CAEA,SAASE,GAAkBF,EAAU,CACnCA,EAAS,KAAK,CAACW,EAAGC,IAAMD,EAAE,QAAUC,EAAE,MAAQA,EAAE,MAAQD,EAAE,MACxDE,GAAeF,EAAE,WAAW,IAAIJ,GAAQA,EAAK,aAAa,EAAGK,EAAE,WAAW,IAAIL,GAAQA,EAAK,aAAa,CAAC,CAAC,CAC9G,CAEA,MAAMO,GAAU,SACVC,GAAsB,EACtBC,GAAkB,EAClBC,GAAoB,EACpBC,GAAqB,GACrBC,GAAe,GAEfC,GAAUC,GAAKA,IAAM,IAE3B,SAASX,GAAapC,EAAMxC,EAAO,CACjC,IAAIwF,EAAWhD,EAAK,MAAM,GAAG,EACzBiD,EAAeD,EAAS,OAE5B,OAAIA,EAAS,KAAKF,EAAO,IACvBG,GAAgBJ,IAGdrF,IACFyF,GAAgBP,IAGXM,EAAS,OAAOD,GAAK,CAACD,GAAQC,CAAC,CAAC,EAAE,OAAO,CAACG,EAAOC,IAAYD,GAASV,GAAQ,KAAKW,CAAO,EAAIV,GAAsBU,IAAY,GAAKR,GAAoBC,IAAqBK,CAAY,CACnM,CAEA,SAASV,GAAeF,EAAGC,EAAG,CAE5B,OADeD,EAAE,SAAWC,EAAE,QAAUD,EAAE,MAAM,EAAG,EAAE,EAAE,MAAM,CAACxE,EAAG,IAAMA,IAAMyE,EAAE,CAAC,CAAC,EAKjFD,EAAEA,EAAE,OAAS,CAAC,EAAIC,EAAEA,EAAE,OAAS,CAAC,EAEhC,CACF,CAEA,SAASR,GAAiBsB,EAAQxE,EAAU,CAC1C,GAAI,CACF,WAAAuD,CACD,EAAGiB,EACAC,EAAgB,CAAA,EAChBC,EAAkB,IAClBzB,EAAU,CAAA,EAEd,QAASjF,EAAI,EAAGA,EAAIuF,EAAW,OAAQ,EAAEvF,EAAG,CAC1C,IAAIqF,EAAOE,EAAWvF,CAAC,EACnB2G,EAAM3G,IAAMuF,EAAW,OAAS,EAChCqB,EAAoBF,IAAoB,IAAM1E,EAAWA,EAAS,MAAM0E,EAAgB,MAAM,GAAK,IACnGG,EAAQC,GAAU,CACpB,KAAMzB,EAAK,aACX,cAAeA,EAAK,cACpB,IAAAsB,CACD,EAAEC,CAAiB,EACpB,GAAI,CAACC,EAAO,OAAO,KACnB,OAAO,OAAOJ,EAAeI,EAAM,MAAM,EACzC,IAAI3C,EAAQmB,EAAK,MACjBJ,EAAQ,KAAK,CAEX,OAAQwB,EACR,SAAUnB,GAAU,CAACoB,EAAiBG,EAAM,QAAQ,CAAC,EACrD,aAAcE,GAAkBzB,GAAU,CAACoB,EAAiBG,EAAM,YAAY,CAAC,CAAC,EAChF,MAAA3C,CACN,CAAK,EAEG2C,EAAM,eAAiB,MACzBH,EAAkBpB,GAAU,CAACoB,EAAiBG,EAAM,YAAY,CAAC,GAIrE,OAAO5B,CACT,CAQA,SAAS+B,GAAa5D,EAAM6D,EAAQ,CAClC,OAAIA,IAAW,SACbA,EAAS,CAAA,GAGJ7D,EAAK,QAAQ,UAAW,CAAC8D,EAAGhH,KACjCuE,EAAUwC,EAAO/G,CAAG,GAAK,KAAM,aAAgBA,EAAM,SAAU,EACxD+G,EAAO/G,CAAG,EAClB,EAAE,QAAQ,UAAW,CAACgH,EAAGC,EAAQC,EAAIC,IAAQ,CAC5C,MAAMC,EAAO,IAEb,OAAIL,EAAOK,CAAI,GAAK,KAGXD,IAAQ,KAAO,IAAM,GAIvB,GAAKF,EAASF,EAAOK,CAAI,CACpC,CAAG,CACH,CAQA,SAASR,GAAUS,EAASvF,EAAU,CAChC,OAAOuF,GAAY,WACrBA,EAAU,CACR,KAAMA,EACN,cAAe,GACf,IAAK,EACX,GAGE,GAAI,CAACC,EAASC,CAAU,EAAIC,GAAYH,EAAQ,KAAMA,EAAQ,cAAeA,EAAQ,GAAG,EACpFV,EAAQ7E,EAAS,MAAMwF,CAAO,EAClC,GAAI,CAACX,EAAO,OAAO,KACnB,IAAIH,EAAkBG,EAAM,CAAC,EACzBc,EAAejB,EAAgB,QAAQ,UAAW,IAAI,EACtDkB,EAAgBf,EAAM,MAAM,CAAC,EAYjC,MAAO,CACL,OAZWY,EAAW,OAAO,CAACI,EAAMC,EAAWlH,IAAU,CAGzD,GAAIkH,IAAc,IAAK,CACrB,IAAIC,EAAaH,EAAchH,CAAK,GAAK,GACzC+G,EAAejB,EAAgB,MAAM,EAAGA,EAAgB,OAASqB,EAAW,MAAM,EAAE,QAAQ,UAAW,IAAI,EAG7G,OAAAF,EAAKC,CAAS,EAAIE,GAAyBJ,EAAchH,CAAK,GAAK,GAAIkH,CAAS,EACzED,CACR,EAAE,CAAE,CAAA,EAGH,SAAUnB,EACV,aAAAiB,EACA,QAAAJ,CACJ,CACA,CAEA,SAASG,GAAYtE,EAAM6E,EAAetB,EAAK,CACzCsB,IAAkB,SACpBA,EAAgB,IAGdtB,IAAQ,SACVA,EAAM,IAGRuB,GAAQ9E,IAAS,KAAO,CAACA,EAAK,SAAS,GAAG,GAAKA,EAAK,SAAS,IAAI,EAAG,eAAkBA,EAAO,oCAAuC,IAAOA,EAAK,QAAQ,MAAO,IAAI,EAAI,qCAAwC,oEAAsE,oCAAuCA,EAAK,QAAQ,MAAO,IAAI,EAAI,KAAM,EAC9V,IAAIqE,EAAa,CAAA,EACbU,EAAe,IAAM/E,EAAK,QAAQ,UAAW,EAAE,EAClD,QAAQ,OAAQ,GAAG,EACnB,QAAQ,sBAAuB,MAAM,EACrC,QAAQ,UAAW,CAAC8D,EAAGY,KACtBL,EAAW,KAAKK,CAAS,EAClB,YACR,EAED,OAAI1E,EAAK,SAAS,GAAG,GACnBqE,EAAW,KAAK,GAAG,EACnBU,GAAgB/E,IAAS,KAAOA,IAAS,KAAO,QAC9C,qBACOuD,EAETwB,GAAgB,QACP/E,IAAS,IAAMA,IAAS,MAQjC+E,GAAgB,iBAIX,CADO,IAAI,OAAOA,EAAcF,EAAgB,OAAY,GAAG,EACrDR,CAAU,CAC7B,CAEA,SAAStC,GAAgBiD,EAAO,CAC9B,GAAI,CACF,OAAO,UAAUA,CAAK,CACvB,OAAQC,EAAP,CACA,OAAAH,GAAQ,GAAO,iBAAoBE,EAAQ,2GAAmH,aAAeC,EAAQ,KAAK,EACnLD,CACR,CACH,CAEA,SAASJ,GAAyBI,EAAON,EAAW,CAClD,GAAI,CACF,OAAO,mBAAmBM,CAAK,CAChC,OAAQC,EAAP,CACA,OAAAH,GAAQ,GAAO,gCAAmCJ,EAAY,iCAAoC,gBAAmBM,EAAQ,mDAAsD,mCAAqCC,EAAQ,KAAK,EAC9ND,CACR,CACH,CAMA,SAASvD,GAAc7C,EAAU4C,EAAU,CACzC,GAAIA,IAAa,IAAK,OAAO5C,EAE7B,GAAI,CAACA,EAAS,YAAa,EAAC,WAAW4C,EAAS,YAAW,CAAE,EAC3D,OAAO,KAKT,IAAI0D,EAAa1D,EAAS,SAAS,GAAG,EAAIA,EAAS,OAAS,EAAIA,EAAS,OACrE2D,EAAWvG,EAAS,OAAOsG,CAAU,EAEzC,OAAIC,GAAYA,IAAa,IAEpB,KAGFvG,EAAS,MAAMsG,CAAU,GAAK,GACvC,CACA,SAAS7D,EAAU2D,EAAOrF,EAAS,CACjC,GAAIqF,IAAU,IAASA,IAAU,MAAQ,OAAOA,EAAU,IACxD,MAAM,IAAI,MAAMrF,CAAO,CAE3B,CAKA,SAASmF,GAAQpF,EAAMC,EAAS,CAC9B,GAAI,CAACD,EAAM,CAEL,OAAO,QAAY,KAAa,QAAQ,KAAKC,CAAO,EAExD,GAAI,CAMF,MAAM,IAAI,MAAMA,CAAO,CAC7B,MAAM,CAAY,EAElB,CAOA,SAASyF,GAAYrH,EAAIsH,EAAc,CACjCA,IAAiB,SACnBA,EAAe,KAGjB,GAAI,CACF,SAAUC,EACV,OAAAzG,EAAS,GACT,KAAAC,EAAO,EACX,EAAM,OAAOf,GAAO,SAAWoB,EAAUpB,CAAE,EAAIA,EAE7C,MAAO,CACL,SAFauH,EAAaA,EAAW,WAAW,GAAG,EAAIA,EAAaC,GAAgBD,EAAYD,CAAY,EAAIA,EAGhH,OAAQG,GAAgB3G,CAAM,EAC9B,KAAM4G,GAAc3G,CAAI,CAC5B,CACA,CAEA,SAASyG,GAAgBG,EAAcL,EAAc,CACnD,IAAIrC,EAAWqC,EAAa,QAAQ,OAAQ,EAAE,EAAE,MAAM,GAAG,EAEzD,OADuBK,EAAa,MAAM,GAAG,EAC5B,QAAQvC,GAAW,CAC9BA,IAAY,KAEVH,EAAS,OAAS,GAAGA,EAAS,IAAG,EAC5BG,IAAY,KACrBH,EAAS,KAAKG,CAAO,CAE3B,CAAG,EACMH,EAAS,OAAS,EAAIA,EAAS,KAAK,GAAG,EAAI,GACpD,CAEA,SAAS2C,GAAoBC,EAAMC,EAAOC,EAAM9F,EAAM,CACpD,MAAO,qBAAuB4F,EAAO,wCAA0C,OAASC,EAAQ,YAAc,KAAK,UAAU7F,CAAI,EAAI,uCAAyC,OAAS8F,EAAO,4DAA8D,mEAC9P,CA0BA,SAASC,GAA2BlE,EAAS,CAC3C,OAAOA,EAAQ,OAAO,CAAC4B,EAAOjG,IAAUA,IAAU,GAAKiG,EAAM,MAAM,MAAQA,EAAM,MAAM,KAAK,OAAS,CAAC,CACxG,CAKA,SAASuC,GAAUC,EAAOC,EAAgBC,EAAkBC,EAAgB,CACtEA,IAAmB,SACrBA,EAAiB,IAGnB,IAAIrI,EAEA,OAAOkI,GAAU,SACnBlI,EAAKoB,EAAU8G,CAAK,GAEpBlI,EAAKrB,EAAS,GAAIuJ,CAAK,EACvB5E,EAAU,CAACtD,EAAG,UAAY,CAACA,EAAG,SAAS,SAAS,GAAG,EAAG4H,GAAoB,IAAK,WAAY,SAAU5H,CAAE,CAAC,EACxGsD,EAAU,CAACtD,EAAG,UAAY,CAACA,EAAG,SAAS,SAAS,GAAG,EAAG4H,GAAoB,IAAK,WAAY,OAAQ5H,CAAE,CAAC,EACtGsD,EAAU,CAACtD,EAAG,QAAU,CAACA,EAAG,OAAO,SAAS,GAAG,EAAG4H,GAAoB,IAAK,SAAU,OAAQ5H,CAAE,CAAC,GAGlG,IAAIsI,EAAcJ,IAAU,IAAMlI,EAAG,WAAa,GAC9CuH,EAAae,EAAc,IAAMtI,EAAG,SACpCuI,EAUJ,GAAIF,GAAkBd,GAAc,KAClCgB,EAAOH,MACF,CACL,IAAII,EAAqBL,EAAe,OAAS,EAEjD,GAAIZ,EAAW,WAAW,IAAI,EAAG,CAC/B,IAAIkB,EAAalB,EAAW,MAAM,GAAG,EAIrC,KAAOkB,EAAW,CAAC,IAAM,MACvBA,EAAW,MAAK,EAChBD,GAAsB,EAGxBxI,EAAG,SAAWyI,EAAW,KAAK,GAAG,EAKnCF,EAAOC,GAAsB,EAAIL,EAAeK,CAAkB,EAAI,IAGxE,IAAIvG,EAAOoF,GAAYrH,EAAIuI,CAAI,EAE3BG,EAA2BnB,GAAcA,IAAe,KAAOA,EAAW,SAAS,GAAG,EAEtFoB,GAA2BL,GAAef,IAAe,MAAQa,EAAiB,SAAS,GAAG,EAElG,MAAI,CAACnG,EAAK,SAAS,SAAS,GAAG,IAAMyG,GAA4BC,KAC/D1G,EAAK,UAAY,KAGZA,CACT,CAKA,SAAS2G,GAAc5I,EAAI,CAEzB,OAAOA,IAAO,IAAMA,EAAG,WAAa,GAAK,IAAM,OAAOA,GAAO,SAAWoB,EAAUpB,CAAE,EAAE,SAAWA,EAAG,QACtG,CAKK,MAACmE,GAAY0E,GAASA,EAAM,KAAK,GAAG,EAAE,QAAQ,SAAU,GAAG,EAK1DjD,GAAoB/E,GAAYA,EAAS,QAAQ,OAAQ,EAAE,EAAE,QAAQ,OAAQ,GAAG,EAKhF4G,GAAkB3G,GAAU,CAACA,GAAUA,IAAW,IAAM,GAAKA,EAAO,WAAW,GAAG,EAAIA,EAAS,IAAMA,EAKrG4G,GAAgB3G,GAAQ,CAACA,GAAQA,IAAS,IAAM,GAAKA,EAAK,WAAW,GAAG,EAAIA,EAAO,IAAMA,EAMzF+H,GAAO,SAAcC,EAAMC,EAAM,CACjCA,IAAS,SACXA,EAAO,CAAA,GAGT,IAAIC,EAAe,OAAOD,GAAS,SAAW,CAC5C,OAAQA,CACT,EAAGA,EACAE,EAAU,IAAI,QAAQD,EAAa,OAAO,EAE9C,OAAKC,EAAQ,IAAI,cAAc,GAC7BA,EAAQ,IAAI,eAAgB,iCAAiC,EAGxD,IAAI,SAAS,KAAK,UAAUH,CAAI,EAAGpK,EAAS,CAAE,EAAEsK,EAAc,CACnE,QAAAC,CACD,CAAA,CAAC,CACJ,EACA,MAAMC,WAA6B,KAAM,CAAE,CAC3C,MAAMC,EAAa,CACjB,YAAYL,EAAM,CAChB,KAAK,YAAc,IAAI,IACvB,KAAK,WAAa,OAClBzF,EAAUyF,GAAQ,OAAOA,GAAS,UAAY,CAAC,MAAM,QAAQA,CAAI,EAAG,oCAAoC,EAGxG,IAAIM,EACJ,KAAK,aAAe,IAAI,QAAQ,CAACtD,EAAGuD,IAAMD,EAASC,CAAC,EACpD,KAAK,WAAa,IAAI,gBAEtB,IAAIC,EAAU,IAAMF,EAAO,IAAIF,GAAqB,uBAAuB,CAAC,EAE5E,KAAK,oBAAsB,IAAM,KAAK,WAAW,OAAO,oBAAoB,QAASI,CAAO,EAE5F,KAAK,WAAW,OAAO,iBAAiB,QAASA,CAAO,EACxD,KAAK,KAAO,OAAO,QAAQR,CAAI,EAAE,OAAO,CAACS,EAAKxH,IAAS,CACrD,GAAI,CAACjD,EAAKkI,CAAK,EAAIjF,EACnB,OAAO,OAAO,OAAOwH,EAAK,CACxB,CAACzK,CAAG,EAAG,KAAK,aAAaA,EAAKkI,CAAK,CAC3C,CAAO,CACF,EAAE,CAAE,CAAA,CACN,CAED,aAAalI,EAAKkI,EAAO,CACvB,GAAI,EAAEA,aAAiB,SACrB,OAAOA,EAGT,KAAK,YAAY,IAAIlI,CAAG,EAGxB,IAAI0K,EAAU,QAAQ,KAAK,CAACxC,EAAO,KAAK,YAAY,CAAC,EAAE,KAAK8B,GAAQ,KAAK,SAASU,EAAS1K,EAAK,KAAMgK,CAAI,EAAG7B,GAAS,KAAK,SAASuC,EAAS1K,EAAKmI,CAAK,CAAC,EAGxJ,OAAAuC,EAAQ,MAAM,IAAM,CAAA,CAAE,EACtB,OAAO,eAAeA,EAAS,WAAY,CACzC,IAAK,IAAM,EACjB,CAAK,EACMA,CACR,CAED,SAASA,EAAS1K,EAAKmI,EAAO6B,EAAM,CAClC,GAAI,KAAK,WAAW,OAAO,SAAW7B,aAAiBiC,GACrD,YAAK,oBAAmB,EACxB,OAAO,eAAeM,EAAS,SAAU,CACvC,IAAK,IAAMvC,CACnB,CAAO,EACM,QAAQ,OAAOA,CAAK,EAG7B,KAAK,YAAY,OAAOnI,CAAG,EAEvB,KAAK,MAEP,KAAK,oBAAmB,EAG1B,MAAM2K,EAAa,KAAK,WAExB,OAAIxC,GACF,OAAO,eAAeuC,EAAS,SAAU,CACvC,IAAK,IAAMvC,CACnB,CAAO,EACDwC,GAAcA,EAAW,EAAK,EACvB,QAAQ,OAAOxC,CAAK,IAG7B,OAAO,eAAeuC,EAAS,QAAS,CACtC,IAAK,IAAMV,CACjB,CAAK,EACDW,GAAcA,EAAW,EAAK,EACvBX,EACR,CAED,UAAUvI,EAAI,CACZ,KAAK,WAAaA,CACnB,CAED,QAAS,CACP,KAAK,WAAW,QAChB,KAAK,YAAY,QAAQ,CAACmJ,EAAGC,IAAM,KAAK,YAAY,OAAOA,CAAC,CAAC,EAC7D,IAAIF,EAAa,KAAK,WACtBA,GAAcA,EAAW,EAAI,CAC9B,CAED,MAAM,YAAYG,EAAQ,CACxB,IAAIC,EAAU,GAEd,GAAI,CAAC,KAAK,KAAM,CACd,IAAIP,EAAU,IAAM,KAAK,SAEzBM,EAAO,iBAAiB,QAASN,CAAO,EACxCO,EAAU,MAAM,IAAI,QAAQC,GAAW,CACrC,KAAK,UAAUD,GAAW,CACxBD,EAAO,oBAAoB,QAASN,CAAO,GAEvCO,GAAW,KAAK,OAClBC,EAAQD,CAAO,CAE3B,CAAS,CACT,CAAO,EAGH,OAAOA,CACR,CAED,IAAI,MAAO,CACT,OAAO,KAAK,YAAY,OAAS,CAClC,CAED,IAAI,eAAgB,CAClB,OAAAxG,EAAU,KAAK,OAAS,MAAQ,KAAK,KAAM,2DAA2D,EAC/F,OAAO,QAAQ,KAAK,IAAI,EAAE,OAAO,CAACkG,EAAKQ,IAAU,CACtD,GAAI,CAACjL,EAAKkI,CAAK,EAAI+C,EACnB,OAAO,OAAO,OAAOR,EAAK,CACxB,CAACzK,CAAG,EAAGkL,GAAqBhD,CAAK,CACzC,CAAO,CACF,EAAE,CAAE,CAAA,CACN,CAEH,CAEA,SAASiD,GAAiBjD,EAAO,CAC/B,OAAOA,aAAiB,SAAWA,EAAM,WAAa,EACxD,CAEA,SAASgD,GAAqBhD,EAAO,CACnC,GAAI,CAACiD,GAAiBjD,CAAK,EACzB,OAAOA,EAGT,GAAIA,EAAM,OACR,MAAMA,EAAM,OAGd,OAAOA,EAAM,KACf,CAEA,SAASkD,GAAMpB,EAAM,CACnB,OAAO,IAAIK,GAAaL,CAAI,CAC9B,CAMK,MAACqB,GAAW,SAAkB5I,EAAKwH,EAAM,CACxCA,IAAS,SACXA,EAAO,KAGT,IAAIC,EAAeD,EAEf,OAAOC,GAAiB,SAC1BA,EAAe,CACb,OAAQA,CACd,EACa,OAAOA,EAAa,OAAW,MACxCA,EAAa,OAAS,KAGxB,IAAIC,EAAU,IAAI,QAAQD,EAAa,OAAO,EAC9C,OAAAC,EAAQ,IAAI,WAAY1H,CAAG,EACpB,IAAI,SAAS,KAAM7C,EAAS,CAAA,EAAIsK,EAAc,CACnD,QAAAC,CACD,CAAA,CAAC,CACJ,EAMA,MAAMmB,CAAc,CAClB,YAAYC,EAAQC,EAAYxB,EAAM,CACpC,KAAK,OAASuB,EACd,KAAK,WAAaC,GAAc,GAChC,KAAK,KAAOxB,CACb,CAEH,CAMA,SAASyB,GAAqB,EAAG,CAC/B,OAAO,aAAaH,CACtB,CAEK,MAACI,GAAkB,CACtB,MAAO,OACP,SAAU,OACV,WAAY,OACZ,WAAY,OACZ,YAAa,OACb,SAAU,MACZ,EACMC,GAAe,CACnB,MAAO,OACP,KAAM,OACN,WAAY,OACZ,WAAY,OACZ,YAAa,OACb,SAAU,MACZ,EACMC,GAAY,OAAO,OAAW,KAAe,OAAO,OAAO,SAAa,KAAe,OAAO,OAAO,SAAS,cAAkB,IAChIC,GAAW,CAACD,GASlB,SAASE,GAAa7B,EAAM,CAC1B1F,EAAU0F,EAAK,OAAO,OAAS,EAAG,2DAA2D,EAC7F,IAAI8B,EAAa9H,GAA0BgG,EAAK,MAAM,EAElD+B,EAAkB,KAElBC,EAAc,IAAI,IAElBC,EAAuB,KAEvBC,EAA0B,KAE1BC,EAAoB,KAKpBC,EAAwB,GACxBC,EAAiB9H,EAAYuH,EAAY9B,EAAK,QAAQ,SAAUA,EAAK,QAAQ,EAC7EsC,EAAgB,KAEpB,GAAID,GAAkB,KAAM,CAG1B,GAAI,CACF,QAAAvH,EACA,MAAAf,EACA,MAAAmE,CACN,EAAQqE,GAAmBT,CAAU,EACjCO,EAAiBvH,EACjBwH,EAAgB,CACd,CAACvI,EAAM,EAAE,EAAGmE,CAClB,EAGE,IAAIsE,EAAc,CAACH,EAAe,KAAKI,GAAKA,EAAE,MAAM,MAAM,GAAKzC,EAAK,eAAiB,KACjF0C,EACAzL,EAAQ,CACV,cAAe+I,EAAK,QAAQ,OAC5B,SAAUA,EAAK,QAAQ,SACvB,QAASqC,EACT,YAAAG,EACA,WAAYf,GACZ,sBAAuB,KACvB,mBAAoB,GACpB,aAAc,OACd,WAAYzB,EAAK,eAAiBA,EAAK,cAAc,YAAc,CAAE,EACrE,WAAYA,EAAK,eAAiBA,EAAK,cAAc,YAAc,KACnE,OAAQA,EAAK,eAAiBA,EAAK,cAAc,QAAUsC,EAC3D,SAAU,IAAI,GAClB,EAGMK,EAAgB3M,EAAO,IAGvB4M,EAA4B,GAE5BC,EAGAC,EAA8B,GAK9BC,EAAyB,GAGzBC,EAA0B,CAAA,EAG1BC,EAAwB,CAAA,EAExBC,EAAmB,IAAI,IAEvBC,GAAqB,EAIrBC,GAA0B,GAE1BC,GAAiB,IAAI,IAErBC,GAAmB,IAAI,IAEvBC,GAAmB,IAAI,IAKvBC,EAAkB,IAAI,IAI1B,SAASC,IAAa,CAGpB,OAAA1B,EAAkB/B,EAAK,QAAQ,OAAOhH,GAAQ,CAC5C,GAAI,CACF,OAAQ0K,EACR,SAAAxM,CACD,EAAG8B,EACJ,OAAO2K,GAAgBD,EAAexM,CAAQ,CACpD,CAAK,EAEID,EAAM,aACT0M,GAAgB3N,EAAO,IAAKiB,EAAM,QAAQ,EAGrCyL,CACR,CAGD,SAASkB,IAAU,CACb7B,GACFA,IAGFC,EAAY,MAAK,EACjBa,GAA+BA,EAA4B,QAC3D5L,EAAM,SAAS,QAAQ,CAAC8F,EAAGhH,IAAQ8N,GAAc9N,CAAG,CAAC,CACtD,CAGD,SAAS+N,GAAUtM,EAAI,CACrB,OAAAwK,EAAY,IAAIxK,CAAE,EACX,IAAMwK,EAAY,OAAOxK,CAAE,CACnC,CAGD,SAASuM,EAAYC,EAAU,CAC7B/M,EAAQtB,EAAS,CAAA,EAAIsB,EAAO+M,CAAQ,EACpChC,EAAY,QAAQtB,GAAcA,EAAWzJ,CAAK,CAAC,CACpD,CAOD,SAASgN,GAAmB/M,EAAU8M,EAAU,CAC9C,IAAIE,EAUJ,IAAIC,EAAiBlN,EAAM,YAAc,MAAQA,EAAM,WAAW,YAAc,MAAQA,EAAM,WAAW,QAAU,aAAeiN,EAAwBjN,EAAM,WAAW,aAAe,KAAO,OAASiN,EAAsB,MAAM,GAAG,EAAE,CAAC,KAAOhN,EAAS,SAExPkN,EAAgBJ,EAAS,WAAa,CACxC,WAAYK,GAAgBpN,EAAM,WAAY+M,EAAS,WAAYA,EAAS,SAAW,EAAE,CAC1F,EAAG,GACJD,EAAYpO,EAAS,GAAIwO,EAAiB,CAAA,EAAK,CAC7C,WAAY,IAClB,EAAOH,EAAUI,EAAe,CAC1B,cAAezB,EACf,SAAAzL,EACA,YAAa,GACb,WAAYuK,GACZ,aAAc,OAEd,sBAAuBxK,EAAM,WAAW,SAAW,GAAQqN,GAAuBpN,EAAU8M,EAAS,SAAW/M,EAAM,OAAO,EAC7H,mBAAoB2L,CACrB,CAAA,CAAC,EAEEE,GAAwCH,IAAkB3M,EAAO,MAAgB2M,IAAkB3M,EAAO,KAC5GgK,EAAK,QAAQ,KAAK9I,EAAUA,EAAS,KAAK,EACjCyL,IAAkB3M,EAAO,SAClCgK,EAAK,QAAQ,QAAQ9I,EAAUA,EAAS,KAAK,GAI/CyL,EAAgB3M,EAAO,IACvB4M,EAA4B,GAC5BE,EAA8B,GAC9BC,EAAyB,GACzBC,EAA0B,CAAA,EAC1BC,EAAwB,CAAA,CACzB,CAID,eAAesB,GAASvN,EAAIwN,EAAM,CAChC,GAAI,OAAOxN,GAAO,SAAU,CAC1BgJ,EAAK,QAAQ,GAAGhJ,CAAE,EAClB,OAGF,GAAI,CACF,KAAAiC,EACA,WAAAwL,EACA,MAAAvG,CACN,EAAQwG,GAAyB1N,EAAIwN,CAAI,EACjCtN,EAAWC,EAAeF,EAAM,SAAUgC,EAAMuL,GAAQA,EAAK,KAAK,EAMtEtN,EAAW8I,EAAK,QAAQ,eAAe9I,CAAQ,EAC/C,IAAIwM,GAAiBc,GAAQA,EAAK,WAAa,IAAQC,GAAc,KAAOzO,EAAO,QAAUA,EAAO,KAChG2O,EAAqBH,GAAQ,uBAAwBA,EAAOA,EAAK,qBAAuB,GAAO,OACnG,OAAO,MAAMb,GAAgBD,EAAexM,EAAU,CACpD,WAAAuN,EAGA,aAAcvG,EACd,mBAAAyG,EACA,QAASH,GAAQA,EAAK,OAC5B,CAAK,CACF,CAKD,SAASI,IAAa,CAOpB,GANAC,KACAd,EAAY,CACV,aAAc,SACpB,CAAK,EAGG9M,EAAM,WAAW,QAAU,aAO/B,IAAIA,EAAM,WAAW,QAAU,OAAQ,CACrC0M,GAAgB1M,EAAM,cAAeA,EAAM,SAAU,CACnD,+BAAgC,EACxC,CAAO,EACD,OAMF0M,GAAgBhB,GAAiB1L,EAAM,cAAeA,EAAM,WAAW,SAAU,CAC/E,mBAAoBA,EAAM,UAChC,CAAK,EACF,CAKD,eAAe0M,GAAgBD,EAAexM,EAAUsN,EAAM,CAI5D3B,GAA+BA,EAA4B,QAC3DA,EAA8B,KAC9BF,EAAgBe,EAChBZ,GAA+B0B,GAAQA,EAAK,kCAAoC,GAGhFM,GAAmB7N,EAAM,SAAUA,EAAM,OAAO,EAChD2L,GAA6B4B,GAAQA,EAAK,sBAAwB,GAClE,IAAIO,EAAoBP,GAAQA,EAAK,mBACjC1J,EAAUP,EAAYuH,EAAY5K,EAAU8I,EAAK,QAAQ,EAE7D,GAAI,CAAClF,EAAS,CACZ,GAAI,CACF,QAASkK,EACT,MAAAjL,GACA,MAAAmE,CACR,EAAUqE,GAAmBT,CAAU,EAEjCmD,KACAhB,GAAmB/M,EAAU,CAC3B,QAAS8N,EACT,WAAY,CAAE,EACd,OAAQ,CACN,CAACjL,GAAM,EAAE,EAAGmE,CACb,CACT,CAAO,EACD,OAIF,GAAIgH,GAAiBjO,EAAM,SAAUC,CAAQ,EAAG,CAC9C+M,GAAmB/M,EAAU,CAC3B,QAAA4D,CACR,CAAO,EACD,OAIF+H,EAA8B,IAAI,gBAClC,IAAIsC,EAAUC,GAAclO,EAAU2L,EAA4B,OAAQ2B,GAAQA,EAAK,UAAU,EAC7Fa,EACAC,EAEJ,GAAId,GAAQA,EAAK,aAKfc,EAAe,CACb,CAACC,EAAoBzK,CAAO,EAAE,MAAM,EAAE,EAAG0J,EAAK,YACtD,UACeA,GAAQA,EAAK,WAAY,CAElC,IAAIgB,EAAe,MAAMC,GAAaN,EAASjO,EAAUsN,EAAK,WAAY1J,EAAS,CACjF,QAAS0J,EAAK,OACtB,CAAO,EAED,GAAIgB,EAAa,eACf,OAGFH,EAAoBG,EAAa,kBACjCF,EAAeE,EAAa,mBAO5BT,EALiBpP,EAAS,CACxB,MAAO,UACP,SAAAuB,CACR,EAASsN,EAAK,UAAU,EAMpB,GAAI,CACF,eAAAkB,EACA,WAAAC,EACA,OAAAC,CACN,EAAQ,MAAMC,GAAcV,EAASjO,EAAU4D,EAASiK,EAAmBP,GAAQA,EAAK,WAAYA,GAAQA,EAAK,QAASa,EAAmBC,CAAY,EAEjJI,IAOJ7C,EAA8B,KAC9BoB,GAAmB/M,EAAU,CAC3B,QAAA4D,EACA,WAAA6K,EACA,OAAAC,CACN,CAAK,EACF,CAID,eAAeH,GAAaN,EAASjO,EAAUuN,EAAY3J,EAAS0J,EAAM,CACxEK,KAEA,IAAIiB,EAAanQ,EAAS,CACxB,MAAO,aACP,SAAAuB,CACD,EAAEuN,CAAU,EAEbV,EAAY,CACV,WAAA+B,CACN,CAAK,EAED,IAAIC,EACAC,EAAcC,GAAenL,EAAS5D,CAAQ,EAElD,GAAI,CAAC8O,EAAY,MAAM,OACrBD,EAASG,GAA0BhP,CAAQ,UAE3C6O,EAAS,MAAMI,EAAmB,SAAUhB,EAASa,EAAalL,EAAS4H,EAAO,QAAQ,EAEtFyC,EAAQ,OAAO,QACjB,MAAO,CACL,eAAgB,EAC1B,EAII,GAAIiB,GAAiBL,CAAM,EAAG,CAC5B,IAAIM,EAAqB1Q,EAAS,CAChC,MAAO,UACP,SAAUwB,EAAeF,EAAM,SAAU8O,EAAO,QAAQ,CACzD,EAAEtB,CAAU,EAEb,aAAM6B,GAAwBP,EAAQM,EAAoB7B,GAAQA,EAAK,OAAO,EACvE,CACL,eAAgB,EACxB,EAGI,GAAI+B,EAAcR,CAAM,EAAG,CAGzB,IAAIS,EAAgBjB,EAAoBzK,EAASkL,EAAY,MAAM,EAAE,EAKrE,OAAKxB,GAAQA,EAAK,WAAa,KAC7B7B,EAAgB3M,EAAO,MAGlB,CACL,mBAAoB,CAClB,CAACwQ,EAAc,MAAM,EAAE,EAAGT,EAAO,KAClC,CACT,EAGI,GAAIU,EAAiBV,CAAM,EACzB,MAAM,IAAI,MAAM,qCAAqC,EAGvD,MAAO,CACL,kBAAmB,CACjB,CAACC,EAAY,MAAM,EAAE,EAAGD,EAAO,IAChC,CACP,CACG,CAID,eAAeF,GAAcV,EAASjO,EAAU4D,EAAS4L,EAAoBjC,EAAY7K,EAASyL,EAAmBC,EAAc,CAEjI,IAAIP,EAAoB2B,EAEnB3B,IASHA,EARiB,CACf,MAAO,UACP,SAAA7N,EACA,WAAY,OACZ,WAAY,OACZ,YAAa,OACb,SAAU,MAClB,GAII,GAAI,CAACyP,EAAeC,CAAoB,EAAIC,GAAiB5P,EAAO6D,EAAS2J,EAAYvN,EAAU6L,EAAwBC,EAAyBC,EAAuBoC,EAAmBC,EAAc/B,EAAgB,EAM5N,GAFA0B,GAAsB6B,GAAW,EAAEhM,GAAWA,EAAQ,KAAK2H,GAAKA,EAAE,MAAM,KAAOqE,CAAO,IAAMH,GAAiBA,EAAc,KAAKlE,GAAKA,EAAE,MAAM,KAAOqE,CAAO,CAAC,EAExJH,EAAc,SAAW,GAAKC,EAAqB,SAAW,EAChE,OAAA3C,GAAmB/M,EAAU,CAC3B,QAAA4D,EACA,WAAYuJ,GAAgBpN,EAAM,WAAY,CAAA,EAAI6D,CAAO,EAEzD,OAAQwK,GAAgB,KACxB,WAAYD,GAAqB,IACzC,CAAO,EACM,CACL,eAAgB,EACxB,EAOSvC,IACH8D,EAAqB,QAAQ5F,GAAS,CACpC,GAAI,CAACjL,CAAG,EAAIiL,EACR+F,GAAU9P,EAAM,SAAS,IAAIlB,CAAG,EAChCiR,GAAsB,CACxB,MAAO,UACP,KAAMD,IAAWA,GAAQ,KACzB,WAAY,OACZ,WAAY,OACZ,YAAa,OACb,SAAU,MACpB,EACQ9P,EAAM,SAAS,IAAIlB,EAAKiR,EAAmB,CACnD,CAAO,EACDjD,EAAYpO,EAAS,CACnB,WAAYoP,EACZ,WAAYM,GAAqBpO,EAAM,YAAc,IAC7D,EAAS2P,EAAqB,OAAS,EAAI,CACnC,SAAU,IAAI,IAAI3P,EAAM,QAAQ,CACxC,EAAU,CAAA,CAAE,CAAC,GAGTmM,GAA0B,EAAED,GAC5ByD,EAAqB,QAAQK,GAAS,CACpC,GAAI,CAAClR,CAAG,EAAIkR,EACZ,OAAO/D,EAAiB,IAAInN,EAAK8M,CAA2B,CAClE,CAAK,EACD,GAAI,CACF,QAAAqE,EACA,cAAAC,GACA,eAAAC,CACN,EAAQ,MAAMC,GAA+BpQ,EAAM,QAAS6D,EAAS6L,EAAeC,EAAsBzB,CAAO,EAE7G,GAAIA,EAAQ,OAAO,QACjB,MAAO,CACL,eAAgB,EACxB,EAMIyB,EAAqB,QAAQU,GAAS,CACpC,GAAI,CAACvR,CAAG,EAAIuR,EACZ,OAAOpE,EAAiB,OAAOnN,CAAG,CACxC,CAAK,EAED,IAAIqL,EAAWmG,GAAaL,CAAO,EAEnC,GAAI9F,EAAU,CACZ,IAAIiF,EAAqBmB,GAAkBvQ,EAAOmK,CAAQ,EAC1D,aAAMkF,GAAwBlF,EAAUiF,EAAoBzM,CAAO,EAC5D,CACL,eAAgB,EACxB,EAII,GAAI,CACF,WAAA+L,GACA,OAAAC,EACN,EAAQ6B,GAAkBxQ,EAAO6D,EAAS6L,EAAeQ,GAAe7B,EAAcsB,EAAsBQ,EAAgB5D,CAAe,EAEvIA,EAAgB,QAAQ,CAACkE,EAAcZ,IAAY,CACjDY,EAAa,UAAU5G,IAAW,EAI5BA,IAAW4G,EAAa,OAC1BlE,EAAgB,OAAOsD,CAAO,CAExC,CAAO,CACP,CAAK,EACDa,KACA,IAAIC,GAAqBC,GAAqBzE,EAAuB,EACrE,OAAOzN,EAAS,CACd,WAAAgQ,GACA,OAAAC,EACD,EAAEgC,IAAsBhB,EAAqB,OAAS,EAAI,CACzD,SAAU,IAAI,IAAI3P,EAAM,QAAQ,CACjC,EAAG,CAAE,CAAA,CACP,CAED,SAAS6Q,GAAW/R,EAAK,CACvB,OAAOkB,EAAM,SAAS,IAAIlB,CAAG,GAAK2L,EACnC,CAGD,SAASqG,GAAMhS,EAAK+Q,EAASvO,EAAMiM,EAAM,CACvC,GAAI5C,GACF,MAAM,IAAI,MAAM,kMAA4M,EAG1NsB,EAAiB,IAAInN,CAAG,GAAGiS,GAAajS,CAAG,EAC/C,IAAI+E,EAAUP,EAAYuH,EAAYvJ,EAAMyH,EAAK,QAAQ,EAEzD,GAAI,CAAClF,EAAS,CACZmN,GAAgBlS,EAAK+Q,EAAS,IAAIzF,EAAc,IAAK,YAAa,IAAI,CAAC,EACvE,OAGF,GAAI,CACF,KAAApI,EACA,WAAAwL,CACD,EAAGC,GAAyBnM,EAAMiM,EAAM,EAAI,EACzC9H,EAAQuJ,GAAenL,EAAS7B,CAAI,EAExC,GAAIwL,EAAY,CACdyD,GAAoBnS,EAAK+Q,EAAS7N,EAAMyD,EAAO5B,EAAS2J,CAAU,EAClE,OAKFlB,GAAiB,IAAIxN,EAAK,CAACkD,EAAMyD,EAAO5B,CAAO,CAAC,EAChDqN,GAAoBpS,EAAK+Q,EAAS7N,EAAMyD,EAAO5B,CAAO,CACvD,CAID,eAAeoN,GAAoBnS,EAAK+Q,EAAS7N,EAAMyD,EAAO0L,EAAgB3D,EAAY,CAIxF,GAHAI,KACAtB,GAAiB,OAAOxN,CAAG,EAEvB,CAAC2G,EAAM,MAAM,OAAQ,CACvB,GAAI,CACF,MAAAwB,CACR,EAAUgI,GAA0BjN,CAAI,EAClCgP,GAAgBlS,EAAK+Q,EAAS5I,CAAK,EACnC,OAIF,IAAImK,EAAkBpR,EAAM,SAAS,IAAIlB,CAAG,EAExCgR,EAAUpR,EAAS,CACrB,MAAO,YACR,EAAE8O,EAAY,CACb,KAAM4D,GAAmBA,EAAgB,IAC/C,CAAK,EAEDpR,EAAM,SAAS,IAAIlB,EAAKgR,CAAO,EAC/BhD,EAAY,CACV,SAAU,IAAI,IAAI9M,EAAM,QAAQ,CACtC,CAAK,EAED,IAAIqR,EAAkB,IAAI,gBACtBC,EAAenD,GAAcnM,EAAMqP,EAAgB,OAAQ7D,CAAU,EACzEvB,EAAiB,IAAInN,EAAKuS,CAAe,EACzC,IAAIE,EAAe,MAAMrC,EAAmB,SAAUoC,EAAc7L,EAAO0L,EAAgB1F,EAAO,QAAQ,EAE1G,GAAI6F,EAAa,OAAO,QAAS,CAG3BrF,EAAiB,IAAInN,CAAG,IAAMuS,GAChCpF,EAAiB,OAAOnN,CAAG,EAG7B,OAGF,GAAIqQ,GAAiBoC,CAAY,EAAG,CAClCtF,EAAiB,OAAOnN,CAAG,EAC3BuN,GAAiB,IAAIvN,CAAG,EAExB,IAAI0S,EAAiB9S,EAAS,CAC5B,MAAO,SACR,EAAE8O,EAAY,CACb,KAAM,MACd,CAAO,EAEDxN,EAAM,SAAS,IAAIlB,EAAK0S,CAAc,EACtC1E,EAAY,CACV,SAAU,IAAI,IAAI9M,EAAM,QAAQ,CACxC,CAAO,EAED,IAAIoP,EAAqB1Q,EAAS,CAChC,MAAO,UACP,SAAUwB,EAAeF,EAAM,SAAUuR,EAAa,QAAQ,CAC/D,EAAE/D,CAAU,EAEb,MAAM6B,GAAwBkC,EAAcnC,CAAkB,EAC9D,OAIF,GAAIE,EAAciC,CAAY,EAAG,CAC/BP,GAAgBlS,EAAK+Q,EAAS0B,EAAa,KAAK,EAChD,OAGE/B,EAAiB+B,CAAY,GAC/BlO,EAAU,GAAO,qCAAqC,EAKxD,IAAIhD,EAAeL,EAAM,WAAW,UAAYA,EAAM,SAClDyR,GAAsBtD,GAAc9N,EAAcgR,EAAgB,MAAM,EACxExN,EAAU7D,EAAM,WAAW,QAAU,OAASsD,EAAYuH,EAAY7K,EAAM,WAAW,SAAU+I,EAAK,QAAQ,EAAI/I,EAAM,QAC5HqD,EAAUQ,EAAS,8CAA8C,EACjE,IAAI6N,EAAS,EAAExF,GACfE,GAAe,IAAItN,EAAK4S,CAAM,EAE9B,IAAIC,GAAcjT,EAAS,CACzB,MAAO,UACP,KAAM6S,EAAa,IACpB,EAAE/D,CAAU,EAEbxN,EAAM,SAAS,IAAIlB,EAAK6S,EAAW,EACnC,GAAI,CAACjC,GAAeC,EAAoB,EAAIC,GAAiB5P,EAAO6D,EAAS2J,EAAYnN,EAAcyL,EAAwBC,EAAyBC,EAAuB,CAC7K,CAACvG,EAAM,MAAM,EAAE,EAAG8L,EAAa,IACrC,EAAO,OACHjF,EAAgB,EAIhBqD,GAAqB,OAAOiC,GAAS,CACnC,GAAI,CAACC,CAAQ,EAAID,EACjB,OAAOC,IAAa/S,CAC1B,CAAK,EAAE,QAAQgT,GAAS,CAClB,GAAI,CAACD,CAAQ,EAAIC,EACbV,GAAkBpR,EAAM,SAAS,IAAI6R,CAAQ,EAC7C9B,GAAsB,CACxB,MAAO,UACP,KAAMqB,IAAmBA,GAAgB,KACzC,WAAY,OACZ,WAAY,OACZ,YAAa,OACb,SAAU,MAClB,EACMpR,EAAM,SAAS,IAAI6R,EAAU9B,EAAmB,EAChD9D,EAAiB,IAAI4F,EAAUR,CAAe,CACpD,CAAK,EACDvE,EAAY,CACV,SAAU,IAAI,IAAI9M,EAAM,QAAQ,CACtC,CAAK,EACD,GAAI,CACF,QAAAiQ,EACA,cAAAC,EACA,eAAAC,EACN,EAAQ,MAAMC,GAA+BpQ,EAAM,QAAS6D,EAAS6L,GAAeC,GAAsB8B,EAAmB,EAEzH,GAAIJ,EAAgB,OAAO,QACzB,OAGFjF,GAAe,OAAOtN,CAAG,EACzBmN,EAAiB,OAAOnN,CAAG,EAC3B6Q,GAAqB,QAAQoC,GAAS,CACpC,GAAI,CAACF,CAAQ,EAAIE,EACjB,OAAO9F,EAAiB,OAAO4F,CAAQ,CAC7C,CAAK,EACD,IAAI1H,GAAWmG,GAAaL,CAAO,EAEnC,GAAI9F,GAAU,CACZ,IAAIiF,EAAqBmB,GAAkBvQ,EAAOmK,EAAQ,EAC1D,MAAMkF,GAAwBlF,GAAUiF,CAAkB,EAC1D,OAIF,GAAI,CACF,WAAAV,GACA,OAAAC,EACD,EAAG6B,GAAkBxQ,EAAOA,EAAM,QAAS0P,GAAeQ,EAAe,OAAWP,GAAsBQ,GAAgB5D,CAAe,EACtIyF,GAAc,CAChB,MAAO,OACP,KAAMT,EAAa,KACnB,WAAY,OACZ,WAAY,OACZ,YAAa,OACb,SAAU,MAChB,EACIvR,EAAM,SAAS,IAAIlB,EAAKkT,EAAW,EACnC,IAAIrB,GAAqBC,GAAqBc,CAAM,EAIhD1R,EAAM,WAAW,QAAU,WAAa0R,EAASvF,IACnD9I,EAAUqI,EAAe,yBAAyB,EAClDE,GAA+BA,EAA4B,QAC3DoB,GAAmBhN,EAAM,WAAW,SAAU,CAC5C,QAAA6D,EACA,WAAA6K,GACA,OAAAC,GACA,SAAU,IAAI,IAAI3O,EAAM,QAAQ,CACxC,CAAO,IAKD8M,EAAYpO,EAAS,CACnB,OAAAiQ,GACA,WAAYvB,GAAgBpN,EAAM,WAAY0O,GAAY7K,CAAO,CAClE,EAAE8M,GAAqB,CACtB,SAAU,IAAI,IAAI3Q,EAAM,QAAQ,CACxC,EAAU,CAAA,CAAE,CAAC,EACP8L,EAAyB,GAE5B,CAGD,eAAeoF,GAAoBpS,EAAK+Q,EAAS7N,EAAMyD,EAAO5B,EAAS,CACrE,IAAIuN,EAAkBpR,EAAM,SAAS,IAAIlB,CAAG,EAExC0S,EAAiB,CACnB,MAAO,UACP,WAAY,OACZ,WAAY,OACZ,YAAa,OACb,SAAU,OACV,KAAMJ,GAAmBA,EAAgB,IAC/C,EACIpR,EAAM,SAAS,IAAIlB,EAAK0S,CAAc,EACtC1E,EAAY,CACV,SAAU,IAAI,IAAI9M,EAAM,QAAQ,CACtC,CAAK,EAED,IAAIqR,EAAkB,IAAI,gBACtBC,EAAenD,GAAcnM,EAAMqP,EAAgB,MAAM,EAC7DpF,EAAiB,IAAInN,EAAKuS,CAAe,EACzC,IAAIvC,EAAS,MAAMI,EAAmB,SAAUoC,EAAc7L,EAAO5B,EAAS4H,EAAO,QAAQ,EAe7F,GAVI+D,EAAiBV,CAAM,IACzBA,EAAU,MAAMmD,GAAoBnD,EAAQwC,EAAa,OAAQ,EAAI,GAAMxC,GAKzE7C,EAAiB,IAAInN,CAAG,IAAMuS,GAChCpF,EAAiB,OAAOnN,CAAG,EAGzBwS,EAAa,OAAO,QACtB,OAIF,GAAInC,GAAiBL,CAAM,EAAG,CAC5B,IAAIM,EAAqBmB,GAAkBvQ,EAAO8O,CAAM,EACxD,MAAMO,GAAwBP,EAAQM,CAAkB,EACxD,OAIF,GAAIE,EAAcR,CAAM,EAAG,CACzB,IAAIS,EAAgBjB,EAAoBtO,EAAM,QAAS6P,CAAO,EAC9D7P,EAAM,SAAS,OAAOlB,CAAG,EAIzBgO,EAAY,CACV,SAAU,IAAI,IAAI9M,EAAM,QAAQ,EAChC,OAAQ,CACN,CAACuP,EAAc,MAAM,EAAE,EAAGT,EAAO,KAClC,CACT,CAAO,EACD,OAGFzL,EAAU,CAACmM,EAAiBV,CAAM,EAAG,iCAAiC,EAEtE,IAAIkD,EAAc,CAChB,MAAO,OACP,KAAMlD,EAAO,KACb,WAAY,OACZ,WAAY,OACZ,YAAa,OACb,SAAU,MAChB,EACI9O,EAAM,SAAS,IAAIlB,EAAKkT,CAAW,EACnClF,EAAY,CACV,SAAU,IAAI,IAAI9M,EAAM,QAAQ,CACtC,CAAK,CACF,CAsBD,eAAeqP,GAAwBlF,EAAU0E,EAAYlM,EAAS,CAChEwH,EAAS,aACX2B,EAAyB,IAG3BzI,EAAUwL,EAAW,SAAU,gDAAgD,EAG/EjD,EAA8B,KAC9B,IAAIsG,EAAwBvP,IAAY,GAAO5D,EAAO,QAAUA,EAAO,KACvE,MAAM2N,GAAgBwF,EAAuBrD,EAAW,SAAU,CAChE,mBAAoBA,CAC1B,CAAK,CACF,CAED,eAAeuB,GAA+B+B,EAAgBtO,EAAS6L,EAAe0C,EAAgBlE,EAAS,CAI7G,IAAI+B,EAAU,MAAM,QAAQ,IAAI,CAAC,GAAGP,EAAc,IAAIjK,GAASyJ,EAAmB,SAAUhB,EAASzI,EAAO5B,EAAS4H,EAAO,QAAQ,CAAC,EAAG,GAAG2G,EAAe,IAAIC,GAAS,CACrK,GAAI,CAAG,CAAA/Q,EAAMmE,EAAO6M,CAAY,EAAID,EACpC,OAAOnD,EAAmB,SAAUf,GAAc7M,EAAM4M,EAAQ,MAAM,EAAGzI,EAAO6M,EAAc7G,EAAO,QAAQ,CAC9G,CAAA,CAAC,CAAC,EACCyE,EAAgBD,EAAQ,MAAM,EAAGP,EAAc,MAAM,EACrDS,EAAiBF,EAAQ,MAAMP,EAAc,MAAM,EACvD,aAAM,QAAQ,IAAI,CAAC6C,GAAuBJ,EAAgBzC,EAAeQ,EAAehC,EAAQ,OAAQ,GAAOlO,EAAM,UAAU,EAAGuS,GAAuBJ,EAAgBC,EAAe,IAAII,GAAS,CACnM,GAAI,CAAI,CAAA,CAAA/M,CAAK,EAAI+M,EACjB,OAAO/M,CACb,CAAK,EAAG0K,EAAgBjC,EAAQ,OAAQ,EAAI,CAAC,CAAC,EACnC,CACL,QAAA+B,EACA,cAAAC,EACA,eAAAC,CACN,CACG,CAED,SAASvC,IAAuB,CAE9B9B,EAAyB,GAGzBC,EAAwB,KAAK,GAAGiC,GAAqB,CAAE,EAEvD1B,GAAiB,QAAQ,CAACxG,EAAGhH,IAAQ,CAC/BmN,EAAiB,IAAInN,CAAG,IAC1BkN,EAAsB,KAAKlN,CAAG,EAC9BiS,GAAajS,CAAG,EAExB,CAAK,CACF,CAED,SAASkS,GAAgBlS,EAAK+Q,EAAS5I,EAAO,CAC5C,IAAIsI,EAAgBjB,EAAoBtO,EAAM,QAAS6P,CAAO,EAC9DjD,GAAc9N,CAAG,EACjBgO,EAAY,CACV,OAAQ,CACN,CAACyC,EAAc,MAAM,EAAE,EAAGtI,CAC3B,EACD,SAAU,IAAI,IAAIjH,EAAM,QAAQ,CACtC,CAAK,CACF,CAED,SAAS4M,GAAc9N,EAAK,CACtBmN,EAAiB,IAAInN,CAAG,GAAGiS,GAAajS,CAAG,EAC/CwN,GAAiB,OAAOxN,CAAG,EAC3BsN,GAAe,OAAOtN,CAAG,EACzBuN,GAAiB,OAAOvN,CAAG,EAC3BkB,EAAM,SAAS,OAAOlB,CAAG,CAC1B,CAED,SAASiS,GAAajS,EAAK,CACzB,IAAI2T,EAAaxG,EAAiB,IAAInN,CAAG,EACzCuE,EAAUoP,EAAY,8BAAgC3T,CAAG,EACzD2T,EAAW,MAAK,EAChBxG,EAAiB,OAAOnN,CAAG,CAC5B,CAED,SAAS4T,GAAiBC,EAAM,CAC9B,QAAS7T,KAAO6T,EAAM,CAEpB,IAAIX,EAAc,CAChB,MAAO,OACP,KAHYnB,GAAW/R,CAAG,EAGZ,KACd,WAAY,OACZ,WAAY,OACZ,YAAa,OACb,SAAU,MAClB,EACMkB,EAAM,SAAS,IAAIlB,EAAKkT,CAAW,EAEtC,CAED,SAAStB,IAAyB,CAChC,IAAIkC,EAAW,CAAA,EAEf,QAAS9T,KAAOuN,GAAkB,CAChC,IAAIyD,EAAU9P,EAAM,SAAS,IAAIlB,CAAG,EACpCuE,EAAUyM,EAAS,qBAAuBhR,CAAG,EAEzCgR,EAAQ,QAAU,YACpBzD,GAAiB,OAAOvN,CAAG,EAC3B8T,EAAS,KAAK9T,CAAG,GAIrB4T,GAAiBE,CAAQ,CAC1B,CAED,SAAShC,GAAqBiC,EAAU,CACtC,IAAIC,EAAa,CAAA,EAEjB,OAAS,CAAChU,EAAKsE,CAAE,IAAKgJ,GACpB,GAAIhJ,EAAKyP,EAAU,CACjB,IAAI/C,EAAU9P,EAAM,SAAS,IAAIlB,CAAG,EACpCuE,EAAUyM,EAAS,qBAAuBhR,CAAG,EAEzCgR,EAAQ,QAAU,YACpBiB,GAAajS,CAAG,EAChBsN,GAAe,OAAOtN,CAAG,EACzBgU,EAAW,KAAKhU,CAAG,GAKzB,OAAA4T,GAAiBI,CAAU,EACpBA,EAAW,OAAS,CAC5B,CAED,SAAS9E,GAAsB+E,EAAW,CACxC,IAAIC,EAAoB,CAAA,EACxB,OAAAzG,EAAgB,QAAQ,CAAC0G,EAAKpD,IAAY,EACpC,CAACkD,GAAaA,EAAUlD,CAAO,KAIjCoD,EAAI,OAAM,EACVD,EAAkB,KAAKnD,CAAO,EAC9BtD,EAAgB,OAAOsD,CAAO,EAEtC,CAAK,EACMmD,CACR,CAID,SAASE,GAAwBC,EAAWC,EAAaC,EAAQ,CAS/D,GARArI,EAAuBmI,EACvBjI,EAAoBkI,EAEpBnI,EAA0BoI,IAAWpT,GAAYA,EAAS,KAKtD,CAACkL,GAAyBnL,EAAM,aAAewK,GAAiB,CAClEW,EAAwB,GACxB,IAAImI,EAAIjG,GAAuBrN,EAAM,SAAUA,EAAM,OAAO,EAExDsT,GAAK,MACPxG,EAAY,CACV,sBAAuBwG,CACjC,CAAS,EAIL,MAAO,IAAM,CACXtI,EAAuB,KACvBE,EAAoB,KACpBD,EAA0B,IAChC,CACG,CAED,SAAS4C,GAAmB5N,EAAU4D,EAAS,CAC7C,GAAImH,GAAwBC,GAA2BC,EAAmB,CACxE,IAAIqI,EAAc1P,EAAQ,IAAI2H,GAAKgI,GAAsBhI,EAAGxL,EAAM,UAAU,CAAC,EACzElB,EAAMmM,EAAwBhL,EAAUsT,CAAW,GAAKtT,EAAS,IACrE+K,EAAqBlM,CAAG,EAAIoM,IAE/B,CAED,SAASmC,GAAuBpN,EAAU4D,EAAS,CACjD,GAAImH,GAAwBC,GAA2BC,EAAmB,CACxE,IAAIqI,EAAc1P,EAAQ,IAAI2H,GAAKgI,GAAsBhI,EAAGxL,EAAM,UAAU,CAAC,EACzElB,EAAMmM,EAAwBhL,EAAUsT,CAAW,GAAKtT,EAAS,IACjEqT,EAAItI,EAAqBlM,CAAG,EAEhC,GAAI,OAAOwU,GAAM,SACf,OAAOA,EAIX,OAAO,IACR,CAED,OAAA7H,EAAS,CACP,IAAI,UAAW,CACb,OAAO1C,EAAK,QACb,EAED,IAAI,OAAQ,CACV,OAAO/I,CACR,EAED,IAAI,QAAS,CACX,OAAO6K,CACR,EAED,WAAA2B,GACA,UAAAK,GACA,wBAAAqG,GACA,SAAA5F,GACA,MAAAwD,GACA,WAAAnD,GAGA,WAAY5N,GAAMgJ,EAAK,QAAQ,WAAWhJ,CAAE,EAC5C,WAAA8Q,GACA,cAAAjE,GACA,QAAAD,GACA,0BAA2BV,EAC3B,yBAA0BM,CAC9B,EACSd,CACT,CAKA,MAAMgI,GAAqB,IAAI,IAAI,CAAC,OAAQ,MAAO,QAAS,QAAQ,CAAC,EAC/DC,GAAsB,IAAI,IAAI,CAAC,MAAO,OAAQ,GAAGD,EAAkB,CAAC,EAC1E,SAASE,GAA6B3Q,EAAQ,CAC5CK,EAAUL,EAAO,OAAS,EAAG,2EAA2E,EACxG,IAAI6H,EAAa9H,GAA0BC,CAAM,EAqBjD,eAAe4Q,EAAM1F,EAAS,CAC5B,IAAI3M,EAAM,IAAI,IAAI2M,EAAQ,GAAG,EACzBjO,EAAWC,EAAe,GAAIE,EAAWmB,CAAG,EAAG,KAAM,SAAS,EAC9DsC,EAAUP,EAAYuH,EAAY5K,CAAQ,EAE9C,GAAKyT,GAAoB,IAAIxF,EAAQ,MAAM,GAkBpC,GAAI,CAACrK,EAAS,CACnB,GAAI,CACF,QAASkK,EACT,MAAAjL,EACA,MAAAmE,CACR,EAAUqE,GAAmBT,CAAU,EACjC,MAAO,CACL,SAAA5K,EACA,QAAS8N,EACT,WAAY,CAAE,EACd,WAAY,KACZ,OAAQ,CACN,CAACjL,EAAM,EAAE,EAAGmE,CACb,EACD,WAAYA,EAAM,OAClB,cAAe,CAAE,EACjB,cAAe,CAAE,CACzB,OAnCkD,CAC5C,GAAI,CACF,QAAS4M,EACT,MAAA/Q,EACA,MAAAmE,CACR,EAAU6M,GAA2BjJ,CAAU,EACzC,MAAO,CACL,SAAA5K,EACA,QAAS4T,EACT,WAAY,CAAE,EACd,WAAY,KACZ,OAAQ,CACN,CAAC/Q,EAAM,EAAE,EAAGmE,CACb,EACD,WAAYA,EAAM,OAClB,cAAe,CAAE,EACjB,cAAe,CAAE,CACzB,EAqBI,IAAI6H,EAAS,MAAMiF,EAAU7F,EAASjO,EAAU4D,CAAO,EAEvD,OAAIiL,aAAkB,SACbA,EAMFpQ,EAAS,CACd,SAAAuB,CACD,EAAE6O,CAAM,CACV,CAoBD,eAAekF,EAAW9F,EAAS2B,EAAS,CAC1C,IAAItO,EAAM,IAAI,IAAI2M,EAAQ,GAAG,EACzBjO,EAAWC,EAAe,GAAIE,EAAWmB,CAAG,EAAG,KAAM,SAAS,EAC9DsC,EAAUP,EAAYuH,EAAY5K,CAAQ,EAE9C,GAAKyT,GAAoB,IAAIxF,EAAQ,MAAM,GAKpC,GAAI,CAACrK,EACV,MAAMoQ,EAA0B,KAAM,CACpC,OAAQ,IACR,WAAY,WACpB,CAAO,MARD,OAAMA,EAA0B,KAAM,CACpC,OAAQ,IACR,WAAY,oBACpB,CAAO,EAQH,IAAIxO,EAAQoK,EAAUhM,EAAQ,KAAK2H,GAAKA,EAAE,MAAM,KAAOqE,CAAO,EAAIb,GAAenL,EAAS5D,CAAQ,EAElG,GAAI,CAACwF,EACH,MAAMwO,EAA0B,KAAM,CACpC,OAAQ,IACR,WAAY,WACpB,CAAO,EAGH,IAAInF,EAAS,MAAMiF,EAAU7F,EAASjO,EAAU4D,EAAS4B,CAAK,EAE9D,GAAIqJ,aAAkB,SACpB,OAAOA,EAGT,IAAI7H,EAAQ6H,EAAO,OAAS,OAAO,OAAOA,EAAO,MAAM,EAAE,CAAC,EAAI,OAE9D,GAAI7H,IAAU,OAKZ,MAAMA,EAIR,IAAIiN,EAAY,CAACpF,EAAO,WAAYA,EAAO,UAAU,EAAE,KAAKpF,GAAKA,CAAC,EAClE,OAAO,OAAO,OAAOwK,GAAa,CAAA,CAAE,EAAE,CAAC,CACxC,CAED,eAAeH,EAAU7F,EAASjO,EAAU4D,EAASsQ,EAAY,CAC/D9Q,EAAU6K,EAAQ,OAAQ,sEAAsE,EAEhG,GAAI,CACF,GAAIuF,GAAmB,IAAIvF,EAAQ,MAAM,EAEvC,OADa,MAAMkG,EAAOlG,EAASrK,EAASsQ,GAAcnF,GAAenL,EAAS5D,CAAQ,EAAGkU,GAAc,IAAI,EAIjH,IAAIrF,EAAS,MAAMuF,EAAcnG,EAASrK,EAASsQ,CAAU,EAC7D,OAAOrF,aAAkB,SAAWA,EAASpQ,EAAS,CAAA,EAAIoQ,EAAQ,CAChE,WAAY,KACZ,cAAe,CAAE,CACzB,CAAO,CACF,OAAQwF,EAAP,CAIA,GAAIC,GAAqBD,CAAC,EAAG,CAC3B,GAAIA,EAAE,OAAS1R,EAAW,OAAS,CAAC4R,GAAmBF,EAAE,QAAQ,EAC/D,MAAMA,EAAE,SAGV,OAAOA,EAAE,SAKX,GAAIE,GAAmBF,CAAC,EACtB,OAAOA,EAGT,MAAMA,CACP,CACF,CAED,eAAeF,EAAOlG,EAASrK,EAASkL,EAAa0F,EAAgB,CACnE,IAAI3F,EAEJ,GAAKC,EAAY,MAAM,QAarB,GAHAD,EAAS,MAAMI,EAAmB,SAAUhB,EAASa,EAAalL,EAAS,OAC3E,GAAM4Q,CAAc,EAEhBvG,EAAQ,OAAO,QAAS,CAC1B,IAAIwG,EAASD,EAAiB,aAAe,QAC7C,MAAM,IAAI,MAAMC,EAAS,iBAAiB,OAff,CAC7B,GAAID,EACF,MAAMR,EAA0B,KAAM,CACpC,OAAQ,IACR,WAAY,oBACtB,CAAS,EAGHnF,EAASG,GAA0Bf,EAAQ,GAAG,EAWhD,GAAIiB,GAAiBL,CAAM,EAKzB,MAAM,IAAI,SAAS,KAAM,CACvB,OAAQA,EAAO,OACf,QAAS,CACP,SAAUA,EAAO,QAClB,CACT,CAAO,EAGH,GAAIU,EAAiBV,CAAM,EACzB,MAAM,IAAI,MAAM,qCAAqC,EAGvD,GAAI2F,EAAgB,CAGlB,GAAInF,EAAcR,CAAM,EAAG,CACzB,IAAIS,EAAgBjB,EAAoBzK,EAASkL,EAAY,MAAM,EAAE,EACrE,MAAO,CACL,QAAS,CAACA,CAAW,EACrB,WAAY,CAAE,EACd,WAAY,KACZ,OAAQ,CACN,CAACQ,EAAc,MAAM,EAAE,EAAGT,EAAO,KAClC,EAGD,WAAY,IACZ,cAAe,CAAE,EACjB,cAAe,CAAE,CAC3B,EAGM,MAAO,CACL,QAAS,CAACC,CAAW,EACrB,WAAY,CAAE,EACd,WAAY,CACV,CAACA,EAAY,MAAM,EAAE,EAAGD,EAAO,IAChC,EACD,OAAQ,KAGR,WAAY,IACZ,cAAe,CAAE,EACjB,cAAe,CAAE,CACzB,EAGI,GAAIQ,EAAcR,CAAM,EAAG,CAGzB,IAAIS,EAAgBjB,EAAoBzK,EAASkL,EAAY,MAAM,EAAE,EACjE4F,EAAU,MAAMN,EAAcnG,EAASrK,EAAS,OAAW,CAC7D,CAAC0L,EAAc,MAAM,EAAE,EAAGT,EAAO,KACzC,CAAO,EAED,OAAOpQ,EAAS,CAAE,EAAEiW,EAAS,CAC3B,WAAYpK,GAAqBuE,EAAO,KAAK,EAAIA,EAAO,MAAM,OAAS,IACvE,WAAY,KACZ,cAAepQ,EAAS,GAAIoQ,EAAO,QAAU,CAC3C,CAACC,EAAY,MAAM,EAAE,EAAGD,EAAO,OAChC,EAAG,EAAE,CACd,CAAO,EAGH,IAAI6F,EAAU,MAAMN,EAAcnG,EAASrK,CAAO,EAClD,OAAOnF,EAAS,CAAE,EAAEiW,EAAS7F,EAAO,WAAa,CAC/C,WAAYA,EAAO,UACpB,EAAG,GAAI,CACN,WAAY,CACV,CAACC,EAAY,MAAM,EAAE,EAAGD,EAAO,IAChC,EACD,cAAepQ,EAAS,GAAIoQ,EAAO,QAAU,CAC3C,CAACC,EAAY,MAAM,EAAE,EAAGD,EAAO,OAChC,EAAG,EAAE,CACZ,CAAK,CACF,CAED,eAAeuF,EAAcnG,EAASrK,EAASsQ,EAAYS,EAAoB,CAC7E,IAAIH,EAAiBN,GAAc,KAE/BzE,GADiByE,EAAa,CAACA,CAAU,EAAIU,GAA8BhR,EAAS,OAAO,KAAK+Q,GAAsB,CAAE,CAAA,EAAE,CAAC,CAAC,GAC7F,OAAOpJ,GAAKA,EAAE,MAAM,MAAM,EAE7D,GAAIkE,EAAc,SAAW,EAC3B,MAAO,CACL,QAAA7L,EACA,WAAY,CAAE,EACd,OAAQ+Q,GAAsB,KAC9B,WAAY,IACZ,cAAe,CAAE,CACzB,EAGI,IAAI3E,EAAU,MAAM,QAAQ,IAAI,CAAC,GAAGP,EAAc,IAAIjK,GAASyJ,EAAmB,SAAUhB,EAASzI,EAAO5B,EAAS,OACrH,GAAM4Q,CAAc,CAAC,CAAC,CAAC,EAEvB,GAAIvG,EAAQ,OAAO,QAAS,CAC1B,IAAIwG,EAASD,EAAiB,aAAe,QAC7C,MAAM,IAAI,MAAMC,EAAS,iBAAiB,EAK5CzE,EAAQ,QAAQnB,GAAU,CACpBU,EAAiBV,CAAM,GACzBA,EAAO,aAAa,QAE5B,CAAK,EAED,IAAI6F,EAAUG,GAAuBjR,EAAS6L,EAAeO,EAAS2E,CAAkB,EACxF,OAAOlW,EAAS,CAAE,EAAEiW,EAAS,CAC3B,QAAA9Q,CACN,CAAK,CACF,CAED,SAASoQ,EAA0Bc,EAAMhM,EAAM,CAC7C,OAAO,IAAI,SAASgM,EAAMrW,EAAS,CAAA,EAAIqK,EAAM,CAC3C,QAASrK,EAAS,GAAIqK,EAAK,QAAS,CAClC,uBAAwB,KAChC,CAAO,CACF,CAAA,CAAC,CACH,CAED,MAAO,CACL,WAAA8B,EACA,MAAA+I,EACA,WAAAI,CACJ,CACA,CAUA,SAASgB,GAA0BhS,EAAQ2R,EAAS1N,EAAO,CAQzD,OAPiBvI,EAAS,CAAE,EAAEiW,EAAS,CACrC,WAAY,IACZ,OAAQ,CACN,CAACA,EAAQ,4BAA8B3R,EAAO,CAAC,EAAE,EAAE,EAAGiE,CACvD,CACL,CAAG,CAGH,CAGA,SAASwG,GAAyB1N,EAAIwN,EAAM0H,EAAW,CACjDA,IAAc,SAChBA,EAAY,IAGd,IAAIjT,EAAO,OAAOjC,GAAO,SAAWA,EAAKK,EAAWL,CAAE,EAEtD,GAAI,CAACwN,GAAQ,EAAE,eAAgBA,IAAS,EAAE,aAAcA,GACtD,MAAO,CACL,KAAAvL,CACN,EAIE,GAAIuL,EAAK,YAAc,MAAQA,EAAK,aAAe,MACjD,MAAO,CACL,KAAAvL,EACA,WAAY,CACV,WAAYuL,EAAK,WACjB,WAAY2H,GAAkBlT,CAAI,EAClC,YAAauL,GAAQA,EAAK,aAAe,oCACzC,SAAUA,EAAK,QAChB,CACP,EAIE,GAAI,CAACA,EAAK,SACR,MAAO,CACL,KAAAvL,CACN,EAIE,IAAIC,EAAad,EAAUa,CAAI,EAE/B,GAAI,CACF,IAAImT,EAAeC,GAA8B7H,EAAK,QAAQ,EAI1D0H,GAAahT,EAAW,QAAUoT,GAAmBpT,EAAW,MAAM,GACxEkT,EAAa,OAAO,QAAS,EAAE,EAGjClT,EAAW,OAAS,IAAMkT,CAC3B,MAAC,CACA,MAAO,CACL,KAAAnT,EACA,MAAO,IAAIoI,EAAc,IAAK,cAAe,0CAA0C,CAC7F,CACG,CAED,MAAO,CACL,KAAMhK,EAAW6B,CAAU,CAC/B,CACA,CAEA,SAASsO,GAAkBvQ,EAAOmK,EAAU,CAC1C,GAAI,CACF,WAAAmL,EACA,WAAAC,EACA,YAAAC,EACA,SAAAC,CACJ,EAAMzV,EAAM,WASV,MARiB,CACf,MAAO,UACP,SAAUE,EAAeF,EAAM,SAAUmK,EAAS,QAAQ,EAC1D,WAAYmL,GAAc,OAC1B,WAAYC,GAAc,OAC1B,YAAaC,GAAe,OAC5B,SAAUC,GAAY,MAC1B,CAEA,CAIA,SAASZ,GAA8BhR,EAAS6R,EAAY,CAC1D,IAAIC,EAAkB9R,EAEtB,GAAI6R,EAAY,CACd,IAAIlW,EAAQqE,EAAQ,UAAU2H,GAAKA,EAAE,MAAM,KAAOkK,CAAU,EAExDlW,GAAS,IACXmW,EAAkB9R,EAAQ,MAAM,EAAGrE,CAAK,GAI5C,OAAOmW,CACT,CAEA,SAAS/F,GAAiB5P,EAAO6D,EAAS2J,EAAYvN,EAAU6L,EAAwBC,EAAyBC,EAAuBoC,EAAmBC,EAAc/B,EAAkB,CACzL,IAAIiF,EAAelD,EAAe,OAAO,OAAOA,CAAY,EAAE,CAAC,EAAID,EAAoB,OAAO,OAAOA,CAAiB,EAAE,CAAC,EAAI,KAEzHsH,EAAarH,EAAe,OAAO,KAAKA,CAAY,EAAE,CAAC,EAAI,OAE3DuH,EADkBf,GAA8BhR,EAAS6R,CAAU,EAC/B,OAAO,CAACjQ,EAAOjG,IAAUiG,EAAM,MAAM,QAAU,OAASoQ,GAAY7V,EAAM,WAAYA,EAAM,QAAQR,CAAK,EAAGiG,CAAK,GACzJsG,EAAwB,KAAK3I,GAAMA,IAAOqC,EAAM,MAAM,EAAE,GAAKqQ,GAAuB9V,EAAM,SAAUA,EAAM,QAAQR,CAAK,EAAGgO,EAAYvN,EAAUwF,EAAOqG,EAAwByF,CAAY,EAAE,EAEzL5B,EAAuB,CAAA,EAC3B,OAAArD,GAAoBA,EAAiB,QAAQ,CAACyJ,EAAQjX,IAAQ,CAC5D,GAAI,CAACwC,EAAMmE,EAAO6M,CAAY,EAAIyD,EAG9B/J,EAAsB,SAASlN,CAAG,EACpC6Q,EAAqB,KAAK,CAAC7Q,EAAKwC,EAAMmE,EAAO6M,CAAY,CAAC,EACjDxG,GACcgK,GAAuBxU,EAAMmE,EAAO+H,EAAYlM,EAAMmE,EAAOqG,EAAwByF,CAAY,GAGtH5B,EAAqB,KAAK,CAAC7Q,EAAKwC,EAAMmE,EAAO6M,CAAY,CAAC,CAGlE,CAAG,EACM,CAACsD,EAAmBjG,CAAoB,CACjD,CAEA,SAASkG,GAAYG,EAAmBC,EAAcxQ,EAAO,CAC3D,IAAIyQ,EACJ,CAACD,GACDxQ,EAAM,MAAM,KAAOwQ,EAAa,MAAM,GAGlCE,EAAgBH,EAAkBvQ,EAAM,MAAM,EAAE,IAAM,OAE1D,OAAOyQ,GAASC,CAClB,CAEA,SAASC,GAAmBH,EAAcxQ,EAAO,CAC/C,IAAI4Q,EAAcJ,EAAa,MAAM,KACrC,OACEA,EAAa,WAAaxQ,EAAM,UAEhC4Q,GAAeA,EAAY,SAAS,GAAG,GAAKJ,EAAa,OAAO,GAAG,IAAMxQ,EAAM,OAAO,GAAG,CAE7F,CAEA,SAASqQ,GAAuBQ,EAAiBL,EAAczI,EAAYvN,EAAUwF,EAAOqG,EAAwByF,EAAc,CAChI,IAAIgF,EAAapU,GAAUmU,CAAe,EACtCE,EAAgBP,EAAa,OAC7BQ,EAAUtU,GAAUlC,CAAQ,EAC5ByW,EAAajR,EAAM,OAOnBkR,EAA0BP,GAAmBH,EAAcxQ,CAAK,GACpE8Q,EAAW,SAAQ,IAAOE,EAAQ,SAAU,GAC5CF,EAAW,SAAWE,EAAQ,QAC9B3K,EAEA,GAAIrG,EAAM,MAAM,iBAAkB,CAChC,IAAImR,EAAcnR,EAAM,MAAM,iBAAiB/G,EAAS,CACtD,WAAA6X,EACA,cAAAC,EACA,QAAAC,EACA,WAAAC,CACD,EAAElJ,EAAY,CACb,aAAA+D,EACA,wBAAAoF,CACD,CAAA,CAAC,EAEF,GAAI,OAAOC,GAAgB,UACzB,OAAOA,EAIX,OAAOD,CACT,CAEA,eAAezH,EAAmB2H,EAAM3I,EAASzI,EAAO5B,EAASL,EAAUsT,EAAiBrC,EAAgB,CACtGqC,IAAoB,SACtBA,EAAkB,IAGhBrC,IAAmB,SACrBA,EAAiB,IAGnB,IAAIsC,EACAjI,EAEA1F,EACA4N,EAAe,IAAI,QAAQ,CAAClR,EAAGuD,IAAMD,EAASC,CAAC,EAE/C4N,EAAW,IAAM7N,IAErB8E,EAAQ,OAAO,iBAAiB,QAAS+I,CAAQ,EAEjD,GAAI,CACF,IAAIC,EAAUzR,EAAM,MAAMoR,CAAI,EAC9BxT,EAAU6T,EAAS,sBAAwBL,EAAO,mBAAsBpR,EAAM,MAAM,GAAK,SAAU,EACnGqJ,EAAS,MAAM,QAAQ,KAAK,CAACoI,EAAQ,CACnC,QAAAhJ,EACA,OAAQzI,EAAM,MACpB,CAAK,EAAGuR,CAAY,CAAC,CAClB,OAAQ1C,EAAP,CACAyC,EAAanU,EAAW,MACxBkM,EAASwF,CACb,QAAY,CACRpG,EAAQ,OAAO,oBAAoB,QAAS+I,CAAQ,CACrD,CAED,GAAInI,aAAkB,SAAU,CAC9B,IAAIzE,EAASyE,EAAO,OAEpB,GAAIzE,GAAU,KAAOA,GAAU,IAAK,CAClC,IAAIpK,EAAW6O,EAAO,QAAQ,IAAI,UAAU,EAC5CzL,EAAUpD,EAAU,4EAA4E,EAEhG,IAAIkX,EAAgBtT,EAAQ,MAAM,EAAGA,EAAQ,QAAQ4B,CAAK,EAAI,CAAC,EAC3DyC,EAAiBH,GAA2BoP,CAAa,EAAE,IAAI1R,GAASA,EAAM,YAAY,EAC1F2R,EAAcjV,GAAU+L,EAAQ,GAAG,EAAE,SACrCmJ,EAAmBrP,GAAU/H,EAAUiI,EAAgBkP,CAAW,EAGtE,GAFA/T,EAAUjD,EAAWiX,CAAgB,EAAG,wCAA0CvI,EAAO,QAAQ,IAAI,UAAU,CAAC,EAE5GtL,EAAU,CACZ,IAAIxB,EAAOqV,EAAiB,SAC5BA,EAAiB,SAAWrV,IAAS,IAAMwB,EAAWU,GAAU,CAACV,EAAUxB,CAAI,CAAC,EAQlF,GALA/B,EAAWG,EAAWiX,CAAgB,EAKlCP,EACF,MAAAhI,EAAO,QAAQ,IAAI,WAAY7O,CAAQ,EACjC6O,EAGR,MAAO,CACL,KAAMlM,EAAW,SACjB,OAAAyH,EACA,SAAApK,EACA,WAAY6O,EAAO,QAAQ,IAAI,oBAAoB,IAAM,IACjE,EAMI,GAAI2F,EAEF,KAAM,CACJ,KAAMsC,GAAcnU,EAAW,KAC/B,SAAUkM,CAClB,EAGI,IAAIhG,EACAwO,EAAcxI,EAAO,QAAQ,IAAI,cAAc,EAQnD,OANIwI,GAAeA,EAAY,WAAW,kBAAkB,EAC1DxO,EAAO,MAAMgG,EAAO,OAEpBhG,EAAO,MAAMgG,EAAO,OAGlBiI,IAAenU,EAAW,MACrB,CACL,KAAMmU,EACN,MAAO,IAAI3M,EAAcC,EAAQyE,EAAO,WAAYhG,CAAI,EACxD,QAASgG,EAAO,OACxB,EAGW,CACL,KAAMlM,EAAW,KACjB,KAAAkG,EACA,WAAYgG,EAAO,OACnB,QAASA,EAAO,OACtB,EAGE,OAAIiI,IAAenU,EAAW,MACrB,CACL,KAAMmU,EACN,MAAOjI,CACb,EAGMA,aAAkB3F,GACb,CACL,KAAMvG,EAAW,SACjB,aAAckM,CACpB,EAGS,CACL,KAAMlM,EAAW,KACjB,KAAMkM,CACV,CACA,CAEA,SAASX,GAAclO,EAAU2J,EAAQ4D,EAAY,CACnD,IAAIjM,EAAMY,GAAU+S,GAAkBjV,CAAQ,CAAC,EAAE,WAC7C8I,EAAO,CACT,OAAAa,CACJ,EAEE,GAAI4D,EAAY,CACd,GAAI,CACF,WAAA8H,EACA,YAAAE,EACA,SAAAC,CACD,EAAGjI,EACJzE,EAAK,OAASuM,EAAW,cACzBvM,EAAK,KAAOyM,IAAgB,oCAAsCJ,GAA8BK,CAAQ,EAAIA,EAI9G,OAAO,IAAI,QAAQlU,EAAKwH,CAAI,CAC9B,CAEA,SAASqM,GAA8BK,EAAU,CAC/C,IAAIN,EAAe,IAAI,gBAEvB,OAAS,CAACrW,EAAKkI,CAAK,IAAKyO,EAAS,QAAO,EACvCpS,EAAU,OAAO2D,GAAU,SAAU,2HAAgI,EACrKmO,EAAa,OAAOrW,EAAKkI,CAAK,EAGhC,OAAOmO,CACT,CAEA,SAASL,GAAuBjR,EAAS6L,EAAeO,EAAS5B,EAAc9B,EAAiB,CAE9F,IAAImC,EAAa,CAAA,EACbC,EAAS,KACT4I,EACAC,EAAa,GACbC,EAAgB,CAAA,EAEpB,OAAAxH,EAAQ,QAAQ,CAACnB,EAAQtP,IAAU,CACjC,IAAI4D,EAAKsM,EAAclQ,CAAK,EAAE,MAAM,GAGpC,GAFA6D,EAAU,CAAC8L,GAAiBL,CAAM,EAAG,qDAAqD,EAEtFQ,EAAcR,CAAM,EAAG,CAGzB,IAAIS,EAAgBjB,EAAoBzK,EAAST,CAAE,EAC/C6D,EAAQ6H,EAAO,MAIfT,IACFpH,EAAQ,OAAO,OAAOoH,CAAY,EAAE,CAAC,EACrCA,EAAe,QAGjBM,EAAS,OAAO,OAAOA,GAAU,CAAA,EAAI,CACnC,CAACY,EAAc,MAAM,EAAE,EAAGtI,CAClC,CAAO,EAGIuQ,IACHA,EAAa,GACbD,EAAahN,GAAqBuE,EAAO,KAAK,EAAIA,EAAO,MAAM,OAAS,KAGtEA,EAAO,UACT2I,EAAcrU,CAAE,EAAI0L,EAAO,cAEpBU,EAAiBV,CAAM,GAChCvC,GAAmBA,EAAgB,IAAInJ,EAAI0L,EAAO,YAAY,EAC9DJ,EAAWtL,CAAE,EAAI0L,EAAO,aAAa,OAErCJ,EAAWtL,CAAE,EAAI0L,EAAO,KAGpBA,EAAO,YAAc,MAAQA,EAAO,aAAe,KAAO,CAAC0I,IAC7DD,EAAazI,EAAO,YAGlBA,EAAO,UACT2I,EAAcrU,CAAE,EAAI0L,EAAO,SAGnC,CAAG,EAGGT,IACFM,EAASN,GAGJ,CACL,WAAAK,EACA,OAAAC,EACA,WAAY4I,GAAc,IAC1B,cAAAE,CACJ,CACA,CAEA,SAASjH,GAAkBxQ,EAAO6D,EAAS6L,EAAeO,EAAS5B,EAAcsB,EAAsBQ,EAAgB5D,EAAiB,CACtI,GAAI,CACF,WAAAmC,EACA,OAAAC,CACJ,EAAMmG,GAAuBjR,EAAS6L,EAAeO,EAAS5B,EAAc9B,CAAe,EAEzF,QAAS/M,EAAQ,EAAGA,EAAQmQ,EAAqB,OAAQnQ,IAAS,CAChE,GAAI,CAACV,EAAM,CAAA2G,CAAK,EAAIkK,EAAqBnQ,CAAK,EAC9C6D,EAAU8M,IAAmB,QAAaA,EAAe3Q,CAAK,IAAM,OAAW,2CAA2C,EAC1H,IAAIsP,EAASqB,EAAe3Q,CAAK,EAEjC,GAAI8P,EAAcR,CAAM,EAAG,CACzB,IAAIS,EAAgBjB,EAAoBtO,EAAM,QAASyF,EAAM,MAAM,EAAE,EAE/DkJ,GAAUA,EAAOY,EAAc,MAAM,EAAE,IAC3CZ,EAASjQ,EAAS,CAAE,EAAEiQ,EAAQ,CAC5B,CAACY,EAAc,MAAM,EAAE,EAAGT,EAAO,KAC3C,CAAS,GAGH9O,EAAM,SAAS,OAAOlB,CAAG,MACpB,IAAIqQ,GAAiBL,CAAM,EAGhC,MAAM,IAAI,MAAM,yCAAyC,EACpD,GAAIU,EAAiBV,CAAM,EAGhC,MAAM,IAAI,MAAM,iCAAiC,EAC5C,CACL,IAAIkD,EAAc,CAChB,MAAO,OACP,KAAMlD,EAAO,KACb,WAAY,OACZ,WAAY,OACZ,YAAa,OACb,SAAU,MAClB,EACM9O,EAAM,SAAS,IAAIlB,EAAKkT,CAAW,IAIvC,MAAO,CACL,WAAAtD,EACA,OAAAC,CACJ,CACA,CAEA,SAASvB,GAAgBsB,EAAYvB,EAAetJ,EAAS,CAC3D,IAAI6T,EAAmBhZ,EAAS,CAAE,EAAEyO,CAAa,EAEjD,OAAAtJ,EAAQ,QAAQ4B,GAAS,CACvB,IAAIrC,EAAKqC,EAAM,MAAM,GAEjB0H,EAAc/J,CAAE,IAAM,QAAasL,EAAWtL,CAAE,IAAM,SACxDsU,EAAiBtU,CAAE,EAAIsL,EAAWtL,CAAE,EAE1C,CAAG,EACMsU,CACT,CAKA,SAASpJ,EAAoBzK,EAASgM,EAAS,CAE7C,OADsBA,EAAUhM,EAAQ,MAAM,EAAGA,EAAQ,UAAU2H,GAAKA,EAAE,MAAM,KAAOqE,CAAO,EAAI,CAAC,EAAI,CAAC,GAAGhM,CAAO,GAC3F,UAAU,KAAK2H,GAAKA,EAAE,MAAM,mBAAqB,EAAI,GAAK3H,EAAQ,CAAC,CAC5F,CAEA,SAAS8T,GAAuB3U,EAAQqH,EAAQC,EAAY,CAE1D,IAAIxH,EAAQE,EAAO,KAAKqG,GAAKA,EAAE,OAAS,CAACA,EAAE,MAAQA,EAAE,OAAS,GAAG,GAAK,CACpE,GAAI,UAAYgB,EAAS,UAC7B,EACE,MAAO,CACL,QAAS,CAAC,CACR,OAAQ,CAAE,EACV,SAAU,GACV,aAAc,GACd,MAAAvH,CACN,CAAK,EACD,MAAAA,EACA,MAAO,IAAIsH,EAAcC,EAAQC,EAAY,IAAI,CACrD,CACA,CAEA,SAASgB,GAAmBtI,EAAQ,CAClC,OAAO2U,GAAuB3U,EAAQ,IAAK,WAAW,CACxD,CAEA,SAAS8Q,GAA2B9Q,EAAQ,CAC1C,OAAO2U,GAAuB3U,EAAQ,IAAK,oBAAoB,CACjE,CAEA,SAASiM,GAA0BjN,EAAM,CACvC,IAAIV,EAAO,OAAOU,GAAS,SAAWA,EAAO5B,EAAW4B,CAAI,EAC5D,eAAQ,KAAK,oIAA2I,IAAMV,EAAO,IAAI,EAClK,CACL,KAAMsB,EAAW,MACjB,MAAO,IAAIwH,EAAc,IAAK,qBAAsB,EAAE,CAC1D,CACA,CAGA,SAASkG,GAAaL,EAAS,CAC7B,QAASrR,EAAIqR,EAAQ,OAAS,EAAGrR,GAAK,EAAGA,IAAK,CAC5C,IAAIkQ,EAASmB,EAAQrR,CAAC,EAEtB,GAAIuQ,GAAiBL,CAAM,EACzB,OAAOA,EAGb,CAEA,SAASoG,GAAkBlT,EAAM,CAC/B,IAAIC,EAAa,OAAOD,GAAS,SAAWb,EAAUa,CAAI,EAAIA,EAC9D,OAAO5B,EAAW1B,EAAS,CAAE,EAAEuD,EAAY,CACzC,KAAM,EACP,CAAA,CAAC,CACJ,CAEA,SAASgM,GAAiB5J,EAAGC,EAAG,CAC9B,OAAOD,EAAE,WAAaC,EAAE,UAAYD,EAAE,SAAWC,EAAE,QAAUD,EAAE,OAASC,EAAE,IAC5E,CAEA,SAASkL,EAAiBV,EAAQ,CAChC,OAAOA,EAAO,OAASlM,EAAW,QACpC,CAEA,SAAS0M,EAAcR,EAAQ,CAC7B,OAAOA,EAAO,OAASlM,EAAW,KACpC,CAEA,SAASuM,GAAiBL,EAAQ,CAChC,OAAQA,GAAUA,EAAO,QAAUlM,EAAW,QAChD,CAEA,SAAS4R,GAAmB1F,EAAQ,CAClC,GAAI,EAAEA,aAAkB,UACtB,MAAO,GAGT,IAAIzE,EAASyE,EAAO,OAChB7O,EAAW6O,EAAO,QAAQ,IAAI,UAAU,EAC5C,OAAOzE,GAAU,KAAOA,GAAU,KAAOpK,GAAY,IACvD,CAEA,SAASsU,GAAqBqD,EAAK,CACjC,OAAOA,GAAOA,EAAI,oBAAoB,WAAaA,EAAI,OAAShV,EAAW,MAAQA,EAAW,MAChG,CAEA,eAAe2P,GAAuBJ,EAAgBzC,EAAeO,EAASrG,EAAQqL,EAAWe,EAAmB,CAClH,QAASxW,EAAQ,EAAGA,EAAQyQ,EAAQ,OAAQzQ,IAAS,CACnD,IAAIsP,EAASmB,EAAQzQ,CAAK,EACtBiG,EAAQiK,EAAclQ,CAAK,EAC3ByW,EAAe9D,EAAe,KAAK3G,GAAKA,EAAE,MAAM,KAAO/F,EAAM,MAAM,EAAE,EACrEoS,EAAuB5B,GAAgB,MAAQ,CAACG,GAAmBH,EAAcxQ,CAAK,IAAMuQ,GAAqBA,EAAkBvQ,EAAM,MAAM,EAAE,KAAO,OAExJ+J,EAAiBV,CAAM,IAAMmG,GAAa4C,IAI5C,MAAM5F,GAAoBnD,EAAQlF,EAAQqL,CAAS,EAAE,KAAKnG,GAAU,CAC9DA,IACFmB,EAAQzQ,CAAK,EAAIsP,GAAUmB,EAAQzQ,CAAK,EAElD,CAAO,EAGP,CAEA,eAAeyS,GAAoBnD,EAAQlF,EAAQkO,EAAQ,CAOzD,GANIA,IAAW,SACbA,EAAS,IAGG,OAAMhJ,EAAO,aAAa,YAAYlF,CAAM,EAM1D,IAAIkO,EACF,GAAI,CACF,MAAO,CACL,KAAMlV,EAAW,KACjB,KAAMkM,EAAO,aAAa,aAClC,CACK,OAAQwF,EAAP,CAEA,MAAO,CACL,KAAM1R,EAAW,MACjB,MAAO0R,CACf,CACK,CAGH,MAAO,CACL,KAAM1R,EAAW,KACjB,KAAMkM,EAAO,aAAa,IAC9B,EACA,CAEA,SAASuG,GAAmBxU,EAAQ,CAClC,OAAO,IAAI,gBAAgBA,CAAM,EAAE,OAAO,OAAO,EAAE,KAAK6I,GAAKA,IAAM,EAAE,CACvE,CAIA,SAAS8J,GAAsB/N,EAAOiJ,EAAY,CAChD,GAAI,CACF,MAAA5L,EACA,SAAAlC,EACA,OAAAiF,CACD,EAAGJ,EACJ,MAAO,CACL,GAAI3C,EAAM,GACV,SAAAlC,EACA,OAAAiF,EACA,KAAM6I,EAAW5L,EAAM,EAAE,EACzB,OAAQA,EAAM,MAClB,CACA,CAEA,SAASkM,GAAenL,EAAS5D,EAAU,CACzC,IAAIY,EAAS,OAAOZ,GAAa,SAAWkB,EAAUlB,CAAQ,EAAE,OAASA,EAAS,OAElF,GAAI4D,EAAQA,EAAQ,OAAS,CAAC,EAAE,MAAM,OAASwR,GAAmBxU,GAAU,EAAE,EAE5E,OAAOgD,EAAQA,EAAQ,OAAS,CAAC,EAKnC,IAAIkU,EAAchQ,GAA2BlE,CAAO,EACpD,OAAOkU,EAAYA,EAAY,OAAS,CAAC,CAC3C"}