@leejpsd/nextjs-cache-handler 0.1.0-rc.1

package/dist/incremental/index.cjs

@@ -0,0 +1,734 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/client/adapter-redis.ts
+var adapter_redis_exports = {};
+__export(adapter_redis_exports, {
+  adaptRedisV5: () => adaptRedisV5,
+  createRedisV5Client: () => createRedisV5Client
+});
+function adaptRedisV5(client) {
+  return client;
+}
+function createRedisV5Client(config) {
+  const { createClient } = __require("redis");
+  const useTls = config.tls ?? config.url.startsWith("rediss://");
+  const opts = {
+    url: config.url,
+    socket: {
+      connectTimeout: config.connectTimeout ?? 1500,
+      reconnectStrategy: false,
+      ...useTls ? { tls: true } : {}
+    }
+  };
+  if (config.password !== void 0) opts.password = config.password;
+  return createClient(opts);
+}
+var init_adapter_redis = __esm({
+  "src/shared/client/adapter-redis.ts"() {
+  }
+});
+
+// src/shared/client/adapter-ioredis.ts
+var adapter_ioredis_exports = {};
+__export(adapter_ioredis_exports, {
+  adaptCluster: () => adaptCluster,
+  adaptIoredis: () => adaptIoredis,
+  createIoredisClient: () => createIoredisClient,
+  createIoredisCluster: () => createIoredisCluster
+});
+function adapt(client, isClusterClient = false) {
+  return {
+    get isOpen() {
+      return client.status === "ready";
+    },
+    connect: async () => {
+      if (client.status !== "ready" && client.status !== "connecting") {
+        await client.connect();
+      }
+    },
+    get: (k) => client.get(k),
+    set: (k, v, opts) => opts?.EX !== void 0 ? client.set(k, v, "EX", opts.EX) : client.set(k, v),
+    del: async (keys) => {
+      const arr = Array.isArray(keys) ? keys : [keys];
+      if (arr.length === 0) return 0;
+      return client.del(...arr);
+    },
+    sAdd: async (k, m) => {
+      const arr = Array.isArray(m) ? m : [m];
+      if (arr.length === 0) return 0;
+      return client.sadd(k, ...arr);
+    },
+    sMembers: (k) => client.smembers(k),
+    expire: async (k, s) => {
+      const r = await client.expire(k, s);
+      return r;
+    },
+    mGet: async (keys) => {
+      if (keys.length === 0) return [];
+      return client.mget(...keys);
+    },
+    eval: (script, opts) => client.eval(
+      script,
+      opts.keys.length,
+      ...opts.keys,
+      ...opts.arguments
+    ),
+    evalSha: (sha, opts) => client.evalsha(
+      sha,
+      opts.keys.length,
+      ...opts.keys,
+      ...opts.arguments
+    ),
+    scriptLoad: async (script) => await client.script("LOAD", script),
+    scanIterator: async function* ({ MATCH, COUNT }) {
+      if (isClusterClient) {
+        const cluster = client;
+        for (const node of cluster.nodes("master")) {
+          let cursor = "0";
+          do {
+            const [next, batch] = await node.scan(
+              cursor,
+              "MATCH",
+              MATCH,
+              "COUNT",
+              COUNT ?? 100
+            );
+            cursor = next;
+            if (batch.length > 0) yield batch;
+          } while (cursor !== "0");
+        }
+      } else {
+        const redis = client;
+        let cursor = "0";
+        do {
+          const [next, batch] = await redis.scan(
+            cursor,
+            "MATCH",
+            MATCH,
+            "COUNT",
+            COUNT ?? 100
+          );
+          cursor = next;
+          if (batch.length > 0) yield batch;
+        } while (cursor !== "0");
+      }
+    },
+    ping: () => client.ping(),
+    on: (event, listener) => {
+      client.on(event, listener);
+      return client;
+    }
+  };
+}
+function adaptIoredis(client) {
+  return adapt(client, false);
+}
+function adaptCluster(cluster) {
+  return adapt(cluster, true);
+}
+function createIoredisClient(config) {
+  const IORedis = __require("ioredis");
+  const Ctor = IORedis.default ?? IORedis;
+  return new Ctor(config.url, {
+    password: config.password,
+    connectTimeout: config.connectTimeout ?? 1500,
+    tls: config.tls ? {} : void 0,
+    lazyConnect: true,
+    maxRetriesPerRequest: 1
+  });
+}
+function createIoredisCluster(config) {
+  const IORedis = __require("ioredis");
+  const ClusterCtor = IORedis.Cluster ?? IORedis.default.Cluster;
+  return new ClusterCtor(config.nodes, {
+    redisOptions: {
+      password: config.password,
+      tls: config.tls ? {} : void 0
+    },
+    enableReadyCheck: true,
+    lazyConnect: true
+  });
+}
+var init_adapter_ioredis = __esm({
+  "src/shared/client/adapter-ioredis.ts"() {
+  }
+});
+
+// src/shared/abort.ts
+var CacheTimeoutError = class extends Error {
+  constructor(opName, ms) {
+    super(`[@leejpsd/nextjs-cache-handler] ${opName} timed out after ${ms}ms`);
+    this.opName = opName;
+    this.ms = ms;
+  }
+  opName;
+  ms;
+  name = "CacheTimeoutError";
+};
+async function withAbortSignal(opName, ms, fn) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), ms);
+  if (typeof timer === "object" && "unref" in timer) {
+    timer.unref();
+  }
+  try {
+    const timeoutPromise = new Promise((_, reject) => {
+      const onAbort = () => {
+        ctrl.signal.removeEventListener("abort", onAbort);
+        reject(new CacheTimeoutError(opName, ms));
+      };
+      if (ctrl.signal.aborted) onAbort();
+      else ctrl.signal.addEventListener("abort", onAbort, { once: true });
+    });
+    return await Promise.race([fn(ctrl.signal), timeoutPromise]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/shared/client/index.ts
+async function buildClient(source) {
+  if (typeof source === "function") {
+    return await source();
+  }
+  switch (source.type) {
+    case "redis": {
+      const { adaptRedisV5: adaptRedisV52, createRedisV5Client: createRedisV5Client2 } = await Promise.resolve().then(() => (init_adapter_redis(), adapter_redis_exports));
+      return adaptRedisV52(createRedisV5Client2(source));
+    }
+    case "ioredis": {
+      const { adaptIoredis: adaptIoredis2, createIoredisClient: createIoredisClient2 } = await Promise.resolve().then(() => (init_adapter_ioredis(), adapter_ioredis_exports));
+      return adaptIoredis2(createIoredisClient2(source));
+    }
+    case "cluster": {
+      const { adaptCluster: adaptCluster2, createIoredisCluster: createIoredisCluster2 } = await Promise.resolve().then(() => (init_adapter_ioredis(), adapter_ioredis_exports));
+      return adaptCluster2(createIoredisCluster2(source));
+    }
+    default: {
+      const exhaustive = source;
+      throw new Error(
+        `[next-cache] unknown client config: ${JSON.stringify(exhaustive)}`
+      );
+    }
+  }
+}
+var ConnectionManager = class {
+  constructor(source, onError) {
+    this.source = source;
+    this.onError = onError;
+  }
+  source;
+  onError;
+  client = null;
+  connecting = null;
+  failed = false;
+  async getOrConnect() {
+    if (this.client?.isOpen) return this.client;
+    if (this.failed) return null;
+    if (this.connecting) return this.connecting;
+    this.connecting = (async () => {
+      try {
+        const c = await buildClient(this.source);
+        c.on("error", (err) => this.onError(err));
+        if (!c.isOpen) await c.connect();
+        this.client = c;
+        return c;
+      } catch (err) {
+        this.failed = true;
+        this.onError(err);
+        return null;
+      } finally {
+        this.connecting = null;
+      }
+    })();
+    return this.connecting;
+  }
+  reset() {
+    this.client = null;
+    this.connecting = null;
+    this.failed = false;
+  }
+};
+
+// src/shared/logger.ts
+var defaultLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: (message, meta) => {
+    if (meta) console.warn(`[next-cache] ${message}`, meta);
+    else console.warn(`[next-cache] ${message}`);
+  },
+  error: (message, meta) => {
+    if (meta) console.error(`[next-cache] ${message}`, meta);
+    else console.error(`[next-cache] ${message}`);
+  }
+};
+
+// src/shared/memory-fallback.ts
+var MAX_TIMER_MS = 2147483647;
+function clampTimerMs(ms) {
+  return Math.min(Math.max(0, ms), MAX_TIMER_MS);
+}
+var MemoryStore = class {
+  kv = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  set(key, value, ttlSeconds) {
+    this.delete(key);
+    const expiresAt = Date.now() + ttlSeconds * 1e3;
+    this.kv.set(key, { value, expiresAt });
+    const timer = setTimeout(() => this.delete(key), clampTimerMs(ttlSeconds * 1e3));
+    if (typeof timer === "object" && "unref" in timer) {
+      timer.unref();
+    }
+    this.timers.set(key, timer);
+  }
+  get(key) {
+    const entry = this.kv.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  delete(key) {
+    const timer = this.timers.get(key);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      this.timers.delete(key);
+    }
+    return this.kv.delete(key);
+  }
+  has(key) {
+    return this.get(key) !== null;
+  }
+  keys() {
+    const now = Date.now();
+    const live = [];
+    for (const [key, entry] of this.kv.entries()) {
+      if (entry.expiresAt >= now) live.push(key);
+    }
+    return live;
+  }
+  size() {
+    return this.keys().length;
+  }
+  clear() {
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+    this.kv.clear();
+  }
+};
+
+// src/shared/metrics.ts
+var counters = /* @__PURE__ */ new Map();
+function bump(event) {
+  const existing = counters.get(event.type);
+  if (existing) {
+    existing.count += 1;
+    if (event.ms !== void 0) existing.totalMs += event.ms;
+    existing.lastTs = Date.now();
+    return;
+  }
+  counters.set(event.type, {
+    count: 1,
+    totalMs: event.ms ?? 0,
+    lastTs: Date.now()
+  });
+}
+function createEmitter(onMetric) {
+  return (event) => {
+    bump(event);
+    if (onMetric) {
+      try {
+        onMetric(event);
+      } catch {
+      }
+    }
+  };
+}
+
+// src/shared/namespace.ts
+var FALLBACK = "unversioned";
+function resolveBuildNamespace(override) {
+  if (override !== void 0) {
+    return typeof override === "function" ? override() : override;
+  }
+  return process.env.DEPLOYMENT_VERSION ?? process.env.GIT_HASH ?? process.env.NEXT_DEPLOYMENT_ID ?? FALLBACK;
+}
+function buildKey(prefix, namespace, rest, hashTag = false) {
+  const ns = hashTag ? `{${namespace}}` : namespace;
+  return `${prefix}${ns}:${rest}`;
+}
+
+// src/shared/build-phase.ts
+var PHASE_PRODUCTION_BUILD = "phase-production-build";
+function isBuildPhase() {
+  return process.env.NEXT_PHASE === PHASE_PRODUCTION_BUILD;
+}
+function shouldUseRedis(opts) {
+  if (opts.fallback === "always") return false;
+  const detector = opts.isBuildPhase ?? isBuildPhase;
+  if (detector()) return false;
+  return true;
+}
+
+// src/incremental/serialize.ts
+function isEnvelope(value) {
+  return typeof value === "object" && value !== null && "__type" in value && typeof value.__type === "string";
+}
+function isLegacyBufferShape(value) {
+  return typeof value === "object" && value !== null && value.type === "Buffer" && Array.isArray(value.data);
+}
+function replacer(_key, value) {
+  if (Buffer.isBuffer(value)) {
+    const env = {
+      __type: "Buffer",
+      data: value.toString("base64")
+    };
+    return env;
+  }
+  if (value instanceof Map) {
+    const env = {
+      __type: "Map",
+      entries: Array.from(value.entries())
+    };
+    return env;
+  }
+  return value;
+}
+function reviver(_key, value) {
+  if (isLegacyBufferShape(value)) {
+    return Buffer.from(value.data);
+  }
+  if (!isEnvelope(value)) return value;
+  if (value.__type === "Buffer") {
+    return Buffer.from(value.data, "base64");
+  }
+  if (value.__type === "Map") {
+    return new Map(value.entries);
+  }
+  return value;
+}
+function serializeCacheRecord(record) {
+  return JSON.stringify(record, replacer);
+}
+function deserializeCacheRecord(serialized) {
+  try {
+    return JSON.parse(serialized, reviver);
+  } catch {
+    return null;
+  }
+}
+
+// src/incremental/handler.ts
+var DEFAULT_KEY_PREFIX = "next-incremental:";
+var ENTRY_SUFFIX = "entry:";
+var TAG_SUFFIX = "tag:";
+var INSTANCE_LOCAL_TAG_PREFIX = "instance-local:";
+var ONE_YEAR_SEC = 60 * 60 * 24 * 365;
+var MIN_TTL_SEC = 60;
+var DEFAULT_ABORT_MS = 1500;
+function gateRedis(state) {
+  const fb = state.opts.fallback;
+  const ibp = state.opts.rest.isBuildPhase;
+  return ibp ? shouldUseRedis({ fallback: fb, isBuildPhase: ibp }) : shouldUseRedis({ fallback: fb });
+}
+function gateRedisInit(state) {
+  return gateRedis(state);
+}
+function init(opts) {
+  const logger = opts.logger ?? defaultLogger;
+  const emit = createEmitter(opts.onMetric);
+  const conn = new ConnectionManager(opts.client, (err) => {
+    logger.warn("Redis client error (incremental)", { message: err.message });
+    emit({ type: "redis.connect.failed", meta: { message: err.message } });
+  });
+  return {
+    opts: {
+      abortTimeoutMs: opts.abortTimeoutMs ?? DEFAULT_ABORT_MS,
+      fallback: opts.fallback ?? "auto",
+      hashTag: opts.hashTag ?? false,
+      keyPrefix: opts.keyPrefix ?? DEFAULT_KEY_PREFIX,
+      rest: opts
+    },
+    logger,
+    emit,
+    conn,
+    memEntries: new MemoryStore(),
+    memTagStates: /* @__PURE__ */ new Map(),
+    resolveNs: () => resolveBuildNamespace(opts.buildNamespace)
+  };
+}
+function entryKey(state, cacheKey) {
+  return buildKey(
+    `${state.opts.keyPrefix}${ENTRY_SUFFIX}`,
+    state.resolveNs(),
+    cacheKey,
+    state.opts.hashTag
+  );
+}
+function tagMetaKey(state, tag) {
+  return `${state.opts.keyPrefix}${TAG_SUFFIX}${tag}`;
+}
+function normalizeTags(tags) {
+  return Array.isArray(tags) ? tags.filter((t) => typeof t === "string" && t.length > 0) : [];
+}
+function shouldUseLocalIncrementalStore(tags) {
+  return tags.some((t) => t.startsWith(INSTANCE_LOCAL_TAG_PREFIX));
+}
+function extractTagsFromValue(value, ctx) {
+  if (!value || typeof value !== "object") return [];
+  const v = value;
+  if (v.kind === "FETCH") {
+    return normalizeTags([
+      ...normalizeTags(v.tags),
+      ...normalizeTags(ctx?.tags),
+      ...normalizeTags(ctx?.softTags)
+    ]);
+  }
+  const headers = v.headers;
+  if (!headers) return [];
+  const tagsHeader = headers["x-next-cache-tags"];
+  if (typeof tagsHeader === "string") {
+    return tagsHeader.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+  }
+  if (Array.isArray(tagsHeader)) {
+    return tagsHeader.flatMap((part) => String(part).split(",")).map((t) => t.trim()).filter((t) => t.length > 0);
+  }
+  return [];
+}
+function isTagStateExpired(state, lastModified, isFetch) {
+  if (!state || typeof lastModified !== "number") return false;
+  if (typeof state.expired === "number" && state.expired >= lastModified) return true;
+  if (isFetch && typeof state.stale === "number" && state.stale >= lastModified) return true;
+  return false;
+}
+function normalizeTtlSeconds(data, ctx) {
+  if (data && typeof data === "object") {
+    const d = data;
+    if (d.kind === "FETCH") {
+      if (typeof d.revalidate === "number" && d.revalidate > 0) {
+        return Math.min(Math.max(Math.ceil(d.revalidate), MIN_TTL_SEC), ONE_YEAR_SEC);
+      }
+      return ONE_YEAR_SEC;
+    }
+  }
+  const revalidate = ctx?.cacheControl?.revalidate;
+  if (revalidate === false || revalidate === void 0) return ONE_YEAR_SEC;
+  if (typeof revalidate === "number" && revalidate > 0) {
+    return Math.min(Math.max(Math.ceil(revalidate), MIN_TTL_SEC), ONE_YEAR_SEC);
+  }
+  return MIN_TTL_SEC;
+}
+async function readTagStates(state, tags) {
+  if (tags.length === 0) return [];
+  const useRedis = gateRedisInit(state);
+  if (!useRedis) {
+    return tags.map((t) => state.memTagStates.get(t) ?? null);
+  }
+  try {
+    return await withAbortSignal(
+      "incremental.readTagStates",
+      state.opts.abortTimeoutMs,
+      async () => {
+        const client = await state.conn.getOrConnect();
+        if (!client) return tags.map((t) => state.memTagStates.get(t) ?? null);
+        const values = await client.mGet(tags.map((t) => tagMetaKey(state, t)));
+        return values.map((v) => {
+          if (!v) return null;
+          try {
+            return JSON.parse(v);
+          } catch {
+            return null;
+          }
+        });
+      }
+    );
+  } catch {
+    return tags.map((t) => state.memTagStates.get(t) ?? null);
+  }
+}
+var IncrementalRedisCacheHandler = class {
+  state;
+  revalidatedTags;
+  constructor(state, ctx) {
+    this.state = state;
+    this.revalidatedTags = normalizeTags(ctx?.revalidatedTags);
+  }
+  async get(cacheKey, ctx) {
+    try {
+      const requestedTags = normalizeTags([
+        ...ctx?.tags ?? [],
+        ...ctx?.softTags ?? []
+      ]);
+      const useLocal = shouldUseLocalIncrementalStore(requestedTags);
+      const eKey = entryKey(this.state, cacheKey);
+      const useRedis = !useLocal && gateRedis(this.state);
+      let raw = null;
+      if (useRedis) {
+        try {
+          raw = await withAbortSignal(
+            "incremental.get",
+            this.state.opts.abortTimeoutMs,
+            async () => {
+              const client = await this.state.conn.getOrConnect();
+              if (!client) return null;
+              return await client.get(eKey);
+            }
+          );
+        } catch (err) {
+          if (err instanceof CacheTimeoutError) {
+            this.state.emit({ type: "redis.timeout", meta: { op: "incremental.get" } });
+          }
+          raw = null;
+        }
+      }
+      if (raw === null) raw = this.state.memEntries.get(eKey);
+      if (raw === null) {
+        this.state.emit({ type: "cache.miss" });
+        return null;
+      }
+      const parsed = deserializeCacheRecord(raw);
+      if (!parsed || typeof parsed !== "object" || !parsed.value) return null;
+      const tags = extractTagsFromValue(parsed.value, ctx);
+      if (tags.some((t) => this.revalidatedTags.includes(t))) {
+        this.state.emit({ type: "cache.miss", meta: { reason: "revalidated-this-request" } });
+        return null;
+      }
+      const tagStates = await readTagStates(this.state, tags);
+      const isFetch = ctx?.kind === "FETCH";
+      if (tagStates.some((s) => isTagStateExpired(s, parsed.lastModified, isFetch))) {
+        this.state.emit({ type: "cache.miss", meta: { reason: "tag-state-expired" } });
+        return null;
+      }
+      this.state.emit({ type: "cache.hit" });
+      return { ...parsed, tags };
+    } catch (err) {
+      this.state.logger.error("get() unexpected error", {
+        message: err.message
+      });
+      return null;
+    }
+  }
+  async set(cacheKey, data, ctx) {
+    if (!data) return;
+    try {
+      const tags = extractTagsFromValue(data, ctx);
+      const useLocal = shouldUseLocalIncrementalStore(tags);
+      const ttl = normalizeTtlSeconds(data, ctx);
+      const record = { lastModified: Date.now(), value: data };
+      const serialized = serializeCacheRecord(record);
+      const eKey = entryKey(this.state, cacheKey);
+      const useRedis = !useLocal && gateRedis(this.state);
+      if (useRedis) {
+        try {
+          await withAbortSignal(
+            "incremental.set",
+            this.state.opts.abortTimeoutMs,
+            async () => {
+              const client = await this.state.conn.getOrConnect();
+              if (!client) {
+                this.state.memEntries.set(eKey, serialized, ttl);
+                return;
+              }
+              await client.set(eKey, serialized, { EX: ttl });
+            }
+          );
+          this.state.emit({ type: "cache.set", meta: { backend: "redis" } });
+          return;
+        } catch (err) {
+          if (err instanceof CacheTimeoutError) {
+            this.state.emit({ type: "redis.timeout", meta: { op: "incremental.set" } });
+          }
+        }
+      }
+      this.state.memEntries.set(eKey, serialized, ttl);
+      this.state.emit({ type: "cache.set", meta: { backend: "memory" } });
+    } catch (err) {
+      this.state.logger.error("set() error", {
+        message: err.message
+      });
+      this.state.emit({ type: "cache.set.failed" });
+    }
+  }
+  async revalidateTag(tags, durations) {
+    const list = normalizeTags([tags].flat());
+    if (list.length === 0) return;
+    const useLocal = shouldUseLocalIncrementalStore(list);
+    const useRedis = !useLocal && gateRedis(this.state);
+    const now = Date.now();
+    const payload = durations ? {
+      stale: now,
+      ...durations.expire !== void 0 ? { expired: now + durations.expire * 1e3 } : {}
+    } : { expired: now };
+    for (const t of list) this.state.memTagStates.set(t, payload);
+    if (!useRedis) {
+      this.state.emit({
+        type: payload.expired ? "tag.invalidate.hard" : "tag.invalidate.soft",
+        meta: { count: list.length, backend: "memory" }
+      });
+      return;
+    }
+    try {
+      await withAbortSignal(
+        "incremental.revalidateTag",
+        this.state.opts.abortTimeoutMs,
+        async () => {
+          const client = await this.state.conn.getOrConnect();
+          if (!client) return;
+          await Promise.all(
+            list.map(
+              (t) => client.set(tagMetaKey(this.state, t), JSON.stringify(payload), {
+                EX: ONE_YEAR_SEC
+              })
+            )
+          );
+        }
+      );
+      this.state.emit({
+        type: payload.expired ? "tag.invalidate.hard" : "tag.invalidate.soft",
+        meta: { count: list.length, backend: "redis" }
+      });
+    } catch (err) {
+      this.state.logger.warn("revalidateTag() failed", {
+        message: err.message
+      });
+      if (payload.expired !== void 0) throw err;
+    }
+  }
+  resetRequestCache() {
+  }
+};
+function createIncrementalCacheHandler(opts) {
+  const state = init(opts);
+  class BoundIncrementalCacheHandler extends IncrementalRedisCacheHandler {
+    constructor(ctx) {
+      super(state, ctx);
+    }
+  }
+  return BoundIncrementalCacheHandler;
+}
+
+exports.IncrementalRedisCacheHandler = IncrementalRedisCacheHandler;
+exports.createIncrementalCacheHandler = createIncrementalCacheHandler;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map