@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-S3A45T7F.cjs

@@ -0,0 +1,166 @@
+"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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/api/config.ts
+var DEFAULT_FARM_API_BASE_PATH = "/api";
+async function resolveFarmAPIConfig(config, context) {
+  const configuredBasePath = await resolveConfigValue(_optionalChain([config, 'optionalAccess', _ => _.basePath]), context, "api.basePath");
+  const basePath = normalizeFarmAPIBasePath(_nullishCoalesce(configuredBasePath, () => ( DEFAULT_FARM_API_BASE_PATH)));
+  const configuredBaseURL = await resolveConfigValue(_optionalChain([config, 'optionalAccess', _2 => _2.baseURL]), context, "api.baseURL");
+  return normalizeFarmAPIConfig({ baseURL: configuredBaseURL, basePath });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmAPIConfig, "resolveFarmAPIConfig");
+function normalizeFarmAPIConfig(config) {
+  const basePath = normalizeFarmAPIBasePath(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _3 => _3.basePath]), () => ( DEFAULT_FARM_API_BASE_PATH)));
+  const baseURL = _optionalChain([config, 'optionalAccess', _4 => _4.baseURL, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]);
+  if (!baseURL) {
+    return { baseURL: basePath, basePath };
+  }
+  if (baseURL.startsWith("//")) {
+    throw new Error(
+      'Farm api.baseURL must be an absolute URL or a root-relative path such as "/api", not a network-path reference.'
+    );
+  }
+  if (baseURL.startsWith("/")) {
+    const url2 = parseRootRelativeBaseURL(baseURL);
+    if (url2.pathname !== "/") {
+      const effectivePath = normalizeFarmAPIBasePath(url2.pathname);
+      return { baseURL: effectivePath, basePath: effectivePath };
+    }
+    return { baseURL: basePath, basePath };
+  }
+  let url;
+  try {
+    url = new URL(baseURL);
+  } catch (e) {
+    throw new Error(
+      'Farm api.baseURL must be an absolute URL or a root-relative path such as "/api".'
+    );
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Farm api.baseURL must use http or https.");
+  }
+  if (url.search || url.hash) {
+    throw new Error("Farm api.baseURL cannot contain a query string or hash.");
+  }
+  if (url.pathname !== "/") {
+    const effectivePath = normalizeFarmAPIBasePath(url.pathname);
+    return {
+      baseURL: `${url.origin}${effectivePath}`,
+      basePath: effectivePath
+    };
+  }
+  return {
+    baseURL: basePath === "/" ? url.origin : `${url.origin}${basePath}`,
+    basePath
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmAPIConfig, "normalizeFarmAPIConfig");
+function normalizeFarmAPIBasePath(value) {
+  const hasUnstableCharacters = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  }), "hasUnstableCharacters");
+  if (hasUnstableCharacters(value)) {
+    throw new Error("Farm api.basePath cannot contain backslashes or control characters.");
+  }
+  const path = value.trim();
+  if (!path) {
+    throw new Error("Farm api.basePath cannot be empty.");
+  }
+  if (path.includes("?") || path.includes("#")) {
+    throw new Error("Farm api.basePath cannot contain a query string or hash.");
+  }
+  if (path.startsWith("//")) {
+    throw new Error('Farm api.basePath must be a pathname such as "/api", not a URL.');
+  }
+  for (const segment of path.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch (e2) {
+    }
+    if (hasUnstableCharacters(decoded)) {
+      throw new Error("Farm api.basePath cannot contain backslashes or control characters.");
+    }
+    if (decoded.includes("/")) {
+      throw new Error("Farm api.basePath cannot contain percent-encoded path separators.");
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new Error('Farm api.basePath cannot contain "." or ".." path segments.');
+    }
+  }
+  const normalized = `/${path.replace(/^\/+|\/+$/g, "")}`;
+  return normalized === "/" ? "/" : normalized;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmAPIBasePath, "normalizeFarmAPIBasePath");
+function getFarmAPIBaseURL() {
+  if (typeof __FARM_API_BASE_URL__ !== "undefined" && __FARM_API_BASE_URL__) {
+    return __FARM_API_BASE_URL__;
+  }
+  return DEFAULT_FARM_API_BASE_PATH;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmAPIBaseURL, "getFarmAPIBaseURL");
+function resolveFarmAPIRequestURL(routePath, baseURL = getFarmAPIBaseURL(), fallbackOrigin = getDefaultOrigin()) {
+  const base = new URL(baseURL, fallbackOrigin);
+  if (base.pathname === "/") {
+    return new URL(routePath, base);
+  }
+  const route = new URL(routePath, fallbackOrigin);
+  const suffix = stripCanonicalAPIBasePath(route.pathname);
+  const joinedPath = joinURLPath(base.pathname, suffix);
+  base.pathname = joinedPath;
+  base.search = route.search;
+  base.hash = route.hash;
+  return base;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmAPIRequestURL, "resolveFarmAPIRequestURL");
+async function resolveConfigValue(value, context, name) {
+  const resolved = typeof value === "function" ? await value(context) : value;
+  if (resolved === void 0) return void 0;
+  if (typeof resolved !== "string") {
+    throw new Error(`Farm ${name} must resolve to a string or undefined.`);
+  }
+  if (!resolved.trim()) {
+    throw new Error(`Farm ${name} cannot be empty.`);
+  }
+  return resolved;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveConfigValue, "resolveConfigValue");
+function parseRootRelativeBaseURL(value) {
+  const url = new URL(value, "http://farm.local");
+  if (url.search || url.hash) {
+    throw new Error("Farm api.baseURL cannot contain a query string or hash.");
+  }
+  return url;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseRootRelativeBaseURL, "parseRootRelativeBaseURL");
+function stripCanonicalAPIBasePath(pathname) {
+  if (pathname === DEFAULT_FARM_API_BASE_PATH) return "";
+  if (pathname.startsWith(`${DEFAULT_FARM_API_BASE_PATH}/`)) {
+    return pathname.slice(DEFAULT_FARM_API_BASE_PATH.length + 1);
+  }
+  return pathname.replace(/^\/+/, "");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, stripCanonicalAPIBasePath, "stripCanonicalAPIBasePath");
+function joinURLPath(basePath, suffix) {
+  const normalizedBase = basePath === "/" ? "" : basePath.replace(/\/+$/, "");
+  const normalizedSuffix = suffix.replace(/^\/+/, "");
+  if (!normalizedSuffix) return normalizedBase || "/";
+  return `${normalizedBase}/${normalizedSuffix}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, joinURLPath, "joinURLPath");
+function getDefaultOrigin() {
+  return typeof window !== "undefined" ? window.location.origin : "http://localhost:3000";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getDefaultOrigin, "getDefaultOrigin");
+
+
+
+
+
+
+
+
+exports.DEFAULT_FARM_API_BASE_PATH = DEFAULT_FARM_API_BASE_PATH; exports.resolveFarmAPIConfig = resolveFarmAPIConfig; exports.normalizeFarmAPIConfig = normalizeFarmAPIConfig; exports.normalizeFarmAPIBasePath = normalizeFarmAPIBasePath; exports.getFarmAPIBaseURL = getFarmAPIBaseURL; exports.resolveFarmAPIRequestURL = resolveFarmAPIRequestURL;

package/dist/chunk-S3JO3N4H.cjs

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// <define:import.meta>
+var define_import_meta_default = {};
+
+
+
+
+
+exports.__name = __name; exports.__require = __require; exports.define_import_meta_default = define_import_meta_default;

package/dist/chunk-SK35NQKK.cjs

@@ -0,0 +1,27 @@
+"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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/server-query-protocol.ts
+var FARM_SERVER_QUERY_RESULT_VERSION = 1;
+function createFarmServerQueryResult(data, metadata) {
+  return {
+    __farmServerQuery: {
+      version: FARM_SERVER_QUERY_RESULT_VERSION,
+      ...metadata
+    },
+    data
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmServerQueryResult, "createFarmServerQueryResult");
+function isFarmServerQueryResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const metadata = value.__farmServerQuery;
+  return _optionalChain([metadata, 'optionalAccess', _ => _.version]) === FARM_SERVER_QUERY_RESULT_VERSION && typeof metadata.key === "string" && (metadata.staleTime === false || typeof metadata.staleTime === "number") && typeof metadata.updatedAt === "number" && "data" in value;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmServerQueryResult, "isFarmServerQueryResult");
+
+
+
+
+exports.createFarmServerQueryResult = createFarmServerQueryResult; exports.isFarmServerQueryResult = isFarmServerQueryResult;

package/dist/chunk-SU7MH53P.cjs

@@ -0,0 +1,180 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+var _chunkPCOTGFSMcjs = require('./chunk-PCOTGFSM.cjs');
+
+
+
+
+var _chunkNO3WWW3Ncjs = require('./chunk-NO3WWW3N.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/router.ts
+function createFarmRouter(routes) {
+  const normalizedRoutes = routes.map(normalizeRouteInput);
+  const patternsByShape = /* @__PURE__ */ new Map();
+  for (const entry of normalizedRoutes) {
+    const shape = _chunkNO3WWW3Ncjs.getRoutePatternShape.call(void 0, entry.route.path, "router");
+    const existingPattern = patternsByShape.get(shape);
+    if (existingPattern) {
+      throw new (0, _chunkNO3WWW3Ncjs.AmbiguousRouteError)(
+        `Ambiguous route patterns "${existingPattern}" and "${entry.route.path}" match the same URLs. Keep only one route for this URL shape.`
+      );
+    }
+    patternsByShape.set(shape, entry.route.path);
+  }
+  normalizedRoutes.sort(compareRoutes);
+  const exactRoutes = /* @__PURE__ */ new Map();
+  for (const entry of normalizedRoutes) {
+    if (entry.segments.every((segment) => segment.type === "static")) {
+      const pathname = entry.segments.length ? `/${entry.segments.map((segment) => encodePathSegment(segment.value)).join("/")}` : "/";
+      exactRoutes.set(pathname, entry);
+    }
+  }
+  return {
+    routes: normalizedRoutes.map((entry) => entry.route),
+    match(pathname) {
+      const normalizedPathname = _chunkPCOTGFSMcjs.normalizePathname.call(void 0, pathname);
+      const exactRoute = exactRoutes.get(normalizedPathname);
+      if (exactRoute) {
+        return {
+          route: exactRoute.route,
+          pathname: normalizedPathname,
+          params: {}
+        };
+      }
+      const parts = _chunkPCOTGFSMcjs.splitNormalizedPathname.call(void 0, normalizedPathname);
+      for (const entry of normalizedRoutes) {
+        const params = _chunkPCOTGFSMcjs.matchSegmentParts.call(void 0, entry.segments, parts);
+        if (params) {
+          return {
+            route: entry.route,
+            pathname: normalizedPathname,
+            params
+          };
+        }
+      }
+      return null;
+    },
+    build: buildFarmRoutePath,
+    isActive: isFarmRouteActive
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmRouter, "createFarmRouter");
+function matchFarmRoute(pattern, pathname) {
+  return matchSegments(_chunkPCOTGFSMcjs.parseRoutePattern.call(void 0, pattern), _chunkPCOTGFSMcjs.normalizePathname.call(void 0, pathname));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchFarmRoute, "matchFarmRoute");
+function buildFarmRoutePath(pattern, params = {}, options = {}) {
+  const parts = [];
+  for (const segment of _chunkPCOTGFSMcjs.parseRoutePattern.call(void 0, pattern)) {
+    if (segment.type === "static") {
+      parts.push(encodePathSegment(segment.value));
+      continue;
+    }
+    const value = params[segment.name];
+    const values = Array.isArray(value) ? value : value == null ? [] : [value];
+    if (values.length === 0) {
+      if (segment.optional) continue;
+      throw new Error(`Missing route param "${segment.name}" for ${pattern}.`);
+    }
+    if (!segment.catchAll && values.length > 1) {
+      throw new Error(`Route param "${segment.name}" for ${pattern} expects a single value.`);
+    }
+    const encodedValues = values.map((item) => {
+      const value2 = String(item);
+      if (!value2) {
+        throw new Error(
+          `Route param "${segment.name}" for ${pattern} cannot contain an empty path segment.`
+        );
+      }
+      return encodePathSegment(value2);
+    });
+    parts.push(...encodedValues);
+  }
+  let pathname = parts.length ? `/${parts.join("/")}` : "/";
+  if (options.trailingSlash && pathname !== "/") {
+    pathname = `${pathname}/`;
+  }
+  return appendQueryAndHash(pathname, options);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, buildFarmRoutePath, "buildFarmRoutePath");
+function isFarmRouteActive(pattern, pathname, options = {}) {
+  const normalizedPathname = _chunkPCOTGFSMcjs.normalizePathname.call(void 0, pathname);
+  const segments = _chunkPCOTGFSMcjs.parseRoutePattern.call(void 0, pattern);
+  const parts = _chunkPCOTGFSMcjs.splitNormalizedPathname.call(void 0, normalizedPathname);
+  if (_chunkPCOTGFSMcjs.matchSegmentParts.call(void 0, segments, parts)) return true;
+  if (options.exact !== false) return false;
+  if (segments.length === 0) return normalizedPathname === "/";
+  return _chunkPCOTGFSMcjs.matchSegmentParts.call(void 0, segments, parts, true) !== null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmRouteActive, "isFarmRouteActive");
+function normalizeRouteInput(input, index) {
+  const route = typeof input === "string" ? { path: input } : input;
+  const segments = _chunkPCOTGFSMcjs.parseRoutePattern.call(void 0, route.path);
+  const path = _chunkPCOTGFSMcjs.normalizeRoutePattern.call(void 0, route.path);
+  return {
+    route: {
+      ...route,
+      path
+    },
+    segments,
+    specificity: segments.map(getRouterSegmentSpecificity),
+    index
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRouteInput, "normalizeRouteInput");
+function matchSegments(segments, pathname, allowTrailingSegments = false) {
+  return _chunkPCOTGFSMcjs.matchSegmentParts.call(void 0, segments, _chunkPCOTGFSMcjs.splitPathname.call(void 0, pathname), allowTrailingSegments);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchSegments, "matchSegments");
+function compareRoutes(left, right) {
+  const specificity = _chunkNO3WWW3Ncjs.compareRouteSpecificity.call(void 0, left.specificity, right.specificity);
+  if (specificity !== 0) return specificity;
+  return left.index - right.index;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compareRoutes, "compareRoutes");
+function getRouterSegmentSpecificity(segment) {
+  if (segment.type === "static") return "static";
+  if (!segment.catchAll) return "dynamic";
+  return segment.optional ? "optional-catch-all" : "catch-all";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRouterSegmentSpecificity, "getRouterSegmentSpecificity");
+function encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, encodePathSegment, "encodePathSegment");
+function appendQueryAndHash(pathname, options) {
+  const search = createSearchParams(options.query);
+  const hash = options.hash ? `#${options.hash.replace(/^#/, "")}` : "";
+  const query = search.toString();
+  return `${pathname}${query ? `?${query}` : ""}${hash}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendQueryAndHash, "appendQueryAndHash");
+function createSearchParams(query) {
+  if (query instanceof URLSearchParams) return query;
+  const search = new URLSearchParams();
+  if (!query) return search;
+  for (const [key, value] of Object.entries(query)) {
+    const values = Array.isArray(value) ? value : [value];
+    for (const item of values) {
+      if (item == null) continue;
+      search.append(key, String(item));
+    }
+  }
+  return search;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createSearchParams, "createSearchParams");
+
+
+
+
+
+
+exports.createFarmRouter = createFarmRouter; exports.matchFarmRoute = matchFarmRoute; exports.buildFarmRoutePath = buildFarmRoutePath; exports.isFarmRouteActive = isFarmRouteActive;

package/dist/chunk-SVRTJOUF.cjs

@@ -0,0 +1,113 @@
+"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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/request-origin.ts
+function getRequestSourceOrigin(request) {
+  const origin = _optionalChain([request, 'access', _ => _.headers, 'access', _2 => _2.get, 'call', _3 => _3("origin"), 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]);
+  if (origin) {
+    return parseSourceOrigin(origin);
+  }
+  const referer = _optionalChain([request, 'access', _6 => _6.headers, 'access', _7 => _7.get, 'call', _8 => _8("referer"), 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]);
+  if (referer) {
+    return parseSourceOrigin(referer);
+  }
+  return { ok: true, origin: null };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRequestSourceOrigin, "getRequestSourceOrigin");
+function parseSourceOrigin(value) {
+  if (value === "null") {
+    return { ok: false, reason: "opaque-origin" };
+  }
+  try {
+    const parsed = new URL(value);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return { ok: false, reason: "invalid-origin" };
+    }
+    return { ok: true, origin: parsed.origin };
+  } catch (e) {
+    return { ok: false, reason: "invalid-origin" };
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseSourceOrigin, "parseSourceOrigin");
+function matchesHostHeader(sourceOrigin, request) {
+  const host = _optionalChain([request, 'access', _11 => _11.headers, 'access', _12 => _12.get, 'call', _13 => _13("host"), 'optionalAccess', _14 => _14.trim, 'call', _15 => _15(), 'access', _16 => _16.toLowerCase, 'call', _17 => _17()]);
+  if (!host) return false;
+  try {
+    const source = new URL(sourceOrigin);
+    const target = new URL(request.url);
+    return source.protocol === target.protocol && source.host.toLowerCase() === host;
+  } catch (e2) {
+    return false;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchesHostHeader, "matchesHostHeader");
+function matchesAllowedOrigin(sourceOrigin, pattern) {
+  const source = new URL(sourceOrigin);
+  if (!pattern.includes("*")) {
+    return pattern.includes("://") ? source.origin === pattern : source.host === pattern;
+  }
+  const schemeEnd = pattern.indexOf("://");
+  const scheme = schemeEnd === -1 ? null : pattern.slice(0, schemeEnd + 1);
+  const hostPattern = pattern.slice(schemeEnd === -1 ? 0 : schemeEnd + 3);
+  const [wildcardHost, port] = splitHostAndPort(hostPattern);
+  const baseHost = wildcardHost.slice(2);
+  if (scheme && source.protocol !== scheme) return false;
+  if (port && getEffectivePort(source) !== port) return false;
+  if (!port && source.port) return false;
+  return source.hostname.endsWith(`.${baseHost}`) && source.hostname !== baseHost;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchesAllowedOrigin, "matchesAllowedOrigin");
+function normalizeAllowedOriginPattern(value, label) {
+  const pattern = value.trim().toLowerCase();
+  if (!pattern) {
+    throw new TypeError(`${label} cannot contain empty values`);
+  }
+  if (pattern.includes("*")) {
+    if (!/^(?:https?:\/\/)?\*\.[a-z0-9.-]+(?::\d+)?$/.test(pattern)) {
+      throw new TypeError(`Invalid ${label} pattern: ${JSON.stringify(value)}`);
+    }
+    return pattern;
+  }
+  if (pattern.includes("://")) {
+    let parsed;
+    try {
+      parsed = new URL(pattern);
+    } catch (e3) {
+      throw new TypeError(`Invalid ${label} value: ${JSON.stringify(value)}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+      throw new TypeError(`${label} must contain origins without paths: ${JSON.stringify(value)}`);
+    }
+    return parsed.origin;
+  }
+  if (/[/@?#]/.test(pattern)) {
+    throw new TypeError(`${label} must contain origins or hosts: ${JSON.stringify(value)}`);
+  }
+  try {
+    return new URL(`http://${pattern}`).host;
+  } catch (e4) {
+    throw new TypeError(`Invalid ${label} value: ${JSON.stringify(value)}`);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeAllowedOriginPattern, "normalizeAllowedOriginPattern");
+function splitHostAndPort(value) {
+  const separator = value.lastIndexOf(":");
+  if (separator === -1) return [value, null];
+  return [value.slice(0, separator), value.slice(separator + 1)];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, splitHostAndPort, "splitHostAndPort");
+function getEffectivePort(url) {
+  if (url.port) return url.port;
+  if (url.protocol === "https:") return "443";
+  if (url.protocol === "http:") return "80";
+  return "";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getEffectivePort, "getEffectivePort");
+
+
+
+
+
+
+exports.getRequestSourceOrigin = getRequestSourceOrigin; exports.matchesHostHeader = matchesHostHeader; exports.matchesAllowedOrigin = matchesAllowedOrigin; exports.normalizeAllowedOriginPattern = normalizeAllowedOriginPattern;

package/dist/chunk-SWN467MP.cjs

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client/navigation-url.ts
+function isFarmExternalNavigationURL(url, currentOrigin) {
+  return url.protocol !== "http:" && url.protocol !== "https:" || url.origin !== currentOrigin;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmExternalNavigationURL, "isFarmExternalNavigationURL");
+function resolveFarmNavigationURL(href, documentUrl) {
+  return new URL(href, documentUrl);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmNavigationURL, "resolveFarmNavigationURL");
+
+
+
+
+exports.isFarmExternalNavigationURL = isFarmExternalNavigationURL; exports.resolveFarmNavigationURL = resolveFarmNavigationURL;

package/dist/chunk-SYQ3MOWW.cjs

@@ -0,0 +1,73 @@
+"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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/route-rendering.ts
+function normalizeDynamicMode(value) {
+  switch (value) {
+    case "auto":
+    case "force-static":
+    case "force-dynamic":
+    case "error":
+      return value;
+    default:
+      return void 0;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeDynamicMode, "normalizeDynamicMode");
+function mergeRouteRenderingDirectiveConfig(directiveConfig, mod, options) {
+  const pprEnabled = _optionalChain([options, 'optionalAccess', _ => _.experimentalPPR]) === true;
+  let ssg = _nullishCoalesce(_optionalChain([directiveConfig, 'optionalAccess', _2 => _2.ssg]), () => ( false));
+  let requestedPPR = _nullishCoalesce(_optionalChain([directiveConfig, 'optionalAccess', _3 => _3.ppr]), () => ( false));
+  let revalidate = _optionalChain([directiveConfig, 'optionalAccess', _4 => _4.revalidate]);
+  const moduleDynamic = normalizeDynamicMode(_optionalChain([mod, 'optionalAccess', _5 => _5.dynamic]));
+  const dynamic = _nullishCoalesce(moduleDynamic, () => ( _optionalChain([directiveConfig, 'optionalAccess', _6 => _6.dynamic])));
+  const hasExplicitSsg = typeof _optionalChain([mod, 'optionalAccess', _7 => _7.ssg]) === "boolean";
+  const hasExplicitPPR = typeof _optionalChain([mod, 'optionalAccess', _8 => _8.ppr]) === "boolean" || typeof _optionalChain([mod, 'optionalAccess', _9 => _9.experimental_ppr]) === "boolean";
+  if (hasExplicitSsg) {
+    ssg = mod.ssg === true;
+  }
+  if (hasExplicitPPR) {
+    requestedPPR = _optionalChain([mod, 'optionalAccess', _10 => _10.ppr]) === true || _optionalChain([mod, 'optionalAccess', _11 => _11.experimental_ppr]) === true;
+  }
+  if (typeof _optionalChain([mod, 'optionalAccess', _12 => _12.revalidate]) === "number") {
+    if (mod.revalidate > 0) {
+      revalidate = mod.revalidate;
+      if (!hasExplicitSsg && !requestedPPR) {
+        ssg = true;
+      }
+    } else {
+      revalidate = void 0;
+      if (!hasExplicitSsg) {
+        ssg = false;
+      }
+    }
+  } else if (_optionalChain([mod, 'optionalAccess', _13 => _13.revalidate]) === false) {
+    revalidate = void 0;
+  }
+  if (moduleDynamic === "force-static" || moduleDynamic === "error") {
+    ssg = true;
+    requestedPPR = false;
+  } else if (moduleDynamic === "force-dynamic") {
+    ssg = false;
+    requestedPPR = false;
+    revalidate = void 0;
+  }
+  if (_optionalChain([directiveConfig, 'optionalAccess', _14 => _14.requestBound]) && ssg) {
+    ssg = false;
+    revalidate = void 0;
+  }
+  const ppr = pprEnabled && !ssg && requestedPPR;
+  return {
+    ssg,
+    ppr,
+    revalidate: ssg || ppr ? revalidate : void 0,
+    dynamic,
+    directive: _optionalChain([directiveConfig, 'optionalAccess', _15 => _15.directive])
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergeRouteRenderingDirectiveConfig, "mergeRouteRenderingDirectiveConfig");
+
+
+
+exports.mergeRouteRenderingDirectiveConfig = mergeRouteRenderingDirectiveConfig;