@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-QZRVZSPN.cjs

@@ -0,0 +1,236 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkYX3DBN4Mcjs = require('./chunk-YX3DBN4M.cjs');
+
+
+
+
+
+var _chunkDVM4FKZLcjs = require('./chunk-DVM4FKZL.cjs');
+
+
+var _chunkOX6O6WVAcjs = require('./chunk-OX6O6WVA.cjs');
+
+
+var _chunk5ZSWG4UXcjs = require('./chunk-5ZSWG4UX.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/plugins/redirects.ts
+function createRedirectsPlugin(redirects, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse,
+  i18n
+} = {}) {
+  for (const redirect of redirects) {
+    if (redirect.statusCode !== void 0 && !_chunkOX6O6WVAcjs.isFarmRedirectStatus.call(void 0, redirect.statusCode)) {
+      throw new RangeError(
+        `Redirect "${redirect.source}" statusCode must be one of 301, 302, 303, 307, or 308.`
+      );
+    }
+  }
+  const compiledRedirects = redirects.map((redirect) => ({
+    redirect,
+    pattern: _chunkDVM4FKZLcjs.compileConfigRoutePattern.call(void 0, redirect.source)
+  }));
+  return {
+    name: "farm:redirects",
+    enforce: "pre",
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+      const url = _chunk5ZSWG4UXcjs.resolveFarmRequestURL.call(void 0, req);
+      const routePath = _chunkDVM4FKZLcjs.resolveConfigRoutePathname.call(void 0, url.pathname, i18n);
+      const pathname = routePath.pathname;
+      for (const { redirect, pattern } of compiledRedirects) {
+        const match = pathname.match(pattern.regex);
+        if (match) {
+          const localizedDestination = _chunkDVM4FKZLcjs.localizeConfigRouteDestination.call(void 0, 
+            _chunkDVM4FKZLcjs.interpolateConfigRouteDestination.call(void 0, redirect.destination, match, pattern.tokens),
+            routePath.locale,
+            i18n
+          );
+          const destination = _chunkYX3DBN4Mcjs.appendFarmRedirectQuery.call(void 0, localizedDestination, url.search);
+          const statusCode = _nullishCoalesce(redirect.statusCode, () => ( (redirect.permanent ? 308 : 307)));
+          res.writeHead(statusCode, {
+            Location: destination
+          });
+          res.end();
+          return;
+        }
+      }
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRedirectsPlugin, "createRedirectsPlugin");
+
+// src/plugins/headers.ts
+var FARM_CONFIG_HEADERS_FINALIZER = /* @__PURE__ */ Symbol.for("farm.configHeadersFinalizer");
+function appendConfiguredLinkHeader(res, value) {
+  const current = res.getHeader("Link");
+  if (current === void 0) {
+    res.setHeader("Link", value);
+    return;
+  }
+  const currentValue = Array.isArray(current) ? current.join(", ") : String(current);
+  if (currentValue !== value && !currentValue.endsWith(`, ${value}`)) {
+    res.setHeader("Link", `${currentValue}, ${value}`);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendConfiguredLinkHeader, "appendConfiguredLinkHeader");
+function appendConfiguredSetCookieHeader(res, value) {
+  const current = res.getHeader("Set-Cookie");
+  if (current === void 0) {
+    res.setHeader("Set-Cookie", value);
+    return;
+  }
+  const values = (Array.isArray(current) ? current : [current]).map(String);
+  if (!values.includes(value)) {
+    res.setHeader("Set-Cookie", [...values, value]);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendConfiguredSetCookieHeader, "appendConfiguredSetCookieHeader");
+function applyResponseHeaders(res, matchedHeaders) {
+  for (const headers of matchedHeaders) {
+    for (const header of headers) {
+      const key = header.key.toLowerCase();
+      if (key === "link") {
+        appendConfiguredLinkHeader(res, header.value);
+      } else if (key === "set-cookie") {
+        appendConfiguredSetCookieHeader(res, header.value);
+      } else {
+        res.setHeader(header.key, header.value);
+      }
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyResponseHeaders, "applyResponseHeaders");
+function applyWriteHeadHeaders(res, headers) {
+  if (Array.isArray(headers)) {
+    let setCookieWritten = false;
+    for (let index = 0; index + 1 < headers.length; index += 2) {
+      const key = String(headers[index]);
+      const value = headers[index + 1];
+      if (key.toLowerCase() === "set-cookie" && setCookieWritten) {
+        const current = res.getHeader("Set-Cookie");
+        const values = (Array.isArray(current) ? current : [current]).filter(
+          (entry) => entry !== void 0
+        );
+        res.setHeader("Set-Cookie", [...values, ...Array.isArray(value) ? value : [value]]);
+      } else {
+        res.setHeader(key, value);
+        if (key.toLowerCase() === "set-cookie") setCookieWritten = true;
+      }
+    }
+    return;
+  }
+  if (!headers || typeof headers !== "object") return;
+  for (const [key, value] of Object.entries(headers)) {
+    if (value !== void 0) res.setHeader(key, value);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyWriteHeadHeaders, "applyWriteHeadHeaders");
+function createHeadersPlugin(headers, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse,
+  i18n
+} = {}) {
+  const compiledHeaders = headers.map((config) => ({
+    config,
+    pattern: _chunkDVM4FKZLcjs.compileConfigRoutePattern.call(void 0, config.source)
+  }));
+  return {
+    name: "farm:headers",
+    enforce: "pre",
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+      const url = _chunk5ZSWG4UXcjs.resolveFarmRequestURL.call(void 0, req);
+      const pathname = _chunkDVM4FKZLcjs.resolveConfigRoutePathname.call(void 0, url.pathname, i18n).pathname;
+      const matchedHeaders = compiledHeaders.filter(({ pattern }) => pattern.regex.test(pathname)).map(({ config }) => config.headers);
+      applyResponseHeaders(res, matchedHeaders);
+      const responseWithFinalizer = res;
+      if (matchedHeaders.length === 0 || responseWithFinalizer[FARM_CONFIG_HEADERS_FINALIZER]) {
+        return;
+      }
+      responseWithFinalizer[FARM_CONFIG_HEADERS_FINALIZER] = true;
+      const writeHead = res.writeHead;
+      res.writeHead = ((statusCode, ...args) => {
+        const statusMessage = typeof args[0] === "string" ? args.shift() : void 0;
+        applyWriteHeadHeaders(res, args[0]);
+        applyResponseHeaders(res, matchedHeaders);
+        return statusMessage === void 0 ? writeHead.call(res, statusCode) : writeHead.call(res, statusCode, statusMessage);
+      });
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createHeadersPlugin, "createHeadersPlugin");
+
+// src/plugins/env.ts
+function createEnvPlugin(env, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse
+} = {}) {
+  return {
+    name: "farm:env",
+    configResolved(config, context) {
+      for (const [key, value] of Object.entries(env)) {
+        process.env[key] = value;
+      }
+    },
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createEnvPlugin, "createEnvPlugin");
+
+// src/plugins/logger.ts
+function createLoggerPlugin({
+  beforeRequest,
+  afterResponse
+} = {}) {
+  const plugin = {
+    name: "farm:logger",
+    enforce: "post"
+  };
+  if (beforeRequest) {
+    plugin.beforeRequest = async (req, res, context) => {
+      await beforeRequest(req, res, context);
+    };
+  }
+  if (afterResponse) {
+    plugin.afterResponse = async (req, res, context) => {
+      await afterResponse(req, res, context);
+    };
+  }
+  return plugin;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createLoggerPlugin, "createLoggerPlugin");
+
+
+
+
+
+
+exports.createRedirectsPlugin = createRedirectsPlugin; exports.createHeadersPlugin = createHeadersPlugin; exports.createEnvPlugin = createEnvPlugin; exports.createLoggerPlugin = createLoggerPlugin;

package/dist/chunk-R5A5KNVX.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client/hash-target.ts
+function getHashTargetElement(hash) {
+  const fragment = hash.startsWith("#") ? hash.slice(1) : hash;
+  if (!fragment) return null;
+  let decoded = fragment;
+  try {
+    decoded = decodeURIComponent(fragment);
+  } catch (e) {
+  }
+  return document.getElementById(decoded) || document.getElementById(fragment) || document.getElementsByName(decoded)[0] || null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getHashTargetElement, "getHashTargetElement");
+
+
+
+exports.getHashTargetElement = getHashTargetElement;

package/dist/chunk-R5JIFR6B.cjs

@@ -0,0 +1,42 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/agent-json-ld.ts
+function pruneUndefined(object) {
+  const result = {};
+  for (const [key, value] of Object.entries(object)) {
+    if (value !== void 0 && value !== null && value !== "") result[key] = value;
+  }
+  return result;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, pruneUndefined, "pruneUndefined");
+function serializeJsonLd(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, serializeJsonLd, "serializeJsonLd");
+function renderFarmAgentJsonLd(config, context) {
+  const base = pruneUndefined({
+    name: _nullishCoalesce(_nullishCoalesce(config.name, () => ( context.siteName)), () => ( context.title)),
+    url: _nullishCoalesce(config.url, () => ( context.metadataBase)),
+    description: _nullishCoalesce(config.description, () => ( context.description)),
+    logo: config.logo,
+    sameAs: config.sameAs && config.sameAs.length > 0 ? config.sameAs : void 0
+  });
+  const object = {
+    "@context": "https://schema.org",
+    "@type": config.type || "Organization",
+    ...base,
+    ...config.properties || {}
+  };
+  if (Object.keys(object).length <= 2 && !config.properties) {
+    return "";
+  }
+  return `<script type="application/ld+json">${serializeJsonLd(object)}</script>`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, renderFarmAgentJsonLd, "renderFarmAgentJsonLd");
+
+
+
+
+exports.serializeJsonLd = serializeJsonLd; exports.renderFarmAgentJsonLd = renderFarmAgentJsonLd;

package/dist/chunk-R6AIILII.cjs

@@ -0,0 +1,193 @@
+"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/plugins/compression.ts
+var _stream = require('stream');
+var _zlib = require('zlib');
+var Q_VALUE = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/;
+function parseEncodingQuality(header) {
+  const qualities = /* @__PURE__ */ new Map();
+  for (const item of header.split(",")) {
+    const [rawEncoding, ...parameters] = item.trim().split(";");
+    const encoding = _optionalChain([rawEncoding, 'optionalAccess', _ => _.trim, 'call', _2 => _2(), 'access', _3 => _3.toLowerCase, 'call', _4 => _4()]);
+    if (!encoding) continue;
+    let quality = 1;
+    for (const parameter of parameters) {
+      const [rawName, rawValue] = parameter.split("=", 2);
+      if (_optionalChain([rawName, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6(), 'access', _7 => _7.toLowerCase, 'call', _8 => _8()]) !== "q") continue;
+      const value = _nullishCoalesce(_optionalChain([rawValue, 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]), () => ( ""));
+      quality = Q_VALUE.test(value) ? Number(value) : 0;
+    }
+    qualities.set(encoding, Math.max(_nullishCoalesce(qualities.get(encoding), () => ( 0)), quality));
+  }
+  return qualities;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseEncodingQuality, "parseEncodingQuality");
+function selectEncoding(header) {
+  if (!header.trim()) return void 0;
+  const qualities = parseEncodingQuality(header);
+  const wildcard = _nullishCoalesce(qualities.get("*"), () => ( 0));
+  const quality = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (encoding) => _nullishCoalesce(qualities.get(encoding), () => ( wildcard)), "quality");
+  const brotli = quality("br");
+  const gzip2 = quality("gzip");
+  if (brotli <= 0 && gzip2 <= 0) return void 0;
+  return brotli >= gzip2 ? "br" : "gzip";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, selectEncoding, "selectEncoding");
+var COMPRESSIBLE_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "application/javascript",
+  "application/json",
+  "application/ndjson",
+  "application/wasm",
+  "application/x-ndjson",
+  "application/xml",
+  // Font formats that store raw glyph tables. `font/woff` and `font/woff2` are
+  // deliberately absent: their payloads are already deflate and brotli streams.
+  "application/vnd.ms-fontobject",
+  "font/otf",
+  "font/ttf"
+]);
+var COMPRESSIBLE_MEDIA_TYPE_SUFFIXES = ["+json", "+xml"];
+function isCompressibleMediaType(mediaType) {
+  if (!mediaType) return false;
+  if (mediaType === "text/event-stream") return false;
+  if (mediaType.startsWith("text/")) return true;
+  if (COMPRESSIBLE_MEDIA_TYPES.has(mediaType)) return true;
+  return COMPRESSIBLE_MEDIA_TYPE_SUFFIXES.some((suffix) => mediaType.endsWith(suffix));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isCompressibleMediaType, "isCompressibleMediaType");
+function isCompressionEligible(request, response) {
+  if (request.method !== "HEAD" && !response.body || response.status === 204 || response.status === 205 || response.status === 304 || response.headers.has("content-encoding") || response.headers.has("content-range") || _optionalChain([response, 'access', _11 => _11.headers, 'access', _12 => _12.get, 'call', _13 => _13("cache-control"), 'optionalAccess', _14 => _14.toLowerCase, 'call', _15 => _15(), 'access', _16 => _16.includes, 'call', _17 => _17("no-transform")])) {
+    return false;
+  }
+  const mediaType = _optionalChain([response, 'access', _18 => _18.headers, 'access', _19 => _19.get, 'call', _20 => _20("content-type"), 'optionalAccess', _21 => _21.split, 'call', _22 => _22(";", 1), 'access', _23 => _23[0], 'optionalAccess', _24 => _24.trim, 'call', _25 => _25(), 'access', _26 => _26.toLowerCase, 'call', _27 => _27()]);
+  return isCompressibleMediaType(mediaType);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isCompressionEligible, "isCompressionEligible");
+function appendVary(headers, value) {
+  const current = headers.get("vary");
+  const values = current ? current.split(",").map((item) => item.trim()).filter(Boolean) : [];
+  if (values.includes("*")) return;
+  if (!values.some((item) => item.toLowerCase() === value.toLowerCase())) {
+    values.push(value);
+  }
+  headers.set("vary", values.join(", "));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendVary, "appendVary");
+var BROTLI_QUALITY = 5;
+function compressedHeaders(response, encoding) {
+  const headers = new Headers(response.headers);
+  headers.set("content-encoding", encoding);
+  headers.delete("content-length");
+  appendVary(headers, "Accept-Encoding");
+  const etag = headers.get("etag");
+  if (etag && !etag.startsWith("W/")) {
+    headers.set("etag", `W/${etag}`);
+  }
+  return headers;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compressedHeaders, "compressedHeaders");
+function compressBufferedResponse(response, text, encoding) {
+  const headers = compressedHeaders(response, encoding);
+  _optionalChain([response, 'access', _28 => _28.body, 'optionalAccess', _29 => _29.cancel, 'call', _30 => _30(), 'access', _31 => _31.catch, 'call', _32 => _32(() => {
+  })]);
+  const input = Buffer.from(text);
+  let cancelled = false;
+  const body = new ReadableStream({
+    start(controller) {
+      const done = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (error, output) => {
+        if (cancelled) return;
+        if (error) {
+          controller.error(error);
+          return;
+        }
+        controller.enqueue(new Uint8Array(output.buffer, output.byteOffset, output.byteLength));
+        controller.close();
+      }, "done");
+      if (encoding === "br") {
+        _zlib.brotliCompress.call(void 0, 
+          input,
+          { params: { [_zlib.constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY } },
+          done
+        );
+      } else {
+        _zlib.gzip.call(void 0, input, done);
+      }
+    },
+    cancel() {
+      cancelled = true;
+    }
+  });
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compressBufferedResponse, "compressBufferedResponse");
+function compressResponse(response, encoding) {
+  const compressor = encoding === "br" ? _zlib.createBrotliCompress.call(void 0, {
+    flush: _zlib.constants.BROTLI_OPERATION_FLUSH,
+    params: { [_zlib.constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY }
+  }) : _zlib.createGzip.call(void 0, { flush: _zlib.constants.Z_SYNC_FLUSH });
+  const input = _stream.Readable.fromWeb(response.body);
+  const output = _stream.pipeline.call(void 0, input, compressor, () => {
+  });
+  const headers = compressedHeaders(response, encoding);
+  return new Response(_stream.Readable.toWeb(output), {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compressResponse, "compressResponse");
+function varyIdentityResponse(response) {
+  const headers = new Headers(response.headers);
+  appendVary(headers, "Accept-Encoding");
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, varyIdentityResponse, "varyIdentityResponse");
+function compressFarmResponse(request, response, bufferedText) {
+  if (!isCompressionEligible(request, response)) return response;
+  if (request.method === "HEAD") return varyIdentityResponse(response);
+  const encoding = selectEncoding(_nullishCoalesce(request.headers.get("accept-encoding"), () => ( "")));
+  if (!encoding) return varyIdentityResponse(response);
+  return bufferedText === void 0 ? compressResponse(response, encoding) : compressBufferedResponse(response, bufferedText, encoding);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compressFarmResponse, "compressFarmResponse");
+function createCompressionPlugin({
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse
+} = {}) {
+  return {
+    name: "farm:compression",
+    enforce: "post",
+    runtime: {
+      after({ request, response, isProd }) {
+        if (!isProd) return;
+        return compressFarmResponse(request, response);
+      }
+    },
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createCompressionPlugin, "createCompressionPlugin");
+
+
+
+
+exports.compressFarmResponse = compressFarmResponse; exports.createCompressionPlugin = createCompressionPlugin;

package/dist/chunk-RG3ZOTG5.cjs

@@ -0,0 +1,34 @@
+"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-cookies.ts
+function parseRequestCookieHeader(header) {
+  if (!_optionalChain([header, 'optionalAccess', _ => _.trim, 'call', _2 => _2()])) return [];
+  return header.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const separatorIndex = part.indexOf("=");
+    if (separatorIndex === -1) {
+      return {
+        name: decodeCookiePart(part),
+        value: ""
+      };
+    }
+    return {
+      name: decodeCookiePart(part.slice(0, separatorIndex).trim()),
+      value: decodeCookiePart(part.slice(separatorIndex + 1).trim())
+    };
+  }).filter((cookie) => cookie.name.length > 0);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseRequestCookieHeader, "parseRequestCookieHeader");
+function decodeCookiePart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch (e) {
+    return value;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, decodeCookiePart, "decodeCookiePart");
+
+
+
+exports.parseRequestCookieHeader = parseRequestCookieHeader;