express-memorize 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+# [1.5.0](https://github.com/ElJijuna/express-memorize/compare/v1.4.0...v1.5.0) (2026-05-11)
+
+
+### Features
+
+* add framework-agnostic cache API and Express adapter architecture ([78b605d](https://github.com/ElJijuna/express-memorize/commit/78b605d1dc33a361f31339c661f5a527bda47a02)), closes [#6](https://github.com/ElJijuna/express-memorize/issues/6)
+* add generic Fetch API cache adapter ([b36bf48](https://github.com/ElJijuna/express-memorize/commit/b36bf489c5a92cef05a2551df37b3d014d3588db)), closes [#12](https://github.com/ElJijuna/express-memorize/issues/12)
+* add Hono adapter for edge/serverless runtimes ([eb2f967](https://github.com/ElJijuna/express-memorize/commit/eb2f9675cb8f668bad76a88aabb19b622d83fac3)), closes [#13](https://github.com/ElJijuna/express-memorize/issues/13)
+* add Infinity TTL support and finite default TTL ([e353785](https://github.com/ElJijuna/express-memorize/commit/e353785966e3ae425610cba200df6f89691beaa0))
+* add maxEntries limit, LRU eviction, and cache size metrics ([14e4c5a](https://github.com/ElJijuna/express-memorize/commit/14e4c5a670d9bd2dcb253130b89f994988dfe466)), closes [#14](https://github.com/ElJijuna/express-memorize/issues/14)
+* configure package exports for tree-shaking and adapter subpaths ([14d4dcc](https://github.com/ElJijuna/express-memorize/commit/14d4dccd145d02e3966a8f977f0cf719c7123e81)), closes [#10](https://github.com/ElJijuna/express-memorize/issues/10)
+* **nestjs:** add cache interceptor adapter (closes [#7](https://github.com/ElJijuna/express-memorize/issues/7)) ([f1b9707](https://github.com/ElJijuna/express-memorize/commit/f1b970792123062dc32d464d2ccb1ccea7a3d7a1))
+
 # Changelog
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  In-memory cache middleware for <strong>Express.js</strong>.<br/>
+  In-memory HTTP cache for <strong>Express, NestJS, Hono, Fetch API</strong>, and more.<br/>
   Caches <code>GET</code> responses with optional TTL — zero dependencies, fully typed.
 </p>
 
@@ -18,13 +18,16 @@
 ## Features
 
 - Caches `GET` responses automatically when status code is `2xx`
-- Per-route TTL override
-- Event hooks: `set`, `delete`, `expire`
-- Cache inspection and invalidation API
+- Works with **Express**, **NestJS**, **Hono**, **Fetch API / serverless**, and direct service-level usage
+- Per-route TTL override and `noCache` bypass
+- **`maxEntries` cap with LRU eviction** to bound memory usage
+- **Size metrics**: `size()`, `byteSize()`, `getStats()`
+- **Service-level cache**: `remember()`, `set()`, `getValue()`
+- Event hooks: `set`, `delete`, `expire`, `evict`
+- Cache inspection and invalidation API (`get`, `getAll`, `delete`, `deleteMatching`, `clear`)
 - Hit counter per cache entry
 - `X-Cache: HIT | MISS | BYPASS` response header
-- Zero runtime dependencies
-- Full TypeScript support
+- Zero runtime dependencies, fully typed
 
 ## Installation
 
@@ -32,14 +35,23 @@
 npm install express-memorize
 ```
 
+Adapters for non-Express runtimes are optional — install only what you need:
+
+```bash
+npm install hono   # only if using the Hono adapter
+npm install @nestjs/common @nestjs/core rxjs   # only if using the NestJS adapter
+```
+
 ## Quick Start
 
+### Express
+
 ```typescript
 import express from 'express';
 import { memorize } from 'express-memorize';
 
 const app = express();
-const cache = memorize({ ttl: 30_000 }); // 30 seconds global TTL
+const cache = memorize({ ttl: 30_000 });
 
 app.get('/users', cache(), async (req, res) => {
   const users = await db.getUsers();
@@ -49,32 +61,92 @@ app.get('/users', cache(), async (req, res) => {
 app.listen(3000);
 ```
 
-The first request computes the response normally. Every subsequent `GET /users` is served from memory until the TTL expires.
+### Hono
 
-## Usage
+```typescript
+import { Hono } from 'hono';
+import { memorize } from 'express-memorize';
+import { createHonoMiddleware } from 'express-memorize/hono';
 
-### Global middleware
+const app = new Hono();
+const cache = memorize({ ttl: 30_000 });
 
-Apply the cache to the entire application with `app.use()`. Every `GET` route is cached automatically — non-`GET` requests are bypassed without any extra configuration.
+app.get('/users', createHonoMiddleware(cache), async (c) => {
+  return c.json(await usersService.findAll());
+});
+```
+
+### NestJS
+
+```typescript
+import { Module } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import {
+  MemorizeCacheKey,
+  MemorizeInterceptor,
+  MemorizeModule,
+  MemorizeTtl,
+} from 'express-memorize/nestjs';
+
+@Module({
+  imports: [MemorizeModule.forRoot({ ttl: 30_000 })],
+  providers: [
+    {
+      provide: APP_INTERCEPTOR,
+      useExisting: MemorizeInterceptor,
+    },
+  ],
+})
+export class AppModule {}
+
+export class UsersController {
+  @MemorizeCacheKey('users:list')
+  @MemorizeTtl(10_000)
+  findAll() {
+    return usersService.findAll();
+  }
+}
+```
+
+### Fetch API / Serverless
+
+```typescript
+import { memorize } from 'express-memorize';
+import { cacheFetchHandler } from 'express-memorize/fetch';
+
+const cache = memorize({ ttl: 30_000 });
+
+export default cacheFetchHandler(cache, async (request) => {
+  const users = await usersService.findAll();
+  return Response.json(users);
+});
+```
+
+### Service-level caching
+
+Cache arbitrary values directly — no HTTP layer required.
 
 ```typescript
 const cache = memorize({ ttl: 60_000 });
 
-app.use(cache()); // applies to all GET routes
+// Compute-and-cache pattern
+const users = await cache.remember('users:list', () => usersService.findAll());
 
-app.get('/users',   (req, res) => { res.json({ data: users }) });
-app.get('/products', (req, res) => { res.json({ data: products }) });
-// POST, PUT, PATCH, DELETE routes are unaffected
+// Explicit set/get
+cache.set('config', appConfig);
+const config = cache.getValue<AppConfig>('config');
 ```
 
-### Per-route cache
+---
+
+## Usage
+
+### Global middleware (Express)
 
 ```typescript
 const cache = memorize({ ttl: 60_000 });
 
-app.get('/products', cache(), (req, res) => {
-  res.json({ data: products });
-});
+app.use(cache()); // applies to all GET routes
 ```
 
 ### Per-route TTL override
@@ -82,40 +154,70 @@ app.get('/products', cache(), (req, res) => {
 ```typescript
 const cache = memorize({ ttl: 60_000 }); // global: 60s
 
-app.get('/users',    cache(),               handler); // 60s
-app.get('/products', cache({ ttl: 10_000 }), handler); // override: 10s
-app.get('/config',   cache({ ttl: 0 }),      handler); // no expiry
+app.get('/users',    cache(),                  handler); // 60s
+app.get('/products', cache({ ttl: 10_000 }),    handler); // 10s
+app.get('/config',   cache({ ttl: Infinity }),  handler); // no expiry
 ```
 
-### Cache invalidation
+### noCache bypass
 
 ```typescript
-const cache = memorize({ ttl: 30_000 });
+app.get('/live-feed', cache({ noCache: true }), handler);
+// Sets X-Cache: BYPASS, never reads or writes the cache
+```
 
-app.get('/users', cache(), (req, res) => {
-  res.json({ data: users });
-});
+### NestJS decorators
+
+Use `MemorizeInterceptor` on a controller or globally, then configure caching at the controller or method level.
+
+```typescript
+import { Controller, Get, UseInterceptors } from '@nestjs/common';
+import {
+  MemorizeCacheKey,
+  MemorizeInterceptor,
+  MemorizeNoCache,
+  MemorizeTtl,
+} from 'express-memorize/nestjs';
+
+@Controller('users')
+@UseInterceptors(MemorizeInterceptor)
+@MemorizeTtl(30_000)
+export class UsersController {
+  @Get()
+  @MemorizeCacheKey('users:list')
+  findAll() {
+    return usersService.findAll();
+  }
+
+  @Get('live')
+  @MemorizeNoCache()
+  live() {
+    return usersService.live();
+  }
+}
+```
 
+For global usage, import `MemorizeModule.forRoot()` and register `APP_INTERCEPTOR` with `useExisting: MemorizeInterceptor` so the interceptor receives the module's shared cache instance.
+
+### Cache invalidation
+
+```typescript
 app.post('/users', (req, res) => {
   users.push(req.body);
-  cache.delete('/users'); // invalidate after mutation
-  res.status(201).json({ data: req.body });
+  cache.delete('/users');
+  res.status(201).json(req.body);
 });
 ```
 
 ### Pattern-based invalidation
 
-Use `cache.deleteMatching(pattern)` to remove all cache entries whose keys match a glob pattern. This is useful when you don't know the exact key — for example, when a URL may have different query strings.
+Use `cache.deleteMatching(pattern)` to remove entries by glob pattern.
 
 ```typescript
-// Cached keys: /api/users/abc123, /api/users/abc123?lang=es, /api/users/abc123?page=1
 app.put('/users/:id', (req, res) => {
   users.update(req.params.id, req.body);
-
-  // Remove all cached variants of this user, regardless of query params
   const deleted = cache.deleteMatching(`**/users/${req.params.id}*`);
-  console.log(`${deleted} cache entries removed`);
-
+  console.log(`${deleted} entries removed`);
   res.json({ ok: true });
 });
 ```
@@ -124,35 +226,33 @@ app.put('/users/:id', (req, res) => {
 
 | Pattern | Behaviour |
 |---------|-----------|
-| `*` | Matches any sequence of characters **within** a single path segment (does not cross `/`) |
-| `**` | Matches any sequence of characters **across** path segments (crosses `/`) |
+| `*` | Matches any sequence within a single path segment (does not cross `/`) |
+| `**` | Matches any sequence across path segments (crosses `/`) |
 | `?` | Matches any single character except `/` |
 
-`deleteMatching` returns the number of entries removed and emits a `delete` event for each one.
+### Bounding memory with `maxEntries`
 
-### Event hooks
+Prevent unbounded growth by setting a maximum number of entries. When the limit is reached, the **least-recently-used (LRU)** entry is evicted before the new one is stored.
 
 ```typescript
-const cache = memorize({ ttl: 30_000 });
+const cache = memorize({ ttl: 30_000, maxEntries: 1_000 });
+```
 
-cache.on('set', (e) => {
-  console.log(`[cache] stored ${e.key} — expires in ${e.expiresAt ? e.expiresAt - Date.now() : '∞'}ms`);
-});
+### Size metrics
 
-cache.on('delete', (e) => {
-  console.log(`[cache] deleted ${e.key}`);
-});
-
-cache.on('expire', (e) => {
-  console.log(`[cache] expired ${e.key}`);
-});
+```typescript
+cache.size();      // number of active entries
+cache.byteSize();  // approximate total body size in bytes
+cache.getStats();  // { entries, maxEntries, byteSize }
 ```
 
+> `byteSize()` is an estimate based on UTF-8 encoding for strings and `byteLength` for buffers. It may not reflect actual VM memory usage.
+
 ### Inspect the cache
 
 ```typescript
-cache.get('/users');   // CacheInfo | null — single entry
-cache.getAll();        // Record<string, CacheInfo> — all active entries
+cache.get('/users');   // CacheInfo | null
+cache.getAll();        // Record<string, CacheInfo>
 ```
 
 `CacheInfo` shape:
@@ -164,31 +264,28 @@ cache.getAll();        // Record<string, CacheInfo> — all active entries
   statusCode: number;
   contentType: string;
   expiresAt: number | null;
-  remainingTtl: number | null; // ms until expiry, null if no TTL
-  hits: number;                // total times this key was requested
+  remainingTtl: number | null; // ms until expiry, null when ttl is Infinity
+  hits: number;                // times this key was served from cache
+  size: number;                // approximate body size in bytes
 }
 ```
 
-`hits` starts at `1` on the initial cache miss (when the entry is stored) and increments by `1` on every subsequent cache hit. It resets to `1` if the entry is evicted and re-cached.
+`hits` starts at `1` on the initial cache miss and increments on every hit. It resets to `1` if the entry is evicted and re-cached.
 
-```typescript
-// Example: monitoring hot keys
-const entries = cache.getAll();
-for (const [key, info] of Object.entries(entries)) {
-  console.log(`${key} → ${info.hits} hits`);
-}
-// /users        → 42 hits
-// /products     → 7 hits
-```
-
-### Clear the cache
+### Event hooks
 
 ```typescript
-cache.delete('/users');                  // remove one entry
-cache.deleteMatching('**/users/*');      // remove all /users/* entries
-cache.clear();                           // remove all entries
+import { MemorizeEventType } from 'express-memorize';
+
+cache.on(MemorizeEventType.Set,    (e) => console.log('stored',  e.key));
+cache.on(MemorizeEventType.Delete, (e) => console.log('deleted', e.key));
+cache.on(MemorizeEventType.Expire, (e) => console.log('expired', e.key));
+cache.on(MemorizeEventType.Evict,  (e) => console.log('evicted', e.key)); // maxEntries LRU
+cache.on(MemorizeEventType.Empty,  ()  => console.log('cache is empty'));
 ```
 
+---
+
 ## API Reference
 
 ### `memorize(options?)`
@@ -197,33 +294,58 @@ Creates a cache instance. Returns a `Memorize` object.
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `ttl` | `number` | `undefined` | Time-to-live in milliseconds. Omit for no expiry. |
+| `ttl` | `number` | `60_000` | Time-to-live in milliseconds. Pass `Infinity` for no expiry. |
+| `maxEntries` | `number` | `undefined` | Maximum number of entries. LRU eviction when reached. |
 
-### `cache(options?)`
+### `cache(options?)` / `cache.express(options?)`
 
-Returns an Express `RequestHandler` middleware. Can override the global TTL.
+Returns an Express `RequestHandler`. `cache()` is a backwards-compatible alias for `cache.express()`.
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `ttl` | `number` | global `ttl` | TTL override for this specific route. |
+| `ttl` | `number` | global `ttl` | TTL override for this route. Pass `Infinity` for no expiry. |
+| `noCache` | `boolean` | `false` | Skip cache entirely. Sets `X-Cache: BYPASS`. |
+
+### Service-level cache methods
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `remember` | `(key, factory, ttl?) => Promise<T>` | Return cached value or call factory and cache the result. |
+| `set` | `(key, value, ttl?) => void` | Store an arbitrary value. |
+| `getValue` | `(key) => T \| undefined` | Retrieve a value stored via `set` or `remember`. |
 
 ### Cache management
 
 | Method | Signature | Description |
 |--------|-----------|-------------|
-| `get` | `(key: string) => CacheInfo \| null` | Returns info for a cached key. |
-| `getAll` | `() => Record<string, CacheInfo>` | Returns all active cache entries. |
-| `delete` | `(key: string) => boolean` | Removes a single entry. Returns `false` if not found. |
-| `deleteMatching` | `(pattern: string) => number` | Removes all entries matching a glob pattern. Returns the count removed. |
+| `get` | `(key) => CacheInfo \| null` | Returns info for a cached key. |
+| `getAll` | `() => Record<string, CacheInfo>` | Returns all active entries. |
+| `delete` | `(key) => boolean` | Removes a single entry. |
+| `deleteMatching` | `(pattern) => number` | Removes entries matching a glob pattern. |
 | `clear` | `() => void` | Removes all entries. |
+| `size` | `() => number` | Number of active entries. |
+| `byteSize` | `() => number` | Approximate total body size in bytes. |
+| `getStats` | `() => MemorizeStats` | Aggregate stats: `{ entries, maxEntries, byteSize }`. |
+
+### Adapters
+
+| Import path | Export | Framework |
+|-------------|--------|-----------|
+| `express-memorize` | `memorize` | Core factory |
+| `express-memorize/express` | `createExpressAdapter(cache, options?)` | Express |
+| `express-memorize/nestjs` | `MemorizeModule`, `MemorizeInterceptor`, decorators | NestJS |
+| `express-memorize/hono` | `createHonoMiddleware(cache, options?)` | Hono |
+| `express-memorize/fetch` | `cacheFetchHandler(cache, handler, options?)` | Fetch API / Serverless |
 
 ### Events
 
 | Event | Payload | When |
 |-------|---------|------|
-| `set` | `{ type, key, body, statusCode, contentType, expiresAt }` | A response is stored |
-| `delete` | `{ type, key }` | `cache.delete()`, `cache.deleteMatching()`, or `cache.clear()` is called |
+| `set` | `{ type, key, body, statusCode, contentType, expiresAt, size }` | A response is stored |
+| `delete` | `{ type, key }` | Manual removal via `delete`, `deleteMatching`, or `clear` |
 | `expire` | `{ type, key }` | TTL timer fires or lazy expiry is detected |
+| `evict` | `{ type, key }` | LRU eviction due to `maxEntries` limit |
+| `empty` | `{ type }` | Last entry removed, cache is now empty |
 
 ## Response Headers
 
@@ -231,14 +353,15 @@ Returns an Express `RequestHandler` middleware. Can override the global TTL.
 |--------|-------|-------------|
 | `X-Cache` | `HIT` | Response served from cache |
 | `X-Cache` | `MISS` | Response computed and stored |
-| `X-Cache` | `BYPASS` | Cache skipped — `noCache: true` was set for this route |
+| `X-Cache` | `BYPASS` | Cache skipped — `noCache: true` |
 
 ## Behavior
 
-- Only `GET` requests are cached. All other methods bypass the middleware entirely.
+- Only `GET` requests are cached. All other methods bypass the cache entirely.
 - Only responses with a `2xx` status code are stored.
-- Each call to `cache()` returns an independent middleware handler, but all handlers created from the same `memorize()` instance **share the same store**.
+- All middleware and adapter instances created from the same `memorize()` call **share the same store**.
 - Two separate `memorize()` calls produce **independent stores**.
+- Byte size is an approximation — strings use UTF-8 encoding, objects use `JSON.stringify` length.
 
 ## License
 

package/dist/MemorizeStore.d.ts

@@ -1,23 +1,28 @@
 import { CacheEntry } from './domain/CacheEntry';
 import { CacheInfo } from './domain/CacheInfo';
+import { MemorizeStats } from './domain/MemorizeStats';
 import { MemorizeEventType } from './domain/MemorizeEventType';
 import { MemorizeEvent } from './domain/MemorizeEvent';
 import { MemorizeSetEvent } from './domain/MemorizeSetEvent';
 import { MemorizeDeleteEvent } from './domain/MemorizeDeleteEvent';
 import { MemorizeExpireEvent } from './domain/MemorizeExpireEvent';
 import { MemorizeEmptyEvent } from './domain/MemorizeEmptyEvent';
-export type { CacheEntry, CacheInfo, MemorizeEvent, MemorizeSetEvent, MemorizeDeleteEvent, MemorizeExpireEvent, MemorizeEmptyEvent, };
+import { MemorizeEvictEvent } from './domain/MemorizeEvictEvent';
+export type { CacheEntry, CacheInfo, MemorizeStats, MemorizeEvent, MemorizeSetEvent, MemorizeDeleteEvent, MemorizeExpireEvent, MemorizeEmptyEvent, MemorizeEvictEvent, };
 export { MemorizeEventType };
 /**
- * Low-level in-memory key-value store with optional TTL and event emission.
+ * Low-level in-memory key-value store with optional TTL, LRU eviction, and event emission.
  *
  * You do not usually interact with this class directly — use the {@link memorize} factory
  * instead, which wraps this store in an Express middleware.
  */
 export declare class MemorizeStore {
+    private readonly _maxEntries?;
     private _store;
     private _timers;
+    private _totalByteSize;
     private _listeners;
+    constructor(_maxEntries?: number | undefined);
     /**
      * Registers an event listener.
      *
@@ -26,25 +31,28 @@ export declare class MemorizeStore {
      *
      * @example
      * ```ts
-     * store.on(MemorizeEventType.Set,    (e) => console.log('cached',  e.key));
-     * store.on(MemorizeEventType.Expire, (e) => console.log('expired', e.key));
+     * store.on(MemorizeEventType.Set,   (e) => console.log('cached',  e.key));
+     * store.on(MemorizeEventType.Evict, (e) => console.log('evicted', e.key));
      * ```
      */
     on(event: MemorizeEventType.Set, handler: (e: MemorizeSetEvent) => void): void;
     on(event: MemorizeEventType.Delete, handler: (e: MemorizeDeleteEvent) => void): void;
     on(event: MemorizeEventType.Expire, handler: (e: MemorizeExpireEvent) => void): void;
     on(event: MemorizeEventType.Empty, handler: (e: MemorizeEmptyEvent) => void): void;
+    on(event: MemorizeEventType.Evict, handler: (e: MemorizeEvictEvent) => void): void;
     /**
      * Stores an entry in the cache.
      *
      * If an entry already exists for the given key its TTL timer is reset and the
-     * value is overwritten. Emits a {@link MemorizeEventType.Set} event.
+     * value is overwritten. If `maxEntries` is configured and the store is full,
+     * the least-recently-used entry is evicted first. Emits a {@link MemorizeEventType.Set} event.
      *
      * @param key - The cache key (typically `req.originalUrl`).
      * @param entry - The response data to store.
-     * @param ttl - Time-to-live in milliseconds. Omit or pass `null` for no expiry.
+     * @param ttl - Time-to-live in milliseconds. Omit or pass `null` to use the default TTL.
+     * Pass `Infinity` for no expiry.
      */
-    set(key: string, entry: Omit<CacheEntry, 'expiresAt' | 'hits'>, ttl?: number | null): void;
+    set(key: string, entry: Omit<CacheEntry, 'expiresAt' | 'hits' | 'size'>, ttl?: number | null): void;
     /**
      * Returns the formatted {@link CacheInfo} for the given key, or `null` if the
      * key does not exist or its TTL has elapsed.
@@ -82,15 +90,30 @@ export declare class MemorizeStore {
      * for each entry.
      */
     clear(): void;
+    /**
+     * Returns the number of active cache entries.
+     */
+    size(): number;
+    /**
+     * Returns the approximate total byte size of all cached bodies.
+     *
+     * The value is an estimate and may not reflect actual memory usage.
+     */
+    byteSize(): number;
+    /**
+     * Returns aggregate cache statistics.
+     */
+    getStats(): MemorizeStats;
     /**
      * Returns the raw {@link CacheEntry} for the given key without formatting metadata,
      * or `null` if the entry is missing or expired. Used internally by the middleware
-     * to serve cached responses.
+     * to serve cached responses. Updates LRU order and increments the hit counter.
      *
      * @param key - The cache key to look up.
      * @internal
      */
     getRaw(key: string): CacheEntry | null;
+    private _evictLRU;
     private _evict;
     private _emit;
     private _format;

package/dist/MemorizeStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MemorizeStore.d.ts","sourceRoot":"","sources":["../src/MemorizeStore.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEjE,YAAY,EACV,UAAU,EACV,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,GACnB,CAAC;AACF,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAS7B;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,OAAO,CAAoD;IACnE,OAAO,CAAC,UAAU,CAKhB;IAEF;;;;;;;;;;;OAWG;IACH,EAAE,CAAC,KAAK,EAAE,iBAAiB,CAAC,GAAG,EAAK,OAAO,EAAE,CAAC,CAAC,EAAE,gBAAgB,KAAK,IAAI,GAAG,IAAI;IACjF,EAAE,CAAC,KAAK,EAAE,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,mBAAmB,KAAK,IAAI,GAAG,IAAI;IACpF,EAAE,CAAC,KAAK,EAAE,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,mBAAmB,KAAK,IAAI,GAAG,IAAI;IACpF,EAAE,CAAC,KAAK,EAAE,iBAAiB,CAAC,KAAK,EAAG,OAAO,EAAE,CAAC,CAAC,EAAE,kBAAkB,KAAK,IAAI,GAAG,IAAI;IAMnF;;;;;;;;;OASG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,WAAW,GAAG,MAAM,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAsB1F;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAYlC;;;OAGG;IACH,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC;IAcnC;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAM5B;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAYvC;;;OAGG;IACH,KAAK,IAAI,IAAI;IAMb;;;;;;;OAOG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAatC,OAAO,CAAC,MAAM;IAYd,OAAO,CAAC,KAAK;IAMb,OAAO,CAAC,OAAO;CAWhB"}
+{"version":3,"file":"MemorizeStore.d.ts","sourceRoot":"","sources":["../src/MemorizeStore.ts"],"names":[],"mappings":"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"}