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

package/dist/chunk-NO3WWW3N.cjs

@@ -0,0 +1,192 @@
+"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/routing/specificity.ts
+var _AmbiguousRouteError = class _AmbiguousRouteError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AmbiguousRouteError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _AmbiguousRouteError, "AmbiguousRouteError");
+var AmbiguousRouteError = _AmbiguousRouteError;
+var _NonTerminalCatchAllRouteError = class _NonTerminalCatchAllRouteError extends TypeError {
+  constructor(message) {
+    super(message);
+    this.name = "NonTerminalCatchAllRouteError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _NonTerminalCatchAllRouteError, "NonTerminalCatchAllRouteError");
+var NonTerminalCatchAllRouteError = _NonTerminalCatchAllRouteError;
+var _DuplicateRouteParameterError = class _DuplicateRouteParameterError extends AmbiguousRouteError {
+  constructor(message) {
+    super(message);
+    this.name = "DuplicateRouteParameterError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _DuplicateRouteParameterError, "DuplicateRouteParameterError");
+var DuplicateRouteParameterError = _DuplicateRouteParameterError;
+var _ReservedRouteParameterError = class _ReservedRouteParameterError extends AmbiguousRouteError {
+  constructor(message) {
+    super(message);
+    this.name = "ReservedRouteParameterError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _ReservedRouteParameterError, "ReservedRouteParameterError");
+var ReservedRouteParameterError = _ReservedRouteParameterError;
+var _BrowserUnstableRouteError = class _BrowserUnstableRouteError extends TypeError {
+  constructor(message) {
+    super(message);
+    this.name = "BrowserUnstableRouteError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _BrowserUnstableRouteError, "BrowserUnstableRouteError");
+var BrowserUnstableRouteError = _BrowserUnstableRouteError;
+var SEGMENT_RANK = {
+  static: 4,
+  dynamic: 3,
+  "catch-all": 1,
+  "optional-catch-all": 0
+};
+var ROUTE_END_RANK = 2;
+function compareRouteSpecificity(left, right) {
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index++) {
+    const leftRank = index < left.length ? SEGMENT_RANK[left[index]] : ROUTE_END_RANK;
+    const rightRank = index < right.length ? SEGMENT_RANK[right[index]] : ROUTE_END_RANK;
+    if (leftRank !== rightRank) return rightRank - leftRank;
+  }
+  return 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compareRouteSpecificity, "compareRouteSpecificity");
+function compareRoutePatternSpecificity(left, right, syntax = "page") {
+  return compareRouteSpecificity(
+    getRoutePatternSpecificity(left, syntax),
+    getRoutePatternSpecificity(right, syntax)
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compareRoutePatternSpecificity, "compareRoutePatternSpecificity");
+var ROUTER_PARAMETER_NAME = "[A-Za-z0-9_$-]+";
+var PAGE_PARAMETER_PATTERN = /^(?:\[\[\.\.\.(.+)\]\]|\[\.\.\.(.+)\]|\[(.+)\])$/;
+var ROUTER_PARAMETER_PATTERN = /^(?:\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]|\[\.\.\.([A-Za-z0-9_$-]+)\]|\[([A-Za-z0-9_$-]+)\]|:([A-Za-z0-9_$-]+)|\*([A-Za-z0-9_$-]+)\??)$/;
+var RESERVED_PARAMETER_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function assertBrowserStableRoutePath(pattern) {
+  if (pattern.includes("\\") || hasControlCharacter(pattern)) {
+    throw new BrowserUnstableRouteError(
+      `Route path "${pattern}" cannot contain backslashes or control characters.`
+    );
+  }
+  for (const segment of pattern.split("/").filter(Boolean)) {
+    if (segment.startsWith("(") && segment.endsWith(")") || segment.startsWith("[") && segment.endsWith("]")) {
+      continue;
+    }
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch (e) {
+    }
+    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasControlCharacter(decoded)) {
+      throw new BrowserUnstableRouteError(
+        `Route path "${pattern}" contains browser-unstable segment "${segment}".`
+      );
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertBrowserStableRoutePath, "assertBrowserStableRoutePath");
+function hasControlCharacter(value) {
+  return Array.from(value).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, hasControlCharacter, "hasControlCharacter");
+function assertUniqueRouteParameters(pattern, syntax = "page") {
+  const parameterPattern = syntax === "router" ? ROUTER_PARAMETER_PATTERN : PAGE_PARAMETER_PATTERN;
+  const names = /* @__PURE__ */ new Set();
+  for (const segment of splitRoutePattern(pattern, syntax)) {
+    const match = parameterPattern.exec(segment);
+    const name = _optionalChain([match, 'optionalAccess', _ => _.slice, 'call', _2 => _2(1), 'access', _3 => _3.find, 'call', _4 => _4(Boolean)]);
+    if (!name) continue;
+    if (RESERVED_PARAMETER_NAMES.has(name)) {
+      throw new ReservedRouteParameterError(
+        `Route parameter "${name}" in route "${pattern}" is reserved. Use a different parameter name.`
+      );
+    }
+    if (names.has(name)) {
+      throw new DuplicateRouteParameterError(
+        `Duplicate route parameter "${name}" in route "${pattern}". Each dynamic segment must use a unique name.`
+      );
+    }
+    names.add(name);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertUniqueRouteParameters, "assertUniqueRouteParameters");
+function splitRoutePattern(pattern, syntax) {
+  return pattern.replace(/\\/g, "/").split("/").filter(Boolean).filter(
+    (segment) => syntax === "api" ? true : !(segment.startsWith("(") && segment.endsWith(")"))
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, splitRoutePattern, "splitRoutePattern");
+function assertTerminalCatchAll(pattern, syntax = "page") {
+  const segments = splitRoutePattern(pattern, syntax);
+  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
+  const catchAllPattern = new RegExp(
+    syntax === "router" ? `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\]|\\*${parameterName}\\??)$` : `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\])$`
+  );
+  const catchAllIndex = segments.findIndex((segment) => catchAllPattern.test(segment));
+  if (catchAllIndex >= 0 && catchAllIndex !== segments.length - 1) {
+    throw new NonTerminalCatchAllRouteError(
+      `Catch-all segment "${segments[catchAllIndex]}" must be the final segment in route "${pattern}".`
+    );
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertTerminalCatchAll, "assertTerminalCatchAll");
+function getRoutePatternShape(pattern, syntax = "page") {
+  assertTerminalCatchAll(pattern, syntax);
+  const segments = splitRoutePattern(pattern, syntax).map((segment) => {
+    const specificity = getPatternSegmentSpecificity(segment, syntax);
+    if (specificity !== "static") return specificity;
+    try {
+      return `static:${decodeURIComponent(segment)}`;
+    } catch (e2) {
+      return `static:${segment}`;
+    }
+  });
+  return segments.length === 0 ? "/" : JSON.stringify(segments);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRoutePatternShape, "getRoutePatternShape");
+function getRoutePatternSpecificity(pattern, syntax = "page") {
+  assertTerminalCatchAll(pattern, syntax);
+  return splitRoutePattern(pattern, syntax).map(
+    (segment) => getPatternSegmentSpecificity(segment, syntax)
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRoutePatternSpecificity, "getRoutePatternSpecificity");
+function getPatternSegmentSpecificity(segment, syntax) {
+  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
+  const supportsColonAndStar = syntax === "router";
+  if (new RegExp(`^\\[\\[\\.\\.\\.${parameterName}\\]\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}\\?$`).test(segment)) {
+    return "optional-catch-all";
+  }
+  if (new RegExp(`^\\[\\.\\.\\.${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}$`).test(segment)) {
+    return "catch-all";
+  }
+  if (new RegExp(`^\\[${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^:${parameterName}$`).test(segment)) {
+    return "dynamic";
+  }
+  return "static";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getPatternSegmentSpecificity, "getPatternSegmentSpecificity");
+
+
+
+
+
+
+
+
+
+
+
+exports.AmbiguousRouteError = AmbiguousRouteError; exports.NonTerminalCatchAllRouteError = NonTerminalCatchAllRouteError; exports.compareRouteSpecificity = compareRouteSpecificity; exports.compareRoutePatternSpecificity = compareRoutePatternSpecificity; exports.assertBrowserStableRoutePath = assertBrowserStableRoutePath; exports.assertUniqueRouteParameters = assertUniqueRouteParameters; exports.assertTerminalCatchAll = assertTerminalCatchAll; exports.getRoutePatternShape = getRoutePatternShape; exports.getRoutePatternSpecificity = getRoutePatternSpecificity;

package/dist/chunk-NPC7VWJE.mjs

@@ -0,0 +1,277 @@
+import {
+  readFarmI18nCatalogs
+} from "./chunk-QCFBDFRS.mjs";
+import {
+  resolveFarmLocaleRequest
+} from "./chunk-GCXWJJKH.mjs";
+import {
+  _setFarmI18nSnapshotResolver
+} from "./chunk-C4NCTZLM.mjs";
+import {
+  getFarmLocaleDirection
+} from "./chunk-L3KT7IXV.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/i18n/server.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// src/i18n/runtime.ts
+import IntlMessageFormat from "intl-messageformat";
+var _FarmI18nRuntime = class _FarmI18nRuntime {
+  constructor(config, catalogs = {}) {
+    this.compiled = /* @__PURE__ */ new Map();
+    this.warnedMissing = /* @__PURE__ */ new Set();
+    this.config = config;
+    this.catalogs = catalogs;
+  }
+  async initialize() {
+    if (!this.config.enabled) return;
+    const bundle = await readFarmI18nCatalogs(this.config);
+    this.replaceCatalogs(bundle.catalogs);
+  }
+  async reload() {
+    await this.initialize();
+  }
+  replaceCatalogs(catalogs) {
+    this.catalogs = catalogs;
+    this.compiled.clear();
+    this.warnedMissing.clear();
+  }
+  getCatalogs() {
+    return Object.fromEntries(
+      Object.entries(this.catalogs).map(([locale, catalog]) => [locale, { ...catalog }])
+    );
+  }
+  resolveRequest(request, options = {}) {
+    return resolveFarmLocaleRequest(request, this.config, options);
+  }
+  translate(locale, key, values) {
+    const result = this.formatMessage(locale, key, values);
+    if (Array.isArray(result) && result.some((part) => typeof part !== "string")) {
+      throw new Error(`Farm i18n message "${key}" contains rich content. Render it with t.rich().`);
+    }
+    return Array.isArray(result) ? result.join("") : String(result);
+  }
+  translateRich(locale, key, values) {
+    const result = this.formatMessage(locale, key, values);
+    return Array.isArray(result) && result.length === 1 ? result[0] : result;
+  }
+  getRawMessage(locale, key) {
+    return this.resolveMessage(locale, key);
+  }
+  hasMessage(locale, key) {
+    return this.readOwnMessage(locale, key) !== void 0;
+  }
+  getClientSnapshot(resolution) {
+    return {
+      locale: resolution.locale,
+      source: resolution.source,
+      locales: this.config.locales,
+      defaultLocale: this.config.defaultLocale,
+      routing: this.config.routing,
+      basePath: this.config.basePath,
+      cookie: this.config.cookie,
+      direction: getFarmLocaleDirection(resolution.locale, this.config.direction),
+      messages: {
+        ...this.catalogs[this.config.fallbackLocale],
+        ...this.catalogs[resolution.locale]
+      }
+    };
+  }
+  formatMessage(locale, key, values) {
+    const message = this.resolveMessage(locale, key);
+    const cacheKey = `${locale}\0${key}\0${message}`;
+    let formatter = this.compiled.get(cacheKey);
+    if (!formatter) {
+      formatter = new IntlMessageFormat(message, locale);
+      this.compiled.set(cacheKey, formatter);
+    }
+    return formatter.format(values);
+  }
+  // Look up a message by own-property only. A key named after an
+  // Object.prototype member (toString, valueOf, constructor, ...) must resolve
+  // to a real catalog entry or undefined, never the inherited prototype value
+  // (mirrors the own-property handling added to catalog.ts in #454).
+  readOwnMessage(locale, key) {
+    const direct = this.catalogs[locale];
+    if (direct && Object.prototype.hasOwnProperty.call(direct, key)) return direct[key];
+    const fallback = this.catalogs[this.config.fallbackLocale];
+    if (fallback && Object.prototype.hasOwnProperty.call(fallback, key)) return fallback[key];
+    return void 0;
+  }
+  resolveMessage(locale, key) {
+    const message = this.readOwnMessage(locale, key);
+    if (message !== void 0) return message;
+    if (this.config.strict) {
+      throw new Error(`Missing Farm i18n message "${key}" for locale "${locale}".`);
+    }
+    const warningKey = `${locale}:${key}`;
+    if (!this.warnedMissing.has(warningKey)) {
+      this.warnedMissing.add(warningKey);
+      console.warn(`[Farm.js] Missing i18n message "${key}" for locale "${locale}".`);
+    }
+    return key;
+  }
+};
+__name(_FarmI18nRuntime, "FarmI18nRuntime");
+var FarmI18nRuntime = _FarmI18nRuntime;
+function createFarmI18nRuntime(config, catalogs) {
+  return new FarmI18nRuntime(config, catalogs);
+}
+__name(createFarmI18nRuntime, "createFarmI18nRuntime");
+
+// src/i18n/server.ts
+var FARM_I18N_REQUEST_STORE = /* @__PURE__ */ Symbol.for("farm.i18n.requestStore");
+var FARM_I18N_DEFAULT_RUNTIME = /* @__PURE__ */ Symbol.for("farm.i18n.defaultRuntime");
+function getRequestStore() {
+  const state = globalThis;
+  return state[FARM_I18N_REQUEST_STORE] ?? (state[FARM_I18N_REQUEST_STORE] = new AsyncLocalStorage());
+}
+__name(getRequestStore, "getRequestStore");
+function getState() {
+  const state = getRequestStore().getStore();
+  if (!state) {
+    throw new Error(
+      "No Farm i18n request context is active. Use this API while rendering, inside an API route, or use createTranslator(locale)."
+    );
+  }
+  return state;
+}
+__name(getState, "getState");
+function _setDefaultFarmI18nRuntime(runtime) {
+  globalThis[FARM_I18N_DEFAULT_RUNTIME] = runtime;
+}
+__name(_setDefaultFarmI18nRuntime, "_setDefaultFarmI18nRuntime");
+async function _runWithFarmI18nRequest(runtime, request, fn, options = {}) {
+  const resolution = runtime.resolveRequest(request, options);
+  const state = {
+    runtime,
+    resolution,
+    snapshot: runtime.getClientSnapshot(resolution)
+  };
+  return getRequestStore().run(state, () => fn(resolution));
+}
+__name(_runWithFarmI18nRequest, "_runWithFarmI18nRequest");
+async function runWithLocale(locale, fn) {
+  const runtime = getDefaultRuntime();
+  assertLocale(runtime, locale);
+  const resolution = {
+    locale,
+    source: "explicit",
+    pathname: "/",
+    persist: false
+  };
+  const state = {
+    runtime,
+    resolution,
+    snapshot: runtime.getClientSnapshot(resolution)
+  };
+  return getRequestStore().run(state, fn);
+}
+__name(runWithLocale, "runWithLocale");
+function getLocale() {
+  return getState().resolution.locale;
+}
+__name(getLocale, "getLocale");
+function getLocaleSource() {
+  return getState().resolution.source;
+}
+__name(getLocaleSource, "getLocaleSource");
+var t = createTranslatorFromState(() => getState());
+function createTranslator(locale) {
+  const runtime = getDefaultRuntime();
+  assertLocale(runtime, locale);
+  return createTranslatorFromState(() => ({
+    runtime,
+    resolution: {
+      locale,
+      source: "explicit",
+      pathname: "/",
+      persist: false
+    },
+    snapshot: runtime.getClientSnapshot({
+      locale,
+      source: "explicit",
+      pathname: "/",
+      persist: false
+    })
+  }));
+}
+__name(createTranslator, "createTranslator");
+function getFarmI18nClientSnapshot() {
+  return getRequestStore().getStore()?.snapshot;
+}
+__name(getFarmI18nClientSnapshot, "getFarmI18nClientSnapshot");
+var format = {
+  number(value, options) {
+    return new Intl.NumberFormat(getLocale(), options).format(value);
+  },
+  currency(value, currency, options = {}) {
+    return new Intl.NumberFormat(getLocale(), {
+      ...options,
+      style: "currency",
+      currency
+    }).format(value);
+  },
+  date(value, options) {
+    return new Intl.DateTimeFormat(getLocale(), options).format(value);
+  },
+  relativeTime(value, unit, options) {
+    return new Intl.RelativeTimeFormat(getLocale(), options).format(value, unit);
+  },
+  list(values, options) {
+    const ListFormat = Intl.ListFormat;
+    return new ListFormat(getLocale(), options).format(Array.from(values));
+  }
+};
+function getDefaultRuntime() {
+  const runtime = globalThis[FARM_I18N_DEFAULT_RUNTIME];
+  if (!runtime?.config.enabled) {
+    throw new Error("Farm i18n is not configured for this application.");
+  }
+  return runtime;
+}
+__name(getDefaultRuntime, "getDefaultRuntime");
+function assertLocale(runtime, locale) {
+  if (!runtime.config.locales.includes(locale)) {
+    throw new Error(`Unsupported Farm i18n locale "${locale}".`);
+  }
+}
+__name(assertLocale, "assertLocale");
+function createTranslatorFromState(resolveState) {
+  const translator = /* @__PURE__ */ __name(((key, values) => {
+    const state = resolveState();
+    return state.runtime.translate(state.resolution.locale, key, values);
+  }), "translator");
+  translator.rich = (key, values) => {
+    const state = resolveState();
+    return state.runtime.translateRich(state.resolution.locale, key, values);
+  };
+  translator.raw = (key) => {
+    const state = resolveState();
+    return state.runtime.getRawMessage(state.resolution.locale, key);
+  };
+  translator.has = (key) => {
+    const state = resolveState();
+    return state.runtime.hasMessage(state.resolution.locale, key);
+  };
+  return translator;
+}
+__name(createTranslatorFromState, "createTranslatorFromState");
+_setFarmI18nSnapshotResolver(() => getFarmI18nClientSnapshot());
+
+export {
+  FarmI18nRuntime,
+  createFarmI18nRuntime,
+  _setDefaultFarmI18nRuntime,
+  _runWithFarmI18nRequest,
+  runWithLocale,
+  getLocale,
+  getLocaleSource,
+  t,
+  createTranslator,
+  getFarmI18nClientSnapshot,
+  format
+};

package/dist/chunk-NRDBW4MP.mjs

@@ -0,0 +1,45 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/client/client-reference.ts
+var CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("farm.isolated-hydration.client-reference");
+function markFarmClientReference(boundary, reference) {
+  Object.defineProperty(boundary, CLIENT_REFERENCE, { value: reference });
+}
+__name(markFarmClientReference, "markFarmClientReference");
+function getFarmClientReference(type) {
+  if (!type || typeof type !== "function" && typeof type !== "object") return void 0;
+  return type[CLIENT_REFERENCE];
+}
+__name(getFarmClientReference, "getFarmClientReference");
+var SERVER_TREE_UPDATES = /* @__PURE__ */ Symbol.for("farm.isolated-hydration.server-tree-updates");
+function getListeners() {
+  const shared = globalThis;
+  return shared[SERVER_TREE_UPDATES] ?? (shared[SERVER_TREE_UPDATES] = /* @__PURE__ */ new Set());
+}
+__name(getListeners, "getListeners");
+function subscribeFarmServerTreeUpdates(listener) {
+  const listeners = getListeners();
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+__name(subscribeFarmServerTreeUpdates, "subscribeFarmServerTreeUpdates");
+function updateFarmServerTreeModule(reference, module) {
+  const listeners = globalThis[SERVER_TREE_UPDATES];
+  let updated = 0;
+  if (listeners) {
+    for (const listener of listeners) if (listener(reference, module)) updated++;
+  }
+  return updated;
+}
+__name(updateFarmServerTreeModule, "updateFarmServerTreeModule");
+
+export {
+  markFarmClientReference,
+  getFarmClientReference,
+  subscribeFarmServerTreeUpdates,
+  updateFarmServerTreeModule
+};

package/dist/chunk-NRSN7G7E.mjs

@@ -0,0 +1,42 @@
+import {
+  parseRequestCookieHeader
+} from "./chunk-JM5XPKWH.mjs";
+import {
+  getCurrentRequest
+} from "./chunk-FDR64H6B.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/headers.ts
+function headers() {
+  return new Headers(getCurrentRequest().headers);
+}
+__name(headers, "headers");
+function cookies() {
+  const cookieHeader = getCurrentRequest().headers.get("cookie") || "";
+  const parsed = parseRequestCookieHeader(cookieHeader);
+  return {
+    get(name) {
+      return parsed.find((cookie) => cookie.name === name);
+    },
+    getAll(name) {
+      return name ? parsed.filter((cookie) => cookie.name === name) : [...parsed];
+    },
+    has(name) {
+      return parsed.some((cookie) => cookie.name === name);
+    },
+    toString() {
+      return cookieHeader;
+    },
+    [Symbol.iterator]() {
+      return parsed[Symbol.iterator]();
+    }
+  };
+}
+__name(cookies, "cookies");
+
+export {
+  headers,
+  cookies
+};