@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-UWPLULNK.mjs

@@ -0,0 +1,520 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/storage/index.ts
+import { createStorage, prefixStorage, builtinDrivers } from "unstorage";
+import memoryDriver from "unstorage/drivers/memory";
+var loadModule = /* @__PURE__ */ __name((specifier) => import(
+  /* @vite-ignore */
+  specifier
+), "loadModule");
+var DATABASE_CONNECTORS = {
+  sqlite: {
+    connector: "node-sqlite",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/node-sqlite"), "load")
+  },
+  "node-sqlite": {
+    connector: "node-sqlite",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/node-sqlite"), "load")
+  },
+  sqlite3: {
+    connector: "sqlite3",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/sqlite3"), "load")
+  },
+  "better-sqlite3": {
+    connector: "better-sqlite3",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/better-sqlite3"), "load")
+  },
+  postgres: {
+    connector: "postgresql",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
+  },
+  postgresql: {
+    connector: "postgresql",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
+  },
+  pg: {
+    connector: "postgresql",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
+  },
+  mysql: {
+    connector: "mysql2",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/mysql2"), "load")
+  },
+  mysql2: {
+    connector: "mysql2",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/mysql2"), "load")
+  },
+  pglite: {
+    connector: "pglite",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/pglite"), "load")
+  },
+  planetscale: {
+    connector: "planetscale",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/planetscale"), "load")
+  },
+  libsql: {
+    connector: "libsql",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/node"), "load")
+  },
+  "libsql-node": {
+    connector: "libsql-node",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/node"), "load")
+  },
+  "libsql-http": {
+    connector: "libsql-http",
+    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/http"), "load")
+  }
+};
+function createMemoryStorage() {
+  return createStorage({
+    driver: memoryDriver()
+  });
+}
+__name(createMemoryStorage, "createMemoryStorage");
+var GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farmjs.storage.global");
+function readGlobalStorage() {
+  return globalThis[GLOBAL_STORAGE_KEY];
+}
+__name(readGlobalStorage, "readGlobalStorage");
+function writeGlobalStorage(storage) {
+  globalThis[GLOBAL_STORAGE_KEY] = storage;
+  return storage;
+}
+__name(writeGlobalStorage, "writeGlobalStorage");
+function getActiveGlobalStorage() {
+  const existing = readGlobalStorage();
+  if (existing) {
+    return existing;
+  }
+  return writeGlobalStorage(createMemoryStorage());
+}
+__name(getActiveGlobalStorage, "getActiveGlobalStorage");
+var globalStorage = getActiveGlobalStorage();
+function normalizeMountKey(base) {
+  return (base || "").trim().replace(/^[:/\\]+|[:/\\]+$/g, "").replace(/[\\/]+/g, ":");
+}
+__name(normalizeMountKey, "normalizeMountKey");
+function isDriverInstance(value) {
+  return !!value && typeof value === "object" && typeof value.getItem === "function" && typeof value.getKeys === "function";
+}
+__name(isDriverInstance, "isDriverInstance");
+function isStorageInstance(value) {
+  return !!value && typeof value === "object" && typeof value.mount === "function" && typeof value.getMount === "function";
+}
+__name(isStorageInstance, "isStorageInstance");
+function isStorageClient(value) {
+  return !!value && typeof value === "object" && value.kind === "farm-storage-client" && typeof value.resolveDriver === "function" && typeof value.createStorage === "function";
+}
+__name(isStorageClient, "isStorageClient");
+function isDatabaseDriverName(name) {
+  return name in DATABASE_CONNECTORS;
+}
+__name(isDatabaseDriverName, "isDatabaseDriverName");
+function extractDriverOptions(config) {
+  const source = config;
+  const {
+    client: _client,
+    driver: _driver,
+    mounts: _mounts,
+    options,
+    tableName: _tableName,
+    ...inlineOptions
+  } = source;
+  const hasInlineOptions = Object.keys(inlineOptions).length > 0;
+  if (options && typeof options === "object" && !Array.isArray(options)) {
+    return hasInlineOptions ? { ...inlineOptions, ...options } : options;
+  }
+  if (hasInlineOptions) {
+    return inlineOptions;
+  }
+  return options;
+}
+__name(extractDriverOptions, "extractDriverOptions");
+async function loadBuiltinDriver(name, options) {
+  const modulePath = builtinDrivers[name];
+  if (!modulePath) {
+    throw new Error(`Unsupported storage driver "${name}".`);
+  }
+  const module = await loadModule(modulePath);
+  return module.default(options);
+}
+__name(loadBuiltinDriver, "loadBuiltinDriver");
+async function loadDatabaseDriver(config) {
+  const connectorEntry = DATABASE_CONNECTORS[config.driver];
+  const [{ createDatabase }, connectorModule, db0DriverModule] = await Promise.all([
+    loadModule("db0"),
+    connectorEntry.load(),
+    loadModule("unstorage/drivers/db0")
+  ]);
+  const database = createDatabase(connectorModule.default(extractDriverOptions(config) || {}));
+  const driver = db0DriverModule.default({
+    database,
+    tableName: config.tableName
+  });
+  return {
+    ...driver,
+    async dispose() {
+      await database.dispose();
+    }
+  };
+}
+__name(loadDatabaseDriver, "loadDatabaseDriver");
+async function resolveDriver(config) {
+  if (config && isStorageClient(config)) {
+    return config.resolveDriver();
+  }
+  const driverInput = config?.driver ?? "memory";
+  if (typeof driverInput === "function") {
+    return await driverInput();
+  }
+  if (isDriverInstance(driverInput)) {
+    return driverInput;
+  }
+  if (isDatabaseDriverName(driverInput)) {
+    return loadDatabaseDriver(config);
+  }
+  if (driverInput === "local") {
+    return loadBuiltinDriver("fs-lite", extractDriverOptions(config));
+  }
+  return loadBuiltinDriver(
+    driverInput,
+    extractDriverOptions(config)
+  );
+}
+__name(resolveDriver, "resolveDriver");
+function createStorageClientFromResolver(resolveDriver2) {
+  let driverPromise;
+  let storagePromise;
+  const ensureDriver = /* @__PURE__ */ __name(() => {
+    if (driverPromise) return driverPromise;
+    const pending = Promise.resolve().then(resolveDriver2);
+    driverPromise = pending;
+    void pending.catch(() => {
+      if (driverPromise === pending) {
+        driverPromise = void 0;
+        storagePromise = void 0;
+      }
+    });
+    return pending;
+  }, "ensureDriver");
+  const ensureStorage = /* @__PURE__ */ __name(() => {
+    if (storagePromise) return storagePromise;
+    const pending = ensureDriver().then(
+      (driver) => createStorage({
+        driver
+      })
+    );
+    storagePromise = pending;
+    void pending.catch(() => {
+      if (storagePromise === pending) storagePromise = void 0;
+    });
+    return pending;
+  }, "ensureStorage");
+  const target = {
+    kind: "farm-storage-client",
+    ready: ensureStorage,
+    createStorage: ensureStorage,
+    resolveDriver: ensureDriver
+  };
+  return new Proxy(target, {
+    get(currentTarget, prop, receiver) {
+      if (prop === "then") {
+        return void 0;
+      }
+      if (Reflect.has(currentTarget, prop)) {
+        return Reflect.get(currentTarget, prop, receiver);
+      }
+      return (...args) => ensureStorage().then(async (storage) => {
+        const member = Reflect.get(storage, prop);
+        if (typeof member !== "function") {
+          return member;
+        }
+        const result = Reflect.apply(member, storage, args);
+        if (prop === "dispose") {
+          return Promise.resolve(result).finally(() => {
+            storagePromise = void 0;
+            driverPromise = void 0;
+          });
+        }
+        return result;
+      });
+    }
+  });
+}
+__name(createStorageClientFromResolver, "createStorageClientFromResolver");
+function defineStorageClient(resolveDriver2) {
+  return createStorageClientFromResolver(resolveDriver2);
+}
+__name(defineStorageClient, "defineStorageClient");
+function createStorageClient(config) {
+  return defineStorageClient(() => resolveDriver(config));
+}
+__name(createStorageClient, "createStorageClient");
+function driverStorage(driver) {
+  return defineStorageClient(() => typeof driver === "function" ? driver() : driver);
+}
+__name(driverStorage, "driverStorage");
+function databaseStorage(database, options = {}) {
+  return defineStorageClient(async () => {
+    const db0DriverModule = await loadModule("unstorage/drivers/db0");
+    const { dispose: _dispose, ...driver } = db0DriverModule.default({
+      database,
+      tableName: options.tableName
+    });
+    return driver;
+  });
+}
+__name(databaseStorage, "databaseStorage");
+function memoryStorage() {
+  return createStorageClient({ driver: "memory" });
+}
+__name(memoryStorage, "memoryStorage");
+function localStorage(options = {}) {
+  return createStorageClient({
+    driver: "local",
+    ...options
+  });
+}
+__name(localStorage, "localStorage");
+function sqliteStorage(options) {
+  return createStorageClient({
+    driver: "sqlite",
+    ...options
+  });
+}
+__name(sqliteStorage, "sqliteStorage");
+function mysqlStorage(options) {
+  return createStorageClient({
+    driver: "mysql",
+    ...options
+  });
+}
+__name(mysqlStorage, "mysqlStorage");
+function mysql2Storage(options) {
+  return mysqlStorage(options);
+}
+__name(mysql2Storage, "mysql2Storage");
+function postgresStorage(options) {
+  return createStorageClient({
+    driver: "postgres",
+    ...options
+  });
+}
+__name(postgresStorage, "postgresStorage");
+function pgStorage(options) {
+  return postgresStorage(options);
+}
+__name(pgStorage, "pgStorage");
+function pgliteStorage(options) {
+  return createStorageClient({
+    driver: "pglite",
+    ...options
+  });
+}
+__name(pgliteStorage, "pgliteStorage");
+function planetscaleStorage(options) {
+  return createStorageClient({
+    driver: "planetscale",
+    ...options
+  });
+}
+__name(planetscaleStorage, "planetscaleStorage");
+function libsqlStorage(options) {
+  return createStorageClient({
+    driver: "libsql",
+    ...options
+  });
+}
+__name(libsqlStorage, "libsqlStorage");
+function redisStorage(options) {
+  return createStorageClient({
+    driver: "redis",
+    ...options
+  });
+}
+__name(redisStorage, "redisStorage");
+function s3Storage(options) {
+  return createStorageClient({
+    driver: "s3",
+    ...options
+  });
+}
+__name(s3Storage, "s3Storage");
+function mongodbStorage(options) {
+  return createStorageClient({
+    driver: "mongodb",
+    ...options
+  });
+}
+__name(mongodbStorage, "mongodbStorage");
+function upstashStorage(options) {
+  return createStorageClient({
+    driver: "upstash",
+    ...options
+  });
+}
+__name(upstashStorage, "upstashStorage");
+function netlifyBlobsStorage(options) {
+  return createStorageClient({
+    driver: "netlify-blobs",
+    ...options
+  });
+}
+__name(netlifyBlobsStorage, "netlifyBlobsStorage");
+function vercelKVStorage(options) {
+  return createStorageClient({
+    driver: "vercel-kv",
+    ...options
+  });
+}
+__name(vercelKVStorage, "vercelKVStorage");
+function vercelBlobStorage(options) {
+  return createStorageClient({
+    driver: "vercel-blob",
+    ...options
+  });
+}
+__name(vercelBlobStorage, "vercelBlobStorage");
+async function mountNamespaces(storage, mounts) {
+  if (!mounts) {
+    return;
+  }
+  for (const [base, config] of Object.entries(mounts)) {
+    storage.mount(normalizeMountKey(base), await resolveDriver(config));
+  }
+}
+__name(mountNamespaces, "mountNamespaces");
+async function createFarmStorage(config = {}) {
+  if (isStorageInstance(config)) {
+    return config;
+  }
+  if (isStorageClient(config)) {
+    return config.createStorage();
+  }
+  const rootConfig = isStorageClient(config.client) ? config.client : config;
+  const storage = createStorage({
+    driver: await resolveDriver(rootConfig)
+  });
+  try {
+    await mountNamespaces(storage, config.mounts);
+  } catch (error) {
+    await storage.dispose().catch(() => {
+    });
+    throw error;
+  }
+  return storage;
+}
+__name(createFarmStorage, "createFarmStorage");
+async function resolveStorageRuntimeClient(config) {
+  if (!config || isStorageInstance(config) || isStorageClient(config)) {
+    return void 0;
+  }
+  const client = config.client;
+  if (!client || isStorageInstance(client) || isStorageClient(client)) {
+    return void 0;
+  }
+  return typeof client === "function" ? await client() : client;
+}
+__name(resolveStorageRuntimeClient, "resolveStorageRuntimeClient");
+async function initStorage(config = {}) {
+  globalStorage = getActiveGlobalStorage();
+  const nextStorage = await createFarmStorage(config);
+  const previousStorage = globalStorage;
+  globalStorage = writeGlobalStorage(nextStorage);
+  if (previousStorage !== nextStorage) {
+    await previousStorage.dispose().catch(() => {
+    });
+  }
+  return globalStorage;
+}
+__name(initStorage, "initStorage");
+function getStorage(namespace) {
+  globalStorage = getActiveGlobalStorage();
+  const base = normalizeMountKey(namespace);
+  if (!base) {
+    return globalStorage;
+  }
+  const namespaced = prefixStorage(globalStorage, base);
+  const store = globalStorage;
+  const prefix = `${base}:`;
+  const stripPrefix = /* @__PURE__ */ __name((key) => key.startsWith(prefix) ? key.slice(prefix.length) : key, "stripPrefix");
+  const viewUnwatchers = /* @__PURE__ */ new Set();
+  const releaseViewWatchers = /* @__PURE__ */ __name(async () => {
+    const current = [...viewUnwatchers];
+    viewUnwatchers.clear();
+    await Promise.all(current.map((unwatch) => unwatch()));
+  }, "releaseViewWatchers");
+  return {
+    ...namespaced,
+    // Scope the wipe to the namespace instead of the whole storage, and keep
+    // the caller's base so `clear("sessions")` cannot take unrelated keys with
+    // it. Dropping the argument silently widens a targeted clear into a
+    // namespace-wide delete.
+    async clear(base2, opts) {
+      const keys = await namespaced.getKeys(base2);
+      await Promise.all(keys.map((key) => namespaced.removeItem(key, opts)));
+    },
+    async watch(callback) {
+      const unwatch = await store.watch((event, key) => {
+        if (key.startsWith(prefix)) callback(event, stripPrefix(key));
+      });
+      viewUnwatchers.add(unwatch);
+      return async () => {
+        viewUnwatchers.delete(unwatch);
+        await unwatch();
+      };
+    },
+    async unwatch() {
+      await releaseViewWatchers();
+    },
+    async dispose() {
+      await releaseViewWatchers();
+    },
+    getMount(key = "") {
+      return store.getMount(prefix + key);
+    },
+    getMounts(base2 = "", options) {
+      return store.getMounts(prefix + base2, options).map((mount) => ({ ...mount, base: stripPrefix(mount.base) }));
+    }
+  };
+}
+__name(getStorage, "getStorage");
+async function disposeStorage() {
+  globalStorage = getActiveGlobalStorage();
+  const previousStorage = globalStorage;
+  globalStorage = writeGlobalStorage(createMemoryStorage());
+  await previousStorage.dispose().catch(() => {
+  });
+}
+__name(disposeStorage, "disposeStorage");
+
+export {
+  defineStorageClient,
+  createStorageClient,
+  driverStorage,
+  databaseStorage,
+  memoryStorage,
+  localStorage,
+  sqliteStorage,
+  mysqlStorage,
+  mysql2Storage,
+  postgresStorage,
+  pgStorage,
+  pgliteStorage,
+  planetscaleStorage,
+  libsqlStorage,
+  redisStorage,
+  s3Storage,
+  mongodbStorage,
+  upstashStorage,
+  netlifyBlobsStorage,
+  vercelKVStorage,
+  vercelBlobStorage,
+  createFarmStorage,
+  resolveStorageRuntimeClient,
+  initStorage,
+  getStorage,
+  disposeStorage
+};

package/dist/chunk-UXFQ3UDA.cjs

@@ -0,0 +1,140 @@
+"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 _chunkU4KT7QP3cjs = require('./chunk-U4KT7QP3.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/server/request.ts
+var _async_hooks = require('async_hooks');
+var _stream = require('stream');
+var REQUEST_STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/request-storage");
+function getRequestStore() {
+  const runtime = globalThis;
+  const existing = runtime[REQUEST_STORAGE_KEY];
+  if (existing instanceof _async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new (0, _async_hooks.AsyncLocalStorage)();
+  runtime[REQUEST_STORAGE_KEY] = storage;
+  return storage;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRequestStore, "getRequestStore");
+var requestStore = getRequestStore();
+var REQUEST_READS_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/request-reads");
+function getRequestReads() {
+  const runtime = globalThis;
+  return _nullishCoalesce(runtime[REQUEST_READS_KEY], () => ( (runtime[REQUEST_READS_KEY] = /* @__PURE__ */ new WeakMap())));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRequestReads, "getRequestReads");
+var requestReads = getRequestReads();
+_chunkU4KT7QP3cjs._setCurrentRequestResolver.call(void 0, () => requestStore.getStore());
+function resolveFarmRequestURL(req, options = {}) {
+  if (options.origin) {
+    return new URL(req.url || "/", options.origin);
+  }
+  const forwardedHost = options.trustProxy ? firstForwardedHeaderValue(req.headers["x-forwarded-host"]) : void 0;
+  const fallbackHost = firstForwardedHeaderValue(req.headers.host) || "localhost";
+  const forwardedProto = options.trustProxy ? firstForwardedHeaderValue(req.headers["x-forwarded-proto"]) : void 0;
+  const normalizedProto = _optionalChain([forwardedProto, 'optionalAccess', _ => _.toLowerCase, 'call', _2 => _2()]);
+  const proto = normalizedProto === "https" || normalizedProto === "http" ? normalizedProto : isEncryptedFarmRequest(req) ? "https" : "http";
+  return new URL(req.url || "/", resolveRequestOrigin(proto, forwardedHost, fallbackHost));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmRequestURL, "resolveFarmRequestURL");
+function resolveFarmWebRequestOrigin(request, options = {}) {
+  const url = new URL(request.url);
+  if (!options.trustProxy) return url.origin;
+  const forwardedHost = firstForwardedHeaderValue(
+    _nullishCoalesce(request.headers.get("x-forwarded-host"), () => ( void 0))
+  );
+  const forwardedProto = _optionalChain([firstForwardedHeaderValue, 'call', _3 => _3(
+    _nullishCoalesce(request.headers.get("x-forwarded-proto"), () => ( void 0))
+  ), 'optionalAccess', _4 => _4.toLowerCase, 'call', _5 => _5()]);
+  const proto = forwardedProto === "https" || forwardedProto === "http" ? forwardedProto : url.protocol === "https:" ? "https" : "http";
+  return resolveRequestOrigin(proto, forwardedHost, url.host);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmWebRequestOrigin, "resolveFarmWebRequestOrigin");
+function createWebRequestFromFarmRequest(req, options = {}) {
+  const fullUrl = resolveFarmRequestURL(req, options).toString();
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
+      }
+      continue;
+    }
+    headers.set(key, value);
+  }
+  const method = (req.method || "GET").toUpperCase();
+  const init = {
+    method: req.method,
+    headers
+  };
+  if (method !== "GET" && method !== "HEAD") {
+    init.body = _stream.Readable.toWeb(req);
+    init.duplex = "half";
+  }
+  return new Request(fullUrl, init);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createWebRequestFromFarmRequest, "createWebRequestFromFarmRequest");
+function isEncryptedFarmRequest(req) {
+  return Boolean(_optionalChain([req, 'access', _6 => _6.socket, 'optionalAccess', _7 => _7.encrypted]));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isEncryptedFarmRequest, "isEncryptedFarmRequest");
+function firstForwardedHeaderValue(value) {
+  const first = Array.isArray(value) ? value[0] : value;
+  const token = _optionalChain([first, 'optionalAccess', _8 => _8.split, 'call', _9 => _9(",", 1), 'access', _10 => _10[0], 'optionalAccess', _11 => _11.trim, 'call', _12 => _12()]);
+  return token || void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, firstForwardedHeaderValue, "firstForwardedHeaderValue");
+function resolveRequestOrigin(proto, host, fallback) {
+  for (const candidate of [host, fallback, "localhost"]) {
+    if (!candidate) continue;
+    if (/[\s/?#@\\]/u.test(candidate)) continue;
+    try {
+      const url = new URL(`${proto}://${candidate}`);
+      if (url.username || url.password || url.pathname !== "/" || url.search || url.hash) continue;
+      return url.origin;
+    } catch (e) {
+    }
+  }
+  return `${proto}://localhost`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveRequestOrigin, "resolveRequestOrigin");
+async function _runWithCurrentRequest(request, fn) {
+  return requestStore.run(request, fn);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithCurrentRequest, "_runWithCurrentRequest");
+function getCurrentRequest() {
+  const request = requestStore.getStore();
+  if (!request) {
+    throw new Error(
+      "No current request is available. getCurrentRequest() can only be used during server rendering."
+    );
+  }
+  requestReads.set(request, (_nullishCoalesce(requestReads.get(request), () => ( 0))) + 1);
+  return request;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getCurrentRequest, "getCurrentRequest");
+function _getRequestReadCount(request = requestStore.getStore()) {
+  return request ? _nullishCoalesce(requestReads.get(request), () => ( 0)) : 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _getRequestReadCount, "_getRequestReadCount");
+function getCurrentRequestOrNull() {
+  return _nullishCoalesce(requestStore.getStore(), () => ( null));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getCurrentRequestOrNull, "getCurrentRequestOrNull");
+
+
+
+
+
+
+
+
+
+exports.resolveFarmRequestURL = resolveFarmRequestURL; exports.resolveFarmWebRequestOrigin = resolveFarmWebRequestOrigin; exports.createWebRequestFromFarmRequest = createWebRequestFromFarmRequest; exports._runWithCurrentRequest = _runWithCurrentRequest; exports.getCurrentRequest = getCurrentRequest; exports._getRequestReadCount = _getRequestReadCount; exports.getCurrentRequestOrNull = getCurrentRequestOrNull;