@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-ONG4RDW3.mjs

@@ -0,0 +1,155 @@
+import {
+  canonicalizeRequestPathname
+} from "./chunk-OHWM2VI4.mjs";
+import {
+  localizeFarmHref,
+  resolveFarmLocalePath
+} from "./chunk-7S7AAK2D.mjs";
+import {
+  assertBrowserStableRoutePath
+} from "./chunk-AYP2YFVN.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;
+}
+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 } : {}
+  };
+}
+function normalizeConfigRoutePathname(pathname) {
+  if (!pathname || pathname === "/") return "/";
+  return pathname.endsWith("/") ? pathname.replace(/\/+$/, "") || "/" : pathname;
+}
+function localizeConfigRouteDestination(destination, locale, i18n) {
+  return locale && i18n?.enabled ? localizeFarmHref(destination, locale, i18n) : destination;
+}
+function appendCatchAll(pattern) {
+  return pattern.endsWith("/") ? `${pattern.slice(0, -1)}(?:/(.*))?` : `${pattern}(.*)`;
+}
+function escapeRegexCharacter(character) {
+  return /[\\^$.*+?()[\]{}|]/.test(character) ? `\\${character}` : character;
+}
+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 };
+}
+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;
+}
+function normalizeConfigRouteCapture(value, catchAll) {
+  const segments = catchAll ? value.split("/").filter(Boolean) : [value];
+  return segments.map((segment) => encodeConfigRouteSegment(decodeConfigRouteSegment(segment))).join("/");
+}
+function decodeConfigRouteSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function encodeConfigRouteSegment(segment) {
+  return encodeURIComponent(segment).replace(
+    /[!'()*]/g,
+    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+
+export {
+  validateConfigRouteSource,
+  resolveConfigRoutePathname,
+  localizeConfigRouteDestination,
+  compileConfigRoutePattern,
+  interpolateConfigRouteDestination
+};

package/dist/chunk-OOJBBHYW.cjs

@@ -0,0 +1,38 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }// src/client/document-head.ts
+var FARM_NAVIGATION_HEAD_SELECTOR = [
+  "meta[name]",
+  "meta[property]",
+  "meta[http-equiv]",
+  "meta[charset]",
+  "meta[itemprop]",
+  'link[rel~="author"]',
+  'link[rel~="canonical"]',
+  'link[rel~="alternate"]',
+  'link[rel~="icon"]',
+  'link[rel~="apple-touch-icon"]',
+  'link[rel~="manifest"]',
+  'link[rel~="search"]',
+  'link[rel~="next"]',
+  'link[rel~="prev"]',
+  'link[rel~="publisher"]',
+  'link[rel~="license"]',
+  'link[rel~="help"]',
+  'link[rel~="me"]',
+  'link[rel~="pingback"]',
+  'link[rel~="privacy-policy"]',
+  'link[rel~="terms-of-service"]',
+  // Page and layout `metadata.jsonLd` (FARM_METADATA_ATTRIBUTE). The site-level
+  // agent JSON-LD and app-authored scripts carry no marker and stay in place.
+  'script[type="application/ld+json"][data-farm-metadata]'
+].join(",");
+function reconcileFarmDocumentHead(nextDocument) {
+  const nextTitle = nextDocument.querySelector("title");
+  document.title = _optionalChain([nextTitle, 'optionalAccess', _ => _.textContent]) || "";
+  document.head.querySelectorAll(FARM_NAVIGATION_HEAD_SELECTOR).forEach((node) => node.remove());
+  nextDocument.head.querySelectorAll(FARM_NAVIGATION_HEAD_SELECTOR).forEach((node) => document.head.appendChild(document.importNode(node, true)));
+}
+
+
+
+
+exports.FARM_NAVIGATION_HEAD_SELECTOR = FARM_NAVIGATION_HEAD_SELECTOR; exports.reconcileFarmDocumentHead = reconcileFarmDocumentHead;

package/dist/chunk-OOZEU5KK.cjs

@@ -0,0 +1,18 @@
+"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; }// src/theme/bridge.ts
+var FALLBACK_SERVER_SNAPSHOT = Object.freeze({
+  theme: "system",
+  resolvedTheme: void 0,
+  mounted: false
+});
+var FARM_THEME_SERVER_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.js.theme.server-snapshot-resolver");
+function _setFarmThemeServerSnapshotResolver(resolver) {
+  globalThis[FARM_THEME_SERVER_SNAPSHOT_RESOLVER] = resolver;
+}
+function getFarmThemeServerSnapshot() {
+  return _nullishCoalesce(_optionalChain([globalThis, 'access', _ => _[FARM_THEME_SERVER_SNAPSHOT_RESOLVER], 'optionalCall', _2 => _2()]), () => ( FALLBACK_SERVER_SNAPSHOT));
+}
+
+
+
+
+exports._setFarmThemeServerSnapshotResolver = _setFarmThemeServerSnapshotResolver; exports.getFarmThemeServerSnapshot = getFarmThemeServerSnapshot;

package/dist/chunk-OWQV6MLM.cjs

@@ -0,0 +1,82 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkD22BUQKWcjs = require('./chunk-D22BUQKW.cjs');
+
+// src/i18n/routing.ts
+var RTL_LANGUAGES = /* @__PURE__ */ new Set([
+  "ar",
+  "arc",
+  "ckb",
+  "dv",
+  "fa",
+  "he",
+  "ku",
+  "nqo",
+  "ps",
+  "sd",
+  "syr",
+  "ug",
+  "ur",
+  "yi"
+]);
+function resolveFarmLocalePath(pathname, config) {
+  const normalized = normalizePathname(_chunkD22BUQKWcjs.stripFarmBasePath.call(void 0, pathname, config.basePath));
+  if (config.routing === "none") {
+    return { pathname: normalized, explicit: false };
+  }
+  const segments = normalized.split("/").filter(Boolean);
+  const firstSegment = segments[0];
+  const locale = config.locales.find(
+    (candidate) => candidate.toLowerCase() === _optionalChain([firstSegment, 'optionalAccess', _ => _.toLowerCase, 'call', _2 => _2()])
+  );
+  if (!locale) {
+    return { pathname: normalized, explicit: false };
+  }
+  const remaining = segments.slice(1);
+  return {
+    locale,
+    pathname: remaining.length > 0 ? `/${remaining.join("/")}` : "/",
+    explicit: true
+  };
+}
+function stripFarmLocaleFromPathname(pathname, config) {
+  return resolveFarmLocalePath(pathname, config).pathname;
+}
+function localizeFarmPathname(pathname, locale, config) {
+  const internalPathname = resolveFarmLocalePath(pathname, config).pathname;
+  let localizedPathname = internalPathname;
+  if (config.routing === "none") {
+    return _chunkD22BUQKWcjs.applyFarmBasePath.call(void 0, localizedPathname, config.basePath);
+  }
+  if (config.routing === "prefix-except-default" && locale === config.defaultLocale) {
+    return _chunkD22BUQKWcjs.applyFarmBasePath.call(void 0, localizedPathname, config.basePath);
+  }
+  localizedPathname = internalPathname === "/" ? `/${locale}` : `/${locale}${internalPathname}`;
+  return _chunkD22BUQKWcjs.applyFarmBasePath.call(void 0, localizedPathname, config.basePath);
+}
+function localizeFarmHref(href, locale, config) {
+  if (!href.startsWith("/") || href.startsWith("//")) return href;
+  const url = new URL(href, "http://farm.local");
+  url.pathname = localizeFarmPathname(url.pathname, locale, config);
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+function getFarmLocaleDirection(locale, direction) {
+  const configured = _optionalChain([direction, 'optionalAccess', _3 => _3[locale]]);
+  if (configured) return configured;
+  const language = _optionalChain([locale, 'access', _4 => _4.split, 'call', _5 => _5("-"), 'access', _6 => _6[0], 'optionalAccess', _7 => _7.toLowerCase, 'call', _8 => _8()]) || locale.toLowerCase();
+  return RTL_LANGUAGES.has(language) ? "rtl" : "ltr";
+}
+function normalizePathname(pathname) {
+  const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (withLeadingSlash === "/") return "/";
+  return withLeadingSlash.replace(/\/{2,}/g, "/").replace(/\/$/, "") || "/";
+}
+
+
+
+
+
+
+
+exports.resolveFarmLocalePath = resolveFarmLocalePath; exports.stripFarmLocaleFromPathname = stripFarmLocaleFromPathname; exports.localizeFarmPathname = localizeFarmPathname; exports.localizeFarmHref = localizeFarmHref; exports.getFarmLocaleDirection = getFarmLocaleDirection;

package/dist/chunk-OY5XDG24.cjs

@@ -0,0 +1,113 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkSHIWRBFIcjs = require('./chunk-SHIWRBFI.cjs');
+
+
+var _chunkR5U7OIPIcjs = require('./chunk-R5U7OIPI.cjs');
+
+// src/desktop/guard.ts
+var FARM_DESKTOP_HANDSHAKE_PATH = "/__farm/desktop/handshake";
+var FARM_DESKTOP_COOKIE = "farm_desktop";
+var FARM_DESKTOP_HANDSHAKE_PARAM = "t";
+var FARM_DESKTOP_MIN_SECRET_LENGTH = 32;
+var LOOPBACK_HOST = /^(?:127\.0\.0\.1|localhost|\[::1\]):(\d{1,5})$/i;
+var SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+function forbidden(reason) {
+  return new Response(`Forbidden: ${reason}
+`, {
+    status: 403,
+    headers: {
+      "cache-control": "no-store",
+      "content-type": "text/plain; charset=utf-8",
+      "x-content-type-options": "nosniff",
+      "x-farm-desktop-guard": reason
+    }
+  });
+}
+function assertSecret(value, name) {
+  if (typeof value !== "string" || value.length < FARM_DESKTOP_MIN_SECRET_LENGTH || !/^[A-Za-z0-9_-]+$/.test(value)) {
+    throw new TypeError(
+      `[Farm] The desktop ${name} must be a random base64url string of at least ${FARM_DESKTOP_MIN_SECRET_LENGTH} characters.`
+    );
+  }
+}
+function splitTarget(url) {
+  let target = url;
+  if (!target.startsWith("/")) {
+    try {
+      const parsed = new URL(target);
+      return { pathname: parsed.pathname, search: parsed.search };
+    } catch (e) {
+      return { pathname: "", search: "" };
+    }
+  }
+  const hash = target.indexOf("#");
+  if (hash !== -1) target = target.slice(0, hash);
+  const query = target.indexOf("?");
+  return query === -1 ? { pathname: target, search: "" } : { pathname: target.slice(0, query), search: target.slice(query) };
+}
+function normalizeBasePath(basePath) {
+  if (!basePath || basePath === "/") return "";
+  return `/${basePath.replace(/^\/+|\/+$/g, "")}`;
+}
+function createFarmDesktopGuard(options) {
+  assertSecret(options.secret, "secret");
+  assertSecret(options.handshakeToken, "handshake token");
+  if (options.secret === options.handshakeToken) {
+    throw new TypeError("[Farm] The desktop secret and handshake token must be different values.");
+  }
+  const { secret, handshakeToken } = options;
+  const handshakeState = _nullishCoalesce(options.handshakeState, () => ( {}));
+  const basePath = normalizeBasePath(options.basePath);
+  const handshakePath = `${basePath}${FARM_DESKTOP_HANDSHAKE_PATH}`;
+  const home = `${basePath}/`;
+  return function farmDesktopGuard(request) {
+    const host = _nullishCoalesce(request.headers.get("host"), () => ( ""));
+    const hostMatch = LOOPBACK_HOST.exec(host);
+    const port = options.port();
+    if (!hostMatch || port === void 0 || Number(hostMatch[1]) !== port) {
+      return forbidden("unexpected host");
+    }
+    const fetchSite = request.headers.get("sec-fetch-site");
+    if (fetchSite && fetchSite !== "same-origin" && fetchSite !== "none") {
+      return forbidden("cross-site request");
+    }
+    const method = request.method.toUpperCase();
+    const origin = request.headers.get("origin");
+    if (origin !== null && !SAFE_METHODS.has(method) && origin !== `http://${host.toLowerCase()}`) {
+      return forbidden("cross-origin request");
+    }
+    const { pathname, search } = splitTarget(request.url);
+    if (pathname === handshakePath) {
+      if (method !== "GET") return forbidden("handshake must be a GET");
+      const token = _nullishCoalesce(new URLSearchParams(search).get(FARM_DESKTOP_HANDSHAKE_PARAM), () => ( ""));
+      if (handshakeState.handshakeUsed || !_chunkSHIWRBFIcjs.farmSecretsMatch.call(void 0, token, handshakeToken)) {
+        return forbidden("invalid or used handshake token");
+      }
+      handshakeState.handshakeUsed = true;
+      return new Response(null, {
+        status: 303,
+        headers: {
+          location: home,
+          "set-cookie": `${FARM_DESKTOP_COOKIE}=${secret}; Path=/; HttpOnly; SameSite=Strict`,
+          "cache-control": "no-store",
+          "referrer-policy": "no-referrer"
+        }
+      });
+    }
+    for (const cookie of _chunkR5U7OIPIcjs.parseRequestCookieHeader.call(void 0, request.headers.get("cookie"))) {
+      if (cookie.name === FARM_DESKTOP_COOKIE && _chunkSHIWRBFIcjs.farmSecretsMatch.call(void 0, cookie.value, secret)) {
+        return void 0;
+      }
+    }
+    return forbidden("this app only answers its own desktop window");
+  };
+}
+
+
+
+
+
+
+
+exports.FARM_DESKTOP_HANDSHAKE_PATH = FARM_DESKTOP_HANDSHAKE_PATH; exports.FARM_DESKTOP_COOKIE = FARM_DESKTOP_COOKIE; exports.FARM_DESKTOP_HANDSHAKE_PARAM = FARM_DESKTOP_HANDSHAKE_PARAM; exports.FARM_DESKTOP_MIN_SECRET_LENGTH = FARM_DESKTOP_MIN_SECRET_LENGTH; exports.createFarmDesktopGuard = createFarmDesktopGuard;

package/dist/chunk-OYZXVBZP.cjs

@@ -0,0 +1,133 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/route-runtime.ts
+function normalizeFarmRouteRuntimeConfig(value, source = "Route configuration") {
+  if (!value) return {};
+  const normalized = {};
+  if (value.runtime !== void 0) {
+    const runtime = value.runtime === "nodejs" ? "node" : value.runtime;
+    if (runtime !== "auto" && runtime !== "node" && runtime !== "edge") {
+      throw new TypeError(`${source} runtime must be "auto", "node", or "edge"`);
+    }
+    normalized.runtime = runtime;
+  }
+  if (value.regions !== void 0) {
+    if (value.regions === "auto") {
+      normalized.regions = "auto";
+    } else {
+      if (!Array.isArray(value.regions) || value.regions.length === 0) {
+        throw new TypeError(`${source} regions must be "auto" or a non-empty string array`);
+      }
+      const regions = Array.from(
+        new Set(
+          value.regions.map((region) => {
+            if (typeof region !== "string" || !region.trim() || /[\u0000-\u001f\u007f]/.test(region)) {
+              throw new TypeError(`${source} regions must contain non-empty region identifiers`);
+            }
+            return region.trim();
+          })
+        )
+      );
+      normalized.regions = regions;
+    }
+  }
+  if (value.maxDuration !== void 0) {
+    if (value.maxDuration === "auto") {
+      normalized.maxDuration = "auto";
+    } else if (typeof value.maxDuration !== "number" || !Number.isInteger(value.maxDuration) || value.maxDuration <= 0) {
+      throw new TypeError(`${source} maxDuration must be "auto" or a positive integer in seconds`);
+    } else {
+      normalized.maxDuration = value.maxDuration;
+    }
+  }
+  return normalized;
+}
+function mergeFarmRouteRuntimeConfigs(...configs) {
+  const merged = {};
+  for (const config of configs) {
+    if (!config) continue;
+    if (config.runtime !== void 0) merged.runtime = config.runtime;
+    if (config.regions !== void 0) merged.regions = config.regions;
+    if (config.maxDuration !== void 0) merged.maxDuration = config.maxDuration;
+  }
+  return merged;
+}
+function resolveFarmRouteRuntimeConfig(config, source) {
+  const normalized = normalizeFarmRouteRuntimeConfig(config, source);
+  return {
+    runtime: _nullishCoalesce(normalized.runtime, () => ( "auto")),
+    ...normalized.regions && normalized.regions !== "auto" ? { regions: [...normalized.regions] } : {},
+    ...typeof normalized.maxDuration === "number" ? { maxDuration: normalized.maxDuration } : {}
+  };
+}
+function hasFarmRouteRuntimeControls(config) {
+  return Boolean(
+    config && (config.runtime !== void 0 || config.regions !== void 0 || config.maxDuration !== void 0)
+  );
+}
+function getFarmRouteRuntimeConfig(value) {
+  if (!value || typeof value !== "object") return {};
+  const route = value;
+  return {
+    ...route.runtime !== void 0 ? { runtime: route.runtime } : {},
+    ...route.regions !== void 0 ? { regions: route.regions } : {},
+    ...route.maxDuration !== void 0 ? { maxDuration: route.maxDuration } : {}
+  };
+}
+function createFarmRouteRuntimeKey(config) {
+  return JSON.stringify({
+    runtime: config.runtime,
+    regions: config.regions || null,
+    maxDuration: config.maxDuration || null
+  });
+}
+function resolveFarmRouteRuleRuntimeConfig(pathname, routeRules) {
+  if (!routeRules) return {};
+  const matches = Object.entries(routeRules).filter(
+    ([pattern, rule]) => hasFarmRouteRuntimeControls(rule) && farmRouteRuleMatches(pattern, pathname)
+  ).sort(([left], [right]) => compareFarmRouteRuleSpecificity(left, right));
+  return mergeFarmRouteRuntimeConfigs(...matches.map(([, rule]) => rule));
+}
+function farmRouteRuleMatches(pattern, pathname) {
+  const normalizedPattern = normalizeRoutePattern(pattern);
+  const normalizedPathname = normalizeRoutePattern(pathname);
+  if (normalizedPattern === normalizedPathname) return true;
+  const expression = normalizedPattern.split("/").filter(Boolean).map((segment) => {
+    if (segment === "**") return ".*";
+    if (segment === "*") return "[^/]+";
+    if (/^\[\[\.\.\..+\]\]$/.test(segment)) return ".*";
+    if (/^\[\.\.\..+\]$/.test(segment)) return ".+";
+    if (/^\[.+\]$/.test(segment) || /^:.+$/.test(segment)) return "[^/]+";
+    return escapeRegExp(segment);
+  }).join("/");
+  return new RegExp(`^/${expression}/?$`).test(normalizedPathname);
+}
+function compareFarmRouteRuleSpecificity(left, right) {
+  const leftScore = getFarmRouteRuleSpecificity(left);
+  const rightScore = getFarmRouteRuleSpecificity(right);
+  return leftScore - rightScore || left.localeCompare(right);
+}
+function getFarmRouteRuleSpecificity(pattern) {
+  return normalizeRoutePattern(pattern).split("/").filter(Boolean).reduce((score, segment) => {
+    if (segment === "**" || segment.startsWith("[[...")) return score + 1;
+    if (segment === "*" || segment.startsWith("[...")) return score + 10;
+    if (/^\[.+\]$/.test(segment) || /^:.+$/.test(segment)) return score + 50;
+    return score + 100;
+  }, 0);
+}
+function normalizeRoutePattern(value) {
+  const withSlash = value.trim().startsWith("/") ? value.trim() : `/${value.trim()}`;
+  return withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+
+
+
+
+
+
+
+
+
+exports.normalizeFarmRouteRuntimeConfig = normalizeFarmRouteRuntimeConfig; exports.mergeFarmRouteRuntimeConfigs = mergeFarmRouteRuntimeConfigs; exports.resolveFarmRouteRuntimeConfig = resolveFarmRouteRuntimeConfig; exports.hasFarmRouteRuntimeControls = hasFarmRouteRuntimeControls; exports.getFarmRouteRuntimeConfig = getFarmRouteRuntimeConfig; exports.createFarmRouteRuntimeKey = createFarmRouteRuntimeKey; exports.resolveFarmRouteRuleRuntimeConfig = resolveFarmRouteRuleRuntimeConfig; exports.farmRouteRuleMatches = farmRouteRuleMatches;

package/dist/chunk-OZC2JPW6.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/config-entry.ts
+function defineConfig(config) {
+  return config;
+}
+var defineFarmConfig = defineConfig;
+
+
+
+
+exports.defineConfig = defineConfig; exports.defineFarmConfig = defineFarmConfig;