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

package/dist/chunk-5C7XMKQ4.cjs

@@ -1,410 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
-
-var _chunkDMAP4RNDcjs = require('./chunk-DMAP4RND.cjs');
-
-
-var _chunkHLYRXN2Icjs = require('./chunk-HLYRXN2I.cjs');
-
-
-
-
-var _chunkYTVSWXEZcjs = require('./chunk-YTVSWXEZ.cjs');
-
-// src/api/endpoint.ts
-var _bettercall = require('better-call');
-var EndpointFailure = class extends Error {
-  constructor(code, data, options) {
-    super(options.message);
-    this.name = "EndpointFailure";
-    this.code = code;
-    this.data = data;
-    this.status = options.status;
-  }
-};
-function isEndpointFailure(value) {
-  return value instanceof EndpointFailure;
-}
-function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
-  let path;
-  let options;
-  let handler;
-  if (typeof pathOrOptions === "function") {
-    path = "";
-    options = {};
-    handler = pathOrOptions;
-  } else if (typeof pathOrOptions === "string") {
-    path = pathOrOptions;
-    options = optionsOrHandler;
-    handler = maybeHandler;
-  } else {
-    path = "";
-    options = pathOrOptions;
-    handler = optionsOrHandler;
-  }
-  if (typeof handler !== "function") {
-    throw new TypeError("createEndpoint requires a handler function");
-  }
-  if (options.use !== void 0) {
-    throw new TypeError(
-      "createEndpoint does not support the `use` option. Move these functions to `middleware`: each receives the endpoint context and returns an object, true, false, or a Response."
-    );
-  }
-  const middleware = normalizeEndpointMiddleware(options.middleware);
-  const errors = normalizeEndpointErrors(options.errors);
-  const error = createEndpointErrorHandler(errors);
-  const wrappedHandler = (async (ctx) => {
-    const execution = await runEndpointMiddleware(
-      middleware,
-      ctx,
-      handler,
-      error,
-      options.invalidates
-    );
-    return execution.result;
-  });
-  const {
-    middleware: _middleware,
-    errors: _errors,
-    invalidates: _invalidates,
-    openapi: _openapi,
-    mcp: _mcp,
-    ...betterCallOptions
-  } = options;
-  const endpoint = _bettercall.createEndpoint.call(void 0, 
-    path || "/__farm_auto_path__",
-    betterCallOptions,
-    wrappedHandler
-  );
-  endpoint.__path = path || void 0;
-  endpoint.__method = options.method || (path ? "GET" : void 0);
-  endpoint.__autoPath = !path;
-  endpoint.__handler = wrappedHandler;
-  endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, error, options.invalidates);
-  endpoint.__middleware = middleware;
-  endpoint.__sourceHandler = handler;
-  endpoint.__invalidates = options.invalidates;
-  endpoint.__errors = errors;
-  endpoint.__openapi = options.openapi;
-  endpoint.__mcp = options.mcp;
-  endpoint.__types = {
-    body: options.body,
-    inputBody: _chunkHLYRXN2Icjs.isMultipartSchema.call(void 0, options.body) ? "form-data" : options.body,
-    query: options.query,
-    inputQuery: options.query,
-    headers: options.headers,
-    response: null,
-    errors
-  };
-  return endpoint;
-}
-var EMPTY_ENDPOINT_MIDDLEWARE = Object.freeze([]);
-var EMPTY_ENDPOINT_CONTEXT = Object.freeze(/* @__PURE__ */ Object.create(null));
-var UNSAFE_ENDPOINT_CONTEXT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function normalizeEndpointErrors(definitions) {
-  if (definitions === void 0) return Object.freeze({});
-  if (!isPlainEndpointContext(definitions)) {
-    throw new TypeError("createEndpoint 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("Endpoint error codes cannot be empty");
-    }
-    if (!definition || typeof definition !== "object") {
-      throw new TypeError(`Endpoint error "${code}" must be an object`);
-    }
-    if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
-      throw new TypeError(`Endpoint error "${code}" status must be an integer between 400 and 599`);
-    }
-    const dataSchema = resolveEndpointErrorSchema(definition);
-    if (!dataSchema || typeof dataSchema.parse !== "function") {
-      throw new TypeError(`Endpoint error "${code}" requires a data schema with parse()`);
-    }
-    if (definition.message !== void 0 && typeof definition.message !== "string") {
-      throw new TypeError(`Endpoint error "${code}" message must be a string`);
-    }
-    normalized[code] = Object.freeze({ ...definition });
-  }
-  return Object.freeze(normalized);
-}
-function resolveEndpointErrorSchema(definition) {
-  if (definition.data && definition.schema) {
-    throw new TypeError("Endpoint errors cannot define both data and schema");
-  }
-  return _nullishCoalesce(definition.data, () => ( definition.schema));
-}
-function createEndpointErrorHandler(definitions) {
-  return ((code, data) => {
-    const definition = definitions[code];
-    if (!definition) {
-      throw new TypeError(`Endpoint error "${code}" is not declared`);
-    }
-    const parsed = resolveEndpointErrorSchema(definition).parse(data);
-    throw new EndpointFailure(code, parsed, {
-      status: definition.status,
-      message: _nullishCoalesce(definition.message, () => ( "Request failed"))
-    });
-  });
-}
-function normalizeEndpointMiddleware(middleware) {
-  if (middleware === void 0) return EMPTY_ENDPOINT_MIDDLEWARE;
-  if (!Array.isArray(middleware)) {
-    throw new TypeError("createEndpoint middleware must be an array of functions");
-  }
-  const normalized = [...middleware];
-  for (const entry of normalized) {
-    if (typeof entry !== "function") {
-      throw new TypeError("createEndpoint middleware entries must be functions");
-    }
-  }
-  return Object.freeze(normalized);
-}
-async function runEndpointMiddleware(middleware, handlerContext, handler, error, invalidations) {
-  let context = createInitialEndpointContext(handlerContext.context);
-  for (let index = 0; index < middleware.length; index++) {
-    const result2 = await middleware[index]({ ...handlerContext, context });
-    if (isEndpointResponse(result2)) {
-      return {
-        result: result2,
-        context,
-        handlerExecuted: false,
-        invalidations: []
-      };
-    }
-    if (result2 === false) {
-      return {
-        result: forbiddenEndpointResponse(),
-        context,
-        handlerExecuted: false,
-        invalidations: []
-      };
-    }
-    if (result2 === true) continue;
-    if (!isPlainEndpointContext(result2)) {
-      throw new TypeError(
-        `Endpoint middleware ${index + 1} must return an object, true, false, or a Response`
-      );
-    }
-    context = mergeEndpointContext(context, result2, index);
-  }
-  const result = await handler({ ...handlerContext, context, error, fail: error });
-  return {
-    result,
-    context,
-    handlerExecuted: true,
-    invalidations: await applyEndpointInvalidations(
-      invalidations,
-      {
-        ...handlerContext,
-        context,
-        result
-      },
-      result
-    )
-  };
-}
-async function applyEndpointInvalidations(declaration, context, result) {
-  if (!declaration || isEndpointResponse(result) && result.status >= 400) {
-    return [];
-  }
-  const targets = typeof declaration === "function" ? await declaration(context) : declaration;
-  if (!Array.isArray(targets)) {
-    throw new TypeError(
-      "Endpoint invalidates must resolve to an array of { key }, { path }, or { tag } targets"
-    );
-  }
-  return _chunkDMAP4RNDcjs.applyFarmCacheInvalidationTargets.call(void 0, targets);
-}
-function createInitialEndpointContext(value) {
-  if (value === void 0 || value === null) return EMPTY_ENDPOINT_CONTEXT;
-  if (!isPlainEndpointContext(value)) {
-    throw new TypeError("Endpoint context must be a plain object");
-  }
-  return mergeEndpointContext(EMPTY_ENDPOINT_CONTEXT, value);
-}
-function mergeEndpointContext(current, added, middlewareIndex) {
-  const next = Object.assign(/* @__PURE__ */ Object.create(null), current);
-  for (const key of Reflect.ownKeys(added)) {
-    if (!Object.prototype.propertyIsEnumerable.call(added, key)) continue;
-    if (typeof key === "string" && UNSAFE_ENDPOINT_CONTEXT_KEYS.has(key)) {
-      throw new TypeError(`Endpoint middleware cannot provide the unsafe context key "${key}"`);
-    }
-    if (Object.prototype.hasOwnProperty.call(current, key)) {
-      const source = middlewareIndex === void 0 ? "Endpoint context" : `Endpoint middleware ${middlewareIndex + 1}`;
-      throw new TypeError(`${source} cannot replace the existing context key "${String(key)}"`);
-    }
-    next[key] = added[key];
-  }
-  return Object.freeze(next);
-}
-function isPlainEndpointContext(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function isEndpointResponse(value) {
-  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
-}
-function forbiddenEndpointResponse() {
-  return new Response(JSON.stringify({ error: "Forbidden" }), {
-    status: 403,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-function GET(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "GET" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "GET" }, args[1]);
-}
-function HEAD(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "HEAD" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "HEAD" }, args[1]);
-}
-function QUERY(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "QUERY" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "QUERY" }, args[1]);
-}
-function POST(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "POST" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "POST" }, args[1]);
-}
-function PUT(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "PUT" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "PUT" }, args[1]);
-}
-function DELETE(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "DELETE" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "DELETE" }, args[1]);
-}
-function PATCH(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "PATCH" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "PATCH" }, args[1]);
-}
-function OPTIONS(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "OPTIONS" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "OPTIONS" }, args[1]);
-}
-
-// src/api/route.ts
-var unavailablePluginLocalAPI = Object.freeze({
-  available: false,
-  get() {
-    return void 0;
-  },
-  list() {
-    return [];
-  }
-});
-function createRouteFactory() {
-  return createRouteFactoryAt("");
-}
-function createRouteFactoryAt(prefix) {
-  const factory = {
-    scope(child) {
-      return createRouteFactoryAt(joinRoutePath(prefix, child));
-    }
-  };
-  for (const method of [
-    "GET",
-    "HEAD",
-    "QUERY",
-    "POST",
-    "PUT",
-    "PATCH",
-    "DELETE",
-    "OPTIONS"
-  ]) {
-    factory[method.toLowerCase()] = (child, options) => {
-      const path = joinRoutePath(prefix, child);
-      const input = _nullishCoalesce(options.input, () => ( {}));
-      const endpoint = createEndpoint(
-        path,
-        {
-          method,
-          body: input.body,
-          query: input.query,
-          headers: input.headers,
-          middleware: options.middleware,
-          mcp: options.mcp
-        },
-        (ctx) => options.handler(ctx.request, {
-          input: { body: ctx.body, query: ctx.query, headers: ctx.headers, params: ctx.params },
-          params: ctx.params,
-          context: ctx.context
-        })
-      );
-      endpoint.__types.params = input.params;
-      endpoint.__output = options.output;
-      return Object.freeze({ path, method, endpoint });
-    };
-  }
-  return Object.freeze(factory);
-}
-function joinRoutePath(prefix, child) {
-  if (typeof child !== "string") throw new TypeError("Route paths must be strings.");
-  const path = child === "" ? prefix : `${prefix}/${child.replace(/^\//, "")}`;
-  if (!(path === "/api" || path.startsWith("/api/")) || /[?#]|\/\/|\/$/.test(path)) {
-    throw new TypeError(
-      `Plugin route "${path}" must be a canonical /api path without a query, hash, or empty segment.`
-    );
-  }
-  _chunkYTVSWXEZcjs.assertBrowserStableRoutePath.call(void 0, path);
-  _chunkYTVSWXEZcjs.assertUniqueRouteParameters.call(void 0, path, "api");
-  _chunkYTVSWXEZcjs.getRoutePatternShape.call(void 0, path, "api");
-  for (const segment of path.split("/")) {
-    if (["__proto__", "constructor", "prototype", "$params"].includes(segment)) {
-      throw new TypeError(`Route segment "${segment}" is reserved.`);
-    }
-  }
-  return path;
-}
-function resolvePluginRoutes(plugins = [], context = {}) {
-  return plugins.flatMap((plugin) => {
-    if (!plugin.routes) return [];
-    const routes = plugin.routes({
-      route: createRouteFactory(),
-      api: _nullishCoalesce(context.api, () => ( unavailablePluginLocalAPI))
-    });
-    if (!Array.isArray(routes))
-      throw new TypeError(`Plugin "${plugin.name}" routes must return an array synchronously.`);
-    for (const route of routes) {
-      if (!route || joinRoutePath("", route.path) !== route.path || typeof route.endpoint !== "function" || !["GET", "HEAD", "QUERY", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"].includes(
-        route.method
-      )) {
-        throw new TypeError(`Plugin "${plugin.name}" returned an invalid API route.`);
-      }
-    }
-    return routes;
-  });
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.EndpointFailure = EndpointFailure; exports.isEndpointFailure = isEndpointFailure; exports.createEndpoint = createEndpoint; exports.GET = GET; exports.HEAD = HEAD; exports.QUERY = QUERY; exports.POST = POST; exports.PUT = PUT; exports.DELETE = DELETE; exports.PATCH = PATCH; exports.OPTIONS = OPTIONS; exports.createRouteFactory = createRouteFactory; exports.resolvePluginRoutes = resolvePluginRoutes;

package/dist/chunk-5DX3O6TT.cjs

@@ -1,266 +0,0 @@
-"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 _chunk6CTFVBATcjs = require('./chunk-6CTFVBAT.cjs');
-
-// src/middleware/matcher.ts
-var compiledConfigCache = /* @__PURE__ */ new WeakMap();
-var compiledRouteCache = /* @__PURE__ */ new WeakMap();
-function compileMiddlewareRoute(entry) {
-  const path = entry.path;
-  if (path === "/") return void 0;
-  const cached = compiledRouteCache.get(entry);
-  if (_optionalChain([cached, 'optionalAccess', _ => _.path]) === path) return cached;
-  const compiled = {
-    path,
-    exact: compilePattern(path),
-    nested: compilePattern(`${path}/:__farmRest*`)
-  };
-  compiledRouteCache.set(entry, compiled);
-  return compiled;
-}
-function matchesMiddlewareRoute(pathname, entry) {
-  const compiled = compileMiddlewareRoute(entry);
-  if (!compiled) return { matched: true };
-  const canonicalPathname = _chunk6CTFVBATcjs.canonicalizeRequestPathname.call(void 0, pathname);
-  const exactMatch = matchPattern(compiled.exact, canonicalPathname);
-  if (exactMatch.matched) return exactMatch;
-  const nestedMatch = matchPattern(compiled.nested, canonicalPathname);
-  if (!nestedMatch.matched) return { matched: false };
-  const params = { ...nestedMatch.params };
-  delete params.__farmRest;
-  return { matched: true, params: Object.keys(params).length > 0 ? params : void 0 };
-}
-function matchesMiddlewareRouteAt(pathnames, entry) {
-  for (const pathname of pathnames) {
-    const match = matchesMiddlewareRoute(pathname, entry);
-    if (match.matched) return match;
-  }
-  return { matched: false };
-}
-function sameEntries(current, previous) {
-  return current === void 0 || previous === void 0 ? current === previous : current.length === previous.length && current.every((entry, index) => entry === previous[index]);
-}
-function toMatcherList(matcher) {
-  if (!matcher) return [];
-  return Array.isArray(matcher) ? matcher : [matcher];
-}
-function escapeRegex(value) {
-  return value.replace(/[|\\{}()[\]^$*+?.]/g, "\\$&");
-}
-function parseColonParam(segment) {
-  const raw = segment.slice(1);
-  const last = raw[raw.length - 1];
-  const modifier = last === "*" || last === "+" || last === "?" ? last : void 0;
-  return {
-    name: modifier ? raw.slice(0, -1) : raw,
-    modifier
-  };
-}
-var MATCHER_PARAM_NAME = /^[\p{L}\p{N}_$-]+$/u;
-var MATCHER_UNSUPPORTED_LITERAL = /[()[\]|\\{}^$?:]|\.[*+]/;
-var MATCHER_BRACKET_PARAM = /^\[\[\.\.\.(.+)\]\]$|^\[\.\.\.(.+)\]$|^\[(.+)\]$/;
-function isSupportedMatcherSegment(segment) {
-  if (segment === "*" || segment === "**") return true;
-  if (segment.startsWith(":")) return MATCHER_PARAM_NAME.test(parseColonParam(segment).name);
-  const bracket = MATCHER_BRACKET_PARAM.exec(segment);
-  if (bracket) return MATCHER_PARAM_NAME.test(_nullishCoalesce(_nullishCoalesce(bracket[1], () => ( bracket[2])), () => ( bracket[3])));
-  return !MATCHER_UNSUPPORTED_LITERAL.test(segment);
-}
-function isLiteralMatcherSegment(segment) {
-  return !MATCHER_UNSUPPORTED_LITERAL.test(segment) && !segment.includes("*");
-}
-function assertSupportedMiddlewareMatcher(pattern) {
-  if (pattern === "*" || pattern === "/(.*)") return;
-  const subtree = pattern.endsWith("(.*)");
-  const path = subtree ? pattern.slice(0, -4) : pattern;
-  const segments = path.split("/").filter(Boolean);
-  if (segments.every(subtree ? isLiteralMatcherSegment : isSupportedMatcherSegment)) return;
-  throw new Error(
-    `Middleware matcher "${pattern}" is not a supported string pattern, so it would never match a request and the middleware would not run. String matchers do not accept regular-expression syntax such as groups, alternation, character classes, lookaheads, or \`.*\`, or a param after literal text such as \`/user-:id\`. Pass a RegExp instead, for example \`matcher: /^\\/(?!api|_next).*/\`, or use the supported forms: /path/:param, /path/:param*, /path/[param], /path/[...param], /path/*, /path/**, or a trailing (.*) such as /path(.*).`
-  );
-}
-function compileConfigPattern(pattern, compile) {
-  if (typeof pattern === "string") assertSupportedMiddlewareMatcher(pattern);
-  return compile(pattern);
-}
-function compilePathPattern(pattern, trailingSlash = false) {
-  const params = [];
-  const segments = pattern.split("/").filter(Boolean);
-  if (segments.length === 0) {
-    return { kind: "path", regex: /^\/$/, params };
-  }
-  const parts = segments.map((segment) => {
-    if (segment === "**") {
-      return "(?:/.*)?";
-    }
-    if (segment === "*") {
-      return "/[^/]+";
-    }
-    if (segment.startsWith(":")) {
-      const { name, modifier } = parseColonParam(segment);
-      params.push(name);
-      if (modifier === "*") {
-        return "(?:/(.*))?";
-      }
-      if (modifier === "+") {
-        return "/(.+)";
-      }
-      if (modifier === "?") {
-        return "(?:/([^/]+))?";
-      }
-      return "/([^/]+)";
-    }
-    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
-      params.push(segment.slice(5, -2));
-      return "(?:/(.*))?";
-    }
-    if (segment.startsWith("[...") && segment.endsWith("]")) {
-      params.push(segment.slice(4, -1));
-      return "(?:/(.*))?";
-    }
-    if (segment.startsWith("[") && segment.endsWith("]")) {
-      params.push(segment.slice(1, -1));
-      return "/([^/]+)";
-    }
-    return `/${escapeRegex(segment).replace(/\\\*/g, "[^/]*")}`;
-  });
-  return {
-    kind: "path",
-    regex: new RegExp(`^${parts.join("")}${trailingSlash ? "/?" : ""}$`),
-    params
-  };
-}
-function compileMatcherPattern(pattern) {
-  if (typeof pattern === "string" && pattern !== "*" && !pattern.endsWith("(.*)")) {
-    return compilePathPattern(pattern, true);
-  }
-  return compilePattern(pattern);
-}
-function compilePattern(pattern) {
-  if (pattern instanceof RegExp) {
-    return { kind: "regexp", regex: pattern };
-  }
-  if (pattern === "*" || pattern === "/(.*)") {
-    return { kind: "all" };
-  }
-  if (pattern.endsWith("(.*)")) {
-    return {
-      kind: "subtree",
-      prefix: pattern.slice(0, -4).replace(/\/$/, "")
-    };
-  }
-  return compilePathPattern(pattern);
-}
-function compileMiddlewareConfig(config) {
-  const compiled = {
-    matcher: config.matcher ? toMatcherList(config.matcher).map(
-      (matcher) => typeof matcher === "function" ? matcher : compileConfigPattern(matcher, compileMatcherPattern)
-    ) : void 0,
-    exclude: _optionalChain([config, 'access', _2 => _2.exclude, 'optionalAccess', _3 => _3.map, 'call', _4 => _4((pattern) => compileConfigPattern(pattern, compilePattern))])
-  };
-  compiledConfigCache.set(config, {
-    compiled,
-    matcher: config.matcher,
-    matcherEntries: Array.isArray(config.matcher) ? config.matcher.slice() : void 0,
-    excludeEntries: _optionalChain([config, 'access', _5 => _5.exclude, 'optionalAccess', _6 => _6.slice, 'call', _7 => _7()])
-  });
-  return compiled;
-}
-function matchPattern(pattern, pathname) {
-  if (pattern.kind === "all") {
-    return { matched: true };
-  }
-  if (pattern.kind === "subtree") {
-    return {
-      matched: pathname === pattern.prefix || pathname.startsWith(`${pattern.prefix}/`)
-    };
-  }
-  pattern.regex.lastIndex = 0;
-  const match = pattern.regex.exec(pathname);
-  if (!match) {
-    return { matched: false };
-  }
-  if (pattern.kind === "regexp") {
-    return {
-      matched: true,
-      params: match.groups ? { ...match.groups } : void 0
-    };
-  }
-  const values = {};
-  pattern.params.forEach((param, index) => {
-    values[param] = match[index + 1] || "";
-  });
-  return {
-    matched: true,
-    params: Object.keys(values).length > 0 ? values : void 0
-  };
-}
-function withRoutePathname(ctx, routePathname) {
-  return new Proxy(ctx, {
-    get(target, key) {
-      return key === "pathname" || key === "routePathname" ? routePathname : Reflect.get(target, key, target);
-    }
-  });
-}
-function matchesMiddlewarePredicate(predicate, ctx, getRoutePathname = () => ctx.routePathname) {
-  if (predicate(ctx)) return true;
-  const routePathname = getRoutePathname();
-  if (routePathname === void 0 || routePathname === ctx.pathname) return false;
-  return Boolean(predicate(withRoutePathname(ctx, routePathname)));
-}
-function toMiddlewareRoutePathname(pathname, toRoutePathname = (value) => value) {
-  return _chunk6CTFVBATcjs.canonicalizeRequestPathname.call(void 0, toRoutePathname(pathname));
-}
-function matchesCompiledMiddlewareConfig(pathname, config, ctx) {
-  let canonicalPathname;
-  const getCanonicalPathname = () => _nullishCoalesce(canonicalPathname, () => ( (canonicalPathname = _chunk6CTFVBATcjs.canonicalizeRequestPathname.call(void 0, pathname))));
-  if (config.exclude) {
-    for (const pattern of config.exclude) {
-      if (matchPattern(pattern, getCanonicalPathname()).matched) {
-        return { matched: false };
-      }
-    }
-  }
-  if (config.matcher) {
-    for (const matcher of config.matcher) {
-      if (typeof matcher === "function") {
-        if (matchesMiddlewarePredicate(matcher, ctx, getCanonicalPathname)) {
-          return { matched: true };
-        }
-        continue;
-      }
-      const result = matchPattern(matcher, getCanonicalPathname());
-      if (result.matched) {
-        return result;
-      }
-    }
-    return { matched: false };
-  }
-  return { matched: true };
-}
-function matchesMiddlewareConfig(pathname, config, ctx) {
-  const cached = compiledConfigCache.get(config);
-  const unchanged = cached && (Array.isArray(config.matcher) ? sameEntries(config.matcher, cached.matcherEntries) : config.matcher === cached.matcher) && sameEntries(config.exclude, cached.excludeEntries);
-  const compiled = unchanged ? cached.compiled : compileMiddlewareConfig(config);
-  return matchesCompiledMiddlewareConfig(pathname, compiled, ctx);
-}
-function matchesMiddlewareConfigAt(pathnames, config, ctx) {
-  for (const pathname of pathnames) {
-    const match = matchesMiddlewareConfig(pathname, config, ctx);
-    if (match.matched) return match;
-  }
-  return { matched: false };
-}
-
-
-
-
-
-
-
-
-
-
-
-
-exports.compileMiddlewareRoute = compileMiddlewareRoute; exports.matchesMiddlewareRoute = matchesMiddlewareRoute; exports.matchesMiddlewareRouteAt = matchesMiddlewareRouteAt; exports.assertSupportedMiddlewareMatcher = assertSupportedMiddlewareMatcher; exports.compileMiddlewareConfig = compileMiddlewareConfig; exports.matchesMiddlewarePredicate = matchesMiddlewarePredicate; exports.toMiddlewareRoutePathname = toMiddlewareRoutePathname; exports.matchesCompiledMiddlewareConfig = matchesCompiledMiddlewareConfig; exports.matchesMiddlewareConfig = matchesMiddlewareConfig; exports.matchesMiddlewareConfigAt = matchesMiddlewareConfigAt;