{"version":3,"sources":["../src/plugins/route-pattern.ts"],"sourcesContent":["import { localizeFarmHref, resolveFarmLocalePath } from \"../i18n/routing\";\nimport type { ResolvedFarmI18nConfig } from \"../i18n/types\";\nimport { assertBrowserStableRoutePath } from \"../routing/specificity\";\n\ntype ConfigRoutePatternToken =\n | { kind: \"param\"; name: string; captureIndex: number; catchAll: boolean }\n | { kind: \"wildcard\"; captureIndex: number };\n\nexport interface CompiledConfigRoutePattern {\n regex: RegExp;\n tokens: ConfigRoutePatternToken[];\n}\n\nexport function validateConfigRouteSource(source: string, field = \"Config route source\"): string {\n if (typeof source !== \"string\" || source.length === 0) {\n throw new TypeError(`${field} must be a non-empty pathname pattern.`);\n }\n if (source.trim() !== source) {\n throw new Error(`${field} cannot contain leading or trailing whitespace.`);\n }\n if (!source.startsWith(\"/\")) {\n throw new Error(`${field} must start with \"/\".`);\n }\n if (source.includes(\"?\") || source.includes(\"#\")) {\n throw new Error(`${field} must be a pathname without a query string or hash.`);\n }\n if (\n source.includes(\"\\\\\") ||\n Array.from(source).some((character) => {\n const code = character.charCodeAt(0);\n return code <= 31 || (code >= 127 && code <= 159);\n })\n ) {\n throw new Error(`${field} cannot contain backslashes or control characters.`);\n }\n assertBrowserStableRoutePath(source);\n return source;\n}\n\nexport function resolveConfigRoutePathname(\n pathname: string,\n i18n?: ResolvedFarmI18nConfig,\n): { pathname: string; locale?: string } {\n if (!i18n?.enabled) return { pathname: normalizeConfigRoutePathname(pathname) };\n const match = resolveFarmLocalePath(pathname, i18n);\n return { pathname: normalizeConfigRoutePathname(match.pathname), locale: match.locale };\n}\n\n/**\n * Drop a trailing slash before matching, mirroring `normalizeRuntimePath` in\n * the generated production matcher. Without this a request for `/old/` misses\n * a `/old` rule in dev while matching it in a built app.\n */\nfunction normalizeConfigRoutePathname(pathname: string): string {\n if (!pathname || pathname === \"/\") return \"/\";\n return pathname.endsWith(\"/\") ? pathname.replace(/\\/+$/, \"\") || \"/\" : pathname;\n}\n\nexport function localizeConfigRouteDestination(\n destination: string,\n locale: string | undefined,\n i18n?: ResolvedFarmI18nConfig,\n): string {\n return locale && i18n?.enabled ? localizeFarmHref(destination, locale, i18n) : destination;\n}\n\n/**\n * Append a catch-all capture, absorbing the separator that precedes it.\n *\n * The production matcher works on split segments and lets a non-terminal\n * catch-all consume zero of them (`minConsume = 0`), so `/x/*` + `/y` matches\n * `/x/y` and `/files/:path*` matches `/files`. Emitting a bare `(.*)` after a\n * literal `/` instead demands at least that separator, so the same rule was\n * inert in dev. Folding the slash into the optional group is how path-to-regexp\n * expresses the same thing, and it keeps one capture group so capture indexes\n * are unchanged (a non-participating group reads back as \"\").\n */\nfunction appendCatchAll(pattern: string): string {\n return pattern.endsWith(\"/\") ? `${pattern.slice(0, -1)}(?:/(.*))?` : `${pattern}(.*)`;\n}\n\nfunction escapeRegexCharacter(character: string): string {\n return /[\\\\^$.*+?()[\\]{}|]/.test(character) ? `\\\\${character}` : character;\n}\n\nexport function compileConfigRoutePattern(source: string): CompiledConfigRoutePattern {\n validateConfigRouteSource(source);\n const tokens: ConfigRoutePatternToken[] = [];\n let pattern = \"\";\n let captureIndex = 1;\n\n for (let index = 0; index < source.length; ) {\n const rest = source.slice(index);\n const parameter = rest.match(/^:([A-Za-z0-9_]+)(\\*)?/);\n if (parameter) {\n tokens.push({\n kind: \"param\",\n name: parameter[1],\n captureIndex,\n catchAll: parameter[2] === \"*\",\n });\n pattern = parameter[2] ? appendCatchAll(pattern) : `${pattern}([^/]+)`;\n captureIndex += 1;\n index += parameter[0].length;\n continue;\n }\n\n if (source[index] === \"*\") {\n tokens.push({ kind: \"wildcard\", captureIndex });\n pattern = appendCatchAll(pattern);\n captureIndex += 1;\n index += 1;\n continue;\n }\n\n pattern += escapeRegexCharacter(source[index]);\n index += 1;\n }\n\n return { regex: new RegExp(`^${pattern}$`), tokens };\n}\n\nexport function interpolateConfigRouteDestination(\n destination: string,\n match: RegExpMatchArray,\n tokens: readonly ConfigRoutePatternToken[],\n): string {\n const namedCaptures = new Map();\n const wildcardCaptures: string[] = [];\n const captures = new Map();\n\n for (const token of tokens) {\n const value = normalizeConfigRouteCapture(\n match[token.captureIndex] || \"\",\n token.kind === \"wildcard\" || token.catchAll,\n );\n captures.set(token.captureIndex, value);\n if (token.kind === \"param\") {\n namedCaptures.set(token.name, value);\n } else {\n wildcardCaptures.push(value);\n }\n }\n\n let result = \"\";\n let wildcardIndex = 0;\n for (let index = 0; index < destination.length; ) {\n const rest = destination.slice(index);\n const parameter = rest.match(/^:([A-Za-z0-9_]+)(\\*)?/);\n if (parameter) {\n const value = namedCaptures.get(parameter[1]);\n result += value === undefined ? parameter[0] : value;\n index += parameter[0].length;\n continue;\n }\n\n const capture = rest.match(/^\\$(\\d+)/);\n if (capture) {\n result += captures.get(Number(capture[1])) ?? \"\";\n index += capture[0].length;\n continue;\n }\n\n if (destination[index] === \"*\") {\n result += wildcardCaptures[wildcardIndex] || \"\";\n wildcardIndex += 1;\n index += 1;\n continue;\n }\n\n result += destination[index];\n index += 1;\n }\n\n return result;\n}\n\nfunction normalizeConfigRouteCapture(value: string, catchAll: boolean): string {\n const segments = catchAll ? value.split(\"/\").filter(Boolean) : [value];\n return segments\n .map((segment) => encodeConfigRouteSegment(decodeConfigRouteSegment(segment)))\n .join(\"/\");\n}\n\nfunction decodeConfigRouteSegment(segment: string): string {\n try {\n return decodeURIComponent(segment);\n } catch {\n return segment;\n }\n}\n\nfunction encodeConfigRouteSegment(segment: string): string {\n return encodeURIComponent(segment).replace(\n /[!'()*]/g,\n (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`,\n );\n}\n"],"mappings":"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","names":[]}