@igstack/app-catalog-frontend-core 6.1.2 → 6.1.3

package/dist/esm/node_modules/.pnpm/@tanstack_router-core@1.151.6/node_modules/@tanstack/router-core/dist/esm/new-process-route-tree.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"new-process-route-tree.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@tanstack+router-core@1.151.6/node_modules/@tanstack/router-core/dist/esm/new-process-route-tree.js"],"sourcesContent":["import invariant from \"tiny-invariant\";\nimport { createLRUCache } from \"./lru-cache.js\";\nimport { last } from \"./utils.js\";\nconst SEGMENT_TYPE_PATHNAME = 0;\nconst SEGMENT_TYPE_PARAM = 1;\nconst SEGMENT_TYPE_WILDCARD = 2;\nconst SEGMENT_TYPE_OPTIONAL_PARAM = 3;\nconst SEGMENT_TYPE_INDEX = 4;\nconst SEGMENT_TYPE_PATHLESS = 5;\nconst PARAM_W_CURLY_BRACES_RE = /^([^{]*)\\{\\$([a-zA-Z_$][a-zA-Z0-9_$]*)\\}([^}]*)$/;\nconst OPTIONAL_PARAM_W_CURLY_BRACES_RE = /^([^{]*)\\{-\\$([a-zA-Z_$][a-zA-Z0-9_$]*)\\}([^}]*)$/;\nconst WILDCARD_W_CURLY_BRACES_RE = /^([^{]*)\\{\\$\\}([^}]*)$/;\nfunction parseSegment(path, start, output = new Uint16Array(6)) {\n  const next = path.indexOf(\"/\", start);\n  const end = next === -1 ? path.length : next;\n  const part = path.substring(start, end);\n  if (!part || !part.includes(\"$\")) {\n    output[0] = SEGMENT_TYPE_PATHNAME;\n    output[1] = start;\n    output[2] = start;\n    output[3] = end;\n    output[4] = end;\n    output[5] = end;\n    return output;\n  }\n  if (part === \"$\") {\n    const total = path.length;\n    output[0] = SEGMENT_TYPE_WILDCARD;\n    output[1] = start;\n    output[2] = start;\n    output[3] = total;\n    output[4] = total;\n    output[5] = total;\n    return output;\n  }\n  if (part.charCodeAt(0) === 36) {\n    output[0] = SEGMENT_TYPE_PARAM;\n    output[1] = start;\n    output[2] = start + 1;\n    output[3] = end;\n    output[4] = end;\n    output[5] = end;\n    return output;\n  }\n  const wildcardBracesMatch = part.match(WILDCARD_W_CURLY_BRACES_RE);\n  if (wildcardBracesMatch) {\n    const prefix = wildcardBracesMatch[1];\n    const pLength = prefix.length;\n    output[0] = SEGMENT_TYPE_WILDCARD;\n    output[1] = start + pLength;\n    output[2] = start + pLength + 1;\n    output[3] = start + pLength + 2;\n    output[4] = start + pLength + 3;\n    output[5] = path.length;\n    return output;\n  }\n  const optionalParamBracesMatch = part.match(OPTIONAL_PARAM_W_CURLY_BRACES_RE);\n  if (optionalParamBracesMatch) {\n    const prefix = optionalParamBracesMatch[1];\n    const paramName = optionalParamBracesMatch[2];\n    const suffix = optionalParamBracesMatch[3];\n    const pLength = prefix.length;\n    output[0] = SEGMENT_TYPE_OPTIONAL_PARAM;\n    output[1] = start + pLength;\n    output[2] = start + pLength + 3;\n    output[3] = start + pLength + 3 + paramName.length;\n    output[4] = end - suffix.length;\n    output[5] = end;\n    return output;\n  }\n  const paramBracesMatch = part.match(PARAM_W_CURLY_BRACES_RE);\n  if (paramBracesMatch) {\n    const prefix = paramBracesMatch[1];\n    const paramName = paramBracesMatch[2];\n    const suffix = paramBracesMatch[3];\n    const pLength = prefix.length;\n    output[0] = SEGMENT_TYPE_PARAM;\n    output[1] = start + pLength;\n    output[2] = start + pLength + 2;\n    output[3] = start + pLength + 2 + paramName.length;\n    output[4] = end - suffix.length;\n    output[5] = end;\n    return output;\n  }\n  output[0] = SEGMENT_TYPE_PATHNAME;\n  output[1] = start;\n  output[2] = start;\n  output[3] = end;\n  output[4] = end;\n  output[5] = end;\n  return output;\n}\nfunction parseSegments(defaultCaseSensitive, data, route, start, node, depth, onRoute) {\n  onRoute?.(route);\n  let cursor = start;\n  {\n    const path = route.fullPath ?? route.from;\n    const length = path.length;\n    const caseSensitive = route.options?.caseSensitive ?? defaultCaseSensitive;\n    const skipOnParamError = !!(route.options?.params?.parse && route.options?.skipRouteOnParseError?.params);\n    while (cursor < length) {\n      const segment = parseSegment(path, cursor, data);\n      let nextNode;\n      const start2 = cursor;\n      const end = segment[5];\n      cursor = end + 1;\n      depth++;\n      const kind = segment[0];\n      switch (kind) {\n        case SEGMENT_TYPE_PATHNAME: {\n          const value = path.substring(segment[2], segment[3]);\n          if (caseSensitive) {\n            const existingNode = node.static?.get(value);\n            if (existingNode) {\n              nextNode = existingNode;\n            } else {\n              node.static ??= /* @__PURE__ */ new Map();\n              const next = createStaticNode(\n                route.fullPath ?? route.from\n              );\n              next.parent = node;\n              next.depth = depth;\n              nextNode = next;\n              node.static.set(value, next);\n            }\n          } else {\n            const name = value.toLowerCase();\n            const existingNode = node.staticInsensitive?.get(name);\n            if (existingNode) {\n              nextNode = existingNode;\n            } else {\n              node.staticInsensitive ??= /* @__PURE__ */ new Map();\n              const next = createStaticNode(\n                route.fullPath ?? route.from\n              );\n              next.parent = node;\n              next.depth = depth;\n              nextNode = next;\n              node.staticInsensitive.set(name, next);\n            }\n          }\n          break;\n        }\n        case SEGMENT_TYPE_PARAM: {\n          const prefix_raw = path.substring(start2, segment[1]);\n          const suffix_raw = path.substring(segment[4], end);\n          const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);\n          const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();\n          const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();\n          const existingNode = !skipOnParamError && node.dynamic?.find(\n            (s) => !s.skipOnParamError && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix\n          );\n          if (existingNode) {\n            nextNode = existingNode;\n          } else {\n            const next = createDynamicNode(\n              SEGMENT_TYPE_PARAM,\n              route.fullPath ?? route.from,\n              actuallyCaseSensitive,\n              prefix,\n              suffix\n            );\n            nextNode = next;\n            next.depth = depth;\n            next.parent = node;\n            node.dynamic ??= [];\n            node.dynamic.push(next);\n          }\n          break;\n        }\n        case SEGMENT_TYPE_OPTIONAL_PARAM: {\n          const prefix_raw = path.substring(start2, segment[1]);\n          const suffix_raw = path.substring(segment[4], end);\n          const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);\n          const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();\n          const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();\n          const existingNode = !skipOnParamError && node.optional?.find(\n            (s) => !s.skipOnParamError && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix\n          );\n          if (existingNode) {\n            nextNode = existingNode;\n          } else {\n            const next = createDynamicNode(\n              SEGMENT_TYPE_OPTIONAL_PARAM,\n              route.fullPath ?? route.from,\n              actuallyCaseSensitive,\n              prefix,\n              suffix\n            );\n            nextNode = next;\n            next.parent = node;\n            next.depth = depth;\n            node.optional ??= [];\n            node.optional.push(next);\n          }\n          break;\n        }\n        case SEGMENT_TYPE_WILDCARD: {\n          const prefix_raw = path.substring(start2, segment[1]);\n          const suffix_raw = path.substring(segment[4], end);\n          const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);\n          const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();\n          const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();\n          const next = createDynamicNode(\n            SEGMENT_TYPE_WILDCARD,\n            route.fullPath ?? route.from,\n            actuallyCaseSensitive,\n            prefix,\n            suffix\n          );\n          nextNode = next;\n          next.parent = node;\n          next.depth = depth;\n          node.wildcard ??= [];\n          node.wildcard.push(next);\n        }\n      }\n      node = nextNode;\n    }\n    if (skipOnParamError && route.children && !route.isRoot && route.id && route.id.charCodeAt(route.id.lastIndexOf(\"/\") + 1) === 95) {\n      const pathlessNode = createStaticNode(\n        route.fullPath ?? route.from\n      );\n      pathlessNode.kind = SEGMENT_TYPE_PATHLESS;\n      pathlessNode.parent = node;\n      depth++;\n      pathlessNode.depth = depth;\n      node.pathless ??= [];\n      node.pathless.push(pathlessNode);\n      node = pathlessNode;\n    }\n    const isLeaf = (route.path || !route.children) && !route.isRoot;\n    if (isLeaf && path.endsWith(\"/\")) {\n      const indexNode = createStaticNode(\n        route.fullPath ?? route.from\n      );\n      indexNode.kind = SEGMENT_TYPE_INDEX;\n      indexNode.parent = node;\n      depth++;\n      indexNode.depth = depth;\n      node.index = indexNode;\n      node = indexNode;\n    }\n    node.parse = route.options?.params?.parse ?? null;\n    node.skipOnParamError = skipOnParamError;\n    node.parsingPriority = route.options?.skipRouteOnParseError?.priority ?? 0;\n    if (isLeaf && !node.route) {\n      node.route = route;\n      node.fullPath = route.fullPath ?? route.from;\n    }\n  }\n  if (route.children)\n    for (const child of route.children) {\n      parseSegments(\n        defaultCaseSensitive,\n        data,\n        child,\n        cursor,\n        node,\n        depth,\n        onRoute\n      );\n    }\n}\nfunction sortDynamic(a, b) {\n  if (a.skipOnParamError && !b.skipOnParamError) return -1;\n  if (!a.skipOnParamError && b.skipOnParamError) return 1;\n  if (a.skipOnParamError && b.skipOnParamError && (a.parsingPriority || b.parsingPriority))\n    return b.parsingPriority - a.parsingPriority;\n  if (a.prefix && b.prefix && a.prefix !== b.prefix) {\n    if (a.prefix.startsWith(b.prefix)) return -1;\n    if (b.prefix.startsWith(a.prefix)) return 1;\n  }\n  if (a.suffix && b.suffix && a.suffix !== b.suffix) {\n    if (a.suffix.endsWith(b.suffix)) return -1;\n    if (b.suffix.endsWith(a.suffix)) return 1;\n  }\n  if (a.prefix && !b.prefix) return -1;\n  if (!a.prefix && b.prefix) return 1;\n  if (a.suffix && !b.suffix) return -1;\n  if (!a.suffix && b.suffix) return 1;\n  if (a.caseSensitive && !b.caseSensitive) return -1;\n  if (!a.caseSensitive && b.caseSensitive) return 1;\n  return 0;\n}\nfunction sortTreeNodes(node) {\n  if (node.pathless) {\n    for (const child of node.pathless) {\n      sortTreeNodes(child);\n    }\n  }\n  if (node.static) {\n    for (const child of node.static.values()) {\n      sortTreeNodes(child);\n    }\n  }\n  if (node.staticInsensitive) {\n    for (const child of node.staticInsensitive.values()) {\n      sortTreeNodes(child);\n    }\n  }\n  if (node.dynamic?.length) {\n    node.dynamic.sort(sortDynamic);\n    for (const child of node.dynamic) {\n      sortTreeNodes(child);\n    }\n  }\n  if (node.optional?.length) {\n    node.optional.sort(sortDynamic);\n    for (const child of node.optional) {\n      sortTreeNodes(child);\n    }\n  }\n  if (node.wildcard?.length) {\n    node.wildcard.sort(sortDynamic);\n    for (const child of node.wildcard) {\n      sortTreeNodes(child);\n    }\n  }\n}\nfunction createStaticNode(fullPath) {\n  return {\n    kind: SEGMENT_TYPE_PATHNAME,\n    depth: 0,\n    pathless: null,\n    index: null,\n    static: null,\n    staticInsensitive: null,\n    dynamic: null,\n    optional: null,\n    wildcard: null,\n    route: null,\n    fullPath,\n    parent: null,\n    parse: null,\n    skipOnParamError: false,\n    parsingPriority: 0\n  };\n}\nfunction createDynamicNode(kind, fullPath, caseSensitive, prefix, suffix) {\n  return {\n    kind,\n    depth: 0,\n    pathless: null,\n    index: null,\n    static: null,\n    staticInsensitive: null,\n    dynamic: null,\n    optional: null,\n    wildcard: null,\n    route: null,\n    fullPath,\n    parent: null,\n    parse: null,\n    skipOnParamError: false,\n    parsingPriority: 0,\n    caseSensitive,\n    prefix,\n    suffix\n  };\n}\nfunction processRouteMasks(routeList, processedTree) {\n  const segmentTree = createStaticNode(\"/\");\n  const data = new Uint16Array(6);\n  for (const route of routeList) {\n    parseSegments(false, data, route, 1, segmentTree, 0);\n  }\n  sortTreeNodes(segmentTree);\n  processedTree.masksTree = segmentTree;\n  processedTree.flatCache = createLRUCache(1e3);\n}\nfunction findFlatMatch(path, processedTree) {\n  path ||= \"/\";\n  const cached = processedTree.flatCache.get(path);\n  if (cached) return cached;\n  const result = findMatch(path, processedTree.masksTree);\n  processedTree.flatCache.set(path, result);\n  return result;\n}\nfunction findSingleMatch(from, caseSensitive, fuzzy, path, processedTree) {\n  from ||= \"/\";\n  path ||= \"/\";\n  const key = caseSensitive ? `case\\0${from}` : from;\n  let tree = processedTree.singleCache.get(key);\n  if (!tree) {\n    tree = createStaticNode(\"/\");\n    const data = new Uint16Array(6);\n    parseSegments(caseSensitive, data, { from }, 1, tree, 0);\n    processedTree.singleCache.set(key, tree);\n  }\n  return findMatch(path, tree, fuzzy);\n}\nfunction findRouteMatch(path, processedTree, fuzzy = false) {\n  const key = fuzzy ? path : `nofuzz\\0${path}`;\n  const cached = processedTree.matchCache.get(key);\n  if (cached !== void 0) return cached;\n  path ||= \"/\";\n  let result;\n  try {\n    result = findMatch(\n      path,\n      processedTree.segmentTree,\n      fuzzy\n    );\n  } catch (err) {\n    if (err instanceof URIError) {\n      result = null;\n    } else {\n      throw err;\n    }\n  }\n  if (result) result.branch = buildRouteBranch(result.route);\n  processedTree.matchCache.set(key, result);\n  return result;\n}\nfunction trimPathRight(path) {\n  return path === \"/\" ? path : path.replace(/\\/{1,}$/, \"\");\n}\nfunction processRouteTree(routeTree, caseSensitive = false, initRoute) {\n  const segmentTree = createStaticNode(routeTree.fullPath);\n  const data = new Uint16Array(6);\n  const routesById = {};\n  const routesByPath = {};\n  let index = 0;\n  parseSegments(caseSensitive, data, routeTree, 1, segmentTree, 0, (route) => {\n    initRoute?.(route, index);\n    invariant(\n      !(route.id in routesById),\n      `Duplicate routes found with id: ${String(route.id)}`\n    );\n    routesById[route.id] = route;\n    if (index !== 0 && route.path) {\n      const trimmedFullPath = trimPathRight(route.fullPath);\n      if (!routesByPath[trimmedFullPath] || route.fullPath.endsWith(\"/\")) {\n        routesByPath[trimmedFullPath] = route;\n      }\n    }\n    index++;\n  });\n  sortTreeNodes(segmentTree);\n  const processedTree = {\n    segmentTree,\n    singleCache: createLRUCache(1e3),\n    matchCache: createLRUCache(1e3),\n    flatCache: null,\n    masksTree: null\n  };\n  return {\n    processedTree,\n    routesById,\n    routesByPath\n  };\n}\nfunction findMatch(path, segmentTree, fuzzy = false) {\n  const parts = path.split(\"/\");\n  const leaf = getNodeMatch(path, parts, segmentTree, fuzzy);\n  if (!leaf) return null;\n  const [rawParams] = extractParams(path, parts, leaf);\n  return {\n    route: leaf.node.route,\n    rawParams,\n    parsedParams: leaf.parsedParams\n  };\n}\nfunction extractParams(path, parts, leaf) {\n  const list = buildBranch(leaf.node);\n  let nodeParts = null;\n  const rawParams = {};\n  let partIndex = leaf.extract?.part ?? 0;\n  let nodeIndex = leaf.extract?.node ?? 0;\n  let pathIndex = leaf.extract?.path ?? 0;\n  for (; nodeIndex < list.length; partIndex++, nodeIndex++, pathIndex++) {\n    const node = list[nodeIndex];\n    const part = parts[partIndex];\n    const currentPathIndex = pathIndex;\n    if (part) pathIndex += part.length;\n    if (node.kind === SEGMENT_TYPE_PARAM) {\n      nodeParts ??= leaf.node.fullPath.split(\"/\");\n      const nodePart = nodeParts[nodeIndex];\n      const preLength = node.prefix?.length ?? 0;\n      const isCurlyBraced = nodePart.charCodeAt(preLength) === 123;\n      if (isCurlyBraced) {\n        const sufLength = node.suffix?.length ?? 0;\n        const name = nodePart.substring(\n          preLength + 2,\n          nodePart.length - sufLength - 1\n        );\n        const value = part.substring(preLength, part.length - sufLength);\n        rawParams[name] = decodeURIComponent(value);\n      } else {\n        const name = nodePart.substring(1);\n        rawParams[name] = decodeURIComponent(part);\n      }\n    } else if (node.kind === SEGMENT_TYPE_OPTIONAL_PARAM) {\n      if (leaf.skipped & 1 << nodeIndex) {\n        partIndex--;\n        continue;\n      }\n      nodeParts ??= leaf.node.fullPath.split(\"/\");\n      const nodePart = nodeParts[nodeIndex];\n      const preLength = node.prefix?.length ?? 0;\n      const sufLength = node.suffix?.length ?? 0;\n      const name = nodePart.substring(\n        preLength + 3,\n        nodePart.length - sufLength - 1\n      );\n      const value = node.suffix || node.prefix ? part.substring(preLength, part.length - sufLength) : part;\n      if (value) rawParams[name] = decodeURIComponent(value);\n    } else if (node.kind === SEGMENT_TYPE_WILDCARD) {\n      const n = node;\n      const value = path.substring(\n        currentPathIndex + (n.prefix?.length ?? 0),\n        path.length - (n.suffix?.length ?? 0)\n      );\n      const splat = decodeURIComponent(value);\n      rawParams[\"*\"] = splat;\n      rawParams._splat = splat;\n      break;\n    }\n  }\n  if (leaf.rawParams) Object.assign(rawParams, leaf.rawParams);\n  return [rawParams, { part: partIndex, node: nodeIndex, path: pathIndex }];\n}\nfunction buildRouteBranch(route) {\n  const list = [route];\n  while (route.parentRoute) {\n    route = route.parentRoute;\n    list.push(route);\n  }\n  list.reverse();\n  return list;\n}\nfunction buildBranch(node) {\n  const list = Array(node.depth + 1);\n  do {\n    list[node.depth] = node;\n    node = node.parent;\n  } while (node);\n  return list;\n}\nfunction getNodeMatch(path, parts, segmentTree, fuzzy) {\n  if (path === \"/\" && segmentTree.index)\n    return { node: segmentTree.index, skipped: 0 };\n  const trailingSlash = !last(parts);\n  const pathIsIndex = trailingSlash && path !== \"/\";\n  const partsLength = parts.length - (trailingSlash ? 1 : 0);\n  const stack = [\n    {\n      node: segmentTree,\n      index: 1,\n      skipped: 0,\n      depth: 1,\n      statics: 1,\n      dynamics: 0,\n      optionals: 0\n    }\n  ];\n  let wildcardMatch = null;\n  let bestFuzzy = null;\n  let bestMatch = null;\n  while (stack.length) {\n    const frame = stack.pop();\n    const { node, index, skipped, depth, statics, dynamics, optionals } = frame;\n    let { extract, rawParams, parsedParams } = frame;\n    if (node.skipOnParamError) {\n      const result = validateMatchParams(path, parts, frame);\n      if (!result) continue;\n      rawParams = frame.rawParams;\n      extract = frame.extract;\n      parsedParams = frame.parsedParams;\n    }\n    if (fuzzy && node.route && node.kind !== SEGMENT_TYPE_INDEX && isFrameMoreSpecific(bestFuzzy, frame)) {\n      bestFuzzy = frame;\n    }\n    const isBeyondPath = index === partsLength;\n    if (isBeyondPath) {\n      if (node.route && !pathIsIndex && isFrameMoreSpecific(bestMatch, frame)) {\n        bestMatch = frame;\n      }\n      if (!node.optional && !node.wildcard && !node.index && !node.pathless)\n        continue;\n    }\n    const part = isBeyondPath ? void 0 : parts[index];\n    let lowerPart;\n    if (isBeyondPath && node.index) {\n      const indexFrame = {\n        node: node.index,\n        index,\n        skipped,\n        depth: depth + 1,\n        statics,\n        dynamics,\n        optionals,\n        extract,\n        rawParams,\n        parsedParams\n      };\n      if (node.index.skipOnParamError) {\n        const result = validateMatchParams(path, parts, indexFrame);\n        if (!result) continue;\n      }\n      if (statics === partsLength && !dynamics && !optionals && !skipped) {\n        return indexFrame;\n      }\n      if (isFrameMoreSpecific(bestMatch, indexFrame)) {\n        bestMatch = indexFrame;\n      }\n    }\n    if (node.wildcard && isFrameMoreSpecific(wildcardMatch, frame)) {\n      for (const segment of node.wildcard) {\n        const { prefix, suffix } = segment;\n        if (prefix) {\n          if (isBeyondPath) continue;\n          const casePart = segment.caseSensitive ? part : lowerPart ??= part.toLowerCase();\n          if (!casePart.startsWith(prefix)) continue;\n        }\n        if (suffix) {\n          if (isBeyondPath) continue;\n          const end = parts.slice(index).join(\"/\").slice(-suffix.length);\n          const casePart = segment.caseSensitive ? end : end.toLowerCase();\n          if (casePart !== suffix) continue;\n        }\n        const frame2 = {\n          node: segment,\n          index: partsLength,\n          skipped,\n          depth,\n          statics,\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n          parsedParams\n        };\n        if (segment.skipOnParamError) {\n          const result = validateMatchParams(path, parts, frame2);\n          if (!result) continue;\n        }\n        wildcardMatch = frame2;\n        break;\n      }\n    }\n    if (node.optional) {\n      const nextSkipped = skipped | 1 << depth;\n      const nextDepth = depth + 1;\n      for (let i = node.optional.length - 1; i >= 0; i--) {\n        const segment = node.optional[i];\n        stack.push({\n          node: segment,\n          index,\n          skipped: nextSkipped,\n          depth: nextDepth,\n          statics,\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n          parsedParams\n        });\n      }\n      if (!isBeyondPath) {\n        for (let i = node.optional.length - 1; i >= 0; i--) {\n          const segment = node.optional[i];\n          const { prefix, suffix } = segment;\n          if (prefix || suffix) {\n            const casePart = segment.caseSensitive ? part : lowerPart ??= part.toLowerCase();\n            if (prefix && !casePart.startsWith(prefix)) continue;\n            if (suffix && !casePart.endsWith(suffix)) continue;\n          }\n          stack.push({\n            node: segment,\n            index: index + 1,\n            skipped,\n            depth: nextDepth,\n            statics,\n            dynamics,\n            optionals: optionals + 1,\n            extract,\n            rawParams,\n            parsedParams\n          });\n        }\n      }\n    }\n    if (!isBeyondPath && node.dynamic && part) {\n      for (let i = node.dynamic.length - 1; i >= 0; i--) {\n        const segment = node.dynamic[i];\n        const { prefix, suffix } = segment;\n        if (prefix || suffix) {\n          const casePart = segment.caseSensitive ? part : lowerPart ??= part.toLowerCase();\n          if (prefix && !casePart.startsWith(prefix)) continue;\n          if (suffix && !casePart.endsWith(suffix)) continue;\n        }\n        stack.push({\n          node: segment,\n          index: index + 1,\n          skipped,\n          depth: depth + 1,\n          statics,\n          dynamics: dynamics + 1,\n          optionals,\n          extract,\n          rawParams,\n          parsedParams\n        });\n      }\n    }\n    if (!isBeyondPath && node.staticInsensitive) {\n      const match = node.staticInsensitive.get(\n        lowerPart ??= part.toLowerCase()\n      );\n      if (match) {\n        stack.push({\n          node: match,\n          index: index + 1,\n          skipped,\n          depth: depth + 1,\n          statics: statics + 1,\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n          parsedParams\n        });\n      }\n    }\n    if (!isBeyondPath && node.static) {\n      const match = node.static.get(part);\n      if (match) {\n        stack.push({\n          node: match,\n          index: index + 1,\n          skipped,\n          depth: depth + 1,\n          statics: statics + 1,\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n          parsedParams\n        });\n      }\n    }\n    if (node.pathless) {\n      const nextDepth = depth + 1;\n      for (let i = node.pathless.length - 1; i >= 0; i--) {\n        const segment = node.pathless[i];\n        stack.push({\n          node: segment,\n          index,\n          skipped,\n          depth: nextDepth,\n          statics,\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n          parsedParams\n        });\n      }\n    }\n  }\n  if (bestMatch && wildcardMatch) {\n    return isFrameMoreSpecific(wildcardMatch, bestMatch) ? bestMatch : wildcardMatch;\n  }\n  if (bestMatch) return bestMatch;\n  if (wildcardMatch) return wildcardMatch;\n  if (fuzzy && bestFuzzy) {\n    let sliceIndex = bestFuzzy.index;\n    for (let i = 0; i < bestFuzzy.index; i++) {\n      sliceIndex += parts[i].length;\n    }\n    const splat = sliceIndex === path.length ? \"/\" : path.slice(sliceIndex);\n    bestFuzzy.rawParams ??= {};\n    bestFuzzy.rawParams[\"**\"] = decodeURIComponent(splat);\n    return bestFuzzy;\n  }\n  return null;\n}\nfunction validateMatchParams(path, parts, frame) {\n  try {\n    const [rawParams, state] = extractParams(path, parts, frame);\n    frame.rawParams = rawParams;\n    frame.extract = state;\n    const parsed = frame.node.parse(rawParams);\n    frame.parsedParams = Object.assign({}, frame.parsedParams, parsed);\n    return true;\n  } catch {\n    return null;\n  }\n}\nfunction isFrameMoreSpecific(prev, next) {\n  if (!prev) return true;\n  return next.statics > prev.statics || next.statics === prev.statics && (next.dynamics > prev.dynamics || next.dynamics === prev.dynamics && (next.optionals > prev.optionals || next.optionals === prev.optionals && ((next.node.kind === SEGMENT_TYPE_INDEX) > (prev.node.kind === SEGMENT_TYPE_INDEX) || next.node.kind === SEGMENT_TYPE_INDEX === (prev.node.kind === SEGMENT_TYPE_INDEX) && next.depth > prev.depth)));\n}\nexport {\n  SEGMENT_TYPE_OPTIONAL_PARAM,\n  SEGMENT_TYPE_PARAM,\n  SEGMENT_TYPE_PATHNAME,\n  SEGMENT_TYPE_WILDCARD,\n  findFlatMatch,\n  findRouteMatch,\n  findSingleMatch,\n  parseSegment,\n  processRouteMasks,\n  processRouteTree,\n  trimPathRight\n};\n//# sourceMappingURL=new-process-route-tree.js.map\n"],"names":[],"mappings":"AAGK,MAAC,wBAAwB;AACzB,MAAC,qBAAqB;AACtB,MAAC,wBAAwB;AACzB,MAAC,8BAA8B;AAGpC,MAAM,0BAA0B;AAChC,MAAM,mCAAmC;AACzC,MAAM,6BAA6B;AACnC,SAAS,aAAa,MAAM,OAAO,SAAS,IAAI,YAAY,CAAC,GAAG;AAC9D,QAAM,OAAO,KAAK,QAAQ,KAAK,KAAK;AACpC,QAAM,MAAM,SAAS,KAAK,KAAK,SAAS;AACxC,QAAM,OAAO,KAAK,UAAU,OAAO,GAAG;AACtC,MAAI,CAAC,QAAQ,CAAC,KAAK,SAAS,GAAG,GAAG;AAChC,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO;AAAA,EACT;AACA,MAAI,SAAS,KAAK;AAChB,UAAM,QAAQ,KAAK;AACnB,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO;AAAA,EACT;AACA,MAAI,KAAK,WAAW,CAAC,MAAM,IAAI;AAC7B,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI,QAAQ;AACpB,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO;AAAA,EACT;AACA,QAAM,sBAAsB,KAAK,MAAM,0BAA0B;AACjE,MAAI,qBAAqB;AACvB,UAAM,SAAS,oBAAoB,CAAC;AACpC,UAAM,UAAU,OAAO;AACvB,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI,QAAQ;AACpB,WAAO,CAAC,IAAI,QAAQ,UAAU;AAC9B,WAAO,CAAC,IAAI,QAAQ,UAAU;AAC9B,WAAO,CAAC,IAAI,QAAQ,UAAU;AAC9B,WAAO,CAAC,IAAI,KAAK;AACjB,WAAO;AAAA,EACT;AACA,QAAM,2BAA2B,KAAK,MAAM,gCAAgC;AAC5E,MAAI,0BAA0B;AAC5B,UAAM,SAAS,yBAAyB,CAAC;AACzC,UAAM,YAAY,yBAAyB,CAAC;AAC5C,UAAM,SAAS,yBAAyB,CAAC;AACzC,UAAM,UAAU,OAAO;AACvB,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI,QAAQ;AACpB,WAAO,CAAC,IAAI,QAAQ,UAAU;AAC9B,WAAO,CAAC,IAAI,QAAQ,UAAU,IAAI,UAAU;AAC5C,WAAO,CAAC,IAAI,MAAM,OAAO;AACzB,WAAO,CAAC,IAAI;AACZ,WAAO;AAAA,EACT;AACA,QAAM,mBAAmB,KAAK,MAAM,uBAAuB;AAC3D,MAAI,kBAAkB;AACpB,UAAM,SAAS,iBAAiB,CAAC;AACjC,UAAM,YAAY,iBAAiB,CAAC;AACpC,UAAM,SAAS,iBAAiB,CAAC;AACjC,UAAM,UAAU,OAAO;AACvB,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI,QAAQ;AACpB,WAAO,CAAC,IAAI,QAAQ,UAAU;AAC9B,WAAO,CAAC,IAAI,QAAQ,UAAU,IAAI,UAAU;AAC5C,WAAO,CAAC,IAAI,MAAM,OAAO;AACzB,WAAO,CAAC,IAAI;AACZ,WAAO;AAAA,EACT;AACA,SAAO,CAAC,IAAI;AACZ,SAAO,CAAC,IAAI;AACZ,SAAO,CAAC,IAAI;AACZ,SAAO,CAAC,IAAI;AACZ,SAAO,CAAC,IAAI;AACZ,SAAO,CAAC,IAAI;AACZ,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/@tanstack_router-core@1.151.6/node_modules/@tanstack/router-core/dist/esm/path.js

@@ -1,107 +0,0 @@
-import { parseSegment, SEGMENT_TYPE_PATHNAME, SEGMENT_TYPE_WILDCARD, SEGMENT_TYPE_PARAM, SEGMENT_TYPE_OPTIONAL_PARAM } from "./new-process-route-tree.js";
-function trimPathLeft(path) {
-  return path === "/" ? path : path.replace(/^\/{1,}/, "");
-}
-function trimPathRight(path) {
-  const len = path.length;
-  return len > 1 && path[len - 1] === "/" ? path.replace(/\/{1,}$/, "") : path;
-}
-function trimPath(path) {
-  return trimPathRight(trimPathLeft(path));
-}
-function encodeParam(key, params, decodeCharMap) {
-  const value = params[key];
-  if (typeof value !== "string") return value;
-  if (key === "_splat") {
-    return encodeURI(value);
-  } else {
-    return encodePathParam(value, decodeCharMap);
-  }
-}
-function interpolatePath({
-  path,
-  params,
-  decodeCharMap
-}) {
-  let isMissingParams = false;
-  const usedParams = {};
-  if (!path || path === "/")
-    return { interpolatedPath: "/", usedParams, isMissingParams };
-  if (!path.includes("$"))
-    return { interpolatedPath: path, usedParams, isMissingParams };
-  const length = path.length;
-  let cursor = 0;
-  let segment;
-  let joined = "";
-  while (cursor < length) {
-    const start = cursor;
-    segment = parseSegment(path, start, segment);
-    const end = segment[5];
-    cursor = end + 1;
-    if (start === end) continue;
-    const kind = segment[0];
-    if (kind === SEGMENT_TYPE_PATHNAME) {
-      joined += "/" + path.substring(start, end);
-      continue;
-    }
-    if (kind === SEGMENT_TYPE_WILDCARD) {
-      const splat = params._splat;
-      usedParams._splat = splat;
-      usedParams["*"] = splat;
-      const prefix = path.substring(start, segment[1]);
-      const suffix = path.substring(segment[4], end);
-      if (!splat) {
-        isMissingParams = true;
-        if (prefix || suffix) {
-          joined += "/" + prefix + suffix;
-        }
-        continue;
-      }
-      const value = encodeParam("_splat", params, decodeCharMap);
-      joined += "/" + prefix + value + suffix;
-      continue;
-    }
-    if (kind === SEGMENT_TYPE_PARAM) {
-      const key = path.substring(segment[2], segment[3]);
-      if (!isMissingParams && !(key in params)) {
-        isMissingParams = true;
-      }
-      usedParams[key] = params[key];
-      const prefix = path.substring(start, segment[1]);
-      const suffix = path.substring(segment[4], end);
-      const value = encodeParam(key, params, decodeCharMap) ?? "undefined";
-      joined += "/" + prefix + value + suffix;
-      continue;
-    }
-    if (kind === SEGMENT_TYPE_OPTIONAL_PARAM) {
-      const key = path.substring(segment[2], segment[3]);
-      const valueRaw = params[key];
-      if (valueRaw == null) continue;
-      usedParams[key] = valueRaw;
-      const prefix = path.substring(start, segment[1]);
-      const suffix = path.substring(segment[4], end);
-      const value = encodeParam(key, params, decodeCharMap) ?? "";
-      joined += "/" + prefix + value + suffix;
-      continue;
-    }
-  }
-  if (path.endsWith("/")) joined += "/";
-  const interpolatedPath = joined || "/";
-  return { usedParams, interpolatedPath, isMissingParams };
-}
-function encodePathParam(value, decodeCharMap) {
-  let encoded = encodeURIComponent(value);
-  if (decodeCharMap) {
-    for (const [encodedChar, char] of decodeCharMap) {
-      encoded = encoded.replaceAll(encodedChar, char);
-    }
-  }
-  return encoded;
-}
-export {
-  interpolatePath,
-  trimPath,
-  trimPathLeft,
-  trimPathRight
-};
-//# sourceMappingURL=path.js.map

package/dist/esm/node_modules/.pnpm/@tanstack_router-core@1.151.6/node_modules/@tanstack/router-core/dist/esm/path.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"path.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@tanstack+router-core@1.151.6/node_modules/@tanstack/router-core/dist/esm/path.js"],"sourcesContent":["import { last } from \"./utils.js\";\nimport { parseSegment, SEGMENT_TYPE_PATHNAME, SEGMENT_TYPE_WILDCARD, SEGMENT_TYPE_PARAM, SEGMENT_TYPE_OPTIONAL_PARAM } from \"./new-process-route-tree.js\";\nfunction joinPaths(paths) {\n  return cleanPath(\n    paths.filter((val) => {\n      return val !== void 0;\n    }).join(\"/\")\n  );\n}\nfunction cleanPath(path) {\n  return path.replace(/\\/{2,}/g, \"/\");\n}\nfunction trimPathLeft(path) {\n  return path === \"/\" ? path : path.replace(/^\\/{1,}/, \"\");\n}\nfunction trimPathRight(path) {\n  const len = path.length;\n  return len > 1 && path[len - 1] === \"/\" ? path.replace(/\\/{1,}$/, \"\") : path;\n}\nfunction trimPath(path) {\n  return trimPathRight(trimPathLeft(path));\n}\nfunction removeTrailingSlash(value, basepath) {\n  if (value?.endsWith(\"/\") && value !== \"/\" && value !== `${basepath}/`) {\n    return value.slice(0, -1);\n  }\n  return value;\n}\nfunction exactPathTest(pathName1, pathName2, basepath) {\n  return removeTrailingSlash(pathName1, basepath) === removeTrailingSlash(pathName2, basepath);\n}\nfunction resolvePath({\n  base,\n  to,\n  trailingSlash = \"never\",\n  cache\n}) {\n  const isAbsolute = to.startsWith(\"/\");\n  const isBase = !isAbsolute && to === \".\";\n  let key;\n  if (cache) {\n    key = isAbsolute ? to : isBase ? base : base + \"\\0\" + to;\n    const cached = cache.get(key);\n    if (cached) return cached;\n  }\n  let baseSegments;\n  if (isBase) {\n    baseSegments = base.split(\"/\");\n  } else if (isAbsolute) {\n    baseSegments = to.split(\"/\");\n  } else {\n    baseSegments = base.split(\"/\");\n    while (baseSegments.length > 1 && last(baseSegments) === \"\") {\n      baseSegments.pop();\n    }\n    const toSegments = to.split(\"/\");\n    for (let index = 0, length = toSegments.length; index < length; index++) {\n      const value = toSegments[index];\n      if (value === \"\") {\n        if (!index) {\n          baseSegments = [value];\n        } else if (index === length - 1) {\n          baseSegments.push(value);\n        } else ;\n      } else if (value === \"..\") {\n        baseSegments.pop();\n      } else if (value === \".\") ;\n      else {\n        baseSegments.push(value);\n      }\n    }\n  }\n  if (baseSegments.length > 1) {\n    if (last(baseSegments) === \"\") {\n      if (trailingSlash === \"never\") {\n        baseSegments.pop();\n      }\n    } else if (trailingSlash === \"always\") {\n      baseSegments.push(\"\");\n    }\n  }\n  let segment;\n  let joined = \"\";\n  for (let i = 0; i < baseSegments.length; i++) {\n    if (i > 0) joined += \"/\";\n    const part = baseSegments[i];\n    if (!part) continue;\n    segment = parseSegment(part, 0, segment);\n    const kind = segment[0];\n    if (kind === SEGMENT_TYPE_PATHNAME) {\n      joined += part;\n      continue;\n    }\n    const end = segment[5];\n    const prefix = part.substring(0, segment[1]);\n    const suffix = part.substring(segment[4], end);\n    const value = part.substring(segment[2], segment[3]);\n    if (kind === SEGMENT_TYPE_PARAM) {\n      joined += prefix || suffix ? `${prefix}{$${value}}${suffix}` : `$${value}`;\n    } else if (kind === SEGMENT_TYPE_WILDCARD) {\n      joined += prefix || suffix ? `${prefix}{$}${suffix}` : \"$\";\n    } else {\n      joined += `${prefix}{-$${value}}${suffix}`;\n    }\n  }\n  joined = cleanPath(joined);\n  const result = joined || \"/\";\n  if (key && cache) cache.set(key, result);\n  return result;\n}\nfunction encodeParam(key, params, decodeCharMap) {\n  const value = params[key];\n  if (typeof value !== \"string\") return value;\n  if (key === \"_splat\") {\n    return encodeURI(value);\n  } else {\n    return encodePathParam(value, decodeCharMap);\n  }\n}\nfunction interpolatePath({\n  path,\n  params,\n  decodeCharMap\n}) {\n  let isMissingParams = false;\n  const usedParams = {};\n  if (!path || path === \"/\")\n    return { interpolatedPath: \"/\", usedParams, isMissingParams };\n  if (!path.includes(\"$\"))\n    return { interpolatedPath: path, usedParams, isMissingParams };\n  const length = path.length;\n  let cursor = 0;\n  let segment;\n  let joined = \"\";\n  while (cursor < length) {\n    const start = cursor;\n    segment = parseSegment(path, start, segment);\n    const end = segment[5];\n    cursor = end + 1;\n    if (start === end) continue;\n    const kind = segment[0];\n    if (kind === SEGMENT_TYPE_PATHNAME) {\n      joined += \"/\" + path.substring(start, end);\n      continue;\n    }\n    if (kind === SEGMENT_TYPE_WILDCARD) {\n      const splat = params._splat;\n      usedParams._splat = splat;\n      usedParams[\"*\"] = splat;\n      const prefix = path.substring(start, segment[1]);\n      const suffix = path.substring(segment[4], end);\n      if (!splat) {\n        isMissingParams = true;\n        if (prefix || suffix) {\n          joined += \"/\" + prefix + suffix;\n        }\n        continue;\n      }\n      const value = encodeParam(\"_splat\", params, decodeCharMap);\n      joined += \"/\" + prefix + value + suffix;\n      continue;\n    }\n    if (kind === SEGMENT_TYPE_PARAM) {\n      const key = path.substring(segment[2], segment[3]);\n      if (!isMissingParams && !(key in params)) {\n        isMissingParams = true;\n      }\n      usedParams[key] = params[key];\n      const prefix = path.substring(start, segment[1]);\n      const suffix = path.substring(segment[4], end);\n      const value = encodeParam(key, params, decodeCharMap) ?? \"undefined\";\n      joined += \"/\" + prefix + value + suffix;\n      continue;\n    }\n    if (kind === SEGMENT_TYPE_OPTIONAL_PARAM) {\n      const key = path.substring(segment[2], segment[3]);\n      const valueRaw = params[key];\n      if (valueRaw == null) continue;\n      usedParams[key] = valueRaw;\n      const prefix = path.substring(start, segment[1]);\n      const suffix = path.substring(segment[4], end);\n      const value = encodeParam(key, params, decodeCharMap) ?? \"\";\n      joined += \"/\" + prefix + value + suffix;\n      continue;\n    }\n  }\n  if (path.endsWith(\"/\")) joined += \"/\";\n  const interpolatedPath = joined || \"/\";\n  return { usedParams, interpolatedPath, isMissingParams };\n}\nfunction encodePathParam(value, decodeCharMap) {\n  let encoded = encodeURIComponent(value);\n  if (decodeCharMap) {\n    for (const [encodedChar, char] of decodeCharMap) {\n      encoded = encoded.replaceAll(encodedChar, char);\n    }\n  }\n  return encoded;\n}\nexport {\n  cleanPath,\n  exactPathTest,\n  interpolatePath,\n  joinPaths,\n  removeTrailingSlash,\n  resolvePath,\n  trimPath,\n  trimPathLeft,\n  trimPathRight\n};\n//# sourceMappingURL=path.js.map\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/@tanstack_router-core@1.151.6/node_modules/@tanstack/router-core/dist/esm/root.js

@@ -1,5 +0,0 @@
-const rootRouteId = "__root__";
-export {
-  rootRouteId
-};
-//# sourceMappingURL=root.js.map

package/dist/esm/node_modules/.pnpm/@tanstack_router-core@1.151.6/node_modules/@tanstack/router-core/dist/esm/root.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"root.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@tanstack+router-core@1.151.6/node_modules/@tanstack/router-core/dist/esm/root.js"],"sourcesContent":["const rootRouteId = \"__root__\";\nexport {\n  rootRouteId\n};\n//# sourceMappingURL=root.js.map\n"],"names":[],"mappings":"AAAK,MAAC,cAAc;","x_google_ignoreList":[0]}