{"mappings":";AACA,IAAMA,EAAc,iBAYdC,EAAW,2EAWXC,EAAY,kEAuBlB,SAASC,EAAcC,EAAa,CAClC,OAAOJ,EAAY,KAAKI,CAAK,CAC/B,CAEA,SAASC,EAAoBD,EAAa,CACxC,OAAOA,EAAM,WAAW,IAAI,CAC9B,CAEA,SAASE,EAAeF,EAAa,CACnC,OAAOA,EAAM,WAAW,GAAG,CAC7B,CAEA,SAASG,EAAUH,EAAa,CAC9B,OAAOA,EAAM,WAAW,OAAO,CACjC,CAEA,SAASI,EAAWJ,EAAa,CAC/B,MAAO,SAAS,KAAKA,CAAK,CAC5B,CAEA,SAASK,EAAiBL,EAAa,CACrC,IAAMM,EAAQT,EAAS,KAAKG,CAAK,EACjC,OAAOO,EACLD,EAAM,CAAC,EACPA,EAAM,CAAC,GAAK,GACZA,EAAM,CAAC,EACPA,EAAM,CAAC,GAAK,GACZA,EAAM,CAAC,GAAK,IACZA,EAAM,CAAC,GAAK,GACZA,EAAM,CAAC,GAAK,EAAE,CAElB,CAEA,SAASE,EAAaR,EAAa,CACjC,IAAMM,EAAQR,EAAU,KAAKE,CAAK,EAC5BS,EAAOH,EAAM,CAAC,EACpB,OAAOC,EACL,QACA,GACAD,EAAM,CAAC,GAAK,GACZ,GACAJ,EAAeO,CAAI,EAAIA,EAAO,IAAMA,EACpCH,EAAM,CAAC,GAAK,GACZA,EAAM,CAAC,GAAK,EAAE,CAElB,CAEA,SAASC,EACPG,EACAC,EACAC,EACAC,EACAJ,EACAK,EACAC,EAAY,CAEZ,MAAO,CACL,OAAAL,EACA,KAAAC,EACA,KAAAC,EACA,KAAAC,EACA,KAAAJ,EACA,MAAAK,EACA,KAAAC,EACA,KAAI,EAER,CAEA,SAASC,EAAShB,EAAa,CAC7B,GAAIC,EAAoBD,CAAK,EAAG,CAC9B,IAAMiB,EAAMZ,EAAiB,QAAUL,CAAK,EAC5C,OAAAiB,EAAI,OAAS,GACbA,EAAI,KAAI,EACDA,EAGT,GAAIf,EAAeF,CAAK,EAAG,CACzB,IAAMiB,EAAMZ,EAAiB,iBAAmBL,CAAK,EACrD,OAAAiB,EAAI,OAAS,GACbA,EAAI,KAAO,GACXA,EAAI,KAAI,EACDA,EAGT,GAAId,EAAUH,CAAK,EAAG,OAAOQ,EAAaR,CAAK,EAE/C,GAAID,EAAcC,CAAK,EAAG,OAAOK,EAAiBL,CAAK,EAEvD,IAAMiB,EAAMZ,EAAiB,kBAAoBL,CAAK,EACtD,OAAAiB,EAAI,OAAS,GACbA,EAAI,KAAO,GACXA,EAAI,KAAOjB,EACPA,EAAM,WAAW,GAAG,IAElBA,EAAM,WAAW,GAAG,QAInBiB,CACT,CAEA,SAASC,EAAkBT,EAAY,CAGrC,GAAIA,EAAK,SAAS,KAAK,EAAG,OAAOA,EACjC,IAAMU,EAAQV,EAAK,YAAY,GAAG,EAClC,OAAOA,EAAK,MAAM,EAAGU,EAAQ,CAAC,CAChC,CAEA,SAASC,EAAWH,EAAUI,EAAS,CACrCC,EAAcD,EAAMA,EAAK,IAAI,EAIzBJ,EAAI,OAAS,IACfA,EAAI,KAAOI,EAAK,KAGhBJ,EAAI,KAAOC,EAAkBG,EAAK,IAAI,EAAIJ,EAAI,IAElD,CAMA,SAASK,EAAcL,EAAUM,EAAa,CAC5C,IAAMC,EAAMD,GAAI,EACVE,EAASR,EAAI,KAAK,MAAM,GAAG,EAI7BS,EAAU,EAIVC,EAAW,EAKXC,EAAmB,GAEvB,QAASC,EAAI,EAAGA,EAAIJ,EAAO,OAAQI,IAAK,CACtC,IAAMC,EAAQL,EAAOI,CAAC,EAGtB,GAAI,CAACC,EAAO,CACVF,EAAmB,GACnB,SAOF,GAHAA,EAAmB,GAGfE,IAAU,IAId,IAAIA,IAAU,KAAM,CACdH,GACFC,EAAmB,GACnBD,IACAD,KACSF,IAGTC,EAAOC,GAAS,EAAII,GAEtB,SAKFL,EAAOC,GAAS,EAAII,EACpBH,KAGF,IAAIlB,EAAO,GACX,QAASoB,EAAI,EAAGA,EAAIH,EAASG,IAC3BpB,GAAQ,IAAMgB,EAAOI,CAAC,GAEpB,CAACpB,GAASmB,GAAoB,CAACnB,EAAK,SAAS,KAAK,KACpDA,GAAQ,KAEVQ,EAAI,KAAOR,CACb,UAKwBsB,EAAQ/B,EAAeqB,EAAwB,CACrE,GAAI,CAACrB,GAAS,CAACqB,EAAM,MAAO,GAE5B,IAAMJ,EAAMD,EAAShB,CAAK,EACtBgC,EAAYf,EAAI,KAEpB,GAAII,GAAQW,IAAS,EAAuB,CAC1C,IAAMC,EAAUjB,EAASK,CAAI,EACvBa,EAAWD,EAAQ,KAEzB,OAAQD,EAAS,CACf,IAAA,GACEf,EAAI,KAAOgB,EAAQ,KAGrB,IAAA,GACEhB,EAAI,MAAQgB,EAAQ,MAGtB,IAAA,GACA,IAAA,GACEb,EAAWH,EAAKgB,CAAO,EAGzB,IAAA,GAEEhB,EAAI,KAAOgB,EAAQ,KACnBhB,EAAI,KAAOgB,EAAQ,KACnBhB,EAAI,KAAOgB,EAAQ,KAGrB,IAAA,GAEEhB,EAAI,OAASgB,EAAQ,OAErBC,EAAWF,IAAWA,EAAYE,GAGxCZ,EAAcL,EAAKe,CAAS,EAE5B,IAAMG,EAAYlB,EAAI,MAAQA,EAAI,KAClC,OAAQe,EAAS,CAIf,IAAA,GACA,IAAA,GACE,OAAOG,EAET,IAAA,GAA2B,CAEzB,IAAM1B,EAAOQ,EAAI,KAAK,MAAM,CAAC,EAE7B,OAAKR,EAEDL,EAAWiB,GAAQrB,CAAK,GAAK,CAACI,EAAWK,CAAI,EAIxC,KAAOA,EAAO0B,EAGhB1B,EAAO0B,EATIA,GAAa,IAYjC,IAAA,GACE,OAAOlB,EAAI,KAAOkB,EAEpB,QACE,OAAOlB,EAAI,OAAS,KAAOA,EAAI,KAAOA,EAAI,KAAOA,EAAI,KAAOA,EAAI,KAAOkB,EAE7E","names":["schemeRegex","urlRegex","fileRegex","isAbsoluteUrl","input","isSchemeRelativeUrl","isAbsolutePath","isFileUrl","isRelative","parseAbsoluteUrl","match","makeUrl","parseFileUrl","path","scheme","user","host","port","query","hash","parseUrl","url","stripPathFilename","index","mergePaths","base","normalizePath","type","rel","pieces","pointer","positive","addTrailingSlash","i","piece","resolve","inputType","baseUrl","baseType","queryHash"],"sources":["../esm/npm/@jridgewell/resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/src/resolve-uri.ts"],"sourcesContent":["// Matches the scheme of a URL, eg \"http://\"\nconst schemeRegex = /^[\\w+.-]+:\\/\\//;\n\n/**\n * Matches the parts of a URL:\n * 1. Scheme, including \":\", guaranteed.\n * 2. User/password, including \"@\", optional.\n * 3. Host, guaranteed.\n * 4. Port, including \":\", optional.\n * 5. Path, including \"/\", optional.\n * 6. Query, including \"?\", optional.\n * 7. Hash, including \"#\", optional.\n */\nconst urlRegex = /^([\\w+.-]+:)\\/\\/([^@/#?]*@)?([^:/#?]*)(:\\d+)?(\\/[^#?]*)?(\\?[^#]*)?(#.*)?/;\n\n/**\n * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start\n * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).\n *\n * 1. Host, optional.\n * 2. Path, which may include \"/\", guaranteed.\n * 3. Query, including \"?\", optional.\n * 4. Hash, including \"#\", optional.\n */\nconst fileRegex = /^file:(?:\\/\\/((?![a-z]:)[^/#?]*)?)?(\\/?[^#?]*)(\\?[^#]*)?(#.*)?/i;\n\ntype Url = {\n  scheme: string;\n  user: string;\n  host: string;\n  port: string;\n  path: string;\n  query: string;\n  hash: string;\n  type: UrlType;\n};\n\nconst enum UrlType {\n  Empty = 1,\n  Hash = 2,\n  Query = 3,\n  RelativePath = 4,\n  AbsolutePath = 5,\n  SchemeRelative = 6,\n  Absolute = 7,\n}\n\nfunction isAbsoluteUrl(input: string): boolean {\n  return schemeRegex.test(input);\n}\n\nfunction isSchemeRelativeUrl(input: string): boolean {\n  return input.startsWith('//');\n}\n\nfunction isAbsolutePath(input: string): boolean {\n  return input.startsWith('/');\n}\n\nfunction isFileUrl(input: string): boolean {\n  return input.startsWith('file:');\n}\n\nfunction isRelative(input: string): boolean {\n  return /^[.?#]/.test(input);\n}\n\nfunction parseAbsoluteUrl(input: string): Url {\n  const match = urlRegex.exec(input)!;\n  return makeUrl(\n    match[1],\n    match[2] || '',\n    match[3],\n    match[4] || '',\n    match[5] || '/',\n    match[6] || '',\n    match[7] || '',\n  );\n}\n\nfunction parseFileUrl(input: string): Url {\n  const match = fileRegex.exec(input)!;\n  const path = match[2];\n  return makeUrl(\n    'file:',\n    '',\n    match[1] || '',\n    '',\n    isAbsolutePath(path) ? path : '/' + path,\n    match[3] || '',\n    match[4] || '',\n  );\n}\n\nfunction makeUrl(\n  scheme: string,\n  user: string,\n  host: string,\n  port: string,\n  path: string,\n  query: string,\n  hash: string,\n): Url {\n  return {\n    scheme,\n    user,\n    host,\n    port,\n    path,\n    query,\n    hash,\n    type: UrlType.Absolute,\n  };\n}\n\nfunction parseUrl(input: string): Url {\n  if (isSchemeRelativeUrl(input)) {\n    const url = parseAbsoluteUrl('http:' + input);\n    url.scheme = '';\n    url.type = UrlType.SchemeRelative;\n    return url;\n  }\n\n  if (isAbsolutePath(input)) {\n    const url = parseAbsoluteUrl('http://foo.com' + input);\n    url.scheme = '';\n    url.host = '';\n    url.type = UrlType.AbsolutePath;\n    return url;\n  }\n\n  if (isFileUrl(input)) return parseFileUrl(input);\n\n  if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);\n\n  const url = parseAbsoluteUrl('http://foo.com/' + input);\n  url.scheme = '';\n  url.host = '';\n  url.type = input\n    ? input.startsWith('?')\n      ? UrlType.Query\n      : input.startsWith('#')\n      ? UrlType.Hash\n      : UrlType.RelativePath\n    : UrlType.Empty;\n  return url;\n}\n\nfunction stripPathFilename(path: string): string {\n  // If a path ends with a parent directory \"..\", then it's a relative path with excess parent\n  // paths. It's not a file, so we can't strip it.\n  if (path.endsWith('/..')) return path;\n  const index = path.lastIndexOf('/');\n  return path.slice(0, index + 1);\n}\n\nfunction mergePaths(url: Url, base: Url) {\n  normalizePath(base, base.type);\n\n  // If the path is just a \"/\", then it was an empty path to begin with (remember, we're a relative\n  // path).\n  if (url.path === '/') {\n    url.path = base.path;\n  } else {\n    // Resolution happens relative to the base path's directory, not the file.\n    url.path = stripPathFilename(base.path) + url.path;\n  }\n}\n\n/**\n * The path can have empty directories \"//\", unneeded parents \"foo/..\", or current directory\n * \"foo/.\". We need to normalize to a standard representation.\n */\nfunction normalizePath(url: Url, type: UrlType) {\n  const rel = type \u003c= UrlType.RelativePath;\n  const pieces = url.path.split('/');\n\n  // We need to preserve the first piece always, so that we output a leading slash. The item at\n  // pieces[0] is an empty string.\n  let pointer = 1;\n\n  // Positive is the number of real directories we've output, used for popping a parent directory.\n  // Eg, \"foo/bar/..\" will have a positive 2, and we can decrement to be left with just \"foo\".\n  let positive = 0;\n\n  // We need to keep a trailing slash if we encounter an empty directory (eg, splitting \"foo/\" will\n  // generate `[\"foo\", \"\"]` pieces). And, if we pop a parent directory. But once we encounter a\n  // real directory, we won't need to append, unless the other conditions happen again.\n  let addTrailingSlash = false;\n\n  for (let i = 1; i \u003c pieces.length; i++) {\n    const piece = pieces[i];\n\n    // An empty directory, could be a trailing slash, or just a double \"//\" in the path.\n    if (!piece) {\n      addTrailingSlash = true;\n      continue;\n    }\n\n    // If we encounter a real directory, then we don't need to append anymore.\n    addTrailingSlash = false;\n\n    // A current directory, which we can always drop.\n    if (piece === '.') continue;\n\n    // A parent directory, we need to see if there are any real directories we can pop. Else, we\n    // have an excess of parents, and we'll need to keep the \"..\".\n    if (piece === '..') {\n      if (positive) {\n        addTrailingSlash = true;\n        positive--;\n        pointer--;\n      } else if (rel) {\n        // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute\n        // URL, protocol relative URL, or an absolute path, we don't need to keep excess.\n        pieces[pointer++] = piece;\n      }\n      continue;\n    }\n\n    // We've encountered a real directory. Move it to the next insertion pointer, which accounts for\n    // any popped or dropped directories.\n    pieces[pointer++] = piece;\n    positive++;\n  }\n\n  let path = '';\n  for (let i = 1; i \u003c pointer; i++) {\n    path += '/' + pieces[i];\n  }\n  if (!path || (addTrailingSlash \u0026\u0026 !path.endsWith('/..'))) {\n    path += '/';\n  }\n  url.path = path;\n}\n\n/**\n * Attempts to resolve `input` URL/path relative to `base`.\n */\nexport default function resolve(input: string, base: string | undefined): string {\n  if (!input \u0026\u0026 !base) return '';\n\n  const url = parseUrl(input);\n  let inputType = url.type;\n\n  if (base \u0026\u0026 inputType !== UrlType.Absolute) {\n    const baseUrl = parseUrl(base);\n    const baseType = baseUrl.type;\n\n    switch (inputType) {\n      case UrlType.Empty:\n        url.hash = baseUrl.hash;\n      // fall through\n\n      case UrlType.Hash:\n        url.query = baseUrl.query;\n      // fall through\n\n      case UrlType.Query:\n      case UrlType.RelativePath:\n        mergePaths(url, baseUrl);\n      // fall through\n\n      case UrlType.AbsolutePath:\n        // The host, user, and port are joined, you can't copy one without the others.\n        url.user = baseUrl.user;\n        url.host = baseUrl.host;\n        url.port = baseUrl.port;\n      // fall through\n\n      case UrlType.SchemeRelative:\n        // The input doesn't have a schema at least, so we need to copy at least that over.\n        url.scheme = baseUrl.scheme;\n    }\n    if (baseType \u003e inputType) inputType = baseType;\n  }\n\n  normalizePath(url, inputType);\n\n  const queryHash = url.query + url.hash;\n  switch (inputType) {\n    // This is impossible, because of the empty checks at the start of the function.\n    // case UrlType.Empty:\n\n    case UrlType.Hash:\n    case UrlType.Query:\n      return queryHash;\n\n    case UrlType.RelativePath: {\n      // The first char is always a \"/\", and we need it to be relative.\n      const path = url.path.slice(1);\n\n      if (!path) return queryHash || '.';\n\n      if (isRelative(base || input) \u0026\u0026 !isRelative(path)) {\n        // If base started with a leading \".\", or there is no base and input started with a \".\",\n        // then we need to ensure that the relative path starts with a \".\". We don't know if\n        // relative starts with a \"..\", though, so check before prepending.\n        return './' + path + queryHash;\n      }\n\n      return path + queryHash;\n    }\n\n    case UrlType.AbsolutePath:\n      return url.path + queryHash;\n\n    default:\n      return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;\n  }\n}\n"],"version":3}