{"version":3,"sources":["../src/router.ts","../src/routing/specificity.ts"],"sourcesContent":["import {\n AmbiguousRouteError,\n assertTerminalCatchAll,\n assertUniqueRouteParameters,\n compareRouteSpecificity,\n getRoutePatternShape,\n type RouteSegmentSpecificity,\n} from \"./routing/specificity\";\n\nexport type FarmRouterPrimitiveParam = string | number | boolean;\nexport type FarmRouterPathParam =\n | FarmRouterPrimitiveParam\n | readonly FarmRouterPrimitiveParam[]\n | null\n | undefined;\nexport type FarmRouterPathParams = Record;\nexport type FarmRouterParams = Record;\n\nexport interface FarmRouterRoute {\n path: string;\n name?: string;\n meta?: TMeta;\n}\n\nexport type FarmRouterRouteInput = string | FarmRouterRoute;\n\nexport interface FarmRouterMatch {\n route: FarmRouterRoute;\n pathname: string;\n params: FarmRouterParams;\n}\n\nexport type FarmRouterQueryValue =\n | FarmRouterPrimitiveParam\n | readonly FarmRouterPrimitiveParam[]\n | null\n | undefined;\n\nexport interface FarmRouterBuildOptions {\n query?: URLSearchParams | Record;\n hash?: string;\n trailingSlash?: boolean;\n}\n\nexport interface FarmRouterActiveOptions {\n exact?: boolean;\n}\n\nexport interface FarmRouter {\n routes: FarmRouterRoute[];\n match(pathname: string): FarmRouterMatch | null;\n build(pattern: string, params?: FarmRouterPathParams, options?: FarmRouterBuildOptions): string;\n isActive(pattern: string, pathname: string, options?: FarmRouterActiveOptions): boolean;\n}\n\ntype RouterSegment =\n | {\n type: \"static\";\n value: string;\n }\n | {\n type: \"dynamic\";\n name: string;\n catchAll: boolean;\n optional: boolean;\n };\n\ninterface NormalizedRouterRoute {\n route: FarmRouterRoute;\n segments: RouterSegment[];\n specificity: RouteSegmentSpecificity[];\n index: number;\n}\n\nexport function createFarmRouter(\n routes: FarmRouterRouteInput[],\n): FarmRouter {\n const normalizedRoutes = routes.map(normalizeRouteInput);\n const patternsByShape = new Map();\n for (const entry of normalizedRoutes) {\n const shape = getRoutePatternShape(entry.route.path, \"router\");\n const existingPattern = patternsByShape.get(shape);\n if (existingPattern) {\n throw new AmbiguousRouteError(\n `Ambiguous route patterns \"${existingPattern}\" and \"${entry.route.path}\" match the same URLs. Keep only one route for this URL shape.`,\n );\n }\n patternsByShape.set(shape, entry.route.path);\n }\n normalizedRoutes.sort(compareRoutes);\n\n return {\n routes: normalizedRoutes.map((entry) => entry.route),\n match(pathname) {\n const normalizedPathname = normalizePathname(pathname);\n\n for (const entry of normalizedRoutes) {\n const params = matchSegments(entry.segments, normalizedPathname);\n if (params) {\n return {\n route: entry.route,\n pathname: normalizedPathname,\n params,\n };\n }\n }\n\n return null;\n },\n build: buildFarmRoutePath,\n isActive: isFarmRouteActive,\n };\n}\n\nexport function matchFarmRoute(pattern: string, pathname: string): FarmRouterParams | null {\n return matchSegments(parseRoutePattern(pattern), normalizePathname(pathname));\n}\n\nexport function buildFarmRoutePath(\n pattern: string,\n params: FarmRouterPathParams = {},\n options: FarmRouterBuildOptions = {},\n): string {\n const parts: string[] = [];\n\n for (const segment of parseRoutePattern(pattern)) {\n if (segment.type === \"static\") {\n parts.push(encodePathSegment(segment.value));\n continue;\n }\n\n const value = params[segment.name];\n const values = Array.isArray(value) ? value : value == null ? [] : [value];\n\n if (values.length === 0) {\n if (segment.optional) continue;\n throw new Error(`Missing route param \"${segment.name}\" for ${pattern}.`);\n }\n\n if (!segment.catchAll && values.length > 1) {\n throw new Error(`Route param \"${segment.name}\" for ${pattern} expects a single value.`);\n }\n\n const encodedValues = values.map((item) => {\n const value = String(item);\n if (!value) {\n throw new Error(\n `Route param \"${segment.name}\" for ${pattern} cannot contain an empty path segment.`,\n );\n }\n return encodePathSegment(value);\n });\n parts.push(...encodedValues);\n }\n\n let pathname = parts.length ? `/${parts.join(\"/\")}` : \"/\";\n\n if (options.trailingSlash && pathname !== \"/\") {\n pathname = `${pathname}/`;\n }\n\n return appendQueryAndHash(pathname, options);\n}\n\nexport function isFarmRouteActive(\n pattern: string,\n pathname: string,\n options: FarmRouterActiveOptions = {},\n): boolean {\n const normalizedPathname = normalizePathname(pathname);\n if (matchFarmRoute(pattern, normalizedPathname)) return true;\n if (options.exact !== false) return false;\n\n const segments = parseRoutePattern(pattern);\n if (segments.length === 0) return normalizedPathname === \"/\";\n return matchSegments(segments, normalizedPathname, true) !== null;\n}\n\nfunction normalizeRouteInput(\n input: FarmRouterRouteInput,\n index: number,\n): NormalizedRouterRoute {\n const route = typeof input === \"string\" ? { path: input } : input;\n const path = normalizeRoutePattern(route.path);\n const segments = parseRoutePattern(path);\n\n return {\n route: {\n ...route,\n path,\n },\n segments,\n specificity: segments.map(getRouterSegmentSpecificity),\n index,\n };\n}\n\nfunction parseRoutePattern(pattern: string): RouterSegment[] {\n assertTerminalCatchAll(pattern, \"router\");\n assertUniqueRouteParameters(pattern, \"router\");\n return splitRoutePattern(pattern)\n .filter((part) => !isRouteGroup(part))\n .map((part) => {\n const optionalCatchAll = part.match(/^\\[\\[\\.\\.\\.([A-Za-z0-9_$-]+)\\]\\]$/);\n if (optionalCatchAll) {\n return {\n type: \"dynamic\",\n name: optionalCatchAll[1],\n catchAll: true,\n optional: true,\n };\n }\n\n const catchAll = part.match(/^\\[\\.\\.\\.([A-Za-z0-9_$-]+)\\]$/);\n if (catchAll) {\n return {\n type: \"dynamic\",\n name: catchAll[1],\n catchAll: true,\n optional: false,\n };\n }\n\n const dynamic = part.match(/^\\[([A-Za-z0-9_$-]+)\\]$/) || part.match(/^:([A-Za-z0-9_$-]+)$/);\n if (dynamic) {\n return {\n type: \"dynamic\",\n name: dynamic[1],\n catchAll: false,\n optional: false,\n };\n }\n\n const star = part.match(/^\\*([A-Za-z0-9_$-]+)(\\?)?$/);\n if (star) {\n return {\n type: \"dynamic\",\n name: star[1],\n catchAll: true,\n optional: !!star[2],\n };\n }\n\n return {\n type: \"static\",\n value: decodePathSegment(part),\n };\n });\n}\n\nfunction matchSegments(\n segments: RouterSegment[],\n pathname: string,\n allowTrailingSegments = false,\n): FarmRouterParams | null {\n const parts = splitPathname(pathname);\n const params: FarmRouterParams = {};\n\n if (segments.length === 0) {\n return parts.length === 0 ? params : null;\n }\n\n let pathIndex = 0;\n\n for (const segment of segments) {\n if (segment.type === \"static\") {\n if (decodePathSegment(parts[pathIndex] || \"\") !== segment.value) return null;\n pathIndex++;\n continue;\n }\n\n if (segment.catchAll) {\n const remaining = parts.slice(pathIndex).map(decodePathSegment);\n if (remaining.length === 0 && !segment.optional) return null;\n params[segment.name] = remaining.join(\"/\");\n pathIndex = parts.length;\n continue;\n }\n\n const value = parts[pathIndex];\n if (!value) return null;\n params[segment.name] = decodePathSegment(value);\n pathIndex++;\n }\n\n return allowTrailingSegments || pathIndex === parts.length ? params : null;\n}\n\nfunction compareRoutes(\n left: NormalizedRouterRoute,\n right: NormalizedRouterRoute,\n) {\n const specificity = compareRouteSpecificity(left.specificity, right.specificity);\n if (specificity !== 0) return specificity;\n return left.index - right.index;\n}\n\nfunction getRouterSegmentSpecificity(segment: RouterSegment): RouteSegmentSpecificity {\n if (segment.type === \"static\") return \"static\";\n if (!segment.catchAll) return \"dynamic\";\n return segment.optional ? \"optional-catch-all\" : \"catch-all\";\n}\n\nfunction normalizePathname(value: string) {\n const raw = value || \"/\";\n let pathname = raw;\n\n try {\n pathname = new URL(raw, \"http://farm.local\").pathname;\n } catch {\n pathname = raw.split(/[?#]/, 1)[0] || \"/\";\n }\n\n pathname = pathname.replace(/\\\\/g, \"/\").replace(/\\/+/g, \"/\");\n if (!pathname.startsWith(\"/\")) pathname = `/${pathname}`;\n if (pathname.length > 1) pathname = pathname.replace(/\\/+$/, \"\");\n return pathname || \"/\";\n}\n\nfunction splitPathname(pathname: string) {\n return normalizePathname(pathname).split(\"/\").filter(Boolean);\n}\n\nfunction normalizeRoutePattern(value: string) {\n let pathname = (value || \"/\").replace(/\\\\/g, \"/\").replace(/\\/+/g, \"/\");\n if (!pathname.startsWith(\"/\")) pathname = `/${pathname}`;\n if (pathname.length > 1) pathname = pathname.replace(/\\/+$/, \"\");\n return pathname || \"/\";\n}\n\nfunction splitRoutePattern(pattern: string) {\n return normalizeRoutePattern(pattern).split(\"/\").filter(Boolean);\n}\n\nfunction isRouteGroup(part: string) {\n return part.startsWith(\"(\") && part.endsWith(\")\");\n}\n\nfunction decodePathSegment(value: string) {\n try {\n return decodeURIComponent(value);\n } catch {\n return value;\n }\n}\n\nfunction encodePathSegment(value: string) {\n return encodeURIComponent(value);\n}\n\nfunction appendQueryAndHash(pathname: string, options: FarmRouterBuildOptions) {\n const search = createSearchParams(options.query);\n const hash = options.hash ? `#${options.hash.replace(/^#/, \"\")}` : \"\";\n const query = search.toString();\n return `${pathname}${query ? `?${query}` : \"\"}${hash}`;\n}\n\nfunction createSearchParams(query: FarmRouterBuildOptions[\"query\"]) {\n if (query instanceof URLSearchParams) return query;\n\n const search = new URLSearchParams();\n if (!query) return search;\n\n for (const [key, value] of Object.entries(query)) {\n const values = Array.isArray(value) ? value : [value];\n for (const item of values) {\n if (item == null) continue;\n search.append(key, String(item));\n }\n }\n\n return search;\n}\n","export type RouteSegmentSpecificity = \"static\" | \"dynamic\" | \"catch-all\" | \"optional-catch-all\";\n\nexport class AmbiguousRouteError extends Error {\n constructor(message: string) {\n super(message);\n this.name = \"AmbiguousRouteError\";\n }\n}\n\nexport class NonTerminalCatchAllRouteError extends TypeError {\n constructor(message: string) {\n super(message);\n this.name = \"NonTerminalCatchAllRouteError\";\n }\n}\n\nexport class DuplicateRouteParameterError extends AmbiguousRouteError {\n constructor(message: string) {\n super(message);\n this.name = \"DuplicateRouteParameterError\";\n }\n}\n\nexport class ReservedRouteParameterError extends AmbiguousRouteError {\n constructor(message: string) {\n super(message);\n this.name = \"ReservedRouteParameterError\";\n }\n}\n\nexport class BrowserUnstableRouteError extends TypeError {\n constructor(message: string) {\n super(message);\n this.name = \"BrowserUnstableRouteError\";\n }\n}\n\nconst SEGMENT_RANK: Record = {\n static: 4,\n dynamic: 3,\n \"catch-all\": 1,\n \"optional-catch-all\": 0,\n};\n\n// Ending a route is more specific than consuming the same path through a\n// catch-all, while a following static or dynamic segment remains more specific.\nconst ROUTE_END_RANK = 2;\n\n/** Sort route patterns from the most specific segment sequence to the least specific. */\nexport function compareRouteSpecificity(\n left: readonly RouteSegmentSpecificity[],\n right: readonly RouteSegmentSpecificity[],\n): number {\n const length = Math.max(left.length, right.length);\n\n for (let index = 0; index < length; index++) {\n const leftRank = index < left.length ? SEGMENT_RANK[left[index]!] : ROUTE_END_RANK;\n const rightRank = index < right.length ? SEGMENT_RANK[right[index]!] : ROUTE_END_RANK;\n if (leftRank !== rightRank) return rightRank - leftRank;\n }\n\n return 0;\n}\n\nexport type RoutePatternSyntax = \"page\" | \"router\" | \"api\";\n\nconst ROUTER_PARAMETER_NAME = \"[A-Za-z0-9_$-]+\";\nconst PAGE_PARAMETER_PATTERN = /^(?:\\[\\[\\.\\.\\.(.+)\\]\\]|\\[\\.\\.\\.(.+)\\]|\\[(.+)\\])$/;\nconst ROUTER_PARAMETER_PATTERN =\n /^(?:\\[\\[\\.\\.\\.([A-Za-z0-9_$-]+)\\]\\]|\\[\\.\\.\\.([A-Za-z0-9_$-]+)\\]|\\[([A-Za-z0-9_$-]+)\\]|:([A-Za-z0-9_$-]+)|\\*([A-Za-z0-9_$-]+)\\??)$/;\nconst RESERVED_PARAMETER_NAMES = new Set([\"__proto__\", \"constructor\", \"prototype\"]);\n\nexport function assertBrowserStableRoutePath(pattern: string): void {\n if (pattern.includes(\"\\\\\") || hasControlCharacter(pattern)) {\n throw new BrowserUnstableRouteError(\n `Route path \"${pattern}\" cannot contain backslashes or control characters.`,\n );\n }\n\n for (const segment of pattern.split(\"/\").filter(Boolean)) {\n if (\n (segment.startsWith(\"(\") && segment.endsWith(\")\")) ||\n (segment.startsWith(\"[\") && segment.endsWith(\"]\"))\n ) {\n continue;\n }\n\n let decoded = segment;\n try {\n decoded = decodeURIComponent(segment);\n } catch {\n // Malformed escapes stay literal in browser pathnames.\n }\n if (\n decoded === \".\" ||\n decoded === \"..\" ||\n decoded.includes(\"/\") ||\n decoded.includes(\"\\\\\") ||\n hasControlCharacter(decoded)\n ) {\n throw new BrowserUnstableRouteError(\n `Route path \"${pattern}\" contains browser-unstable segment \"${segment}\".`,\n );\n }\n }\n}\n\nfunction hasControlCharacter(value: string): boolean {\n return Array.from(value).some((character) => {\n const code = character.charCodeAt(0);\n return code <= 31 || (code >= 127 && code <= 159);\n });\n}\n\nexport function assertUniqueRouteParameters(\n pattern: string,\n syntax: RoutePatternSyntax = \"page\",\n): void {\n const parameterPattern = syntax === \"router\" ? ROUTER_PARAMETER_PATTERN : PAGE_PARAMETER_PATTERN;\n const names = new Set();\n\n for (const segment of splitRoutePattern(pattern, syntax)) {\n const match = parameterPattern.exec(segment);\n const name = match?.slice(1).find(Boolean);\n if (!name) continue;\n if (RESERVED_PARAMETER_NAMES.has(name)) {\n throw new ReservedRouteParameterError(\n `Route parameter \"${name}\" in route \"${pattern}\" is reserved. Use a different parameter name.`,\n );\n }\n if (names.has(name)) {\n throw new DuplicateRouteParameterError(\n `Duplicate route parameter \"${name}\" in route \"${pattern}\". Each dynamic segment must use a unique name.`,\n );\n }\n names.add(name);\n }\n}\n\nfunction splitRoutePattern(pattern: string, syntax: RoutePatternSyntax): string[] {\n return pattern\n .replace(/\\\\/g, \"/\")\n .split(\"/\")\n .filter(Boolean)\n .filter((segment) =>\n syntax === \"api\" ? true : !(segment.startsWith(\"(\") && segment.endsWith(\")\")),\n );\n}\n\nexport function assertTerminalCatchAll(pattern: string, syntax: RoutePatternSyntax = \"page\"): void {\n const segments = splitRoutePattern(pattern, syntax);\n const parameterName = syntax === \"router\" ? ROUTER_PARAMETER_NAME : \".+\";\n const catchAllPattern = new RegExp(\n syntax === \"router\"\n ? `^(?:\\\\[\\\\[\\\\.\\\\.\\\\.${parameterName}\\\\]\\\\]|\\\\[\\\\.\\\\.\\\\.${parameterName}\\\\]|\\\\*${parameterName}\\\\??)$`\n : `^(?:\\\\[\\\\[\\\\.\\\\.\\\\.${parameterName}\\\\]\\\\]|\\\\[\\\\.\\\\.\\\\.${parameterName}\\\\])$`,\n );\n const catchAllIndex = segments.findIndex((segment) => catchAllPattern.test(segment));\n if (catchAllIndex >= 0 && catchAllIndex !== segments.length - 1) {\n throw new NonTerminalCatchAllRouteError(\n `Catch-all segment \"${segments[catchAllIndex]}\" must be the final segment in route \"${pattern}\".`,\n );\n }\n}\n\n/** Return the URL-matching shape of a route without its parameter names. */\nexport function getRoutePatternShape(pattern: string, syntax: RoutePatternSyntax = \"page\"): string {\n assertTerminalCatchAll(pattern, syntax);\n const segments = splitRoutePattern(pattern, syntax).map((segment) => {\n const specificity = getPatternSegmentSpecificity(segment, syntax);\n if (specificity !== \"static\") return specificity;\n\n try {\n return `static:${decodeURIComponent(segment)}`;\n } catch {\n return `static:${segment}`;\n }\n });\n\n return segments.length === 0 ? \"/\" : JSON.stringify(segments);\n}\n\n/** Return the specificity of every URL-consuming segment in a route pattern. */\nexport function getRoutePatternSpecificity(\n pattern: string,\n syntax: RoutePatternSyntax = \"page\",\n): RouteSegmentSpecificity[] {\n assertTerminalCatchAll(pattern, syntax);\n return splitRoutePattern(pattern, syntax).map((segment) =>\n getPatternSegmentSpecificity(segment, syntax),\n );\n}\n\nfunction getPatternSegmentSpecificity(\n segment: string,\n syntax: RoutePatternSyntax,\n): RouteSegmentSpecificity {\n const parameterName = syntax === \"router\" ? ROUTER_PARAMETER_NAME : \".+\";\n const supportsColonAndStar = syntax === \"router\";\n if (\n new RegExp(`^\\\\[\\\\[\\\\.\\\\.\\\\.${parameterName}\\\\]\\\\]$`).test(segment) ||\n (supportsColonAndStar && new RegExp(`^\\\\*${parameterName}\\\\?$`).test(segment))\n ) {\n return \"optional-catch-all\";\n }\n if (\n new RegExp(`^\\\\[\\\\.\\\\.\\\\.${parameterName}\\\\]$`).test(segment) ||\n (supportsColonAndStar && new RegExp(`^\\\\*${parameterName}$`).test(segment))\n ) {\n return \"catch-all\";\n }\n if (\n new RegExp(`^\\\\[${parameterName}\\\\]$`).test(segment) ||\n (supportsColonAndStar && new RegExp(`^:${parameterName}$`).test(segment))\n ) {\n return \"dynamic\";\n }\n\n return \"static\";\n}\n"],"mappings":"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","names":["value","splitRoutePattern"]}