@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-FJSWYIR7.cjs

@@ -0,0 +1,482 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _chunkY53ZSFN6cjs = require('./chunk-Y53ZSFN6.cjs');
+
+
+var _chunkHBTUGXHScjs = require('./chunk-HBTUGXHS.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/middleware/chain.ts
+var DEFAULT_MEMORY_RATE_LIMIT_ENTRIES = 1e5;
+var _UnsupportedRateLimitStorageError = class _UnsupportedRateLimitStorageError extends TypeError {
+  constructor() {
+    super(
+      "RateLimitStorage must implement atomic increment(key, windowMs). Legacy get/set adapters can lose increments under concurrency. Use memoryRateLimitStorage() for one process or redisRateLimitStorage() from @farm.js/cache-redis for production."
+    );
+    this.name = "UnsupportedRateLimitStorageError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _UnsupportedRateLimitStorageError, "UnsupportedRateLimitStorageError");
+var UnsupportedRateLimitStorageError = _UnsupportedRateLimitStorageError;
+function memoryRateLimitStorage(options = {}) {
+  const maxEntries = _nullishCoalesce(options.maxEntries, () => ( DEFAULT_MEMORY_RATE_LIMIT_ENTRIES));
+  if (!Number.isSafeInteger(maxEntries) || maxEntries <= 0) {
+    throw new TypeError("memoryRateLimitStorage maxEntries must be a positive safe integer.");
+  }
+  const records = /* @__PURE__ */ new Map();
+  let earliestExpiry = Infinity;
+  function read(key, now) {
+    const record = records.get(key);
+    if (!record) return null;
+    if (record.resetAt <= now) {
+      records.delete(key);
+      return null;
+    }
+    return record;
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, read, "read");
+  function pruneExpired(now) {
+    if (now < earliestExpiry) return;
+    earliestExpiry = Infinity;
+    for (const [key, record] of records) {
+      if (record.resetAt <= now) records.delete(key);
+      else earliestExpiry = Math.min(earliestExpiry, record.resetAt);
+    }
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, pruneExpired, "pruneExpired");
+  return {
+    increment(key, windowMs) {
+      if (!Number.isSafeInteger(windowMs) || windowMs <= 0) {
+        throw new TypeError("Rate-limit windowMs must be a positive safe integer.");
+      }
+      const now = Date.now();
+      const current = read(key, now);
+      if (current) {
+        current.count++;
+        return { ...current };
+      }
+      if (records.size >= maxEntries) pruneExpired(now);
+      if (records.size >= maxEntries) {
+        throw new Error(
+          `Process-local rate-limit storage reached its ${maxEntries} active-key capacity. Configure a shared production adapter or increase maxEntries.`
+        );
+      }
+      const next = { count: 1, resetAt: now + windowMs };
+      records.set(key, next);
+      earliestExpiry = Math.min(earliestExpiry, next.resetAt);
+      return { ...next };
+    },
+    get(key) {
+      const record = read(key, Date.now());
+      return record ? { ...record } : null;
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, memoryRateLimitStorage, "memoryRateLimitStorage");
+var defaultRateLimitStorage = memoryRateLimitStorage();
+function parseTimeWindow(window) {
+  const match = window.match(/^(\d+)(ms|s|m|h|d)$/);
+  if (!match) throw new Error(`Invalid time window: ${window}`);
+  const [, amount, unit] = match;
+  const value = Number.parseInt(amount, 10);
+  const multipliers = {
+    ms: 1,
+    s: 1e3,
+    m: 60 * 1e3,
+    h: 60 * 60 * 1e3,
+    d: 24 * 60 * 60 * 1e3
+  };
+  const windowMs = value * multipliers[unit];
+  if (!Number.isSafeInteger(windowMs) || windowMs <= 0) {
+    throw new Error(`Invalid time window: ${window}`);
+  }
+  return windowMs;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseTimeWindow, "parseTimeWindow");
+function createRateLimitMiddleware(config) {
+  if (!Number.isSafeInteger(config.requests) || config.requests <= 0) {
+    throw new TypeError("Rate limit requests must be a positive safe integer.");
+  }
+  const windowMs = parseTimeWindow(config.window);
+  const storage = config.storage || defaultRateLimitStorage;
+  assertAtomicRateLimitStorage(storage);
+  return async (ctx, next) => {
+    const key = config.keyGenerator ? config.keyGenerator(ctx) : `${requireRateLimitClientAddress(ctx)}:${ctx.pathname}`;
+    const current = await storage.increment(key, windowMs);
+    assertRateLimitIncrementResult(current);
+    const now = Date.now();
+    const resetIn = Math.max(1, Math.ceil((current.resetAt - now) / 1e3));
+    const remaining = Math.max(0, config.requests - current.count);
+    setRateLimitHeaders(ctx, config.requests, remaining, resetIn, Math.ceil(windowMs / 1e3));
+    if (current.count > config.requests) {
+      setMiddlewareResponseHeader(ctx, "Retry-After", String(resetIn));
+      if (config.onLimit) {
+        const result = await config.onLimit(ctx);
+        if (result) return result;
+      }
+      ctx.json(
+        {
+          error: "Rate limit exceeded",
+          retryAfter: resetIn
+        },
+        429
+      );
+      return;
+    }
+    return next();
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRateLimitMiddleware, "createRateLimitMiddleware");
+function requireRateLimitClientAddress(ctx) {
+  const address = _optionalChain([ctx, 'access', _ => _.request, 'access', _2 => _2.socket, 'optionalAccess', _3 => _3.remoteAddress]);
+  if (address) return address;
+  throw new Error(
+    "Rate limiting could not identify the caller: this runtime reports no client address. Set `server.trustProxy` so a proxy's x-forwarded-for is trusted, or pass a `keyGenerator` that derives the bucket from something you do have, such as a session or an API key."
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, requireRateLimitClientAddress, "requireRateLimitClientAddress");
+function assertAtomicRateLimitStorage(storage) {
+  if (!storage || typeof storage.increment !== "function") {
+    throw new UnsupportedRateLimitStorageError();
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertAtomicRateLimitStorage, "assertAtomicRateLimitStorage");
+function assertRateLimitIncrementResult(result) {
+  if (!result || !Number.isSafeInteger(result.count) || result.count <= 0 || !Number.isFinite(result.resetAt) || result.resetAt <= 0) {
+    throw new TypeError(
+      "RateLimitStorage.increment() must return a positive integer count and a resetAt timestamp."
+    );
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertRateLimitIncrementResult, "assertRateLimitIncrementResult");
+function setRateLimitHeaders(ctx, limit, remaining, resetIn, windowSeconds) {
+  setMiddlewareResponseHeader(ctx, "RateLimit-Policy", `"farm";q=${limit};w=${windowSeconds}`);
+  setMiddlewareResponseHeader(ctx, "RateLimit", `"farm";r=${remaining};t=${resetIn}`);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, setRateLimitHeaders, "setRateLimitHeaders");
+function setMiddlewareResponseHeader(ctx, name, value) {
+  ctx.headers.set(name, value);
+  if (!ctx.response.headersSent && !ctx.response.writableEnded) {
+    ctx.response.setHeader(name, value);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, setMiddlewareResponseHeader, "setMiddlewareResponseHeader");
+function matchPattern(pattern, pathname) {
+  if (pattern instanceof RegExp) {
+    return pattern.test(pathname);
+  }
+  const regexPattern = pattern.replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "__SINGLE_STAR__").replace(/[.+?^${}()|[\]\\/]/g, "\\$&").replace(/__DOUBLE_STAR__/g, ".*").replace(/__SINGLE_STAR__/g, "[^/]+");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(pathname);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchPattern, "matchPattern");
+var _MiddlewareChainImpl = class _MiddlewareChainImpl {
+  constructor(basePath = "/") {
+    this.handlers = [];
+    this.basePath = basePath === "/" ? "/" : basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+  }
+  /**
+   * Set the base path for this middleware chain (called by manager when loading)
+   */
+  setBasePath(path2) {
+    this.basePath = path2 === "/" ? "/" : path2.endsWith("/") ? path2.slice(0, -1) : path2;
+  }
+  use(fn) {
+    this.handlers.push(fn);
+    return this;
+  }
+  /**
+   * Normalize a path pattern - auto-scope to middleware route
+   * If middleware is in /contact, then "/api" becomes "/contact/api"
+   */
+  normalizePattern(pattern) {
+    if (this.basePath === "/") {
+      return pattern.startsWith("/") ? pattern : `/${pattern}`;
+    }
+    const cleanPattern = pattern.startsWith("/") ? pattern.slice(1) : pattern;
+    return `${this.basePath}/${cleanPattern}`;
+  }
+  /**
+   * Conditionally run middleware based on a condition.
+   * Only supports boolean values or functions that evaluate to boolean.
+   * Route-based string matching has been removed - use function conditions instead.
+   *
+   * @example
+   * .when(true, (ctx, next) => { ... })  // Always run
+   * .when((ctx) => ctx.data.get('flag'), (ctx, next) => { ... })  // Conditional
+   * .when((ctx) => ctx.pathname === '/contact', (ctx, next) => { ... })  // Path-based condition
+   */
+  when(condition, fn) {
+    const conditionalMiddleware = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (ctx, next) => {
+      const shouldRun = typeof condition === "function" ? condition(ctx) : condition;
+      if (!shouldRun) {
+        return next();
+      }
+      if (typeof fn === "function" && fn.length === 2) {
+        return fn(ctx, next);
+      } else {
+        const subChain = middleware(this.basePath);
+        fn(subChain);
+        const { handlers } = subChain.build();
+        let index = 0;
+        let returnedResponse;
+        const executeNext = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async () => {
+          if (index < handlers.length) {
+            const handler = handlers[index++];
+            const result = await handler(ctx, executeNext);
+            if (result instanceof Response) {
+              returnedResponse = result;
+              return result;
+            }
+          } else {
+            const result = await next();
+            if (result instanceof Response) {
+              returnedResponse = result;
+              return result;
+            }
+          }
+          return returnedResponse;
+        }, "executeNext");
+        return executeNext();
+      }
+    }, "conditionalMiddleware");
+    this.handlers.push(conditionalMiddleware);
+    return this;
+  }
+  rateLimit(config) {
+    this.handlers.push(createRateLimitMiddleware(config));
+    return this;
+  }
+  redirect(source, destination, permanent = false) {
+    const redirectMiddleware = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (ctx, next) => {
+      const normalizedSource = this.normalizePattern(source);
+      if (matchPattern(normalizedSource, ctx.pathname)) {
+        ctx.redirect(destination, permanent ? 308 : 307);
+        return;
+      }
+      return next();
+    }, "redirectMiddleware");
+    this.handlers.push(redirectMiddleware);
+    return this;
+  }
+  /**
+   * Rewrite the current middleware route to a new destination.
+   * Since each middleware file is route-specific, the source is automatically
+   * the middleware's route, so you only need to specify the destination.
+   *
+   * @param destination - The destination path to rewrite to
+   * @param condition - Optional boolean or function that evaluates to boolean.
+   *                    If provided and evaluates to false, rewrite is skipped.
+   *                    If not provided, rewrite always happens.
+   *
+   * @example
+   * // In /contact/middleware.ts
+   * .rewrite('/about')  // Always rewrites /contact to /about
+   * .rewrite('/about', true)  // Always rewrites
+   * .rewrite('/about', false)  // Never rewrites
+   * .rewrite('/about', (ctx) => ctx.data.get('shouldRewrite'))  // Conditional rewrite
+   */
+  rewrite(destination, condition) {
+    const rewriteMiddleware = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (ctx, next) => {
+      if (condition !== void 0) {
+        const shouldRewrite = typeof condition === "function" ? condition(ctx) : condition;
+        if (!shouldRewrite) {
+          return next();
+        }
+      }
+      if (this.basePath !== "/") {
+        if (ctx.pathname === this.basePath) {
+          ctx.rewrite(destination);
+        } else if (ctx.pathname.startsWith(this.basePath + "/")) {
+          const subPath = ctx.pathname.slice(this.basePath.length);
+          const newPath = destination + subPath;
+          ctx.rewrite(newPath);
+        }
+      } else {
+        ctx.rewrite(destination);
+      }
+      return next();
+    }, "rewriteMiddleware");
+    this.handlers.push(rewriteMiddleware);
+    return this;
+  }
+  build() {
+    return {
+      handlers: this.handlers,
+      config: this.config
+    };
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _MiddlewareChainImpl, "MiddlewareChainImpl");
+var MiddlewareChainImpl = _MiddlewareChainImpl;
+async function getRateLimitStatus(key, limit, storage = defaultRateLimitStorage) {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new TypeError("Rate limit must be a positive safe integer.");
+  }
+  assertAtomicRateLimitStorage(storage);
+  if (typeof storage.get !== "function") {
+    throw new TypeError(
+      "getRateLimitStatus() requires a RateLimitStorage adapter that implements get(key)."
+    );
+  }
+  const record = await storage.get(key);
+  if (!record) {
+    return {
+      requests: 0,
+      limit,
+      remaining: limit,
+      resetIn: null,
+      resetAt: null,
+      isLimited: false
+    };
+  }
+  assertRateLimitIncrementResult(record);
+  const now = Date.now();
+  if (record.resetAt && now > record.resetAt) {
+    return {
+      requests: 0,
+      limit,
+      remaining: limit,
+      resetIn: null,
+      resetAt: null,
+      isLimited: false
+    };
+  }
+  const requests = record.count || 0;
+  const remaining = Math.max(0, limit - requests);
+  const isLimited = requests >= limit;
+  let resetIn = null;
+  let resetAt = null;
+  if (record.resetAt) {
+    const remainingMs = record.resetAt - now;
+    resetIn = remainingMs > 0 ? Math.ceil(remainingMs / 1e3) : null;
+    resetAt = new Date(record.resetAt);
+  }
+  return {
+    requests,
+    limit,
+    remaining,
+    resetIn,
+    resetAt,
+    isLimited
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRateLimitStatus, "getRateLimitStatus");
+function middleware(basePath = "/") {
+  return new MiddlewareChainImpl(basePath);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, middleware, "middleware");
+
+// src/middleware/helpers.ts
+function unwrapMiddleware(middleware2, defaults) {
+  if (!middleware2) {
+    return defaults || {};
+  }
+  const result = { ...defaults };
+  for (const [key, value] of middleware2.data) {
+    result[key] = value;
+  }
+  return result;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, unwrapMiddleware, "unwrapMiddleware");
+function getFromMiddleware(middleware2, key, defaultValue) {
+  if (!middleware2) {
+    return defaultValue;
+  }
+  const value = middleware2.data.get(key);
+  return value !== void 0 ? value : defaultValue;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFromMiddleware, "getFromMiddleware");
+function hasMiddlewareData(middleware2) {
+  if (!middleware2) return false;
+  return middleware2.data.size > 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, hasMiddlewareData, "hasMiddlewareData");
+
+// src/middleware/vite-plugin.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function getMiddlewareAppDirectory(root, srcDir) {
+  const sourceDirectory = _path2.default.join(root, srcDir);
+  const appDirectory = _path2.default.join(sourceDirectory, "app");
+  return _fs2.default.existsSync(appDirectory) ? appDirectory : sourceDirectory;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareAppDirectory, "getMiddlewareAppDirectory");
+function farmMiddlewarePlugin(options = {}) {
+  const srcDir = _nullishCoalesce(options.srcDir, () => ( "src"));
+  let manager = null;
+  let discoveryComplete = false;
+  let discoveryPromise = null;
+  const discover = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (server) => {
+    const i18n = _chunkHBTUGXHScjs.resolveFarmI18nConfig.call(void 0, false, {
+      root: server.config.root,
+      mode: server.config.mode === "production" ? "production" : "development",
+      basePath: _nullishCoalesce(options.basePath, () => ( "/"))
+    });
+    manager = new (0, _chunkY53ZSFN6cjs.MiddlewareManager)(
+      getMiddlewareAppDirectory(server.config.root, srcDir),
+      server,
+      void 0,
+      i18n
+    );
+    await manager.discover();
+    discoveryComplete = true;
+  }, "discover");
+  return {
+    name: "@farm.js/core:middleware",
+    enforce: "pre",
+    configureServer(server) {
+      discoveryPromise = discover(server);
+      void discoveryPromise.catch((error) => {
+        console.error("[FARM] Middleware discovery error:", error);
+      });
+      const execute = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (req, res, _pathname, sharedData) => {
+        if (discoveryPromise) {
+          await discoveryPromise;
+        }
+        if (!manager) {
+          return false;
+        }
+        const handled = await manager.execute(req, res);
+        const middlewareData = req.__FARM_MIDDLEWARE_DATA__;
+        if (sharedData && middlewareData instanceof Map) {
+          for (const [key, value] of middlewareData) {
+            sharedData.set(key, value);
+          }
+        }
+        return handled;
+      }, "execute");
+      server.__farmMiddleware__ = {
+        execute,
+        getMiddlewares: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => _nullishCoalesce(_optionalChain([manager, 'optionalAccess', _4 => _4.getMiddlewares, 'call', _5 => _5()]), () => ( [])), "getMiddlewares"),
+        isReady: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => discoveryComplete, "isReady"),
+        waitForDiscovery: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => discoveryPromise, "waitForDiscovery")
+      };
+    },
+    async handleHotUpdate({ file, server, modules }) {
+      if (!/^middleware\.[tj]sx?$/.test(_path2.default.basename(file))) {
+        return;
+      }
+      for (const module of modules) {
+        server.moduleGraph.invalidateModule(module);
+      }
+      await _optionalChain([manager, 'optionalAccess', _6 => _6.reload, 'call', _7 => _7()]);
+      server.ws.send({ type: "full-reload", path: "*" });
+      return [];
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, farmMiddlewarePlugin, "farmMiddlewarePlugin");
+
+
+
+
+
+
+
+
+
+
+exports.UnsupportedRateLimitStorageError = UnsupportedRateLimitStorageError; exports.memoryRateLimitStorage = memoryRateLimitStorage; exports.getRateLimitStatus = getRateLimitStatus; exports.middleware = middleware; exports.unwrapMiddleware = unwrapMiddleware; exports.getFromMiddleware = getFromMiddleware; exports.hasMiddlewareData = hasMiddlewareData; exports.farmMiddlewarePlugin = farmMiddlewarePlugin;

package/dist/chunk-FK6GO24V.cjs

@@ -0,0 +1,54 @@
+"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/theme/runtime.ts
+var FALLBACK_CLIENT_SNAPSHOT = Object.freeze({
+  theme: "system",
+  resolvedTheme: "light",
+  mounted: true
+});
+var cachedClientSnapshot = FALLBACK_CLIENT_SNAPSHOT;
+function snapshotsMatch(left, right) {
+  return left.theme === right.theme && left.resolvedTheme === right.resolvedTheme && left.mounted === right.mounted;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, snapshotsMatch, "snapshotsMatch");
+function getTheme() {
+  const next = typeof window === "undefined" ? FALLBACK_CLIENT_SNAPSHOT : _optionalChain([window, 'access', _ => _.__FARM_THEME__, 'optionalAccess', _2 => _2.snapshot]);
+  if (!next) return cachedClientSnapshot;
+  if (!snapshotsMatch(cachedClientSnapshot, next)) cachedClientSnapshot = next;
+  return cachedClientSnapshot;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getTheme, "getTheme");
+function setTheme(theme) {
+  const runtime = typeof window === "undefined" ? void 0 : window.__FARM_THEME__;
+  if (!runtime) {
+    throw new Error("The FARMJS theme runtime is not enabled. Add `theme` to farm.config.ts.");
+  }
+  runtime.setTheme(theme);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, setTheme, "setTheme");
+function toggleTheme() {
+  const next = getTheme().resolvedTheme === "dark" ? "light" : "dark";
+  setTheme(next);
+  return next;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toggleTheme, "toggleTheme");
+function subscribeTheme(listener) {
+  if (typeof window === "undefined") return () => {
+  };
+  const handleThemeChange = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    getTheme();
+    listener();
+  }, "handleThemeChange");
+  window.addEventListener("farm:themechange", handleThemeChange);
+  return () => window.removeEventListener("farm:themechange", handleThemeChange);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, subscribeTheme, "subscribeTheme");
+
+
+
+
+
+
+exports.getTheme = getTheme; exports.setTheme = setTheme; exports.toggleTheme = toggleTheme; exports.subscribeTheme = subscribeTheme;