{"version":3,"sources":["jsdelivr-header.js","/npm/src/path-to-regexp.ts","/npm/src/universal-router.ts"],"names":[],"mappings":"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","file":"/npm/universal-router@10.0.1/universal-router.js/+esm","sourceRoot":"","sourcesContent":["/**\n * Bundled by jsDelivr using Rollup v2.79.2 and Terser v5.39.0.\n * Original file: /npm/universal-router@10.0.1/universal-router.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*! Path-to-RegExp | MIT License | https://github.com/pillarjs/path-to-regexp */// @ts-nocheck\n\nconst DEFAULT_DELIMITER = \"/\";\nconst NOOP_VALUE = (value: string) => value;\nconst ID_START = /^[$_\\p{ID_Start}]$/u;\nconst ID_CONTINUE = /^[$\\u200c\\u200d\\p{ID_Continue}]$/u;\nconst DEBUG_URL = \"https://git.new/pathToRegexpError\";\n\n/**\n * Encode a string into another string.\n */\nexport type Encode = (value: string) => string;\n\n/**\n * Decode a string into another string.\n */\nexport type Decode = (value: string) => string;\n\nexport interface ParseOptions {\n  /**\n   * A function for encoding input strings.\n   */\n  encodePath?: Encode;\n}\n\nexport interface PathToRegexpOptions {\n  /**\n   * Matches the path completely without trailing characters. (default: `true`)\n   */\n  end?: boolean;\n  /**\n   * Allows optional trailing delimiter to match. (default: `true`)\n   */\n  trailing?: boolean;\n  /**\n   * Match will be case sensitive. (default: `false`)\n   */\n  sensitive?: boolean;\n  /**\n   * The default delimiter for segments. (default: `'/'`)\n   */\n  delimiter?: string;\n}\n\nexport interface MatchOptions extends PathToRegexpOptions {\n  /**\n   * Function for decoding strings for params, or `false` to disable entirely. (default: `decodeURIComponent`)\n   */\n  decode?: Decode | false;\n}\n\nexport interface CompileOptions {\n  /**\n   * Function for encoding input strings for output into the path, or `false` to disable entirely. (default: `encodeURIComponent`)\n   */\n  encode?: Encode | false;\n  /**\n   * The default delimiter for segments. (default: `'/'`)\n   */\n  delimiter?: string;\n}\n\ntype TokenType =\n  | \"{\"\n  | \"}\"\n  | \"WILDCARD\"\n  | \"PARAM\"\n  | \"CHAR\"\n  | \"ESCAPED\"\n  | \"END\"\n  // Reserved for use or ambiguous due to past use.\n  | \"(\"\n  | \")\"\n  | \"[\"\n  | \"]\"\n  | \"+\"\n  | \"?\"\n  | \"!\";\n\n/**\n * Tokenizer results.\n */\ninterface LexToken {\n  type: TokenType;\n  index: number;\n  value: string;\n}\n\nconst SIMPLE_TOKENS: Record<string, TokenType> = {\n  // Groups.\n  \"{\": \"{\",\n  \"}\": \"}\",\n  // Reserved.\n  \"(\": \"(\",\n  \")\": \")\",\n  \"[\": \"[\",\n  \"]\": \"]\",\n  \"+\": \"+\",\n  \"?\": \"?\",\n  \"!\": \"!\",\n};\n\n/**\n * Escape text for stringify to path.\n */\nfunction escapeText(str: string) {\n  return str.replace(/[{}()\\[\\]+?!:*]/g, \"\\\\$&\");\n}\n\n/**\n * Escape a regular expression string.\n */\nfunction escape(str: string) {\n  return str.replace(/[.+*?^${}()[\\]|/\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Tokenize input string.\n */\nfunction* lexer(str: string): Generator<LexToken, LexToken> {\n  const chars = [...str];\n  let i = 0;\n\n  function name() {\n    let value = \"\";\n\n    if (ID_START.test(chars[++i])) {\n      value += chars[i];\n      while (ID_CONTINUE.test(chars[++i])) {\n        value += chars[i];\n      }\n    } else if (chars[i] === '\"') {\n      let pos = i;\n\n      while (i < chars.length) {\n        if (chars[++i] === '\"') {\n          i++;\n          pos = 0;\n          break;\n        }\n\n        if (chars[i] === \"\\\\\") {\n          value += chars[++i];\n        } else {\n          value += chars[i];\n        }\n      }\n\n      if (pos) {\n        throw new TypeError(`Unterminated quote at ${pos}: ${DEBUG_URL}`);\n      }\n    }\n\n    if (!value) {\n      throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);\n    }\n\n    return value;\n  }\n\n  while (i < chars.length) {\n    const value = chars[i];\n    const type = SIMPLE_TOKENS[value];\n\n    if (type) {\n      yield { type, index: i++, value };\n    } else if (value === \"\\\\\") {\n      yield { type: \"ESCAPED\", index: i++, value: chars[i++] };\n    } else if (value === \":\") {\n      const value = name();\n      yield { type: \"PARAM\", index: i, value };\n    } else if (value === \"*\") {\n      const value = name();\n      yield { type: \"WILDCARD\", index: i, value };\n    } else {\n      yield { type: \"CHAR\", index: i, value: chars[i++] };\n    }\n  }\n\n  return { type: \"END\", index: i, value: \"\" };\n}\n\nclass Iter {\n  private _peek?: LexToken;\n\n  constructor(private tokens: Generator<LexToken, LexToken>) {}\n\n  peek(): LexToken {\n    if (!this._peek) {\n      const next = this.tokens.next();\n      this._peek = next.value;\n    }\n    return this._peek;\n  }\n\n  tryConsume(type: TokenType): string | undefined {\n    const token = this.peek();\n    if (token.type !== type) return;\n    this._peek = undefined; // Reset after consumed.\n    return token.value;\n  }\n\n  consume(type: TokenType): string {\n    const value = this.tryConsume(type);\n    if (value !== undefined) return value;\n    const { type: nextType, index } = this.peek();\n    throw new TypeError(\n      `Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`,\n    );\n  }\n\n  text(): string {\n    let result = \"\";\n    let value: string | undefined;\n    while ((value = this.tryConsume(\"CHAR\") || this.tryConsume(\"ESCAPED\"))) {\n      result += value;\n    }\n    return result;\n  }\n}\n\n/**\n * Plain text.\n */\nexport interface Text {\n  type: \"text\";\n  value: string;\n}\n\n/**\n * A parameter designed to match arbitrary text within a segment.\n */\nexport interface Parameter {\n  type: \"param\";\n  name: string;\n}\n\n/**\n * A wildcard parameter designed to match multiple segments.\n */\nexport interface Wildcard {\n  type: \"wildcard\";\n  name: string;\n}\n\n/**\n * A set of possible tokens to expand when matching.\n */\nexport interface Group {\n  type: \"group\";\n  tokens: Token[];\n}\n\n/**\n * A token that corresponds with a regexp capture.\n */\nexport type Key = Parameter | Wildcard;\n\n/**\n * A sequence of `path-to-regexp` keys that match capturing groups.\n */\nexport type Keys = Array<Key>;\n\n/**\n * A sequence of path match characters.\n */\nexport type Token = Text | Parameter | Wildcard | Group;\n\n/**\n * Tokenized path instance.\n */\nexport class TokenData {\n  constructor(public readonly tokens: Token[]) {}\n}\n\n/**\n * Parse a string for the raw tokens.\n */\nexport function parse(str: string, options: ParseOptions = {}): TokenData {\n  const { encodePath = NOOP_VALUE } = options;\n  const it = new Iter(lexer(str));\n\n  function consume(endType: TokenType): Token[] {\n    const tokens: Token[] = [];\n\n    while (true) {\n      const path = it.text();\n      if (path) tokens.push({ type: \"text\", value: encodePath(path) });\n\n      const param = it.tryConsume(\"PARAM\");\n      if (param) {\n        tokens.push({\n          type: \"param\",\n          name: param,\n        });\n        continue;\n      }\n\n      const wildcard = it.tryConsume(\"WILDCARD\");\n      if (wildcard) {\n        tokens.push({\n          type: \"wildcard\",\n          name: wildcard,\n        });\n        continue;\n      }\n\n      const open = it.tryConsume(\"{\");\n      if (open) {\n        tokens.push({\n          type: \"group\",\n          tokens: consume(\"}\"),\n        });\n        continue;\n      }\n\n      it.consume(endType);\n      return tokens;\n    }\n  }\n\n  const tokens = consume(\"END\");\n  return new TokenData(tokens);\n}\n\n/**\n * Compile a string to a template function for the path.\n */\nexport function compile<P extends ParamData = ParamData>(\n  path: Path,\n  options: CompileOptions & ParseOptions = {},\n) {\n  const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } =\n    options;\n  const data = path instanceof TokenData ? path : parse(path, options);\n  const fn = tokensToFunction(data.tokens, delimiter, encode);\n\n  return function path(data: P = {} as P) {\n    const [path, ...missing] = fn(data);\n    if (missing.length) {\n      throw new TypeError(`Missing parameters: ${missing.join(\", \")}`);\n    }\n    return path;\n  };\n}\n\nexport type ParamData = Partial<Record<string, string | string[]>>;\nexport type PathFunction<P extends ParamData> = (data?: P) => string;\n\nfunction tokensToFunction(\n  tokens: Token[],\n  delimiter: string,\n  encode: Encode | false,\n) {\n  const encoders = tokens.map((token) =>\n    tokenToFunction(token, delimiter, encode),\n  );\n\n  return (data: ParamData) => {\n    const result: string[] = [\"\"];\n\n    for (const encoder of encoders) {\n      const [value, ...extras] = encoder(data);\n      result[0] += value;\n      result.push(...extras);\n    }\n\n    return result;\n  };\n}\n\n/**\n * Convert a single token into a path building function.\n */\nfunction tokenToFunction(\n  token: Token,\n  delimiter: string,\n  encode: Encode | false,\n): (data: ParamData) => string[] {\n  if (token.type === \"text\") return () => [token.value];\n\n  if (token.type === \"group\") {\n    const fn = tokensToFunction(token.tokens, delimiter, encode);\n\n    return (data) => {\n      const [value, ...missing] = fn(data);\n      if (!missing.length) return [value];\n      return [\"\"];\n    };\n  }\n\n  const encodeValue = encode || NOOP_VALUE;\n\n  if (token.type === \"wildcard\" && encode !== false) {\n    return (data) => {\n      const value = data[token.name];\n      if (value == null) return [\"\", token.name];\n\n      if (!Array.isArray(value) || value.length === 0) {\n        throw new TypeError(`Expected \"${token.name}\" to be a non-empty array`);\n      }\n\n      return [\n        value\n          .map((value, index) => {\n            if (typeof value !== \"string\") {\n              throw new TypeError(\n                `Expected \"${token.name}/${index}\" to be a string`,\n              );\n            }\n\n            return encodeValue(value);\n          })\n          .join(delimiter),\n      ];\n    };\n  }\n\n  return (data) => {\n    const value = data[token.name];\n    if (value == null) return [\"\", token.name];\n\n    if (typeof value !== \"string\") {\n      throw new TypeError(`Expected \"${token.name}\" to be a string`);\n    }\n\n    return [encodeValue(value)];\n  };\n}\n\n/**\n * A match result contains data about the path match.\n */\nexport interface MatchResult<P extends ParamData> {\n  path: string;\n  params: P;\n}\n\n/**\n * A match is either `false` (no match) or a match result.\n */\nexport type Match<P extends ParamData> = false | MatchResult<P>;\n\n/**\n * The match function takes a string and returns whether it matched the path.\n */\nexport type MatchFunction<P extends ParamData> = (path: string) => Match<P>;\n\n/**\n * Supported path types.\n */\nexport type Path = string | TokenData;\n\n/**\n * Transform a path into a match function.\n */\nexport function match<P extends ParamData>(\n  path: Path | Path[],\n  options: MatchOptions & ParseOptions = {},\n): MatchFunction<P> {\n  const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } =\n    options;\n  const { regexp, keys } = pathToRegexp(path, options);\n\n  const decoders = keys.map((key) => {\n    if (decode === false) return NOOP_VALUE;\n    if (key.type === \"param\") return decode;\n    return (value: string) => value.split(delimiter).map(decode);\n  });\n\n  return function match(input: string) {\n    const m = regexp.exec(input);\n    if (!m) return false;\n\n    const path = m[0];\n    const params = Object.create(null);\n\n    for (let i = 1; i < m.length; i++) {\n      if (m[i] === undefined) continue;\n\n      const key = keys[i - 1];\n      const decoder = decoders[i - 1];\n      params[key.name] = decoder(m[i]);\n    }\n\n    return { path, params };\n  };\n}\n\nexport function pathToRegexp(\n  path: Path | Path[],\n  options: PathToRegexpOptions & ParseOptions = {},\n) {\n  const {\n    delimiter = DEFAULT_DELIMITER,\n    end = true,\n    sensitive = false,\n    trailing = true,\n  } = options;\n  const keys: Keys = [];\n  const sources: string[] = [];\n  const flags = sensitive ? \"\" : \"i\";\n  const paths = Array.isArray(path) ? path : [path];\n  const items = paths.map((path) =>\n    path instanceof TokenData ? path : parse(path, options),\n  );\n\n  for (const { tokens } of items) {\n    for (const seq of flatten(tokens, 0, [])) {\n      const regexp = sequenceToRegExp(seq, delimiter, keys);\n      sources.push(regexp);\n    }\n  }\n\n  let pattern = `^(?:${sources.join(\"|\")})`;\n  if (trailing) pattern += `(?:${escape(delimiter)}$)?`;\n  pattern += end ? \"$\" : `(?=${escape(delimiter)}|$)`;\n\n  const regexp = new RegExp(pattern, flags);\n  return { regexp, keys };\n}\n\n/**\n * Flattened token set.\n */\ntype Flattened = Text | Parameter | Wildcard;\n\n/**\n * Generate a flat list of sequence tokens from the given tokens.\n */\nfunction* flatten(\n  tokens: Token[],\n  index: number,\n  init: Flattened[],\n): Generator<Flattened[]> {\n  if (index === tokens.length) {\n    return yield init;\n  }\n\n  const token = tokens[index];\n\n  if (token.type === \"group\") {\n    const fork = init.slice();\n    for (const seq of flatten(token.tokens, 0, fork)) {\n      yield* flatten(tokens, index + 1, seq);\n    }\n  } else {\n    init.push(token);\n  }\n\n  yield* flatten(tokens, index + 1, init);\n}\n\n/**\n * Transform a flat sequence of tokens into a regular expression.\n */\nfunction sequenceToRegExp(tokens: Flattened[], delimiter: string, keys: Keys) {\n  let result = \"\";\n  let backtrack = \"\";\n  let isSafeSegmentParam = true;\n\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n\n    if (token.type === \"text\") {\n      result += escape(token.value);\n      backtrack += token.value;\n      isSafeSegmentParam ||= token.value.includes(delimiter);\n      continue;\n    }\n\n    if (token.type === \"param\" || token.type === \"wildcard\") {\n      if (!isSafeSegmentParam && !backtrack) {\n        throw new TypeError(`Missing text after \"${token.name}\": ${DEBUG_URL}`);\n      }\n\n      if (token.type === \"param\") {\n        result += `(${negate(delimiter, isSafeSegmentParam ? \"\" : backtrack)}+)`;\n      } else {\n        result += `([\\\\s\\\\S]+)`;\n      }\n\n      keys.push(token);\n      backtrack = \"\";\n      isSafeSegmentParam = false;\n      continue;\n    }\n  }\n\n  return result;\n}\n\nfunction negate(delimiter: string, backtrack: string) {\n  if (backtrack.length < 2) {\n    if (delimiter.length < 2) return `[^${escape(delimiter + backtrack)}]`;\n    return `(?:(?!${escape(delimiter)})[^${escape(backtrack)}])`;\n  }\n  if (delimiter.length < 2) {\n    return `(?:(?!${escape(backtrack)})[^${escape(delimiter)}])`;\n  }\n  return `(?:(?!${escape(backtrack)}|${escape(delimiter)})[\\\\s\\\\S])`;\n}\n\n/**\n * Stringify token data into a path string.\n */\nexport function stringify(data: TokenData) {\n  return data.tokens\n    .map(function stringifyToken(token, index, tokens): string {\n      if (token.type === \"text\") return escapeText(token.value);\n      if (token.type === \"group\") {\n        return `{${token.tokens.map(stringifyToken).join(\"\")}}`;\n      }\n\n      const isSafe =\n        isNameSafe(token.name) && isNextNameSafe(tokens[index + 1]);\n      const key = isSafe ? token.name : JSON.stringify(token.name);\n\n      if (token.type === \"param\") return `:${key}`;\n      if (token.type === \"wildcard\") return `*${key}`;\n      throw new TypeError(`Unexpected token: ${token}`);\n    })\n    .join(\"\");\n}\n\nfunction isNameSafe(name: string) {\n  const [first, ...rest] = name;\n  if (!ID_START.test(first)) return false;\n  return rest.every((char) => ID_CONTINUE.test(char));\n}\n\nfunction isNextNameSafe(token: Token | undefined) {\n  if (token?.type !== \"text\") return true;\n  return !ID_CONTINUE.test(token.value[0]);\n}\n","/**\n * Universal Router (https://www.kriasoft.com/universal-router/)\n *\n * Copyright (c) 2015-present Kriasoft.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.txt file in the root directory of this source tree.\n */\n\nimport { match } from './path-to-regexp.js'\nimport type {\n  Path,\n  Match,\n  MatchFunction,\n  ParseOptions,\n  MatchOptions,\n  PathToRegexpOptions,\n  CompileOptions,\n} from './path-to-regexp.js'\n\n/**\n * In addition to a URL path string, any arbitrary data can be passed to\n * the `router.resolve()` method, that becomes available inside action functions.\n */\nexport interface RouterContext {\n  [propName: string]: any\n}\n\nexport interface ResolveContext extends RouterContext {\n  /**\n   * URL which was transmitted to `router.resolve()`.\n   */\n  pathname: string\n}\n\n/**\n * Params is a key/value object that represents extracted URL parameters.\n */\nexport interface RouteParams {\n  [paramName: string]: string | string[]\n}\n\nexport type RouteResult<T> =\n  | T\n  | null\n  | undefined\n  | Promise<T | null | undefined>\n\nexport interface RouteContext<R = any, C extends RouterContext = RouterContext>\n  extends ResolveContext {\n  /**\n   * Current router instance.\n   */\n  router: UniversalRouter<R, C>\n  /**\n   * Matched route object.\n   */\n  route: Route<R, C>\n  /**\n   * Base URL path relative to the path of the current route.\n   */\n  baseUrl: string\n  /**\n   * Matched path.\n   */\n  path: string\n  /**\n   * Matched path params.\n   */\n  params: RouteParams\n  /**\n   * Middleware style function which can continue resolving.\n   */\n  next: (resume?: boolean) => Promise<R>\n}\n\n/**\n * A Route is a singular route in your application. It contains a path, an\n * action function, and optional children which are an array of Route.\n * @template C User context that is made union with RouterContext.\n * @template R Result that every action function resolves to.\n * If the action returns a Promise, R can be the type the Promise resolves to.\n */\nexport interface Route<R = any, C extends RouterContext = RouterContext> {\n  /**\n   * A string, array of strings, or a regular expression. Defaults to an empty string.\n   */\n  path?: Path | Path[]\n  /**\n   * A unique string that can be used to generate the route URL.\n   */\n  name?: string\n  /**\n   * The link to the parent route is automatically populated by the router. Useful for breadcrumbs.\n   */\n  parent?: Route<R, C> | null\n  /**\n   * An array of Route objects. Nested routes are perfect to be used in middleware routes.\n   */\n  children?: Routes<R, C> | null\n  /**\n   * Action method should return anything except `null` or `undefined` to be resolved by router\n   * otherwise router will throw `Page not found` error if all matched routes returned nothing.\n   */\n  action?: (context: RouteContext<R, C>, params: RouteParams) => RouteResult<R>\n  /**\n   * The route path match function. Used for internal caching.\n   */\n  match?: MatchFunction<RouteParams>\n}\n\n/**\n * Routes is an array of type Route.\n * @template C User context that is made union with RouterContext.\n * @template R Result that every action function resolves to.\n * If the action returns a Promise, R can be the type the Promise resolves to.\n */\nexport type Routes<R = any, C extends RouterContext = RouterContext> = Route<\n  R,\n  C\n>[]\n\nexport type ResolveRoute<R = any, C extends RouterContext = RouterContext> = (\n  context: RouteContext<R, C>,\n  params: RouteParams,\n) => RouteResult<R>\n\nexport type RouteError = Error & { status?: number }\n\nexport type ErrorHandler<R = any> = (\n  error: RouteError,\n  context: ResolveContext,\n) => RouteResult<R>\n\nexport interface RouterOptions<R = any, C extends RouterContext = RouterContext>\n  extends ParseOptions,\n    MatchOptions,\n    PathToRegexpOptions,\n    CompileOptions {\n  context?: C\n  baseUrl?: string\n  resolveRoute?: ResolveRoute<R, C>\n  errorHandler?: ErrorHandler<R>\n}\n\nexport interface RouteMatch<R = any, C extends RouterContext = RouterContext> {\n  route: Route<R, C>\n  baseUrl: string\n  path: string\n  params: RouteParams\n}\n\nfunction decode(val: string): string {\n  try {\n    return decodeURIComponent(val)\n  } catch {\n    return val\n  }\n}\n\nfunction matchRoute<R, C extends RouterContext>(\n  route: Route<R, C>,\n  baseUrl: string,\n  options: RouterOptions<R, C>,\n  pathname: string,\n  parentParams?: RouteParams,\n): Iterator<RouteMatch<R, C>, false, Route<R, C> | false> {\n  let matchResult: Match<RouteParams>\n  let childMatches: Iterator<\n    RouteMatch<R, C>,\n    false,\n    Route<R, C> | false\n  > | null\n  let childIndex = 0\n\n  return {\n    next(\n      routeToSkip: Route<R, C> | false,\n    ): IteratorResult<RouteMatch<R, C>, false> {\n      if (route === routeToSkip) {\n        return { done: true, value: false }\n      }\n\n      if (!matchResult) {\n        const rt = route\n        const end = !rt.children\n        if (!rt.match) {\n          rt.match = match<RouteParams>(rt.path || '', { end, ...options })\n        }\n        matchResult = rt.match(pathname)\n\n        if (matchResult) {\n          const { path } = matchResult\n          matchResult.path =\n            !end && path.charAt(path.length - 1) === '/' ? path.substr(1) : path\n          matchResult.params = { ...parentParams, ...matchResult.params }\n          return {\n            done: false,\n            value: {\n              route,\n              baseUrl,\n              path: matchResult.path,\n              params: matchResult.params,\n            },\n          }\n        }\n      }\n\n      if (matchResult && route.children) {\n        while (childIndex < route.children.length) {\n          if (!childMatches) {\n            const childRoute = route.children[childIndex]!\n            childRoute.parent = route\n\n            childMatches = matchRoute<R, C>(\n              childRoute,\n              baseUrl + matchResult.path,\n              options,\n              pathname.substr(matchResult.path.length),\n              matchResult.params,\n            )\n          }\n\n          const childMatch = childMatches.next(routeToSkip)\n          if (!childMatch.done) {\n            return { done: false, value: childMatch.value }\n          }\n\n          childMatches = null\n          childIndex++\n        }\n      }\n\n      return { done: true, value: false }\n    },\n  }\n}\n\nfunction resolveRoute<R = any, C extends RouterContext = object>(\n  context: RouteContext<R, C>,\n  params: RouteParams,\n): RouteResult<R> {\n  if (typeof context.route.action === 'function') {\n    return context.route.action(context, params)\n  }\n  return undefined\n}\n\nfunction isChildRoute<R = any, C extends RouterContext = object>(\n  parentRoute: Route<R, C> | false,\n  childRoute: Route<R, C>,\n): boolean {\n  let route: Route<R, C> | null | undefined = childRoute\n  while (route) {\n    route = route.parent\n    if (route === parentRoute) {\n      return true\n    }\n  }\n  return false\n}\n\nclass UniversalRouter<R = any, C extends RouterContext = RouterContext> {\n  root: Route<R, C>\n\n  baseUrl: string\n\n  options: RouterOptions<R, C>\n\n  constructor(\n    routes: Routes<R, C> | Route<R, C>,\n    options?: RouterOptions<R, C>,\n  ) {\n    if (!routes || typeof routes !== 'object') {\n      throw new TypeError('Invalid routes')\n    }\n\n    this.options = { decode, ...options }\n    this.baseUrl = this.options.baseUrl || ''\n    this.root = Array.isArray(routes)\n      ? { path: '', children: routes, parent: null }\n      : routes\n    this.root.parent = null\n  }\n\n  /**\n   * Traverses the list of routes in the order they are defined until it finds\n   * the first route that matches provided URL path string and whose action function\n   * returns anything other than `null` or `undefined`.\n   */\n  resolve(pathnameOrContext: string | ResolveContext): Promise<RouteResult<R>> {\n    const context: ResolveContext = {\n      router: this,\n      ...this.options.context,\n      ...(typeof pathnameOrContext === 'string'\n        ? { pathname: pathnameOrContext }\n        : pathnameOrContext),\n    }\n    const matchResult = matchRoute(\n      this.root,\n      this.baseUrl,\n      this.options,\n      context.pathname.substr(this.baseUrl.length),\n    )\n    const resolve = this.options.resolveRoute || resolveRoute\n    let matches: IteratorResult<RouteMatch<R, C>, false>\n    let nextMatches: IteratorResult<RouteMatch<R, C>, false> | null\n    let currentContext = context\n\n    function next(\n      resume: boolean,\n      parent: Route<R, C> | false = !matches.done && matches.value.route,\n      prevResult?: RouteResult<R>,\n    ): Promise<RouteResult<R>> {\n      const routeToSkip =\n        prevResult === null && !matches.done && matches.value.route\n      matches = nextMatches || matchResult.next(routeToSkip)\n      nextMatches = null\n\n      if (!resume) {\n        if (matches.done || !isChildRoute(parent, matches.value.route)) {\n          nextMatches = matches\n          return Promise.resolve(null)\n        }\n      }\n\n      if (matches.done) {\n        const error: RouteError = new Error('Route not found')\n        error.status = 404\n        return Promise.reject(error)\n      }\n\n      currentContext = { ...context, ...matches.value }\n\n      return Promise.resolve(\n        resolve(currentContext as RouteContext<R, C>, matches.value.params),\n      ).then((result) => {\n        if (result !== null && result !== undefined) {\n          return result\n        }\n        return next(resume, parent, result)\n      })\n    }\n\n    context['next'] = next\n\n    return Promise.resolve()\n      .then(() => next(true, this.root))\n      .catch((error: RouteError) => {\n        if (this.options.errorHandler) {\n          return this.options.errorHandler(error, currentContext)\n        }\n        throw error\n      })\n  }\n}\n\nexport default UniversalRouter\n"]}