@farm.js/core 0.1.17 → 0.1.18

package/dist/chunk-YA6LLTIJ.cjs

@@ -0,0 +1,411 @@
+"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 _chunkE3UK5IIBcjs = require('./chunk-E3UK5IIB.cjs');
+
+
+var _chunk5ZSWG4UXcjs = require('./chunk-5ZSWG4UX.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/plugins/infra-analytics.ts
+var FARM_PRERENDER_ENV = "FARM_PRERENDER";
+var DEFAULT_URL = "https://app.farmjs.dev";
+var EVENTS_PATH = "/api/telemetry/v1/events";
+var INGESTION_KEY = /^fti_[A-Za-z0-9_-]{43}$/;
+var API_KEY = /^farmjs_[A-Za-z0-9_-]{32}$/;
+var PROJECT = /^proj_[0-9a-f-]{36}$/;
+var ENVIRONMENTS = ["production", "staging", "development"];
+var METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "QUERY"]);
+var MAX_QUEUE = 500;
+var MAX_AGE = 3e5;
+var MAX_ATTEMPTS = 5;
+var FLUSH_BUDGET = 5e3;
+var TIMEOUT = 2e3;
+var encoder = new TextEncoder();
+var sleep = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (ms) => new Promise((resolve) => setTimeout(resolve, ms)), "sleep");
+var uuid = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => globalThis.crypto.randomUUID(), "uuid");
+function processEnv() {
+  return _nullishCoalesce(_optionalChain([globalThis, 'access', _ => _.process, 'optionalAccess', _2 => _2.env]), () => ( {}));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, processEnv, "processEnv");
+function defaultFarmInfraEnvironment(env = processEnv()) {
+  const explicit = env.FARMJS_ENVIRONMENT;
+  if (explicit && ENVIRONMENTS.includes(explicit)) return explicit;
+  if (env.VERCEL_ENV === "production") return "production";
+  if (env.VERCEL_ENV === "preview") return "staging";
+  if (env.VERCEL_ENV === "development") return "development";
+  return env.NODE_ENV === "production" ? "production" : "development";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defaultFarmInfraEnvironment, "defaultFarmInfraEnvironment");
+function resolveFarmInfraAnalytics(env = processEnv()) {
+  const key = _optionalChain([env, 'access', _3 => _3.FARMJS_API_KEY, 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]);
+  if (!key || env[FARM_PRERENDER_ENV] === "1") return { off: null };
+  const ingestionKey = INGESTION_KEY.test(key);
+  const projectId = _optionalChain([env, 'access', _6 => _6.FARMJS_PROJECT_ID, 'optionalAccess', _7 => _7.trim, 'call', _8 => _8()]) || void 0;
+  if (!ingestionKey && !projectId) return { off: null };
+  if (!ingestionKey && !API_KEY.test(key)) {
+    return {
+      off: "FARMJS_API_KEY isn't a Farm Infra API key (farmjs_\u2026) or write-only key (fti_\u2026)"
+    };
+  }
+  if (!ingestionKey && !PROJECT.test(projectId)) {
+    return { off: "FARMJS_PROJECT_ID isn't a Farm Infra project ID (proj_\u2026)" };
+  }
+  if (env.FARMJS_ENVIRONMENT && !ENVIRONMENTS.includes(env.FARMJS_ENVIRONMENT)) {
+    return { off: "FARMJS_ENVIRONMENT must be production, staging or development" };
+  }
+  let endpoint;
+  try {
+    endpoint = new URL(EVENTS_PATH, _optionalChain([env, 'access', _9 => _9.FARMJS_API_URL, 'optionalAccess', _10 => _10.trim, 'call', _11 => _11()]) || DEFAULT_URL);
+  } catch (e) {
+    return { off: "FARMJS_API_URL isn't a URL" };
+  }
+  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(endpoint.hostname);
+  if (endpoint.protocol !== "https:" && !(endpoint.protocol === "http:" && loopback) || endpoint.username || endpoint.password) {
+    return { off: "FARMJS_API_URL must use HTTPS (HTTP only for localhost)" };
+  }
+  return {
+    options: {
+      endpoint: endpoint.href,
+      key,
+      ...ingestionKey ? {} : { projectId, environment: defaultFarmInfraEnvironment(env) }
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmInfraAnalytics, "resolveFarmInfraAnalytics");
+var AGENT_TOKENS = [
+  ["ChatGPT-User", "openai", "agent"],
+  ["OAI-SearchBot", "openai", "crawler"],
+  ["GPTBot", "openai", "crawler"],
+  ["Claude-User", "anthropic", "agent"],
+  ["Claude-SearchBot", "anthropic", "crawler"],
+  ["ClaudeBot", "anthropic", "crawler"]
+];
+var AGENT_PATTERNS = AGENT_TOKENS.map(([token, family, category]) => ({
+  pattern: new RegExp(`(?:^|[\\s;(])${token}(?=[/\\s;)]|$)`, "i"),
+  family,
+  category
+}));
+function classifyFarmInfraAgent(userAgent) {
+  const value = (_nullishCoalesce(userAgent, () => ( ""))).slice(0, 2048);
+  const matches = AGENT_PATTERNS.filter(({ pattern }) => pattern.test(value));
+  if (matches.length === 1) {
+    const { family, category } = matches[0];
+    return { family, category, identity: "self-reported" };
+  }
+  return { family: "unknown", category: "unknown", identity: "unknown" };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, classifyFarmInfraAgent, "classifyFarmInfraAgent");
+function routeTemplate(pattern) {
+  return typeof pattern === "string" && pattern.length <= 256 && /^\/(?!\/)[a-zA-Z0-9_./:[\]()*-]*$/.test(pattern) ? pattern : "/[unmatched]";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, routeTemplate, "routeTemplate");
+function duration(value) {
+  return Number.isFinite(value) ? Math.min(864e5, Math.max(0, value)) : 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, duration, "duration");
+function isToolEvent(value) {
+  if (!value || typeof value !== "object") return false;
+  const event = value;
+  return event.type === "mcp.tool.complete" && typeof event.tool === "string" && /^[a-zA-Z0-9_.:/-]{1,128}$/.test(event.tool) && (event.outcome === "success" || event.outcome === "error") && typeof event.durationMs === "number" && Number.isFinite(event.durationMs);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isToolEvent, "isToolEvent");
+function retryAt(value, now) {
+  if (!value) return now;
+  if (/^\d+$/.test(value.trim())) return now + Math.min(Number(value), 86400) * 1e3;
+  const date = Date.parse(value);
+  return Number.isFinite(date) ? Math.max(now, Math.min(date, now + 864e5)) : now;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, retryAt, "retryAt");
+function createFarmInfraAnalyticsExporter(options, send = (input, init) => fetch(input, init)) {
+  const requestHeaders = {
+    "content-type": "application/json",
+    authorization: `Bearer ${options.key}`
+  };
+  if (!INGESTION_KEY.test(options.key)) {
+    requestHeaders["x-farm-project"] = options.projectId;
+    requestHeaders["x-farm-environment"] = _nullishCoalesce(options.environment, () => ( defaultFarmInfraEnvironment()));
+  }
+  const queue = [];
+  let stopped = false;
+  let closing = false;
+  let pending;
+  let notBefore = 0;
+  let active;
+  let inFlight = /* @__PURE__ */ new Set();
+  const diagnostic = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (event) => {
+    try {
+      void Promise.resolve(_optionalChain([options, 'access', _12 => _12.onDiagnostic, 'optionalCall', _13 => _13(event)])).catch(() => {
+      });
+    } catch (e2) {
+    }
+  }, "diagnostic");
+  const expired = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (item, now) => !inFlight.has(item) && (now - item.enqueuedAt >= MAX_AGE || item.attempts >= MAX_ATTEMPTS), "expired");
+  function prune() {
+    const now = Date.now();
+    let count = 0;
+    for (let i = queue.length - 1; i >= 0; i--) {
+      if (expired(queue[i], now)) {
+        queue.splice(i, 1);
+        count++;
+      }
+    }
+    if (count) diagnostic({ code: "dropped", count });
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, prune, "prune");
+  function remove(batch) {
+    const sent = new Set(batch);
+    for (let i = queue.length - 1; i >= 0; i--) if (sent.has(queue[i])) queue.splice(i, 1);
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, remove, "remove");
+  function enqueue(event) {
+    if (stopped || closing) return;
+    prune();
+    if (queue.length >= MAX_QUEUE) {
+      diagnostic({ code: "dropped", count: 1 });
+      return;
+    }
+    queue.push({ event, enqueuedAt: Date.now(), attempts: 0 });
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, enqueue, "enqueue");
+  async function drain() {
+    const deadline = Date.now() + FLUSH_BUDGET;
+    await sleep(25);
+    while (!stopped && queue.length && Date.now() < deadline) {
+      prune();
+      if (!queue.length || notBefore >= deadline) break;
+      if (notBefore > Date.now()) await sleep(notBefore - Date.now());
+      if (stopped || Date.now() >= deadline) break;
+      const batch = queue.slice(0, 50);
+      const body = JSON.stringify({ schemaVersion: 1, events: batch.map(({ event }) => event) });
+      if (encoder.encode(body).length > 128 * 1024) {
+        queue.splice(0, batch.length);
+        diagnostic({ code: "dropped", count: batch.length });
+        continue;
+      }
+      for (const item of batch) item.attempts++;
+      inFlight = new Set(batch);
+      active = new AbortController();
+      const timeout = setTimeout(() => _optionalChain([active, 'optionalAccess', _14 => _14.abort, 'call', _15 => _15()]), Math.min(TIMEOUT, deadline - Date.now()));
+      let status;
+      try {
+        const response = await send(options.endpoint, {
+          method: "POST",
+          redirect: "error",
+          signal: active.signal,
+          headers: requestHeaders,
+          body
+        });
+        status = response.status;
+        void _optionalChain([response, 'access', _16 => _16.body, 'optionalAccess', _17 => _17.cancel, 'call', _18 => _18(), 'access', _19 => _19.catch, 'call', _20 => _20(() => {
+        })]);
+        if (response.ok) {
+          remove(batch);
+          continue;
+        }
+        if ([400, 401, 403, 404, 413, 415].includes(status) || status >= 300 && status < 400) {
+          stopped = true;
+          queue.length = 0;
+          diagnostic({ code: "disabled", status });
+          break;
+        }
+        if (status !== 408 && status !== 429 && status < 500) {
+          remove(batch);
+          diagnostic({ code: "dropped", count: batch.length, status });
+          continue;
+        }
+        notBefore = Math.max(notBefore, retryAt(response.headers.get("retry-after"), Date.now()));
+      } catch (e3) {
+      } finally {
+        clearTimeout(timeout);
+        active = void 0;
+        inFlight.clear();
+      }
+      notBefore = Math.max(
+        notBefore,
+        Date.now() + Math.min(3e4, 500 * 2 ** (batch[0].attempts - 1))
+      );
+      diagnostic({ code: "retry", ...status === void 0 ? {} : { status } });
+    }
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, drain, "drain");
+  function flush() {
+    if (stopped || !queue.length || notBefore > Date.now() + FLUSH_BUDGET)
+      return _nullishCoalesce(pending, () => ( Promise.resolve()));
+    _nullishCoalesce(pending, () => ( (pending = drain().catch(() => {
+    }).finally(() => {
+      pending = void 0;
+    }))));
+    return pending;
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, flush, "flush");
+  async function close() {
+    if (closing) {
+      await pending;
+      return;
+    }
+    closing = true;
+    await flush();
+    stopped = true;
+    _optionalChain([active, 'optionalAccess', _21 => _21.abort, 'call', _22 => _22()]);
+    if (queue.length) diagnostic({ code: "dropped", count: queue.length });
+    queue.length = 0;
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, close, "close");
+  return { enqueue, flush, close };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmInfraAnalyticsExporter, "createFarmInfraAnalyticsExporter");
+var CONTEXT_KEY = "farm.infra.analytics";
+function beginRequest(request, pattern, waitUntil) {
+  return {
+    id: uuid(),
+    agent: classifyFarmInfraAgent(request.headers.get("user-agent")),
+    route: routeTemplate(pattern),
+    completed: false,
+    waitUntil
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, beginRequest, "beginRequest");
+function requestEvent(metadata, method, status, durationMs) {
+  return {
+    id: uuid(),
+    requestId: metadata.id,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    route: metadata.route,
+    agent: metadata.agent,
+    kind: "request",
+    method,
+    status,
+    durationMs: duration(durationMs)
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, requestEvent, "requestEvent");
+function farmInfraAnalyticsPlugin(options, send) {
+  const contextKey = `${CONTEXT_KEY}.${uuid()}`;
+  return {
+    name: "farm:infra-analytics",
+    enforce: "post",
+    setup(context) {
+      const state = { exporter: createFarmInfraAnalyticsExporter(options, send) };
+      context.lifecycle.onShutdown(async () => {
+        _optionalChain([state, 'access', _23 => _23.unsubscribe, 'optionalCall', _24 => _24()]);
+        await state.exporter.close();
+      });
+      return state;
+    },
+    runtime: {
+      start(context) {
+        const { exporter } = context.state;
+        context.state.unsubscribe = _chunkE3UK5IIBcjs.onFarmEvent.call(void 0, 
+          (event) => {
+            if (!isToolEvent(event)) return;
+            const request = _chunk5ZSWG4UXcjs.getCurrentRequestOrNull.call(void 0, );
+            if (!request) return;
+            const metadata = context.requestContext.get(request, contextKey);
+            if (!metadata) return;
+            exporter.enqueue({
+              id: uuid(),
+              requestId: metadata.id,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              route: metadata.route,
+              agent: metadata.agent,
+              kind: "mcp.tool",
+              tool: event.tool,
+              outcome: event.outcome,
+              durationMs: duration(event.durationMs)
+            });
+            metadata.waitUntil(exporter.flush());
+          },
+          { unfiltered: true }
+        );
+      },
+      before(event) {
+        if (event.kind === "asset" || !event.state) return;
+        event.req.set(
+          contextKey,
+          beginRequest(event.request, _optionalChain([event, 'access', _25 => _25.route, 'optionalAccess', _26 => _26.pattern]), event.waitUntil)
+        );
+      },
+      after(event) {
+        const metadata = event.req.get(contextKey);
+        if (!metadata || metadata.completed || !event.state) return;
+        metadata.completed = true;
+        if (!METHODS.has(event.request.method)) return;
+        event.state.exporter.enqueue(
+          requestEvent(metadata, event.request.method, event.response.status, event.durationMs)
+        );
+        event.waitUntil(event.state.exporter.flush());
+      },
+      // Unhandled exceptions have no final HTTP status at this boundary. Do not fabricate a 500.
+      error(event) {
+        const metadata = event.req.get(contextKey);
+        if (metadata) metadata.completed = true;
+        if (event.state) event.waitUntil(event.state.exporter.flush());
+      }
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, farmInfraAnalyticsPlugin, "farmInfraAnalyticsPlugin");
+function farmInfraAnalyticsRecorder(options, send) {
+  const exporter = createFarmInfraAnalyticsExporter(options, send);
+  return {
+    async record(request, runtime, waitUntil, handler) {
+      if (runtime.kind === "asset") return handler();
+      const background = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (promise) => waitUntil ? waitUntil(promise) : void promise.catch(() => {
+      }), "background");
+      const metadata = beginRequest(request, _optionalChain([runtime, 'access', _27 => _27.route, 'optionalAccess', _28 => _28.pattern]), background);
+      const startedAt = performance.now();
+      let response;
+      try {
+        response = await handler();
+      } catch (error) {
+        background(exporter.flush());
+        throw error;
+      }
+      if (METHODS.has(request.method)) {
+        exporter.enqueue(
+          requestEvent(metadata, request.method, response.status, performance.now() - startedAt)
+        );
+      }
+      background(exporter.flush());
+      return response;
+    },
+    close: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => exporter.close(), "close")
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, farmInfraAnalyticsRecorder, "farmInfraAnalyticsRecorder");
+function linkedOptions(env, warn) {
+  const resolved = resolveFarmInfraAnalytics(env);
+  if ("off" in resolved) {
+    if (resolved.off) warn(`[Farm] Farm Infra analytics is off: ${resolved.off}.`);
+    return null;
+  }
+  return {
+    ...resolved.options,
+    onDiagnostic(event) {
+      if (event.code === "disabled") {
+        warn(
+          `[Farm] Farm Infra analytics stopped: Farm Infra answered ${event.status}. Check FARMJS_API_KEY and FARMJS_PROJECT_ID, then restart the server.`
+        );
+      }
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, linkedOptions, "linkedOptions");
+function createFarmInfraAnalyticsPlugin(env = processEnv(), warn = console.warn) {
+  const options = linkedOptions(env, warn);
+  return options ? farmInfraAnalyticsPlugin(options) : null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmInfraAnalyticsPlugin, "createFarmInfraAnalyticsPlugin");
+function createFarmInfraAnalyticsRecorder(env = processEnv(), warn = console.warn) {
+  const options = linkedOptions(env, warn);
+  return options ? farmInfraAnalyticsRecorder(options) : null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmInfraAnalyticsRecorder, "createFarmInfraAnalyticsRecorder");
+
+
+
+
+
+exports.FARM_PRERENDER_ENV = FARM_PRERENDER_ENV; exports.createFarmInfraAnalyticsPlugin = createFarmInfraAnalyticsPlugin; exports.createFarmInfraAnalyticsRecorder = createFarmInfraAnalyticsRecorder;

package/dist/chunk-YFPGHF5F.cjs

@@ -0,0 +1,202 @@
+"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/image-config.ts
+var DEFAULT_FARM_IMAGE_PATH = "/_farm/image";
+var DEFAULT_FARM_IMAGE_DEVICE_SIZES = [
+  640,
+  750,
+  828,
+  1080,
+  1200,
+  1920,
+  2048,
+  3840
+];
+var DEFAULT_FARM_IMAGE_SIZES = [16, 32, 48, 64, 96, 128, 256, 384];
+var DEFAULT_FARM_IMAGE_QUALITIES = [75];
+var DEFAULT_FARM_IMAGE_FORMATS = ["image/webp"];
+var SIZE_UNITS = {
+  b: 1,
+  kb: 1e3,
+  mb: 1e6,
+  gb: 1e9,
+  kib: 1024,
+  mib: 1048576,
+  gib: 1073741824
+};
+function resolveFarmImageConfig(config) {
+  const path = normalizeImagePath(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _ => _.path]), () => ( DEFAULT_FARM_IMAGE_PATH)));
+  const deviceSizes = normalizeIntegerList(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _2 => _2.deviceSizes]), () => ( DEFAULT_FARM_IMAGE_DEVICE_SIZES)),
+    "images.deviceSizes"
+  );
+  const imageSizes = normalizeIntegerList(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _3 => _3.imageSizes]), () => ( DEFAULT_FARM_IMAGE_SIZES)),
+    "images.imageSizes"
+  );
+  const qualities = normalizeIntegerList(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _4 => _4.qualities]), () => ( DEFAULT_FARM_IMAGE_QUALITIES)),
+    "images.qualities",
+    100
+  );
+  const formats = [...new Set(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _5 => _5.formats]), () => ( DEFAULT_FARM_IMAGE_FORMATS)))];
+  if (formats.some((format) => format !== "image/avif" && format !== "image/webp")) {
+    throw new TypeError('images.formats only supports "image/avif" and "image/webp"');
+  }
+  const minimumCacheTTL = normalizeNonNegativeInteger(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _6 => _6.minimumCacheTTL]), () => ( 60)),
+    "images.minimumCacheTTL"
+  );
+  const maximumRedirects = normalizeNonNegativeInteger(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _7 => _7.maximumRedirects]), () => ( 3)),
+    "images.maximumRedirects"
+  );
+  return Object.freeze({
+    provider: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _8 => _8.provider]), () => ( "auto")),
+    path,
+    domains: Object.freeze([
+      ...new Set(
+        (_nullishCoalesce(_optionalChain([config, 'optionalAccess', _9 => _9.domains]), () => ( []))).map((domain) => domain.trim().toLowerCase()).filter(Boolean)
+      )
+    ]),
+    remotePatterns: Object.freeze(
+      (_nullishCoalesce(_optionalChain([config, 'optionalAccess', _10 => _10.remotePatterns]), () => ( []))).map((pattern) => normalizeRemotePattern(pattern))
+    ),
+    localPatterns: Object.freeze(
+      (_nullishCoalesce(_optionalChain([config, 'optionalAccess', _11 => _11.localPatterns]), () => ( [{ pathname: "/**" }]))).map(
+        (pattern) => normalizeLocalPattern(pattern)
+      )
+    ),
+    deviceSizes: Object.freeze(deviceSizes),
+    imageSizes: Object.freeze(imageSizes),
+    qualities: Object.freeze(qualities),
+    formats: Object.freeze(formats),
+    minimumCacheTTL,
+    maximumResponseBody: parseSize(
+      _nullishCoalesce(_optionalChain([config, 'optionalAccess', _12 => _12.maximumResponseBody]), () => ( "10mb")),
+      "images.maximumResponseBody"
+    ),
+    maximumRedirects,
+    dangerouslyAllowSVG: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _13 => _13.dangerouslyAllowSVG]), () => ( false)),
+    dangerouslyAllowLocalIP: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _14 => _14.dangerouslyAllowLocalIP]), () => ( false))
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmImageConfig, "resolveFarmImageConfig");
+function getPublicFarmImageConfig(config) {
+  return {
+    provider: config.provider,
+    path: config.path,
+    deviceSizes: config.deviceSizes,
+    imageSizes: config.imageSizes,
+    qualities: config.qualities,
+    formats: config.formats
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getPublicFarmImageConfig, "getPublicFarmImageConfig");
+function normalizeImagePath(value) {
+  const hasUnstableCharacters = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  }), "hasUnstableCharacters");
+  if (hasUnstableCharacters(value)) {
+    throw new TypeError("images.path cannot contain backslashes or control characters");
+  }
+  const path = value.trim().replace(/\/+$/, "") || "/";
+  if (!path.startsWith("/") || path.startsWith("//") || path.includes("?") || path.includes("#")) {
+    throw new TypeError("images.path must be an absolute pathname without a query or hash");
+  }
+  for (const segment of path.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch (e) {
+    }
+    if (hasUnstableCharacters(decoded)) {
+      throw new TypeError("images.path cannot contain backslashes or control characters");
+    }
+    if (decoded.includes("/")) {
+      throw new TypeError("images.path cannot contain percent-encoded path separators");
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new TypeError('images.path cannot contain "." or ".." path segments');
+    }
+  }
+  return path;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeImagePath, "normalizeImagePath");
+function normalizeIntegerList(values, name, max) {
+  if (values.length === 0) {
+    throw new TypeError(`${name} must contain at least one value`);
+  }
+  const normalized = [...new Set(values)].sort((left, right) => left - right);
+  for (const value of normalized) {
+    if (!Number.isSafeInteger(value) || value <= 0 || max !== void 0 && value > max) {
+      throw new TypeError(
+        `${name} must contain positive integers${max ? ` no greater than ${max}` : ""}`
+      );
+    }
+  }
+  return normalized;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeIntegerList, "normalizeIntegerList");
+function normalizeNonNegativeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${name} must be a non-negative safe integer`);
+  }
+  return value;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeNonNegativeInteger, "normalizeNonNegativeInteger");
+function parseSize(value, name) {
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new TypeError(`${name} must be a positive safe integer`);
+    }
+    return value;
+  }
+  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|kib|mib|gib)$/);
+  if (!match) {
+    throw new TypeError(`${name} must be bytes or a size string such as "5mb"`);
+  }
+  const bytes = Number(match[1]) * SIZE_UNITS[match[2]];
+  if (!Number.isSafeInteger(bytes) || bytes <= 0) {
+    throw new TypeError(`${name} must resolve to a positive safe integer`);
+  }
+  return bytes;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseSize, "parseSize");
+function normalizeRemotePattern(pattern) {
+  const hostname = pattern.hostname.trim().toLowerCase();
+  if (!hostname || hostname.includes("/") || hostname.includes(":")) {
+    throw new TypeError("images.remotePatterns[].hostname must be a hostname or wildcard hostname");
+  }
+  if (pattern.pathname && !pattern.pathname.startsWith("/")) {
+    throw new TypeError("images.remotePatterns[].pathname must start with /");
+  }
+  if (pattern.search && !pattern.search.startsWith("?")) {
+    throw new TypeError("images.remotePatterns[].search must start with ?");
+  }
+  return Object.freeze({ ...pattern, hostname });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRemotePattern, "normalizeRemotePattern");
+function normalizeLocalPattern(pattern) {
+  if (!pattern.pathname.startsWith("/")) {
+    throw new TypeError("images.localPatterns[].pathname must start with /");
+  }
+  if (pattern.search && !pattern.search.startsWith("?")) {
+    throw new TypeError("images.localPatterns[].search must start with ?");
+  }
+  return Object.freeze({ ...pattern });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeLocalPattern, "normalizeLocalPattern");
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_FARM_IMAGE_PATH = DEFAULT_FARM_IMAGE_PATH; exports.DEFAULT_FARM_IMAGE_DEVICE_SIZES = DEFAULT_FARM_IMAGE_DEVICE_SIZES; exports.DEFAULT_FARM_IMAGE_SIZES = DEFAULT_FARM_IMAGE_SIZES; exports.DEFAULT_FARM_IMAGE_QUALITIES = DEFAULT_FARM_IMAGE_QUALITIES; exports.DEFAULT_FARM_IMAGE_FORMATS = DEFAULT_FARM_IMAGE_FORMATS; exports.resolveFarmImageConfig = resolveFarmImageConfig; exports.getPublicFarmImageConfig = getPublicFarmImageConfig;

package/dist/chunk-YJRZR7VU.cjs

@@ -0,0 +1,28 @@
+"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/devtools-config.ts
+var DEFAULT_FARM_DEVTOOLS_SHORTCUT = "mod+shift+.";
+var FARM_DEVTOOLS_PATH = "/__farm/devtools";
+var FARM_DEVTOOLS_LAUNCH_PARAM = "__farm_devtools";
+function resolveFarmDevtoolsConfig(config, mode = "development") {
+  if (mode !== "development" || config === false) {
+    return { enabled: false, shortcut: false };
+  }
+  const options = config === true || config === void 0 ? {} : config;
+  const enabled = _nullishCoalesce(options.enabled, () => ( true));
+  if (!enabled) {
+    return { enabled: false, shortcut: false };
+  }
+  const shortcut = typeof options.shortcut === "string" && options.shortcut.trim() ? options.shortcut.toLowerCase().split("+").map((part) => part.trim()).filter(Boolean).join("+") : options.shortcut === false ? false : DEFAULT_FARM_DEVTOOLS_SHORTCUT;
+  return { enabled: true, shortcut };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmDevtoolsConfig, "resolveFarmDevtoolsConfig");
+
+
+
+
+
+
+exports.DEFAULT_FARM_DEVTOOLS_SHORTCUT = DEFAULT_FARM_DEVTOOLS_SHORTCUT; exports.FARM_DEVTOOLS_PATH = FARM_DEVTOOLS_PATH; exports.FARM_DEVTOOLS_LAUNCH_PARAM = FARM_DEVTOOLS_LAUNCH_PARAM; exports.resolveFarmDevtoolsConfig = resolveFarmDevtoolsConfig;

package/dist/chunk-YTAABQEV.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/chunk-YX3DBN4M.cjs

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/redirect-query.ts
+function appendFarmRedirectQuery(destination, search) {
+  if (!search || search === "?") return destination;
+  const hashIndex = destination.indexOf("#");
+  const pathAndQuery = hashIndex === -1 ? destination : destination.slice(0, hashIndex);
+  if (pathAndQuery.includes("?")) return destination;
+  if (hashIndex === -1) return `${destination}${search}`;
+  return `${pathAndQuery}${search}${destination.slice(hashIndex)}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendFarmRedirectQuery, "appendFarmRedirectQuery");
+
+
+
+exports.appendFarmRedirectQuery = appendFarmRedirectQuery;