rust-node-cache 0.1.0

package/dist/fastify.mjs

@@ -0,0 +1,48 @@
+// js/fastify.ts
+var CACHE_KEY = /* @__PURE__ */ Symbol("rustNodeCacheKey");
+async function cachePlugin(fastify, options) {
+  const { cache } = options;
+  const ttlSeconds = options.ttlSeconds;
+  const methods = options.methods ?? ["GET"];
+  const keyGenerator = options.keyGenerator ?? ((req) => `${req.method}:${req.url}`);
+  fastify.addHook(
+    "onRequest",
+    (request, reply, done) => {
+      if (!methods.includes(request.method)) {
+        done();
+        return;
+      }
+      const key = keyGenerator(request);
+      const cached = cache.get(key);
+      if (cached !== null) {
+        reply.header("X-Cache", "HIT");
+        reply.send(cached);
+        return;
+      }
+      reply.header("X-Cache", "MISS");
+      request[CACHE_KEY] = key;
+      done();
+    }
+  );
+  fastify.addHook(
+    "onSend",
+    (request, reply, payload, done) => {
+      const key = request[CACHE_KEY];
+      if (key && typeof payload === "string" && reply.statusCode >= 200 && reply.statusCode < 300) {
+        try {
+          cache.set(
+            key,
+            JSON.parse(payload),
+            ttlSeconds ? { ttlSeconds } : void 0
+          );
+        } catch {
+        }
+      }
+      done(null, payload);
+    }
+  );
+}
+export {
+  cachePlugin
+};
+//# sourceMappingURL=fastify.mjs.map

package/dist/fastify.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../js/fastify.ts"],"sourcesContent":["/**\n * Integração com Fastify: cache de respostas JSON via plugin.\n *\n * Uso:\n *   import { Cache } from \"rust-node-cache\";\n *   import { cachePlugin } from \"rust-node-cache/fastify\";\n *\n *   const cache = new Cache();\n *   fastify.register(cachePlugin, { cache, ttlSeconds: 60 });\n *\n * Fluxo: o hook `onRequest` checa o cache e, num HIT, responde imediatamente\n * (curto-circuito). Num MISS, o hook `onSend` guarda o payload serializado.\n */\n\nimport type {\n  FastifyInstance,\n  FastifyReply,\n  FastifyRequest,\n} from \"fastify\";\nimport type { Cache } from \"./index\";\n\nexport interface CachePluginOptions {\n  /** Instância de cache a usar. */\n  cache: Cache;\n  /** TTL aplicado às respostas guardadas (em segundos). */\n  ttlSeconds?: number;\n  /** Métodos HTTP elegíveis para cache. Padrão: `[\"GET\"]`. */\n  methods?: string[];\n  /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */\n  keyGenerator?: (req: FastifyRequest) => string;\n}\n\n// Guardamos a chave calculada na própria request entre os hooks.\nconst CACHE_KEY = Symbol(\"rustNodeCacheKey\");\n\n/**\n * Plugin Fastify que cacheia respostas JSON. Use com `fastify.register`.\n */\nexport async function cachePlugin(\n  fastify: FastifyInstance,\n  options: CachePluginOptions,\n): Promise<void> {\n  const { cache } = options;\n  const ttlSeconds = options.ttlSeconds;\n  const methods = options.methods ?? [\"GET\"];\n  const keyGenerator =\n    options.keyGenerator ?? ((req: FastifyRequest) => `${req.method}:${req.url}`);\n\n  fastify.addHook(\n    \"onRequest\",\n    (request: FastifyRequest, reply: FastifyReply, done: () => void) => {\n      if (!methods.includes(request.method)) {\n        done();\n        return;\n      }\n\n      const key = keyGenerator(request);\n      const cached = cache.get(key);\n      if (cached !== null) {\n        reply.header(\"X-Cache\", \"HIT\");\n        reply.send(cached);\n        return; // não chama done(): a resposta já foi enviada.\n      }\n\n      reply.header(\"X-Cache\", \"MISS\");\n      (request as unknown as Record<symbol, string>)[CACHE_KEY] = key;\n      done();\n    },\n  );\n\n  fastify.addHook(\n    \"onSend\",\n    (\n      request: FastifyRequest,\n      reply: FastifyReply,\n      payload: unknown,\n      done: (err: Error | null, value?: unknown) => void,\n    ) => {\n      const key = (request as unknown as Record<symbol, string | undefined>)[\n        CACHE_KEY\n      ];\n      if (\n        key &&\n        typeof payload === \"string\" &&\n        reply.statusCode >= 200 &&\n        reply.statusCode < 300\n      ) {\n        try {\n          cache.set(\n            key,\n            JSON.parse(payload),\n            ttlSeconds ? { ttlSeconds } : undefined,\n          );\n        } catch {\n          // payload não-JSON: simplesmente não cacheia.\n        }\n      }\n      done(null, payload);\n    },\n  );\n}\n"],"mappings":";AAiCA,IAAM,YAAY,uBAAO,kBAAkB;AAK3C,eAAsB,YACpB,SACA,SACe;AACf,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,aAAa,QAAQ;AAC3B,QAAM,UAAU,QAAQ,WAAW,CAAC,KAAK;AACzC,QAAM,eACJ,QAAQ,iBAAiB,CAAC,QAAwB,GAAG,IAAI,MAAM,IAAI,IAAI,GAAG;AAE5E,UAAQ;AAAA,IACN;AAAA,IACA,CAAC,SAAyB,OAAqB,SAAqB;AAClE,UAAI,CAAC,QAAQ,SAAS,QAAQ,MAAM,GAAG;AACrC,aAAK;AACL;AAAA,MACF;AAEA,YAAM,MAAM,aAAa,OAAO;AAChC,YAAM,SAAS,MAAM,IAAI,GAAG;AAC5B,UAAI,WAAW,MAAM;AACnB,cAAM,OAAO,WAAW,KAAK;AAC7B,cAAM,KAAK,MAAM;AACjB;AAAA,MACF;AAEA,YAAM,OAAO,WAAW,MAAM;AAC9B,MAAC,QAA8C,SAAS,IAAI;AAC5D,WAAK;AAAA,IACP;AAAA,EACF;AAEA,UAAQ;AAAA,IACN;AAAA,IACA,CACE,SACA,OACA,SACA,SACG;AACH,YAAM,MAAO,QACX,SACF;AACA,UACE,OACA,OAAO,YAAY,YACnB,MAAM,cAAc,OACpB,MAAM,aAAa,KACnB;AACA,YAAI;AACF,gBAAM;AAAA,YACJ;AAAA,YACA,KAAK,MAAM,OAAO;AAAA,YAClB,aAAa,EAAE,WAAW,IAAI;AAAA,UAChC;AAAA,QACF,QAAQ;AAAA,QAER;AAAA,MACF;AACA,WAAK,MAAM,OAAO;AAAA,IACpB;AAAA,EACF;AACF;","names":[]}

package/dist/index.d.mts

@@ -0,0 +1,91 @@
+/**
+ * rust-node-cache — API pública (TypeScript).
+ *
+ * "Ultra-fast in-memory cache powered by Rust."
+ *
+ * Esta camada é um wrapper fino e tipado sobre a classe `Cache` nativa gerada
+ * pelo Rust/napi-rs. Por que envolver em vez de re-exportar direto?
+ *  - permite **genéricos** ergonômicos: `cache.get<User>("user:1")`;
+ *  - normaliza `undefined`/`null` para sempre devolver `null` num miss;
+ *  - dá um único lugar para JSDoc e para evoluir a API sem quebrar o core Rust.
+ *
+ * O custo é uma chamada de função extra por operação — desprezível frente ao
+ * trabalho real (serialização + acesso ao DashMap) que acontece no Rust.
+ */
+/** Opções do construtor do cache. */
+interface CacheOptions {
+    /**
+     * Limite máximo de chaves. Ao ser atingido, `set` de uma chave **nova**
+     * retorna `false` (sobrescrever chave existente continua permitido).
+     * Sem valor => cache ilimitado.
+     */
+    maxSize?: number;
+}
+/** Opções por operação de escrita. */
+interface SetOptions {
+    /** Tempo de vida em segundos. Ausente => a entrada não expira por tempo. */
+    ttlSeconds?: number;
+}
+/** Estatísticas acumuladas do cache (mais o tamanho atual). */
+interface CacheStats {
+    /** Leituras que encontraram uma entrada válida. */
+    hits: number;
+    /** Leituras sem chave válida (ausente ou expirada). */
+    misses: number;
+    /** Total de escritas (`set`). */
+    sets: number;
+    /** Total de remoções explícitas (`delete`). */
+    deletes: number;
+    /** Total de entradas removidas por expiração. */
+    expired: number;
+    /** Número de chaves armazenadas agora. */
+    size: number;
+}
+/**
+ * Cache em memória ultrarrápido com núcleo em Rust (DashMap + contadores
+ * atômicos). Thread-safe e com suporte a TTL por entrada.
+ *
+ * @example
+ * ```ts
+ * import { Cache } from "rust-node-cache";
+ *
+ * const cache = new Cache();
+ * cache.set("user:1", { id: 1, name: "Roberto" });
+ * cache.get<{ id: number; name: string }>("user:1"); // { id: 1, name: "Roberto" }
+ * ```
+ */
+declare class Cache {
+    /** Instância da classe nativa (Rust). */
+    private readonly native;
+    constructor(options?: CacheOptions);
+    /**
+     * Armazena (ou sobrescreve) um valor. O valor é serializado como JSON no core.
+     *
+     * @returns `true` em sucesso; `false` se `maxSize` foi atingido e a chave é nova.
+     */
+    set<T>(key: string, value: T, options?: SetOptions): boolean;
+    /**
+     * Lê um valor. Aplica expiração preguiçosa: chaves vencidas contam como miss.
+     *
+     * @returns o valor desserializado, ou `null` se ausente/expirado.
+     */
+    get<T = unknown>(key: string): T | null;
+    /** Remove uma chave. Retorna `true` se ela existia. */
+    delete(key: string): boolean;
+    /** Indica se a chave existe e está válida (não expirada). */
+    exists(key: string): boolean;
+    /** Esvazia o cache (não zera os contadores históricos de `stats`). */
+    clear(): void;
+    /** Número de chaves armazenadas no momento. */
+    size(): number;
+    /**
+     * Varre e remove todas as entradas expiradas de uma só vez.
+     *
+     * @returns quantas entradas foram removidas.
+     */
+    cleanupExpired(): number;
+    /** Retorna as estatísticas acumuladas + o tamanho atual. */
+    stats(): CacheStats;
+}
+
+export { Cache, type CacheOptions, type CacheStats, type SetOptions };

package/dist/index.d.ts

@@ -0,0 +1,91 @@
+/**
+ * rust-node-cache — API pública (TypeScript).
+ *
+ * "Ultra-fast in-memory cache powered by Rust."
+ *
+ * Esta camada é um wrapper fino e tipado sobre a classe `Cache` nativa gerada
+ * pelo Rust/napi-rs. Por que envolver em vez de re-exportar direto?
+ *  - permite **genéricos** ergonômicos: `cache.get<User>("user:1")`;
+ *  - normaliza `undefined`/`null` para sempre devolver `null` num miss;
+ *  - dá um único lugar para JSDoc e para evoluir a API sem quebrar o core Rust.
+ *
+ * O custo é uma chamada de função extra por operação — desprezível frente ao
+ * trabalho real (serialização + acesso ao DashMap) que acontece no Rust.
+ */
+/** Opções do construtor do cache. */
+interface CacheOptions {
+    /**
+     * Limite máximo de chaves. Ao ser atingido, `set` de uma chave **nova**
+     * retorna `false` (sobrescrever chave existente continua permitido).
+     * Sem valor => cache ilimitado.
+     */
+    maxSize?: number;
+}
+/** Opções por operação de escrita. */
+interface SetOptions {
+    /** Tempo de vida em segundos. Ausente => a entrada não expira por tempo. */
+    ttlSeconds?: number;
+}
+/** Estatísticas acumuladas do cache (mais o tamanho atual). */
+interface CacheStats {
+    /** Leituras que encontraram uma entrada válida. */
+    hits: number;
+    /** Leituras sem chave válida (ausente ou expirada). */
+    misses: number;
+    /** Total de escritas (`set`). */
+    sets: number;
+    /** Total de remoções explícitas (`delete`). */
+    deletes: number;
+    /** Total de entradas removidas por expiração. */
+    expired: number;
+    /** Número de chaves armazenadas agora. */
+    size: number;
+}
+/**
+ * Cache em memória ultrarrápido com núcleo em Rust (DashMap + contadores
+ * atômicos). Thread-safe e com suporte a TTL por entrada.
+ *
+ * @example
+ * ```ts
+ * import { Cache } from "rust-node-cache";
+ *
+ * const cache = new Cache();
+ * cache.set("user:1", { id: 1, name: "Roberto" });
+ * cache.get<{ id: number; name: string }>("user:1"); // { id: 1, name: "Roberto" }
+ * ```
+ */
+declare class Cache {
+    /** Instância da classe nativa (Rust). */
+    private readonly native;
+    constructor(options?: CacheOptions);
+    /**
+     * Armazena (ou sobrescreve) um valor. O valor é serializado como JSON no core.
+     *
+     * @returns `true` em sucesso; `false` se `maxSize` foi atingido e a chave é nova.
+     */
+    set<T>(key: string, value: T, options?: SetOptions): boolean;
+    /**
+     * Lê um valor. Aplica expiração preguiçosa: chaves vencidas contam como miss.
+     *
+     * @returns o valor desserializado, ou `null` se ausente/expirado.
+     */
+    get<T = unknown>(key: string): T | null;
+    /** Remove uma chave. Retorna `true` se ela existia. */
+    delete(key: string): boolean;
+    /** Indica se a chave existe e está válida (não expirada). */
+    exists(key: string): boolean;
+    /** Esvazia o cache (não zera os contadores históricos de `stats`). */
+    clear(): void;
+    /** Número de chaves armazenadas no momento. */
+    size(): number;
+    /**
+     * Varre e remove todas as entradas expiradas de uma só vez.
+     *
+     * @returns quantas entradas foram removidas.
+     */
+    cleanupExpired(): number;
+    /** Retorna as estatísticas acumuladas + o tamanho atual. */
+    stats(): CacheStats;
+}
+
+export { Cache, type CacheOptions, type CacheStats, type SetOptions };

package/dist/index.js

@@ -0,0 +1,91 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// js/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Cache: () => Cache2
+});
+module.exports = __toCommonJS(index_exports);
+var native = __toESM(require("../binding.js"));
+var Cache2 = class {
+  constructor(options = {}) {
+    this.native = options.maxSize !== void 0 ? new native.Cache({ maxSize: options.maxSize }) : new native.Cache();
+  }
+  /**
+   * Armazena (ou sobrescreve) um valor. O valor é serializado como JSON no core.
+   *
+   * @returns `true` em sucesso; `false` se `maxSize` foi atingido e a chave é nova.
+   */
+  set(key, value, options) {
+    return this.native.set(key, value, options);
+  }
+  /**
+   * Lê um valor. Aplica expiração preguiçosa: chaves vencidas contam como miss.
+   *
+   * @returns o valor desserializado, ou `null` se ausente/expirado.
+   */
+  get(key) {
+    const value = this.native.get(key);
+    return value === null || value === void 0 ? null : value;
+  }
+  /** Remove uma chave. Retorna `true` se ela existia. */
+  delete(key) {
+    return this.native.delete(key);
+  }
+  /** Indica se a chave existe e está válida (não expirada). */
+  exists(key) {
+    return this.native.exists(key);
+  }
+  /** Esvazia o cache (não zera os contadores históricos de `stats`). */
+  clear() {
+    this.native.clear();
+  }
+  /** Número de chaves armazenadas no momento. */
+  size() {
+    return this.native.size();
+  }
+  /**
+   * Varre e remove todas as entradas expiradas de uma só vez.
+   *
+   * @returns quantas entradas foram removidas.
+   */
+  cleanupExpired() {
+    return this.native.cleanupExpired();
+  }
+  /** Retorna as estatísticas acumuladas + o tamanho atual. */
+  stats() {
+    return this.native.stats();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cache
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../js/index.ts"],"sourcesContent":["/**\n * rust-node-cache — API pública (TypeScript).\n *\n * \"Ultra-fast in-memory cache powered by Rust.\"\n *\n * Esta camada é um wrapper fino e tipado sobre a classe `Cache` nativa gerada\n * pelo Rust/napi-rs. Por que envolver em vez de re-exportar direto?\n *  - permite **genéricos** ergonômicos: `cache.get<User>(\"user:1\")`;\n *  - normaliza `undefined`/`null` para sempre devolver `null` num miss;\n *  - dá um único lugar para JSDoc e para evoluir a API sem quebrar o core Rust.\n *\n * O custo é uma chamada de função extra por operação — desprezível frente ao\n * trabalho real (serialização + acesso ao DashMap) que acontece no Rust.\n */\n\n// Namespace import: funciona igual em CommonJS e ESM ao consumir o addon nativo\n// (que é um módulo CJS gerado pelo napi-rs).\nimport * as native from \"../binding.js\";\n\n/** Opções do construtor do cache. */\nexport interface CacheOptions {\n  /**\n   * Limite máximo de chaves. Ao ser atingido, `set` de uma chave **nova**\n   * retorna `false` (sobrescrever chave existente continua permitido).\n   * Sem valor => cache ilimitado.\n   */\n  maxSize?: number;\n}\n\n/** Opções por operação de escrita. */\nexport interface SetOptions {\n  /** Tempo de vida em segundos. Ausente => a entrada não expira por tempo. */\n  ttlSeconds?: number;\n}\n\n/** Estatísticas acumuladas do cache (mais o tamanho atual). */\nexport interface CacheStats {\n  /** Leituras que encontraram uma entrada válida. */\n  hits: number;\n  /** Leituras sem chave válida (ausente ou expirada). */\n  misses: number;\n  /** Total de escritas (`set`). */\n  sets: number;\n  /** Total de remoções explícitas (`delete`). */\n  deletes: number;\n  /** Total de entradas removidas por expiração. */\n  expired: number;\n  /** Número de chaves armazenadas agora. */\n  size: number;\n}\n\n/**\n * Cache em memória ultrarrápido com núcleo em Rust (DashMap + contadores\n * atômicos). Thread-safe e com suporte a TTL por entrada.\n *\n * @example\n * ```ts\n * import { Cache } from \"rust-node-cache\";\n *\n * const cache = new Cache();\n * cache.set(\"user:1\", { id: 1, name: \"Roberto\" });\n * cache.get<{ id: number; name: string }>(\"user:1\"); // { id: 1, name: \"Roberto\" }\n * ```\n */\nexport class Cache {\n  /** Instância da classe nativa (Rust). */\n  private readonly native: native.Cache;\n\n  constructor(options: CacheOptions = {}) {\n    // Só repassamos o objeto de opções ao Rust quando há algo relevante.\n    this.native =\n      options.maxSize !== undefined\n        ? new native.Cache({ maxSize: options.maxSize })\n        : new native.Cache();\n  }\n\n  /**\n   * Armazena (ou sobrescreve) um valor. O valor é serializado como JSON no core.\n   *\n   * @returns `true` em sucesso; `false` se `maxSize` foi atingido e a chave é nova.\n   */\n  set<T>(key: string, value: T, options?: SetOptions): boolean {\n    return this.native.set(key, value as unknown as object, options);\n  }\n\n  /**\n   * Lê um valor. Aplica expiração preguiçosa: chaves vencidas contam como miss.\n   *\n   * @returns o valor desserializado, ou `null` se ausente/expirado.\n   */\n  get<T = unknown>(key: string): T | null {\n    const value = this.native.get(key);\n    return value === null || value === undefined ? null : (value as T);\n  }\n\n  /** Remove uma chave. Retorna `true` se ela existia. */\n  delete(key: string): boolean {\n    return this.native.delete(key);\n  }\n\n  /** Indica se a chave existe e está válida (não expirada). */\n  exists(key: string): boolean {\n    return this.native.exists(key);\n  }\n\n  /** Esvazia o cache (não zera os contadores históricos de `stats`). */\n  clear(): void {\n    this.native.clear();\n  }\n\n  /** Número de chaves armazenadas no momento. */\n  size(): number {\n    return this.native.size();\n  }\n\n  /**\n   * Varre e remove todas as entradas expiradas de uma só vez.\n   *\n   * @returns quantas entradas foram removidas.\n   */\n  cleanupExpired(): number {\n    return this.native.cleanupExpired();\n  }\n\n  /** Retorna as estatísticas acumuladas + o tamanho atual. */\n  stats(): CacheStats {\n    return this.native.stats();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,eAAAA;AAAA;AAAA;AAiBA,aAAwB;AA+CjB,IAAMA,SAAN,MAAY;AAAA,EAIjB,YAAY,UAAwB,CAAC,GAAG;AAEtC,SAAK,SACH,QAAQ,YAAY,SAChB,IAAW,aAAM,EAAE,SAAS,QAAQ,QAAQ,CAAC,IAC7C,IAAW,aAAM;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAO,KAAa,OAAU,SAA+B;AAC3D,WAAO,KAAK,OAAO,IAAI,KAAK,OAA4B,OAAO;AAAA,EACjE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAiB,KAAuB;AACtC,UAAM,QAAQ,KAAK,OAAO,IAAI,GAAG;AACjC,WAAO,UAAU,QAAQ,UAAU,SAAY,OAAQ;AAAA,EACzD;AAAA;AAAA,EAGA,OAAO,KAAsB;AAC3B,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EAC/B;AAAA;AAAA,EAGA,OAAO,KAAsB;AAC3B,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EAC/B;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,OAAO,MAAM;AAAA,EACpB;AAAA;AAAA,EAGA,OAAe;AACb,WAAO,KAAK,OAAO,KAAK;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,iBAAyB;AACvB,WAAO,KAAK,OAAO,eAAe;AAAA,EACpC;AAAA;AAAA,EAGA,QAAoB;AAClB,WAAO,KAAK,OAAO,MAAM;AAAA,EAC3B;AACF;","names":["Cache"]}

package/dist/index.mjs

@@ -0,0 +1,56 @@
+// js/index.ts
+import * as native from "../binding.js";
+var Cache2 = class {
+  constructor(options = {}) {
+    this.native = options.maxSize !== void 0 ? new native.Cache({ maxSize: options.maxSize }) : new native.Cache();
+  }
+  /**
+   * Armazena (ou sobrescreve) um valor. O valor é serializado como JSON no core.
+   *
+   * @returns `true` em sucesso; `false` se `maxSize` foi atingido e a chave é nova.
+   */
+  set(key, value, options) {
+    return this.native.set(key, value, options);
+  }
+  /**
+   * Lê um valor. Aplica expiração preguiçosa: chaves vencidas contam como miss.
+   *
+   * @returns o valor desserializado, ou `null` se ausente/expirado.
+   */
+  get(key) {
+    const value = this.native.get(key);
+    return value === null || value === void 0 ? null : value;
+  }
+  /** Remove uma chave. Retorna `true` se ela existia. */
+  delete(key) {
+    return this.native.delete(key);
+  }
+  /** Indica se a chave existe e está válida (não expirada). */
+  exists(key) {
+    return this.native.exists(key);
+  }
+  /** Esvazia o cache (não zera os contadores históricos de `stats`). */
+  clear() {
+    this.native.clear();
+  }
+  /** Número de chaves armazenadas no momento. */
+  size() {
+    return this.native.size();
+  }
+  /**
+   * Varre e remove todas as entradas expiradas de uma só vez.
+   *
+   * @returns quantas entradas foram removidas.
+   */
+  cleanupExpired() {
+    return this.native.cleanupExpired();
+  }
+  /** Retorna as estatísticas acumuladas + o tamanho atual. */
+  stats() {
+    return this.native.stats();
+  }
+};
+export {
+  Cache2 as Cache
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../js/index.ts"],"sourcesContent":["/**\n * rust-node-cache — API pública (TypeScript).\n *\n * \"Ultra-fast in-memory cache powered by Rust.\"\n *\n * Esta camada é um wrapper fino e tipado sobre a classe `Cache` nativa gerada\n * pelo Rust/napi-rs. Por que envolver em vez de re-exportar direto?\n *  - permite **genéricos** ergonômicos: `cache.get<User>(\"user:1\")`;\n *  - normaliza `undefined`/`null` para sempre devolver `null` num miss;\n *  - dá um único lugar para JSDoc e para evoluir a API sem quebrar o core Rust.\n *\n * O custo é uma chamada de função extra por operação — desprezível frente ao\n * trabalho real (serialização + acesso ao DashMap) que acontece no Rust.\n */\n\n// Namespace import: funciona igual em CommonJS e ESM ao consumir o addon nativo\n// (que é um módulo CJS gerado pelo napi-rs).\nimport * as native from \"../binding.js\";\n\n/** Opções do construtor do cache. */\nexport interface CacheOptions {\n  /**\n   * Limite máximo de chaves. Ao ser atingido, `set` de uma chave **nova**\n   * retorna `false` (sobrescrever chave existente continua permitido).\n   * Sem valor => cache ilimitado.\n   */\n  maxSize?: number;\n}\n\n/** Opções por operação de escrita. */\nexport interface SetOptions {\n  /** Tempo de vida em segundos. Ausente => a entrada não expira por tempo. */\n  ttlSeconds?: number;\n}\n\n/** Estatísticas acumuladas do cache (mais o tamanho atual). */\nexport interface CacheStats {\n  /** Leituras que encontraram uma entrada válida. */\n  hits: number;\n  /** Leituras sem chave válida (ausente ou expirada). */\n  misses: number;\n  /** Total de escritas (`set`). */\n  sets: number;\n  /** Total de remoções explícitas (`delete`). */\n  deletes: number;\n  /** Total de entradas removidas por expiração. */\n  expired: number;\n  /** Número de chaves armazenadas agora. */\n  size: number;\n}\n\n/**\n * Cache em memória ultrarrápido com núcleo em Rust (DashMap + contadores\n * atômicos). Thread-safe e com suporte a TTL por entrada.\n *\n * @example\n * ```ts\n * import { Cache } from \"rust-node-cache\";\n *\n * const cache = new Cache();\n * cache.set(\"user:1\", { id: 1, name: \"Roberto\" });\n * cache.get<{ id: number; name: string }>(\"user:1\"); // { id: 1, name: \"Roberto\" }\n * ```\n */\nexport class Cache {\n  /** Instância da classe nativa (Rust). */\n  private readonly native: native.Cache;\n\n  constructor(options: CacheOptions = {}) {\n    // Só repassamos o objeto de opções ao Rust quando há algo relevante.\n    this.native =\n      options.maxSize !== undefined\n        ? new native.Cache({ maxSize: options.maxSize })\n        : new native.Cache();\n  }\n\n  /**\n   * Armazena (ou sobrescreve) um valor. O valor é serializado como JSON no core.\n   *\n   * @returns `true` em sucesso; `false` se `maxSize` foi atingido e a chave é nova.\n   */\n  set<T>(key: string, value: T, options?: SetOptions): boolean {\n    return this.native.set(key, value as unknown as object, options);\n  }\n\n  /**\n   * Lê um valor. Aplica expiração preguiçosa: chaves vencidas contam como miss.\n   *\n   * @returns o valor desserializado, ou `null` se ausente/expirado.\n   */\n  get<T = unknown>(key: string): T | null {\n    const value = this.native.get(key);\n    return value === null || value === undefined ? null : (value as T);\n  }\n\n  /** Remove uma chave. Retorna `true` se ela existia. */\n  delete(key: string): boolean {\n    return this.native.delete(key);\n  }\n\n  /** Indica se a chave existe e está válida (não expirada). */\n  exists(key: string): boolean {\n    return this.native.exists(key);\n  }\n\n  /** Esvazia o cache (não zera os contadores históricos de `stats`). */\n  clear(): void {\n    this.native.clear();\n  }\n\n  /** Número de chaves armazenadas no momento. */\n  size(): number {\n    return this.native.size();\n  }\n\n  /**\n   * Varre e remove todas as entradas expiradas de uma só vez.\n   *\n   * @returns quantas entradas foram removidas.\n   */\n  cleanupExpired(): number {\n    return this.native.cleanupExpired();\n  }\n\n  /** Retorna as estatísticas acumuladas + o tamanho atual. */\n  stats(): CacheStats {\n    return this.native.stats();\n  }\n}\n"],"mappings":";AAiBA,YAAY,YAAY;AA+CjB,IAAMA,SAAN,MAAY;AAAA,EAIjB,YAAY,UAAwB,CAAC,GAAG;AAEtC,SAAK,SACH,QAAQ,YAAY,SAChB,IAAW,aAAM,EAAE,SAAS,QAAQ,QAAQ,CAAC,IAC7C,IAAW,aAAM;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAO,KAAa,OAAU,SAA+B;AAC3D,WAAO,KAAK,OAAO,IAAI,KAAK,OAA4B,OAAO;AAAA,EACjE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAiB,KAAuB;AACtC,UAAM,QAAQ,KAAK,OAAO,IAAI,GAAG;AACjC,WAAO,UAAU,QAAQ,UAAU,SAAY,OAAQ;AAAA,EACzD;AAAA;AAAA,EAGA,OAAO,KAAsB;AAC3B,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EAC/B;AAAA;AAAA,EAGA,OAAO,KAAsB;AAC3B,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EAC/B;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,OAAO,MAAM;AAAA,EACpB;AAAA;AAAA,EAGA,OAAe;AACb,WAAO,KAAK,OAAO,KAAK;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,iBAAyB;AACvB,WAAO,KAAK,OAAO,eAAe;AAAA,EACpC;AAAA;AAAA,EAGA,QAAoB;AAClB,WAAO,KAAK,OAAO,MAAM;AAAA,EAC3B;AACF;","names":["Cache"]}

package/dist/nestjs.d.mts

@@ -0,0 +1,46 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { Cache } from './index.mjs';
+
+/**
+ * Integração com NestJS: interceptor de cache de respostas.
+ *
+ * Uso:
+ *   import { Cache } from "rust-node-cache";
+ *   import { CacheInterceptor } from "rust-node-cache/nestjs";
+ *
+ *   const cache = new Cache();
+ *   app.useGlobalInterceptors(new CacheInterceptor({ cache, ttlSeconds: 60 }));
+ *
+ * Usamos `import type` para `@nestjs/common`, ou seja, NÃO há import em runtime
+ * do Nest aqui — o pacote não força o Nest como dependência. A única dependência
+ * de runtime são os operadores `of`/`tap` do RxJS (presentes em qualquer app Nest).
+ */
+
+interface CacheInterceptorOptions {
+    /** Instância de cache a usar. */
+    cache: Cache;
+    /** TTL aplicado às respostas guardadas (em segundos). */
+    ttlSeconds?: number;
+    /** Métodos HTTP elegíveis para cache. Padrão: `["GET"]`. */
+    methods?: string[];
+    /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */
+    keyGenerator?: (req: {
+        method: string;
+        url: string;
+    }) => string;
+}
+/**
+ * Interceptor NestJS que cacheia o valor retornado pelos handlers. Num HIT,
+ * devolve o valor do cache sem executar o handler.
+ */
+declare class CacheInterceptor implements NestInterceptor {
+    private readonly cache;
+    private readonly ttlSeconds?;
+    private readonly methods;
+    private readonly keyGenerator;
+    constructor(options: CacheInterceptorOptions);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+}
+
+export { CacheInterceptor, type CacheInterceptorOptions };

package/dist/nestjs.d.ts

@@ -0,0 +1,46 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { Cache } from './index.js';
+
+/**
+ * Integração com NestJS: interceptor de cache de respostas.
+ *
+ * Uso:
+ *   import { Cache } from "rust-node-cache";
+ *   import { CacheInterceptor } from "rust-node-cache/nestjs";
+ *
+ *   const cache = new Cache();
+ *   app.useGlobalInterceptors(new CacheInterceptor({ cache, ttlSeconds: 60 }));
+ *
+ * Usamos `import type` para `@nestjs/common`, ou seja, NÃO há import em runtime
+ * do Nest aqui — o pacote não força o Nest como dependência. A única dependência
+ * de runtime são os operadores `of`/`tap` do RxJS (presentes em qualquer app Nest).
+ */
+
+interface CacheInterceptorOptions {
+    /** Instância de cache a usar. */
+    cache: Cache;
+    /** TTL aplicado às respostas guardadas (em segundos). */
+    ttlSeconds?: number;
+    /** Métodos HTTP elegíveis para cache. Padrão: `["GET"]`. */
+    methods?: string[];
+    /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */
+    keyGenerator?: (req: {
+        method: string;
+        url: string;
+    }) => string;
+}
+/**
+ * Interceptor NestJS que cacheia o valor retornado pelos handlers. Num HIT,
+ * devolve o valor do cache sem executar o handler.
+ */
+declare class CacheInterceptor implements NestInterceptor {
+    private readonly cache;
+    private readonly ttlSeconds?;
+    private readonly methods;
+    private readonly keyGenerator;
+    constructor(options: CacheInterceptorOptions);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+}
+
+export { CacheInterceptor, type CacheInterceptorOptions };

package/dist/nestjs.js

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// js/nestjs.ts
+var nestjs_exports = {};
+__export(nestjs_exports, {
+  CacheInterceptor: () => CacheInterceptor
+});
+module.exports = __toCommonJS(nestjs_exports);
+var import_rxjs = require("rxjs");
+var CacheInterceptor = class {
+  constructor(options) {
+    this.cache = options.cache;
+    this.ttlSeconds = options.ttlSeconds;
+    this.methods = options.methods ?? ["GET"];
+    this.keyGenerator = options.keyGenerator ?? ((req) => `${req.method}:${req.url}`);
+  }
+  intercept(context, next) {
+    const req = context.switchToHttp().getRequest();
+    if (!this.methods.includes(req.method)) {
+      return next.handle();
+    }
+    const key = this.keyGenerator(req);
+    const cached = this.cache.get(key);
+    if (cached !== null) {
+      return (0, import_rxjs.of)(cached);
+    }
+    return next.handle().pipe(
+      (0, import_rxjs.tap)((body) => {
+        if (body !== void 0 && body !== null) {
+          this.cache.set(
+            key,
+            body,
+            this.ttlSeconds ? { ttlSeconds: this.ttlSeconds } : void 0
+          );
+        }
+      })
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheInterceptor
+});
+//# sourceMappingURL=nestjs.js.map

package/dist/nestjs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../js/nestjs.ts"],"sourcesContent":["/**\n * Integração com NestJS: interceptor de cache de respostas.\n *\n * Uso:\n *   import { Cache } from \"rust-node-cache\";\n *   import { CacheInterceptor } from \"rust-node-cache/nestjs\";\n *\n *   const cache = new Cache();\n *   app.useGlobalInterceptors(new CacheInterceptor({ cache, ttlSeconds: 60 }));\n *\n * Usamos `import type` para `@nestjs/common`, ou seja, NÃO há import em runtime\n * do Nest aqui — o pacote não força o Nest como dependência. A única dependência\n * de runtime são os operadores `of`/`tap` do RxJS (presentes em qualquer app Nest).\n */\n\nimport type {\n  CallHandler,\n  ExecutionContext,\n  NestInterceptor,\n} from \"@nestjs/common\";\nimport type { Observable } from \"rxjs\";\nimport { of, tap } from \"rxjs\";\nimport type { Cache } from \"./index\";\n\nexport interface CacheInterceptorOptions {\n  /** Instância de cache a usar. */\n  cache: Cache;\n  /** TTL aplicado às respostas guardadas (em segundos). */\n  ttlSeconds?: number;\n  /** Métodos HTTP elegíveis para cache. Padrão: `[\"GET\"]`. */\n  methods?: string[];\n  /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */\n  keyGenerator?: (req: { method: string; url: string }) => string;\n}\n\n/**\n * Interceptor NestJS que cacheia o valor retornado pelos handlers. Num HIT,\n * devolve o valor do cache sem executar o handler.\n */\nexport class CacheInterceptor implements NestInterceptor {\n  private readonly cache: Cache;\n  private readonly ttlSeconds?: number;\n  private readonly methods: string[];\n  private readonly keyGenerator: (req: {\n    method: string;\n    url: string;\n  }) => string;\n\n  constructor(options: CacheInterceptorOptions) {\n    this.cache = options.cache;\n    this.ttlSeconds = options.ttlSeconds;\n    this.methods = options.methods ?? [\"GET\"];\n    this.keyGenerator =\n      options.keyGenerator ?? ((req) => `${req.method}:${req.url}`);\n  }\n\n  intercept(\n    context: ExecutionContext,\n    next: CallHandler,\n  ): Observable<unknown> {\n    const req = context.switchToHttp().getRequest<{\n      method: string;\n      url: string;\n    }>();\n\n    if (!this.methods.includes(req.method)) {\n      return next.handle();\n    }\n\n    const key = this.keyGenerator(req);\n    const cached = this.cache.get(key);\n    if (cached !== null) {\n      return of(cached);\n    }\n\n    return next.handle().pipe(\n      tap((body) => {\n        if (body !== undefined && body !== null) {\n          this.cache.set(\n            key,\n            body,\n            this.ttlSeconds ? { ttlSeconds: this.ttlSeconds } : undefined,\n          );\n        }\n      }),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBA,kBAAwB;AAkBjB,IAAM,mBAAN,MAAkD;AAAA,EASvD,YAAY,SAAkC;AAC5C,SAAK,QAAQ,QAAQ;AACrB,SAAK,aAAa,QAAQ;AAC1B,SAAK,UAAU,QAAQ,WAAW,CAAC,KAAK;AACxC,SAAK,eACH,QAAQ,iBAAiB,CAAC,QAAQ,GAAG,IAAI,MAAM,IAAI,IAAI,GAAG;AAAA,EAC9D;AAAA,EAEA,UACE,SACA,MACqB;AACrB,UAAM,MAAM,QAAQ,aAAa,EAAE,WAGhC;AAEH,QAAI,CAAC,KAAK,QAAQ,SAAS,IAAI,MAAM,GAAG;AACtC,aAAO,KAAK,OAAO;AAAA,IACrB;AAEA,UAAM,MAAM,KAAK,aAAa,GAAG;AACjC,UAAM,SAAS,KAAK,MAAM,IAAI,GAAG;AACjC,QAAI,WAAW,MAAM;AACnB,iBAAO,gBAAG,MAAM;AAAA,IAClB;AAEA,WAAO,KAAK,OAAO,EAAE;AAAA,UACnB,iBAAI,CAAC,SAAS;AACZ,YAAI,SAAS,UAAa,SAAS,MAAM;AACvC,eAAK,MAAM;AAAA,YACT;AAAA,YACA;AAAA,YACA,KAAK,aAAa,EAAE,YAAY,KAAK,WAAW,IAAI;AAAA,UACtD;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}

package/dist/nestjs.mjs

@@ -0,0 +1,36 @@
+// js/nestjs.ts
+import { of, tap } from "rxjs";
+var CacheInterceptor = class {
+  constructor(options) {
+    this.cache = options.cache;
+    this.ttlSeconds = options.ttlSeconds;
+    this.methods = options.methods ?? ["GET"];
+    this.keyGenerator = options.keyGenerator ?? ((req) => `${req.method}:${req.url}`);
+  }
+  intercept(context, next) {
+    const req = context.switchToHttp().getRequest();
+    if (!this.methods.includes(req.method)) {
+      return next.handle();
+    }
+    const key = this.keyGenerator(req);
+    const cached = this.cache.get(key);
+    if (cached !== null) {
+      return of(cached);
+    }
+    return next.handle().pipe(
+      tap((body) => {
+        if (body !== void 0 && body !== null) {
+          this.cache.set(
+            key,
+            body,
+            this.ttlSeconds ? { ttlSeconds: this.ttlSeconds } : void 0
+          );
+        }
+      })
+    );
+  }
+};
+export {
+  CacheInterceptor
+};
+//# sourceMappingURL=nestjs.mjs.map

package/dist/nestjs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../js/nestjs.ts"],"sourcesContent":["/**\n * Integração com NestJS: interceptor de cache de respostas.\n *\n * Uso:\n *   import { Cache } from \"rust-node-cache\";\n *   import { CacheInterceptor } from \"rust-node-cache/nestjs\";\n *\n *   const cache = new Cache();\n *   app.useGlobalInterceptors(new CacheInterceptor({ cache, ttlSeconds: 60 }));\n *\n * Usamos `import type` para `@nestjs/common`, ou seja, NÃO há import em runtime\n * do Nest aqui — o pacote não força o Nest como dependência. A única dependência\n * de runtime são os operadores `of`/`tap` do RxJS (presentes em qualquer app Nest).\n */\n\nimport type {\n  CallHandler,\n  ExecutionContext,\n  NestInterceptor,\n} from \"@nestjs/common\";\nimport type { Observable } from \"rxjs\";\nimport { of, tap } from \"rxjs\";\nimport type { Cache } from \"./index\";\n\nexport interface CacheInterceptorOptions {\n  /** Instância de cache a usar. */\n  cache: Cache;\n  /** TTL aplicado às respostas guardadas (em segundos). */\n  ttlSeconds?: number;\n  /** Métodos HTTP elegíveis para cache. Padrão: `[\"GET\"]`. */\n  methods?: string[];\n  /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */\n  keyGenerator?: (req: { method: string; url: string }) => string;\n}\n\n/**\n * Interceptor NestJS que cacheia o valor retornado pelos handlers. Num HIT,\n * devolve o valor do cache sem executar o handler.\n */\nexport class CacheInterceptor implements NestInterceptor {\n  private readonly cache: Cache;\n  private readonly ttlSeconds?: number;\n  private readonly methods: string[];\n  private readonly keyGenerator: (req: {\n    method: string;\n    url: string;\n  }) => string;\n\n  constructor(options: CacheInterceptorOptions) {\n    this.cache = options.cache;\n    this.ttlSeconds = options.ttlSeconds;\n    this.methods = options.methods ?? [\"GET\"];\n    this.keyGenerator =\n      options.keyGenerator ?? ((req) => `${req.method}:${req.url}`);\n  }\n\n  intercept(\n    context: ExecutionContext,\n    next: CallHandler,\n  ): Observable<unknown> {\n    const req = context.switchToHttp().getRequest<{\n      method: string;\n      url: string;\n    }>();\n\n    if (!this.methods.includes(req.method)) {\n      return next.handle();\n    }\n\n    const key = this.keyGenerator(req);\n    const cached = this.cache.get(key);\n    if (cached !== null) {\n      return of(cached);\n    }\n\n    return next.handle().pipe(\n      tap((body) => {\n        if (body !== undefined && body !== null) {\n          this.cache.set(\n            key,\n            body,\n            this.ttlSeconds ? { ttlSeconds: this.ttlSeconds } : undefined,\n          );\n        }\n      }),\n    );\n  }\n}\n"],"mappings":";AAqBA,SAAS,IAAI,WAAW;AAkBjB,IAAM,mBAAN,MAAkD;AAAA,EASvD,YAAY,SAAkC;AAC5C,SAAK,QAAQ,QAAQ;AACrB,SAAK,aAAa,QAAQ;AAC1B,SAAK,UAAU,QAAQ,WAAW,CAAC,KAAK;AACxC,SAAK,eACH,QAAQ,iBAAiB,CAAC,QAAQ,GAAG,IAAI,MAAM,IAAI,IAAI,GAAG;AAAA,EAC9D;AAAA,EAEA,UACE,SACA,MACqB;AACrB,UAAM,MAAM,QAAQ,aAAa,EAAE,WAGhC;AAEH,QAAI,CAAC,KAAK,QAAQ,SAAS,IAAI,MAAM,GAAG;AACtC,aAAO,KAAK,OAAO;AAAA,IACrB;AAEA,UAAM,MAAM,KAAK,aAAa,GAAG;AACjC,UAAM,SAAS,KAAK,MAAM,IAAI,GAAG;AACjC,QAAI,WAAW,MAAM;AACnB,aAAO,GAAG,MAAM;AAAA,IAClB;AAEA,WAAO,KAAK,OAAO,EAAE;AAAA,MACnB,IAAI,CAAC,SAAS;AACZ,YAAI,SAAS,UAAa,SAAS,MAAM;AACvC,eAAK,MAAM;AAAA,YACT;AAAA,YACA;AAAA,YACA,KAAK,aAAa,EAAE,YAAY,KAAK,WAAW,IAAI;AAAA,UACtD;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}