@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-2SJ4RQ6P.cjs

@@ -0,0 +1,57 @@
+"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/instrumentation-runtime.ts
+function createFarmInstrumentationLifecycle(module, context) {
+  let startPromise;
+  let shutdownPromise;
+  let cleanup;
+  return {
+    start() {
+      if (!startPromise) {
+        startPromise = Promise.resolve(_optionalChain([module, 'optionalAccess', _ => _.register, 'optionalCall', _2 => _2(context)])).then((result) => {
+          cleanup = result || void 0;
+        });
+      }
+      return startPromise;
+    },
+    shutdown() {
+      if (!shutdownPromise) {
+        shutdownPromise = (async () => {
+          try {
+            await startPromise;
+          } catch (e) {
+          }
+          try {
+            if (typeof cleanup === "function") {
+              await cleanup();
+            } else if (_optionalChain([cleanup, 'optionalAccess', _3 => _3.shutdown])) {
+              await cleanup.shutdown();
+            }
+          } finally {
+            if (_optionalChain([module, 'optionalAccess', _4 => _4.shutdown])) {
+              await module.shutdown();
+            }
+          }
+        })();
+      }
+      return shutdownPromise;
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmInstrumentationLifecycle, "createFarmInstrumentationLifecycle");
+function resolveFarmInstrumentationRuntime(preset) {
+  const normalized = _nullishCoalesce(_optionalChain([preset, 'optionalAccess', _5 => _5.toLowerCase, 'call', _6 => _6()]), () => ( ""));
+  if (normalized.includes("cloudflare") || normalized.includes("worker") || normalized.includes("edge")) {
+    return "edge";
+  }
+  if (normalized.includes("bun")) return "bun";
+  return "nodejs";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmInstrumentationRuntime, "resolveFarmInstrumentationRuntime");
+
+
+
+
+exports.createFarmInstrumentationLifecycle = createFarmInstrumentationLifecycle; exports.resolveFarmInstrumentationRuntime = resolveFarmInstrumentationRuntime;

package/dist/chunk-2UC36WAC.mjs

@@ -0,0 +1,22 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/secret-compare.ts
+function farmSecretsMatch(provided, expected) {
+  if (typeof provided !== "string" || typeof expected !== "string") return false;
+  if (expected.length === 0) return false;
+  let mismatch = provided.length ^ expected.length;
+  const length = Math.max(provided.length, expected.length);
+  for (let index = 0; index < length; index += 1) {
+    const providedCode = index < provided.length ? provided.charCodeAt(index) : 0;
+    const expectedCode = index < expected.length ? expected.charCodeAt(index) : 0;
+    mismatch |= providedCode ^ expectedCode;
+  }
+  return mismatch === 0;
+}
+__name(farmSecretsMatch, "farmSecretsMatch");
+
+export {
+  farmSecretsMatch
+};

package/dist/chunk-2VQKKQ6D.mjs

@@ -0,0 +1,51 @@
+import {
+  formatOptionalPeerInstallHint,
+  isMissingPackageError,
+  withOptionalPeerCause
+} from "./chunk-YOZYCI6Z.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/docs/engine.ts
+var FARMING_LABS_DOCS_INSTALL_HINT = formatOptionalPeerInstallHint(
+  "@farming-labs/docs",
+  "use the docs engine"
+);
+var engine;
+var loading;
+function loadFarmDocsEngine() {
+  loading ?? (loading = Promise.all([import("@farming-labs/docs"), import("@farming-labs/docs/server")]).then(
+    ([docs, server]) => {
+      engine = {
+        ...docs,
+        resolveApiReferenceOpenApiDiscovery: server.resolveApiReferenceOpenApiDiscovery
+      };
+      return engine;
+    },
+    (error) => {
+      loading = void 0;
+      if (!isMissingPackageError(error, "@farming-labs/docs")) throw error;
+      throw withOptionalPeerCause(
+        new Error(
+          `docs is enabled, but @farming-labs/docs is not installed. ${FARMING_LABS_DOCS_INSTALL_HINT}`
+        ),
+        error
+      );
+    }
+  ));
+  return loading;
+}
+__name(loadFarmDocsEngine, "loadFarmDocsEngine");
+function docsEngine() {
+  if (!engine) {
+    throw new Error("Farm docs engine was used before loadFarmDocsEngine() resolved.");
+  }
+  return engine;
+}
+__name(docsEngine, "docsEngine");
+
+export {
+  loadFarmDocsEngine,
+  docsEngine
+};

package/dist/chunk-2Y3JRYVG.mjs

@@ -0,0 +1,71 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/environment.ts
+var _FarmEnvironmentError = class _FarmEnvironmentError extends Error {
+  constructor(api, expected, actual) {
+    super(`${api}() can only be called on the ${expected}. It was called on the ${actual}.`);
+    this.api = api;
+    this.expected = expected;
+    this.actual = actual;
+    this.code = "FARM_ENVIRONMENT_MISMATCH";
+    this.name = "FarmEnvironmentError";
+  }
+};
+__name(_FarmEnvironmentError, "FarmEnvironmentError");
+var FarmEnvironmentError = _FarmEnvironmentError;
+function createServerOnlyFn(implementation, compiledActualEnvironment) {
+  if (compiledActualEnvironment) {
+    return createMismatchFunction("createServerOnlyFn", "server", compiledActualEnvironment);
+  }
+  if (getRuntimeEnvironment() !== "server") {
+    return createMismatchFunction("createServerOnlyFn", "server");
+  }
+  assertFunction(implementation, "createServerOnlyFn");
+  return implementation;
+}
+__name(createServerOnlyFn, "createServerOnlyFn");
+function createClientOnlyFn(implementation, compiledActualEnvironment) {
+  if (compiledActualEnvironment) {
+    return createMismatchFunction("createClientOnlyFn", "client", compiledActualEnvironment);
+  }
+  if (getRuntimeEnvironment() !== "client") {
+    return createMismatchFunction("createClientOnlyFn", "client");
+  }
+  assertFunction(implementation, "createClientOnlyFn");
+  return implementation;
+}
+__name(createClientOnlyFn, "createClientOnlyFn");
+function createIsomorphicFn(options) {
+  if (!options || typeof options !== "object") {
+    throw new TypeError("createIsomorphicFn requires server and client functions");
+  }
+  assertFunction(options.server, "createIsomorphicFn server");
+  assertFunction(options.client, "createIsomorphicFn client");
+  return getRuntimeEnvironment() === "server" ? options.server : options.client;
+}
+__name(createIsomorphicFn, "createIsomorphicFn");
+function getRuntimeEnvironment() {
+  return typeof window === "undefined" ? "server" : "client";
+}
+__name(getRuntimeEnvironment, "getRuntimeEnvironment");
+function createMismatchFunction(api, expected, actual = expected === "server" ? "client" : "server") {
+  return /* @__PURE__ */ __name(function farmEnvironmentBoundary() {
+    throw new FarmEnvironmentError(api, expected, actual);
+  }, "farmEnvironmentBoundary");
+}
+__name(createMismatchFunction, "createMismatchFunction");
+function assertFunction(value, label) {
+  if (typeof value !== "function") {
+    throw new TypeError(`${label} must be a function`);
+  }
+}
+__name(assertFunction, "assertFunction");
+
+export {
+  FarmEnvironmentError,
+  createServerOnlyFn,
+  createClientOnlyFn,
+  createIsomorphicFn
+};

package/dist/chunk-35GKZR22.mjs

@@ -0,0 +1,157 @@
+import {
+  _attachServerFunctionDescriptor,
+  _parseServerFnSchema,
+  _runServerFunctionForCaller,
+  createServerFn,
+  createServerFunctionDescriptor
+} from "./chunk-EWET4D2Y.mjs";
+import {
+  createFarmServerQueryResult
+} from "./chunk-KGB5UXJJ.mjs";
+import {
+  getServerActionExecutionContext
+} from "./chunk-4WVJLURN.mjs";
+import {
+  createRouteDataCacheTag,
+  getFarmDataCache
+} from "./chunk-MSSFIQGM.mjs";
+import {
+  createFarmCacheKey,
+  createRouteDataCacheKey
+} from "./chunk-CNOQY6Z7.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/server-query.ts
+var FARM_SERVER_QUERY_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-query");
+var requestInflight = /* @__PURE__ */ new WeakMap();
+var detachedInflight = /* @__PURE__ */ new Map();
+function createServerQuery(options) {
+  if (!options || typeof options.handler !== "function") {
+    throw new TypeError("createServerQuery requires a handler function");
+  }
+  if (typeof options.key !== "function") {
+    throw new TypeError("createServerQuery requires a key function");
+  }
+  const staleTime = normalizeServerQueryStaleTime(options.staleTime);
+  const execute = createServerFn({
+    input: options.input,
+    middleware: options.middleware,
+    handler: /* @__PURE__ */ __name(async (context) => {
+      const routeKey = await options.key(context);
+      assertServerQueryKey(routeKey);
+      const clientKey = createRouteDataCacheKey(routeKey);
+      const cacheKey = createFarmCacheKey(["route-data", routeKey]);
+      const producer = /* @__PURE__ */ __name(async () => {
+        const value = await options.handler(context);
+        return _parseServerFnSchema(options.output, value, "output", "createServerQuery");
+      }, "producer");
+      let data;
+      let updatedAt;
+      if (staleTime === 0) {
+        data = await dedupeServerQueryRequest(cacheKey, context.request, producer);
+        updatedAt = Date.now();
+      } else {
+        const cache = getFarmDataCache();
+        data = await cache.getOrSet(cacheKey, producer, {
+          tags: [createRouteDataCacheTag(routeKey)],
+          revalidate: staleTime === false ? false : staleTime / 1e3
+        });
+        updatedAt = (await cache.getEntryAsync(cacheKey, { allowStale: true }))?.createdAt ?? Date.now();
+      }
+      return createFarmServerQueryResult(data, {
+        key: clientKey,
+        staleTime,
+        updatedAt,
+        ...options.persist === true ? { persist: true } : {}
+      });
+    }, "handler")
+  });
+  const query = /* @__PURE__ */ __name(async (input) => {
+    const result = await execute(input);
+    return getServerActionExecutionContext() ? result : result.data;
+  }, "query");
+  Object.defineProperties(query, {
+    [FARM_SERVER_QUERY_SYMBOL]: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerQuery: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerQueryInput: {
+      value: options.input,
+      enumerable: false
+    },
+    __farmServerQueryOutput: {
+      value: options.output,
+      enumerable: false
+    }
+  });
+  _attachServerFunctionDescriptor(
+    query,
+    createServerFunctionDescriptor("query", options, async (value) => {
+      const result = await _runServerFunctionForCaller(
+        execute,
+        value
+      );
+      return result.data;
+    })
+  );
+  return query;
+}
+__name(createServerQuery, "createServerQuery");
+async function dedupeServerQueryRequest(key, request, producer) {
+  let inflight;
+  if (request) {
+    inflight = requestInflight.get(request) ?? /* @__PURE__ */ new Map();
+    requestInflight.set(request, inflight);
+  } else {
+    inflight = detachedInflight;
+  }
+  const existing = inflight.get(key);
+  if (existing) return existing;
+  const promise = Promise.resolve().then(producer);
+  inflight.set(key, promise);
+  try {
+    return await promise;
+  } finally {
+    inflight.delete(key);
+  }
+}
+__name(dedupeServerQueryRequest, "dedupeServerQueryRequest");
+function normalizeServerQueryStaleTime(value) {
+  if (value === false) return false;
+  if (value === void 0) return 0;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new TypeError("createServerQuery staleTime must be a non-negative duration");
+    }
+    return value;
+  }
+  const match = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/);
+  if (!match) {
+    throw new TypeError('createServerQuery staleTime must look like "250ms", "30s", "5m", or "1h"');
+  }
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5;
+  return amount * multiplier;
+}
+__name(normalizeServerQueryStaleTime, "normalizeServerQueryStaleTime");
+function assertServerQueryKey(key) {
+  if (typeof key === "string") {
+    if (key.trim().length > 0) return;
+  } else if (Array.isArray(key)) {
+    return;
+  }
+  throw new TypeError("createServerQuery key must return a non-empty string or an array");
+}
+__name(assertServerQueryKey, "assertServerQueryKey");
+
+export {
+  FARM_SERVER_QUERY_SYMBOL,
+  createServerQuery
+};

package/dist/chunk-3BU22U3M.cjs

@@ -0,0 +1,237 @@
+"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 _chunkAI7QMY7Ocjs = require('./chunk-AI7QMY7O.cjs');
+
+
+var _chunkUXFQ3UDAcjs = require('./chunk-UXFQ3UDA.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/middleware/server.ts
+var _async_hooks = require('async_hooks');
+var MIDDLEWARE_DATA_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.middlewareDataStore");
+var MIDDLEWARE_CONTEXT_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.middlewareContextStore");
+function getGlobalMiddlewareStore(key) {
+  const state = globalThis;
+  const existing = state[key];
+  if (existing instanceof _async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const store = new (0, _async_hooks.AsyncLocalStorage)();
+  state[key] = store;
+  return store;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getGlobalMiddlewareStore, "getGlobalMiddlewareStore");
+var middlewareStore = getGlobalMiddlewareStore(MIDDLEWARE_DATA_STORE_KEY);
+var middlewareContextStore = getGlobalMiddlewareStore(MIDDLEWARE_CONTEXT_STORE_KEY);
+function toMiddlewareMap(data) {
+  if (data instanceof Map) {
+    return new Map(data);
+  }
+  return new Map(Object.entries(data));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toMiddlewareMap, "toMiddlewareMap");
+function _clearCurrentMiddlewareData() {
+  middlewareStore.enterWith(/* @__PURE__ */ new Map());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _clearCurrentMiddlewareData, "_clearCurrentMiddlewareData");
+function _clearCurrentMiddlewareContext() {
+  middlewareContextStore.enterWith(/* @__PURE__ */ new Map());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _clearCurrentMiddlewareContext, "_clearCurrentMiddlewareContext");
+async function _runWithMiddlewareData(data, fn) {
+  return middlewareStore.run(toMiddlewareMap(data), fn);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithMiddlewareData, "_runWithMiddlewareData");
+async function _runWithMiddlewareContext(context, fn) {
+  return middlewareContextStore.run(toMiddlewareMap(context), fn);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithMiddlewareContext, "_runWithMiddlewareContext");
+function getMiddlewareData() {
+  return middlewareStore.getStore() || /* @__PURE__ */ new Map();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareData, "getMiddlewareData");
+function getMiddlewareValue(key) {
+  const data = getMiddlewareData();
+  return data.get(key);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareValue, "getMiddlewareValue");
+function getMiddlewareContext() {
+  return middlewareContextStore.getStore() || /* @__PURE__ */ new Map();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareContext, "getMiddlewareContext");
+
+// src/middleware/cookie-header.ts
+function parseMiddlewareCookieHeader(cookieHeader) {
+  const cookies = /* @__PURE__ */ Object.create(null);
+  for (const cookie of _chunkAI7QMY7Ocjs.parseRequestCookieHeader.call(void 0, cookieHeader)) {
+    if (!Object.prototype.hasOwnProperty.call(cookies, cookie.name)) {
+      cookies[cookie.name] = cookie.value;
+    }
+  }
+  return cookies;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseMiddlewareCookieHeader, "parseMiddlewareCookieHeader");
+function applyCookieNamePrefixRequirements(name, options) {
+  if (name.startsWith("__Host-")) {
+    return { ...options, secure: true, path: "/", domain: void 0 };
+  }
+  if (name.startsWith("__Secure-")) {
+    return { ...options, secure: true };
+  }
+  return options;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyCookieNamePrefixRequirements, "applyCookieNamePrefixRequirements");
+function serializeMiddlewareCookie(name, value, options = {}) {
+  const resolved = applyCookieNamePrefixRequirements(name, options);
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (resolved.maxAge != null) cookie += `; Max-Age=${resolved.maxAge}`;
+  if (resolved.expires) cookie += `; Expires=${resolved.expires.toUTCString()}`;
+  cookie += `; Path=${resolved.path || "/"}`;
+  if (resolved.domain) cookie += `; Domain=${resolved.domain}`;
+  if (resolved.secure || resolved.sameSite === "none") cookie += "; Secure";
+  if (resolved.httpOnly) cookie += "; HttpOnly";
+  if (resolved.sameSite) {
+    cookie += `; SameSite=${resolved.sameSite.charAt(0).toUpperCase()}${resolved.sameSite.slice(1)}`;
+  }
+  return cookie;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, serializeMiddlewareCookie, "serializeMiddlewareCookie");
+function serializeMiddlewareCookieDeletion(name, options = {}) {
+  return serializeMiddlewareCookie(name, "", { ...options, maxAge: 0, expires: /* @__PURE__ */ new Date(0) });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, serializeMiddlewareCookieDeletion, "serializeMiddlewareCookieDeletion");
+
+// src/middleware/module.ts
+function isWebRequest(request) {
+  return typeof Request !== "undefined" && request instanceof Request;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isWebRequest, "isWebRequest");
+function toWebRequest(ctx) {
+  if (isWebRequest(ctx.request)) {
+    return ctx.request;
+  }
+  return _chunkUXFQ3UDAcjs.createWebRequestFromFarmRequest.call(void 0, ctx.request, { origin: ctx.url.origin });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toWebRequest, "toWebRequest");
+function createRequestMiddlewareContext(ctx) {
+  const context = {
+    get url() {
+      return ctx.url;
+    },
+    get pathname() {
+      return ctx.pathname;
+    },
+    get searchParams() {
+      return ctx.searchParams;
+    },
+    get method() {
+      return ctx.method;
+    },
+    get params() {
+      return ctx.params;
+    },
+    get route() {
+      return ctx.route;
+    },
+    get locals() {
+      return ctx.locals;
+    },
+    get data() {
+      return ctx.data;
+    },
+    get headers() {
+      return ctx.headers;
+    },
+    get cookies() {
+      return ctx.cookies;
+    },
+    get(key) {
+      return ctx.locals.get(key);
+    },
+    has(key) {
+      return ctx.locals.has(key);
+    },
+    set(key, value) {
+      ctx.locals.set(key, value);
+    },
+    delete(key) {
+      return ctx.locals.delete(key);
+    },
+    redirect(url, status) {
+      ctx.redirect(url, status);
+    },
+    rewrite(url) {
+      ctx.rewrite(url);
+    },
+    json(data, status) {
+      ctx.json(data, status);
+    },
+    text(content, status) {
+      ctx.text(content, status);
+    },
+    html(content, status) {
+      ctx.html(content, status);
+    }
+  };
+  return context;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRequestMiddlewareContext, "createRequestMiddlewareContext");
+function normalizeMiddlewareModule(middlewareModule, routePath) {
+  const module = middlewareModule;
+  const defaultExport = module.default;
+  const namedExport = module.middleware;
+  const hasNamedExport = typeof namedExport === "function";
+  if (namedExport !== void 0 && !hasNamedExport) {
+    throw new TypeError("The named middleware export must be a function");
+  }
+  if (defaultExport && hasNamedExport) {
+    throw new Error(
+      "A middleware file cannot export both a default handler and a named middleware handler"
+    );
+  }
+  if (hasNamedExport) {
+    return {
+      handlers: [
+        async (ctx) => {
+          return namedExport(toWebRequest(ctx), createRequestMiddlewareContext(ctx));
+        }
+      ],
+      config: module.config
+    };
+  }
+  if (defaultExport && typeof defaultExport === "object" && "build" in defaultExport) {
+    if (typeof defaultExport.setBasePath === "function") {
+      defaultExport.setBasePath(routePath);
+    }
+    const built = defaultExport.build();
+    const handlers = Array.isArray(_optionalChain([built, 'optionalAccess', _ => _.handlers])) ? built.handlers.filter((handler) => typeof handler === "function") : [];
+    return handlers.length > 0 ? {
+      handlers,
+      config: module.config || _optionalChain([built, 'optionalAccess', _2 => _2.config])
+    } : null;
+  }
+  if (typeof defaultExport === "function") {
+    return {
+      handlers: [defaultExport],
+      config: module.config
+    };
+  }
+  return null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeMiddlewareModule, "normalizeMiddlewareModule");
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports._clearCurrentMiddlewareData = _clearCurrentMiddlewareData; exports._clearCurrentMiddlewareContext = _clearCurrentMiddlewareContext; exports._runWithMiddlewareData = _runWithMiddlewareData; exports._runWithMiddlewareContext = _runWithMiddlewareContext; exports.getMiddlewareData = getMiddlewareData; exports.getMiddlewareValue = getMiddlewareValue; exports.getMiddlewareContext = getMiddlewareContext; exports.parseMiddlewareCookieHeader = parseMiddlewareCookieHeader; exports.serializeMiddlewareCookie = serializeMiddlewareCookie; exports.serializeMiddlewareCookieDeletion = serializeMiddlewareCookieDeletion; exports.normalizeMiddlewareModule = normalizeMiddlewareModule;