@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-G3HRIVEY.cjs

@@ -0,0 +1,395 @@
+"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 _chunkT5CERMEHcjs = require('./chunk-T5CERMEH.cjs');
+
+
+var _chunkH6G5INWMcjs = require('./chunk-H6G5INWM.cjs');
+
+
+var _chunkOX6O6WVAcjs = require('./chunk-OX6O6WVA.cjs');
+
+
+var _chunkU4KT7QP3cjs = require('./chunk-U4KT7QP3.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/server-fn.ts
+var FARM_SERVER_FN_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn");
+var FARM_SERVER_FUNCTION_DESCRIPTOR = /* @__PURE__ */ Symbol.for("farm.server-function.descriptor");
+var _ServerFnInputError = class _ServerFnInputError extends Error {
+  constructor(cause) {
+    super("Server function input is invalid");
+    this.cause = cause;
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _ServerFnInputError, "ServerFnInputError");
+var ServerFnInputError = _ServerFnInputError;
+function createServerFunctionDescriptor(kind, options, run) {
+  return Object.freeze({
+    kind,
+    input: options.input,
+    output: options.output,
+    mcp: options.mcp === void 0 ? void 0 : Object.freeze({ ...options.mcp }),
+    run
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createServerFunctionDescriptor, "createServerFunctionDescriptor");
+function _attachServerFunctionDescriptor(target, descriptor) {
+  Object.defineProperty(target, FARM_SERVER_FUNCTION_DESCRIPTOR, {
+    value: descriptor,
+    enumerable: false
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _attachServerFunctionDescriptor, "_attachServerFunctionDescriptor");
+function getServerFunctionRunner(value) {
+  if (typeof value !== "function") return void 0;
+  return value[FARM_SERVER_FUNCTION_DESCRIPTOR];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getServerFunctionRunner, "getServerFunctionRunner");
+function _runServerFunctionForCaller(value, input) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) throw new TypeError("Expected a function created with createServerFn");
+  return runner.run(input);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runServerFunctionForCaller, "_runServerFunctionForCaller");
+function _describeServerFunction(value) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) return void 0;
+  const { kind, input, output, mcp } = runner;
+  return Object.freeze({ kind, input, output, mcp });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _describeServerFunction, "_describeServerFunction");
+async function _invokeServerFunction(value, input, request) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) {
+    throw new TypeError("Expected a function created with createServerFn or createServerQuery");
+  }
+  try {
+    const data = await _chunkT5CERMEHcjs.runWithServerActionRequest.call(void 0, request, () => runner.run(input));
+    return { ok: true, data };
+  } catch (error) {
+    if (error instanceof ServerFnInputError) {
+      return { ok: false, reason: "input", error: error.cause };
+    }
+    if (_chunkT5CERMEHcjs.isServerFnFailure.call(void 0, error)) return { ok: false, reason: "failure", failure: error };
+    const redirect = _chunkOX6O6WVAcjs.getFarmRedirectError.call(void 0, error);
+    if (redirect) {
+      return { ok: false, reason: "redirect", url: redirect.url, status: redirect.status };
+    }
+    return { ok: false, reason: "error", error };
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _invokeServerFunction, "_invokeServerFunction");
+var UNSAFE_FORM_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function createServerMiddleware(options) {
+  if (!options || typeof options.handler !== "function") {
+    throw new TypeError("createServerMiddleware requires a handler function");
+  }
+  const middleware = Object.freeze([..._nullishCoalesce(options.middleware, () => ( []))]);
+  for (const entry of middleware) {
+    assertServerFnMiddleware(entry);
+  }
+  return Object.freeze({
+    __farmServerFnMiddleware: true,
+    middleware,
+    handler: options.handler
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createServerMiddleware, "createServerMiddleware");
+function createServerFn(options) {
+  if (!options || typeof options.handler !== "function") {
+    throw new TypeError("createServerFn requires a handler function");
+  }
+  const middleware = resolveServerFnMiddleware(options.middleware);
+  const errors = normalizeServerFnErrors(options.errors);
+  const error = createServerFnErrorHandler(errors);
+  const run = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (value, labelInputErrors) => {
+    const formData = isFormData(value) ? value : void 0;
+    const rawInput = formData ? formDataToObject(formData) : value;
+    let input;
+    try {
+      input = await _parseServerFnSchema(options.input, rawInput, "input");
+    } catch (cause) {
+      throw labelInputErrors && isSchemaValidationFailure(cause) ? new ServerFnInputError(cause) : cause;
+    }
+    const executionContext = _chunkT5CERMEHcjs.getServerActionExecutionContext.call(void 0, );
+    const request = _nullishCoalesce(_optionalChain([executionContext, 'optionalAccess', _ => _.request]), () => ( _chunkU4KT7QP3cjs._resolveCurrentRequest.call(void 0, )));
+    const signal = _nullishCoalesce(_nullishCoalesce(_optionalChain([executionContext, 'optionalAccess', _2 => _2.signal]), () => ( _optionalChain([request, 'optionalAccess', _3 => _3.signal]))), () => ( _chunkT5CERMEHcjs.getServerActionSignal.call(void 0, )));
+    const handlerContext = {
+      input,
+      rawInput,
+      formData,
+      request,
+      signal
+    };
+    let resolvedContext = Object.freeze(/* @__PURE__ */ Object.create(null));
+    const result = await runServerFnMiddleware(middleware, handlerContext, async (context) => {
+      resolvedContext = context.context;
+      return options.handler({ ...context, error });
+    });
+    const parsedResult = await _parseServerFnSchema(options.output, result, "output");
+    if (options.invalidates) {
+      const declaration = typeof options.invalidates === "function" ? await options.invalidates({
+        ...handlerContext,
+        context: resolvedContext,
+        result: parsedResult
+      }) : options.invalidates;
+      await _chunkH6G5INWMcjs.applyFarmCacheInvalidationTargets.call(void 0, declaration);
+    }
+    return parsedResult;
+  }, "run");
+  const serverFn = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (value) => run(value, false), "serverFn");
+  Object.defineProperties(serverFn, {
+    [FARM_SERVER_FN_SYMBOL]: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerFn: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerFnInput: {
+      value: options.input,
+      enumerable: false
+    },
+    __farmServerFnOutput: {
+      value: options.output,
+      enumerable: false
+    },
+    __farmServerFnError: {
+      value: void 0,
+      enumerable: false
+    },
+    __farmServerFnMiddleware: {
+      value: middleware,
+      enumerable: false
+    },
+    __farmServerFnInvalidates: {
+      value: options.invalidates,
+      enumerable: false
+    }
+  });
+  _attachServerFunctionDescriptor(
+    serverFn,
+    createServerFunctionDescriptor("action", options, (value) => run(value, true))
+  );
+  return serverFn;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createServerFn, "createServerFn");
+async function runServerFnMiddleware(middleware, handlerContext, handler) {
+  const dispatch = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (index, context) => {
+    const current = middleware[index];
+    if (!current) {
+      return handler({ ...handlerContext, context });
+    }
+    let nextCalled = false;
+    const result = await current.handler({
+      ...handlerContext,
+      context,
+      next: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (nextOptions) => {
+        if (nextCalled) {
+          throw new Error("Server function middleware next() can only be called once");
+        }
+        nextCalled = true;
+        return dispatch(index + 1, mergeServerFnContext(context, _optionalChain([nextOptions, 'optionalAccess', _4 => _4.context])));
+      }, "next")
+    });
+    if (!nextCalled) {
+      throw new Error("Server function middleware must call next()");
+    }
+    return result;
+  }, "dispatch");
+  return dispatch(0, Object.freeze(/* @__PURE__ */ Object.create(null)));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, runServerFnMiddleware, "runServerFnMiddleware");
+function normalizeServerFnErrors(definitions) {
+  if (definitions === void 0) return Object.freeze({});
+  if (!isPlainServerFnObject(definitions)) {
+    throw new TypeError("createServerFn errors must be an object");
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [code, definition] of Object.entries(definitions)) {
+    if (!code.trim()) {
+      throw new TypeError("Server function error codes cannot be empty");
+    }
+    if (!definition || typeof definition !== "object") {
+      throw new TypeError(`Server function error "${code}" must be an object`);
+    }
+    if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
+      throw new TypeError(
+        `Server function error "${code}" status must be an integer between 400 and 599`
+      );
+    }
+    if (!definition.data || typeof definition.data.parse !== "function" && typeof definition.data.safeParse !== "function") {
+      throw new TypeError(
+        `Server function error "${code}" data must provide synchronous parse() or safeParse()`
+      );
+    }
+    if (definition.message !== void 0 && typeof definition.message !== "string") {
+      throw new TypeError(`Server function error "${code}" message must be a string`);
+    }
+    normalized[code] = Object.freeze({ ...definition });
+  }
+  return Object.freeze(normalized);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeServerFnErrors, "normalizeServerFnErrors");
+function createServerFnErrorHandler(definitions) {
+  return ((code, data) => {
+    const definition = definitions[code];
+    if (!definition) {
+      throw new TypeError(`Server function error "${code}" is not declared`);
+    }
+    const parsed = parseServerFnFailureData(code, definition.data, data);
+    throw new (0, _chunkT5CERMEHcjs.ServerFnFailure)(code, parsed, {
+      status: definition.status,
+      message: _nullishCoalesce(definition.message, () => ( "Server function failed"))
+    });
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createServerFnErrorHandler, "createServerFnErrorHandler");
+function parseServerFnFailureData(code, schema, value) {
+  if (typeof schema.safeParse === "function") {
+    const result2 = schema.safeParse(value);
+    if (isPromiseLike(result2)) {
+      throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+    }
+    return unwrapSafeParseResult(result2);
+  }
+  const result = schema.parse(value);
+  if (isPromiseLike(result)) {
+    throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+  }
+  return result;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseServerFnFailureData, "parseServerFnFailureData");
+function isPlainServerFnObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isPlainServerFnObject, "isPlainServerFnObject");
+function isPromiseLike(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function"
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isPromiseLike, "isPromiseLike");
+function resolveServerFnMiddleware(middleware) {
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (entry) => {
+    assertServerFnMiddleware(entry);
+    if (seen.has(entry)) return;
+    if (visiting.has(entry)) {
+      throw new Error("Server function middleware dependencies cannot contain a cycle");
+    }
+    visiting.add(entry);
+    for (const dependency of entry.middleware) {
+      visit(dependency);
+    }
+    visiting.delete(entry);
+    seen.add(entry);
+    resolved.push(entry);
+  }, "visit");
+  for (const entry of _nullishCoalesce(middleware, () => ( []))) {
+    visit(entry);
+  }
+  return Object.freeze(resolved);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveServerFnMiddleware, "resolveServerFnMiddleware");
+function assertServerFnMiddleware(value) {
+  if (!value || typeof value !== "object" || value.__farmServerFnMiddleware !== true || typeof value.handler !== "function" || !Array.isArray(value.middleware)) {
+    throw new TypeError("createServerFn middleware must be created with createServerMiddleware");
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertServerFnMiddleware, "assertServerFnMiddleware");
+function mergeServerFnContext(current, added) {
+  if (added !== void 0 && (added === null || typeof added !== "object" || Array.isArray(added))) {
+    throw new TypeError("Server function middleware context must be an object");
+  }
+  return Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), current, added));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergeServerFnContext, "mergeServerFnContext");
+async function _parseServerFnSchema(schema, value, contract, owner = "createServerFn") {
+  if (!schema) return value;
+  if (typeof schema.safeParseAsync === "function") {
+    const result = await schema.safeParseAsync(value);
+    return unwrapSafeParseResult(result);
+  }
+  if (typeof schema.safeParse === "function") {
+    const result = schema.safeParse(value);
+    return unwrapSafeParseResult(await result);
+  }
+  if (typeof schema.parseAsync === "function") {
+    return schema.parseAsync(value);
+  }
+  if (typeof schema.parse === "function") {
+    return schema.parse(value);
+  }
+  throw new TypeError(`${owner} ${contract} must provide parse, parseAsync, or safeParse`);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _parseServerFnSchema, "_parseServerFnSchema");
+var schemaValidationFailures = /* @__PURE__ */ new WeakSet();
+function isSchemaValidationFailure(error) {
+  if (!error || typeof error !== "object") return false;
+  return schemaValidationFailures.has(error) || Array.isArray(error.issues);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isSchemaValidationFailure, "isSchemaValidationFailure");
+function unwrapSafeParseResult(result) {
+  if (result && typeof result === "object" && "success" in result && result.success === false) {
+    const error = result.error;
+    if (error && typeof error === "object") schemaValidationFailures.add(error);
+    throw error;
+  }
+  if (result && typeof result === "object" && "success" in result && result.success === true) {
+    return result.data;
+  }
+  return result;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, unwrapSafeParseResult, "unwrapSafeParseResult");
+function formDataToObject(formData) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of formData.entries()) {
+    if (!isSafeFormKey(key)) continue;
+    const existing = output[key];
+    if (existing === void 0) {
+      output[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      output[key] = [existing, value];
+    }
+  }
+  return output;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, formDataToObject, "formDataToObject");
+function isSafeFormKey(key) {
+  return !key.startsWith("$ACTION_") && !UNSAFE_FORM_KEYS.has(key);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isSafeFormKey, "isSafeFormKey");
+function isFormData(value) {
+  if (!value || typeof value !== "object") return false;
+  if (typeof FormData !== "undefined" && value instanceof FormData) {
+    return true;
+  }
+  return Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFormData, "isFormData");
+
+
+
+
+
+
+
+
+
+
+
+exports.FARM_SERVER_FN_SYMBOL = FARM_SERVER_FN_SYMBOL; exports.createServerFunctionDescriptor = createServerFunctionDescriptor; exports._attachServerFunctionDescriptor = _attachServerFunctionDescriptor; exports._runServerFunctionForCaller = _runServerFunctionForCaller; exports._describeServerFunction = _describeServerFunction; exports._invokeServerFunction = _invokeServerFunction; exports.createServerMiddleware = createServerMiddleware; exports.createServerFn = createServerFn; exports._parseServerFnSchema = _parseServerFnSchema;

package/dist/chunk-G643DQCH.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/schema.ts
+function defineSchema(schema) {
+  return schema;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defineSchema, "defineSchema");
+
+
+
+exports.defineSchema = defineSchema;

package/dist/chunk-G7HXGLEC.cjs

@@ -0,0 +1,175 @@
+"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 _chunkNO3WWW3Ncjs = require('./chunk-NO3WWW3N.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/api/route-pattern.ts
+var compiledEntries = /* @__PURE__ */ new WeakMap();
+function createStaticAPIRouteMatcher(routes) {
+  const table = new Map(routes.map((route) => [route.path, Object.freeze({ ...route })]));
+  const root = { children: /* @__PURE__ */ new Map(), candidates: [] };
+  let order = 0;
+  for (const route of table.values()) {
+    const compiled = compileRouteEntry(route.path);
+    let node = root;
+    for (const segment of compiled.segments) {
+      if (segment.dynamic) break;
+      let child = node.children.get(segment.value);
+      if (!child) {
+        child = { children: /* @__PURE__ */ new Map(), candidates: [] };
+        node.children.set(segment.value, child);
+      }
+      node = child;
+    }
+    node.candidates.push({ route, compiled, order: order++ });
+  }
+  return (pathname) => {
+    const exactRoute = table.get(pathname);
+    if (exactRoute) return { route: exactRoute, params: {} };
+    const normalizedPathname = normalizePathname(pathname);
+    if (normalizedPathname !== pathname) {
+      const normalizedRoute = table.get(normalizedPathname);
+      if (normalizedRoute) return { route: normalizedRoute, params: {} };
+    }
+    const segments = getPathSegments(normalizedPathname).map(decodePathSegment);
+    let best;
+    let bestMatch = null;
+    let node = root;
+    let depth = 0;
+    while (node) {
+      for (const candidate of node.candidates) {
+        const params = matchRouteEntry(candidate.compiled, segments);
+        if (!params) continue;
+        const comparison = best ? _chunkNO3WWW3Ncjs.compareRouteSpecificity.call(void 0, candidate.compiled.specificity, best.compiled.specificity) : -1;
+        if (comparison < 0 || comparison === 0 && candidate.order < best.order) {
+          best = candidate;
+          bestMatch = { route: candidate.route, params };
+        }
+      }
+      node = depth < segments.length ? node.children.get(segments[depth++]) : void 0;
+    }
+    return bestMatch;
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createStaticAPIRouteMatcher, "createStaticAPIRouteMatcher");
+function matchAPIRoute(routes, pathname) {
+  const exactRoute = routes.get(pathname);
+  if (exactRoute) return { route: exactRoute, params: {} };
+  const normalizedPathname = normalizePathname(pathname);
+  if (normalizedPathname !== pathname) {
+    const normalizedRoute = routes.get(normalizedPathname);
+    if (normalizedRoute) return { route: normalizedRoute, params: {} };
+  }
+  const pathnameSegments = getPathSegments(normalizedPathname).map(decodePathSegment);
+  let bestMatch = null;
+  let bestSpecificity = null;
+  for (const route of routes.values()) {
+    const routePath = route.path;
+    let entry = compiledEntries.get(route);
+    if (!entry || entry.path !== routePath) {
+      entry = compileRouteEntry(routePath);
+      compiledEntries.set(route, entry);
+    }
+    const params = matchRouteEntry(entry, pathnameSegments);
+    if (!params) continue;
+    if (bestSpecificity === null || _chunkNO3WWW3Ncjs.compareRouteSpecificity.call(void 0, entry.specificity, bestSpecificity) < 0) {
+      bestMatch = { route, params };
+      bestSpecificity = entry.specificity;
+    }
+  }
+  return bestMatch;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchAPIRoute, "matchAPIRoute");
+function compileRouteEntry(path) {
+  const segments = getPathSegments(path).map((segment) => {
+    const dynamic = parseDynamicSegment(segment);
+    return dynamic ? { dynamic } : { value: decodePathSegment(segment) };
+  });
+  return {
+    path,
+    segments,
+    specificity: segments.map((segment) => {
+      const dynamic = segment.dynamic;
+      if (!dynamic) return "static";
+      if (!dynamic.catchAll) return "dynamic";
+      return dynamic.optional ? "optional-catch-all" : "catch-all";
+    })
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compileRouteEntry, "compileRouteEntry");
+function matchRouteEntry(entry, pathnameSegments) {
+  const params = {};
+  let pathIndex = 0;
+  for (const routeSegment of entry.segments) {
+    const dynamicSegment = routeSegment.dynamic;
+    if (_optionalChain([dynamicSegment, 'optionalAccess', _ => _.catchAll])) {
+      const remainingSegments = pathnameSegments.slice(pathIndex);
+      if (remainingSegments.length === 0 && !dynamicSegment.optional) {
+        return null;
+      }
+      if (remainingSegments.length > 0) {
+        params[dynamicSegment.name] = remainingSegments;
+      }
+      pathIndex = pathnameSegments.length;
+      continue;
+    }
+    const pathnameSegment = pathnameSegments[pathIndex];
+    if (pathnameSegment === void 0) {
+      return null;
+    }
+    if (dynamicSegment) {
+      params[dynamicSegment.name] = pathnameSegment;
+      pathIndex++;
+      continue;
+    }
+    if (routeSegment.value !== pathnameSegment) {
+      return null;
+    }
+    pathIndex++;
+  }
+  return pathIndex === pathnameSegments.length ? params : null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchRouteEntry, "matchRouteEntry");
+function getPathSegments(pathname) {
+  return normalizePathname(pathname).split("/").filter((segment) => segment.length > 0);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getPathSegments, "getPathSegments");
+function normalizePathname(pathname) {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.replace(/\/+$/, "");
+  }
+  return pathname;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizePathname, "normalizePathname");
+function parseDynamicSegment(segment) {
+  const optionalCatchAll = segment.match(/^\[\[\.\.\.(.+)\]\]$/);
+  if (_optionalChain([optionalCatchAll, 'optionalAccess', _2 => _2[1]])) {
+    return { name: optionalCatchAll[1], catchAll: true, optional: true };
+  }
+  const catchAll = segment.match(/^\[\.\.\.(.+)\]$/);
+  if (_optionalChain([catchAll, 'optionalAccess', _3 => _3[1]])) {
+    return { name: catchAll[1], catchAll: true, optional: false };
+  }
+  const dynamic = segment.match(/^\[(.+)\]$/);
+  if (_optionalChain([dynamic, 'optionalAccess', _4 => _4[1]])) {
+    return { name: dynamic[1], catchAll: false, optional: false };
+  }
+  return null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseDynamicSegment, "parseDynamicSegment");
+function decodePathSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch (e) {
+    return segment;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, decodePathSegment, "decodePathSegment");
+
+
+
+
+
+exports.createStaticAPIRouteMatcher = createStaticAPIRouteMatcher; exports.matchAPIRoute = matchAPIRoute; exports.parseDynamicSegment = parseDynamicSegment;