@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-S6VYG6XU.cjs

@@ -0,0 +1,493 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkIWZKTWHZcjs = require('./chunk-IWZKTWHZ.cjs');
+
+
+var _chunkWMAPPDMMcjs = require('./chunk-WMAPPDMM.cjs');
+
+
+var _chunkTKJZFIMLcjs = require('./chunk-TKJZFIML.cjs');
+
+
+var _chunkLSKZMJMPcjs = require('./chunk-LSKZMJMP.cjs');
+
+
+
+
+var _chunkKIIMAWOJcjs = require('./chunk-KIIMAWOJ.cjs');
+
+
+var _chunkKNBBQHO2cjs = require('./chunk-KNBBQHO2.cjs');
+
+
+
+var _chunkG7HXGLECcjs = require('./chunk-G7HXGLEC.cjs');
+
+
+
+var _chunkS3A45T7Fcjs = require('./chunk-S3A45T7F.cjs');
+
+
+
+
+var _chunkZEG3OPIBcjs = require('./chunk-ZEG3OPIB.cjs');
+
+
+var _chunkUXFQ3UDAcjs = require('./chunk-UXFQ3UDA.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/api/route-schema.ts
+async function parseRouteSchema(schema, value) {
+  if (schema.parseAsync) return schema.parseAsync(value);
+  if (schema["~standard"]) {
+    const result = await schema["~standard"].validate(value);
+    if (result.issues)
+      throw Object.assign(new Error("Validation failed"), { issues: result.issues });
+    return result.value;
+  }
+  if (schema.parse) return schema.parse(value);
+  throw new TypeError("Route validators must implement Standard Schema or parse().");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseRouteSchema, "parseRouteSchema");
+
+// src/api/plugin-route-runtime.ts
+function mergePluginAPIRoutes(existing, plugins, expected, options = {}) {
+  const routes = /* @__PURE__ */ new Map();
+  const shapes = /* @__PURE__ */ new Map();
+  for (const route of existing) {
+    _chunkWMAPPDMMcjs.registerAPIRouteShape.call(void 0, shapes, route.path, route.filePath || route.path, "app");
+    routes.set(route.path, {
+      ...route,
+      filePath: route.filePath || "",
+      methods: [...route.methods],
+      endpoints: { ...route.endpoints }
+    });
+  }
+  const api = createPluginLocalAPI(existing, options.bodySizeLimit, options.dispatch);
+  for (const definition of _chunkIWZKTWHZcjs.resolvePluginRoutes.call(void 0, plugins, { api })) {
+    _chunkWMAPPDMMcjs.registerAPIRouteShape.call(void 0, shapes, definition.path, `plugin:${definition.path}`, "app");
+    let route = routes.get(definition.path);
+    if (_optionalChain([route, 'optionalAccess', _ => _.methods, 'access', _2 => _2.includes, 'call', _3 => _3(definition.method)])) {
+      throw new Error(
+        `Duplicate API route for ${definition.method} ${definition.path}. Plugin routes cannot override app or other plugin endpoints.`
+      );
+    }
+    if (!route) {
+      route = { path: definition.path, filePath: "", methods: [], endpoints: {} };
+      routes.set(definition.path, route);
+    }
+    route.methods.push(definition.method);
+    route.pluginMethods = [..._nullishCoalesce(route.pluginMethods, () => ( [])), definition.method];
+    route.endpoints[definition.method] = definition.endpoint;
+  }
+  const result = [...routes.values()];
+  if (expected) {
+    const signature = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (entries) => entries.map(({ path, methods }) => `${path}:${[...methods].sort().join(",")}`).sort().join("\n"), "signature");
+    const actualSignature = signature(result);
+    const expectedSignature = signature(expected);
+    if (actualSignature !== expectedSignature) {
+      throw new Error(
+        `Plugin API routes changed between build and runtime. Route paths and methods must be stable across environments; rebuild the app.
+Expected:
+${expectedSignature || "(none)"}
+Received:
+${actualSignature || "(none)"}`
+      );
+    }
+  }
+  return result;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergePluginAPIRoutes, "mergePluginAPIRoutes");
+var DISPATCH_DROPPED_HEADERS = [
+  "accept-encoding",
+  "connection",
+  "content-length",
+  "keep-alive",
+  "proxy-connection",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+];
+function createPluginLocalAPI(routes, bodySizeLimit, dispatch) {
+  const endpoints = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    for (const method of route.methods) {
+      const normalizedMethod = method.toUpperCase();
+      const endpoint = route.endpoints[normalizedMethod];
+      if (typeof endpoint !== "function") continue;
+      const descriptor = Object.freeze({
+        path: route.path,
+        method: normalizedMethod,
+        input: Object.freeze({
+          body: _optionalChain([endpoint, 'access', _4 => _4.__types, 'optionalAccess', _5 => _5.body]),
+          query: _optionalChain([endpoint, 'access', _6 => _6.__types, 'optionalAccess', _7 => _7.query]),
+          params: _optionalChain([endpoint, 'access', _8 => _8.__types, 'optionalAccess', _9 => _9.params]),
+          headers: _optionalChain([endpoint, 'access', _10 => _10.__types, 'optionalAccess', _11 => _11.headers])
+        }),
+        output: endpoint.__output,
+        mcp: endpoint.__mcp === true ? true : endpoint.__mcp ? Object.freeze({ ...endpoint.__mcp }) : void 0,
+        async invoke(request, params = {}) {
+          if (!dispatch)
+            return invokeAPIRouteEndpoint(endpoint, request, { ...params }, bodySizeLimit);
+          const headers = new Headers(request.headers);
+          for (const name of DISPATCH_DROPPED_HEADERS) headers.delete(name);
+          return dispatch(new Request(request, { headers }));
+        }
+      });
+      endpoints.set(`${normalizedMethod} ${route.path}`, descriptor);
+    }
+  }
+  const listedEndpoints = Object.freeze(Array.from(endpoints.values()));
+  return Object.freeze({
+    available: true,
+    get(method, path) {
+      return endpoints.get(`${method.toUpperCase()} ${path}`);
+    },
+    list() {
+      return listedEndpoints;
+    }
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createPluginLocalAPI, "createPluginLocalAPI");
+
+// src/api/runtime.ts
+var API_ROUTE_METHODS = [
+  "GET",
+  "HEAD",
+  "QUERY",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS"
+];
+function resolveAPIRouteEndpoint(route, method) {
+  const normalizedMethod = method.toUpperCase();
+  return _nullishCoalesce(route.endpoints[normalizedMethod], () => ( (normalizedMethod === "HEAD" ? route.endpoints.GET : void 0)));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveAPIRouteEndpoint, "resolveAPIRouteEndpoint");
+function getAllowedAPIRouteMethods(route) {
+  const methods = [...route.methods];
+  const getIndex = methods.indexOf("GET");
+  if (getIndex >= 0 && !methods.includes("HEAD")) {
+    methods.splice(getIndex + 1, 0, "HEAD");
+  }
+  return methods;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getAllowedAPIRouteMethods, "getAllowedAPIRouteMethods");
+function matchAPIRouteAtBasePath(routes, pathname, serverBasePath = _chunkS3A45T7Fcjs.DEFAULT_FARM_API_BASE_PATH) {
+  const directMatch = _chunkG7HXGLECcjs.matchAPIRoute.call(void 0, routes, pathname);
+  if (directMatch) return directMatch;
+  const canonicalPathname = _chunkKNBBQHO2cjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath);
+  return canonicalPathname === pathname ? null : _chunkG7HXGLECcjs.matchAPIRoute.call(void 0, routes, canonicalPathname);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchAPIRouteAtBasePath, "matchAPIRouteAtBasePath");
+function createStaticAPIRouteMatcherAtBasePath(routes, serverBasePath = _chunkS3A45T7Fcjs.DEFAULT_FARM_API_BASE_PATH) {
+  const match = _chunkG7HXGLECcjs.createStaticAPIRouteMatcher.call(void 0, routes);
+  return (pathname) => {
+    const directMatch = match(pathname);
+    if (directMatch) return directMatch;
+    const canonicalPathname = _chunkKNBBQHO2cjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath);
+    return canonicalPathname === pathname ? null : match(canonicalPathname);
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createStaticAPIRouteMatcherAtBasePath, "createStaticAPIRouteMatcherAtBasePath");
+function isFarmAPIPathname(pathname, serverBasePath = _chunkS3A45T7Fcjs.DEFAULT_FARM_API_BASE_PATH) {
+  const basePath = _chunkS3A45T7Fcjs.normalizeFarmAPIBasePath.call(void 0, serverBasePath);
+  return basePath !== "/" && (pathname === basePath || pathname.startsWith(`${basePath}/`));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmAPIPathname, "isFarmAPIPathname");
+async function invokeAPIRouteEndpoint(endpoint, request, params = {}, bodySizeLimit = _chunkKIIMAWOJcjs.DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT) {
+  try {
+    request = await _chunkKIIMAWOJcjs.bufferFarmRequestBody.call(void 0, request, bodySizeLimit);
+  } catch (error) {
+    const response2 = _chunkKIIMAWOJcjs.createFarmRequestBodyErrorResponse.call(void 0, error);
+    if (response2) return response2;
+    throw error;
+  }
+  const response = await _chunkUXFQ3UDAcjs._runWithCurrentRequest.call(void 0, 
+    request,
+    () => invokeAPIRouteEndpointInContext(endpoint, request, params)
+  );
+  if (request.method.toUpperCase() !== "HEAD") {
+    return response;
+  }
+  return _chunkTKJZFIMLcjs.omitFarmResponseBody.call(void 0, response);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, invokeAPIRouteEndpoint, "invokeAPIRouteEndpoint");
+async function invokeAPIRouteEndpointInContext(endpoint, request, params) {
+  const queryContentTypeError = validateQueryContentType(request);
+  if (queryContentTypeError) {
+    return queryContentTypeError;
+  }
+  const farmHandler = endpoint.__handler || null;
+  if (!farmHandler) {
+    const result = await endpoint(request, {
+      params: Promise.resolve(params)
+    });
+    return normalizeRouteResponse(result);
+  }
+  const url = new URL(request.url);
+  const query = {
+    ...searchParamsToObject(url.searchParams)
+  };
+  let body = void 0;
+  if (request.method.toUpperCase() !== "GET" && request.method.toUpperCase() !== "HEAD") {
+    const parsedBody = await readRequestBody(request);
+    if (parsedBody.error) return parsedBody.error;
+    body = parsedBody.body;
+  }
+  const headers = Object.fromEntries(request.headers.entries());
+  const types = endpoint.__types || {};
+  const queryValidation = await validateInput(types.query, query, "Invalid query parameters");
+  if (queryValidation instanceof Response) {
+    return queryValidation;
+  }
+  const bodyValidation = await validateInput(types.body, body, "Invalid request body");
+  if (bodyValidation instanceof Response) {
+    return bodyValidation;
+  }
+  const headersValidation = await validateInput(types.headers, headers, "Invalid request headers");
+  if (headersValidation instanceof Response) {
+    return headersValidation;
+  }
+  const paramsValidation = await validateInput(types.params, params, "Invalid route parameters");
+  if (paramsValidation instanceof Response) return paramsValidation;
+  const handlerContext = {
+    query: queryValidation,
+    body: bodyValidation,
+    headers: headersValidation,
+    request,
+    context: {},
+    params: paramsValidation
+  };
+  let execution;
+  try {
+    execution = typeof endpoint.__farmInvoke === "function" ? await endpoint.__farmInvoke(handlerContext) : {
+      result: await farmHandler(handlerContext),
+      context: handlerContext.context,
+      handlerExecuted: true,
+      invalidations: []
+    };
+  } catch (error) {
+    if (_chunkIWZKTWHZcjs.isEndpointFailure.call(void 0, error)) {
+      return createEndpointFailureResponse(error);
+    }
+    throw error;
+  }
+  if (execution.handlerExecuted && endpoint.__output && !isWebResponse(execution.result)) {
+    try {
+      execution.result = await parseRouteSchema(endpoint.__output, execution.result);
+    } catch (e) {
+      throw new Error("API route returned a value that does not match its output schema.");
+    }
+  }
+  const response = normalizeRouteResponse(execution.result);
+  return attachEndpointInvalidations(response, execution.invalidations);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, invokeAPIRouteEndpointInContext, "invokeAPIRouteEndpointInContext");
+function validateQueryContentType(request) {
+  if (request.method.toUpperCase() !== "QUERY" || request.headers.has("content-type")) {
+    return null;
+  }
+  return new Response(
+    JSON.stringify({
+      error: "Invalid QUERY request",
+      message: "QUERY requests must include a Content-Type header."
+    }),
+    {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    }
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, validateQueryContentType, "validateQueryContentType");
+function normalizeRouteResponse(result) {
+  if (isWebResponse(result)) {
+    return result;
+  }
+  if (result === void 0) {
+    return new Response(null, { status: 204 });
+  }
+  let body;
+  try {
+    body = JSON.stringify(result);
+  } catch (error) {
+    const serializationError = new TypeError(
+      "API route result must be a JSON-serializable value or a Response."
+    );
+    serializationError.cause = error;
+    throw serializationError;
+  }
+  if (body === void 0) {
+    throw new TypeError("API route result must be a JSON-serializable value or a Response.");
+  }
+  return new Response(body, {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRouteResponse, "normalizeRouteResponse");
+function isWebResponse(value) {
+  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isWebResponse, "isWebResponse");
+function attachEndpointInvalidations(response, keys) {
+  const existing = _chunkZEG3OPIBcjs.decodeFarmCacheInvalidations.call(void 0, 
+    response.headers.get(_chunkZEG3OPIBcjs.FARM_CACHE_INVALIDATION_HEADER)
+  );
+  const encoded = _chunkZEG3OPIBcjs.encodeFarmCacheInvalidations.call(void 0, [...existing, ...keys]);
+  if (!encoded) return response;
+  const headers = new Headers(response.headers);
+  headers.set(_chunkZEG3OPIBcjs.FARM_CACHE_INVALIDATION_HEADER, encoded);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, attachEndpointInvalidations, "attachEndpointInvalidations");
+function createEndpointFailureResponse(failure) {
+  return new Response(
+    JSON.stringify({
+      error: {
+        code: failure.code,
+        message: failure.message,
+        data: failure.data
+      }
+    }),
+    {
+      status: failure.status,
+      headers: {
+        "cache-control": "no-store",
+        "content-type": "application/json"
+      }
+    }
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createEndpointFailureResponse, "createEndpointFailureResponse");
+async function readRequestBody(request) {
+  const contentType = _optionalChain([request, 'access', _12 => _12.headers, 'access', _13 => _13.get, 'call', _14 => _14("content-type"), 'optionalAccess', _15 => _15.split, 'call', _16 => _16(";", 1), 'access', _17 => _17[0], 'optionalAccess', _18 => _18.trim, 'call', _19 => _19(), 'access', _20 => _20.toLowerCase, 'call', _21 => _21()]);
+  if (contentType === "multipart/form-data") {
+    try {
+      return { body: formDataToObject(await request.clone().formData()) };
+    } catch (e2) {
+      return invalidRequestBody("The request body is not valid multipart form data.");
+    }
+  }
+  let text;
+  try {
+    text = await request.clone().text();
+  } catch (e3) {
+    if (contentType === "application/json" || _optionalChain([contentType, 'optionalAccess', _22 => _22.endsWith, 'call', _23 => _23("+json")])) {
+      return invalidRequestBody("The request body is not valid JSON.");
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+      return invalidRequestBody("The request body is not valid URL-encoded form data.");
+    }
+    return { body: void 0 };
+  }
+  if (contentType === "application/json" || _optionalChain([contentType, 'optionalAccess', _24 => _24.endsWith, 'call', _25 => _25("+json")])) {
+    if (!text && request.method.toUpperCase() === "QUERY") {
+      return { body: void 0 };
+    }
+    try {
+      return { body: JSON.parse(text) };
+    } catch (e4) {
+      return invalidRequestBody("The request body is not valid JSON.");
+    }
+  }
+  if (contentType === "application/x-www-form-urlencoded") {
+    return { body: searchParamsToObject(new URLSearchParams(text)) };
+  }
+  if (!text) return { body: void 0 };
+  if (contentType === void 0) {
+    if (!_chunkLSKZMJMPcjs.validateIntegrationRequestOrigin.call(void 0, request, { requireOriginMetadata: false }).ok) {
+      return { body: void 0 };
+    }
+    try {
+      return { body: JSON.parse(text) };
+    } catch (e5) {
+      return { body: void 0 };
+    }
+  }
+  return { body: void 0 };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readRequestBody, "readRequestBody");
+function invalidRequestBody(message) {
+  return {
+    error: new Response(
+      JSON.stringify({
+        error: "Invalid request body",
+        message
+      }),
+      {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      }
+    )
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, invalidRequestBody, "invalidRequestBody");
+function formDataToObject(formData) {
+  return entriesToObject(formData.entries());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, formDataToObject, "formDataToObject");
+function searchParamsToObject(searchParams) {
+  return entriesToObject(searchParams.entries());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, searchParamsToObject, "searchParamsToObject");
+function entriesToObject(entries) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of entries) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    const current = output[key];
+    if (current === void 0) {
+      output[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      output[key] = [current, value];
+    }
+  }
+  return output;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, entriesToObject, "entriesToObject");
+async function validateInput(schema, value, error) {
+  if (!schema) return value;
+  try {
+    return await parseRouteSchema(schema, value);
+  } catch (validationError) {
+    return Response.json(
+      {
+        error,
+        details: (validationError.issues || validationError.errors || []).map((issue) => ({
+          path: issue.path,
+          message: issue.message,
+          code: issue.code
+        }))
+      },
+      { status: 400 }
+    );
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, validateInput, "validateInput");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.parseRouteSchema = parseRouteSchema; exports.API_ROUTE_METHODS = API_ROUTE_METHODS; exports.resolveAPIRouteEndpoint = resolveAPIRouteEndpoint; exports.getAllowedAPIRouteMethods = getAllowedAPIRouteMethods; exports.matchAPIRouteAtBasePath = matchAPIRouteAtBasePath; exports.createStaticAPIRouteMatcherAtBasePath = createStaticAPIRouteMatcherAtBasePath; exports.isFarmAPIPathname = isFarmAPIPathname; exports.invokeAPIRouteEndpoint = invokeAPIRouteEndpoint; exports.normalizeRouteResponse = normalizeRouteResponse; exports.isWebResponse = isWebResponse; exports.createEndpointFailureResponse = createEndpointFailureResponse; exports.mergePluginAPIRoutes = mergePluginAPIRoutes;

package/dist/chunk-SAXPH6G5.mjs

@@ -0,0 +1,169 @@
+import {
+  canonicalizeRequestPathname
+} from "./chunk-CQ6OSQ3K.mjs";
+import {
+  localizeFarmHref,
+  resolveFarmLocalePath
+} from "./chunk-L3KT7IXV.mjs";
+import {
+  assertBrowserStableRoutePath
+} from "./chunk-55YI3RRB.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/plugins/route-pattern.ts
+function validateConfigRouteSource(source, field = "Config route source") {
+  if (typeof source !== "string" || source.length === 0) {
+    throw new TypeError(`${field} must be a non-empty pathname pattern.`);
+  }
+  if (source.trim() !== source) {
+    throw new Error(`${field} cannot contain leading or trailing whitespace.`);
+  }
+  if (!source.startsWith("/")) {
+    throw new Error(`${field} must start with "/".`);
+  }
+  if (source.includes("?") || source.includes("#")) {
+    throw new Error(`${field} must be a pathname without a query string or hash.`);
+  }
+  if (source.includes("\\") || Array.from(source).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  })) {
+    throw new Error(`${field} cannot contain backslashes or control characters.`);
+  }
+  assertBrowserStableRoutePath(source);
+  return source;
+}
+__name(validateConfigRouteSource, "validateConfigRouteSource");
+function resolveConfigRoutePathname(pathname, i18n) {
+  const localizedPathname = i18n?.enabled ? resolveFarmLocalePath(pathname, i18n) : { pathname };
+  return {
+    pathname: normalizeConfigRoutePathname(canonicalizeRequestPathname(localizedPathname.pathname)),
+    ...i18n?.enabled && "locale" in localizedPathname ? { locale: localizedPathname.locale } : {}
+  };
+}
+__name(resolveConfigRoutePathname, "resolveConfigRoutePathname");
+function normalizeConfigRoutePathname(pathname) {
+  if (!pathname || pathname === "/") return "/";
+  return pathname.endsWith("/") ? pathname.replace(/\/+$/, "") || "/" : pathname;
+}
+__name(normalizeConfigRoutePathname, "normalizeConfigRoutePathname");
+function localizeConfigRouteDestination(destination, locale, i18n) {
+  return locale && i18n?.enabled ? localizeFarmHref(destination, locale, i18n) : destination;
+}
+__name(localizeConfigRouteDestination, "localizeConfigRouteDestination");
+function appendCatchAll(pattern) {
+  return pattern.endsWith("/") ? `${pattern.slice(0, -1)}(?:/(.*))?` : `${pattern}(.*)`;
+}
+__name(appendCatchAll, "appendCatchAll");
+function escapeRegexCharacter(character) {
+  return /[\\^$.*+?()[\]{}|]/.test(character) ? `\\${character}` : character;
+}
+__name(escapeRegexCharacter, "escapeRegexCharacter");
+function compileConfigRoutePattern(source) {
+  validateConfigRouteSource(source);
+  const tokens = [];
+  let pattern = "";
+  let captureIndex = 1;
+  for (let index = 0; index < source.length; ) {
+    const rest = source.slice(index);
+    const parameter = rest.match(/^:([A-Za-z0-9_]+)(\*)?/);
+    if (parameter) {
+      tokens.push({
+        kind: "param",
+        name: parameter[1],
+        captureIndex,
+        catchAll: parameter[2] === "*"
+      });
+      pattern = parameter[2] ? appendCatchAll(pattern) : `${pattern}([^/]+)`;
+      captureIndex += 1;
+      index += parameter[0].length;
+      continue;
+    }
+    if (source[index] === "*") {
+      tokens.push({ kind: "wildcard", captureIndex });
+      pattern = appendCatchAll(pattern);
+      captureIndex += 1;
+      index += 1;
+      continue;
+    }
+    pattern += escapeRegexCharacter(source[index]);
+    index += 1;
+  }
+  return { regex: new RegExp(`^${pattern}$`), tokens };
+}
+__name(compileConfigRoutePattern, "compileConfigRoutePattern");
+function interpolateConfigRouteDestination(destination, match, tokens) {
+  const namedCaptures = /* @__PURE__ */ new Map();
+  const wildcardCaptures = [];
+  const captures = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const value = normalizeConfigRouteCapture(
+      match[token.captureIndex] || "",
+      token.kind === "wildcard" || token.catchAll
+    );
+    captures.set(token.captureIndex, value);
+    if (token.kind === "param") {
+      namedCaptures.set(token.name, value);
+    } else {
+      wildcardCaptures.push(value);
+    }
+  }
+  let result = "";
+  let wildcardIndex = 0;
+  for (let index = 0; index < destination.length; ) {
+    const rest = destination.slice(index);
+    const parameter = rest.match(/^:([A-Za-z0-9_]+)(\*)?/);
+    if (parameter) {
+      const value = namedCaptures.get(parameter[1]);
+      result += value === void 0 ? parameter[0] : value;
+      index += parameter[0].length;
+      continue;
+    }
+    const capture = rest.match(/^\$(\d+)/);
+    if (capture) {
+      result += captures.get(Number(capture[1])) ?? "";
+      index += capture[0].length;
+      continue;
+    }
+    if (destination[index] === "*") {
+      result += wildcardCaptures[wildcardIndex] || "";
+      wildcardIndex += 1;
+      index += 1;
+      continue;
+    }
+    result += destination[index];
+    index += 1;
+  }
+  return result;
+}
+__name(interpolateConfigRouteDestination, "interpolateConfigRouteDestination");
+function normalizeConfigRouteCapture(value, catchAll) {
+  const segments = catchAll ? value.split("/").filter(Boolean) : [value];
+  return segments.map((segment) => encodeConfigRouteSegment(decodeConfigRouteSegment(segment))).join("/");
+}
+__name(normalizeConfigRouteCapture, "normalizeConfigRouteCapture");
+function decodeConfigRouteSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+__name(decodeConfigRouteSegment, "decodeConfigRouteSegment");
+function encodeConfigRouteSegment(segment) {
+  return encodeURIComponent(segment).replace(
+    /[!'()*]/g,
+    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+__name(encodeConfigRouteSegment, "encodeConfigRouteSegment");
+
+export {
+  validateConfigRouteSource,
+  resolveConfigRoutePathname,
+  localizeConfigRouteDestination,
+  compileConfigRoutePattern,
+  interpolateConfigRouteDestination
+};