@frontmcp/plugin-remember 1.8.6 → 1.8.7

package/esm/index.mjs

@@ -289,6 +289,16 @@ var RememberIdentityError = class extends PublicMcpError {
     super(message, "REMEMBER_IDENTITY_REQUIRED", 403);
   }
 };
+var RememberScopeNotAllowedError = class extends PublicMcpError {
+  name = "RememberScopeNotAllowedError";
+  constructor(scope, allowedScopes) {
+    super(
+      `Scope '${scope}' is not allowed. Allowed scopes: ${allowedScopes.join(", ")}`,
+      "REMEMBER_SCOPE_NOT_ALLOWED",
+      400
+    );
+  }
+};
 
 // plugins/plugin-remember/src/remember.legacy-purge.ts
 var LEGACY_SCOPES = ["session", "tool", "user"];
@@ -1129,6 +1139,265 @@ var RememberAccessorToken = /* @__PURE__ */ Symbol(
   "plugin:remember:accessor"
 );
 
+// plugins/plugin-remember/src/tools/remember-tools.factory.ts
+import { Tool as Tool5 } from "@frontmcp/sdk";
+
+// plugins/plugin-remember/src/tools/forget.tool.ts
+import { z as z2 } from "@frontmcp/lazy-zod";
+import { Tool, ToolContext } from "@frontmcp/sdk";
+
+// plugins/plugin-remember/src/tools/remember-scope.description.ts
+var REMEMBER_SCOPE_DESCRIPTION = "Whose memory to use (default: session). session: this session; without one (stateless HTTP, MCP 2026-07-28), the signed-in caller across its requests. user: the signed-in caller, across all of its sessions. tool: the tool running the call, for the same caller as session; each memory tool has its own, so the other memory tools do not see what one of them stores in tool scope. global: shared by every caller. An anonymous caller cannot use user scope, nor session or tool scope without a session.";
+
+// plugins/plugin-remember/src/tools/remember-tool-names.ts
+function rememberToolNames(prefix = "") {
+  return {
+    rememberThis: `${prefix}remember_this`,
+    recall: `${prefix}recall`,
+    forget: `${prefix}forget`,
+    listMemories: `${prefix}list_memories`
+  };
+}
+
+// plugins/plugin-remember/src/tools/forget.tool.ts
+var forgetInputSchema = {
+  key: z2.string().min(1).describe("What memory to forget"),
+  scope: z2.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION)
+};
+var forgetOutputSchema = z2.object({
+  success: z2.boolean(),
+  key: z2.string(),
+  scope: z2.string(),
+  existed: z2.boolean()
+});
+function forgetDescription() {
+  return "Forget a previously remembered value. Use this when the user wants to delete stored preferences or information.";
+}
+function forgetToolMetadata(names = rememberToolNames()) {
+  return {
+    name: names.forget,
+    description: forgetDescription(),
+    inputSchema: forgetInputSchema,
+    outputSchema: forgetOutputSchema,
+    annotations: { readOnlyHint: false }
+  };
+}
+var ForgetTool = class extends ToolContext {
+  async execute(input) {
+    const remember = this.get(RememberAccessorToken);
+    const config = this.get(RememberConfigToken);
+    const scope = input.scope ?? "session";
+    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
+    if (!allowedScopes.includes(scope)) {
+      throw this.fail(new RememberScopeNotAllowedError(scope, allowedScopes));
+    }
+    const existed = await remember.knows(input.key, { scope });
+    await remember.forget(input.key, { scope });
+    return {
+      success: true,
+      key: input.key,
+      scope,
+      existed
+    };
+  }
+};
+ForgetTool = __decorateClass([
+  Tool(forgetToolMetadata())
+], ForgetTool);
+
+// plugins/plugin-remember/src/tools/list-memories.tool.ts
+import { z as z3 } from "@frontmcp/lazy-zod";
+import { Tool as Tool2, ToolContext as ToolContext2 } from "@frontmcp/sdk";
+var listMemoriesInputSchema = {
+  scope: z3.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION),
+  pattern: z3.string().optional().describe('Pattern to filter keys (e.g., "user_*")'),
+  limit: z3.number().positive().max(100).optional().describe("Maximum number of keys to return (default: 50)")
+};
+var listMemoriesOutputSchema = z3.object({
+  keys: z3.array(z3.string()),
+  scope: z3.string(),
+  count: z3.number(),
+  truncated: z3.boolean()
+});
+function listMemoriesDescription(names = rememberToolNames()) {
+  return `List the remembered keys in one scope (default: session). Use this to see what memories are stored before you ${names.recall} or ${names.forget} one.`;
+}
+function listMemoriesToolMetadata(names = rememberToolNames()) {
+  return {
+    name: names.listMemories,
+    description: listMemoriesDescription(names),
+    inputSchema: listMemoriesInputSchema,
+    outputSchema: listMemoriesOutputSchema,
+    annotations: { readOnlyHint: true }
+  };
+}
+var ListMemoriesTool = class extends ToolContext2 {
+  async execute(input) {
+    const remember = this.get(RememberAccessorToken);
+    const config = this.get(RememberConfigToken);
+    const scope = input.scope ?? "session";
+    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
+    if (!allowedScopes.includes(scope)) {
+      throw this.fail(new RememberScopeNotAllowedError(scope, allowedScopes));
+    }
+    const limit = input.limit ?? 50;
+    let keys = await remember.list({ scope, pattern: input.pattern });
+    const truncated = keys.length > limit;
+    if (truncated) {
+      keys = keys.slice(0, limit);
+    }
+    return {
+      keys,
+      scope,
+      count: keys.length,
+      truncated
+    };
+  }
+};
+ListMemoriesTool = __decorateClass([
+  Tool2(listMemoriesToolMetadata())
+], ListMemoriesTool);
+
+// plugins/plugin-remember/src/tools/recall.tool.ts
+import { z as z4 } from "@frontmcp/lazy-zod";
+import { Tool as Tool3, ToolContext as ToolContext3 } from "@frontmcp/sdk";
+var recallInputSchema = {
+  key: z4.string().min(1).describe("What memory to recall"),
+  scope: z4.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION)
+};
+var recallOutputSchema = z4.object({
+  found: z4.boolean(),
+  key: z4.string(),
+  value: z4.unknown().optional(),
+  scope: z4.string(),
+  createdAt: z4.number().optional(),
+  expiresAt: z4.number().optional()
+});
+function recallDescription(names = rememberToolNames()) {
+  return `Recall something that was previously remembered. Use this to retrieve stored preferences, settings, or any information that was saved with ${names.rememberThis}.`;
+}
+function recallToolMetadata(names = rememberToolNames()) {
+  return {
+    name: names.recall,
+    description: recallDescription(names),
+    inputSchema: recallInputSchema,
+    outputSchema: recallOutputSchema,
+    annotations: { readOnlyHint: true }
+  };
+}
+var RecallTool = class extends ToolContext3 {
+  async execute(input) {
+    const remember = this.get(RememberAccessorToken);
+    const config = this.get(RememberConfigToken);
+    const scope = input.scope ?? "session";
+    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
+    if (!allowedScopes.includes(scope)) {
+      throw this.fail(new RememberScopeNotAllowedError(scope, allowedScopes));
+    }
+    const entry = await remember.getEntry(input.key, { scope });
+    if (!entry) {
+      return {
+        found: false,
+        key: input.key,
+        scope
+      };
+    }
+    return {
+      found: true,
+      key: input.key,
+      value: entry.value,
+      scope,
+      createdAt: entry.createdAt,
+      expiresAt: entry.expiresAt
+    };
+  }
+};
+RecallTool = __decorateClass([
+  Tool3(recallToolMetadata())
+], RecallTool);
+
+// plugins/plugin-remember/src/tools/remember-this.tool.ts
+import { z as z5 } from "@frontmcp/lazy-zod";
+import { Tool as Tool4, ToolContext as ToolContext4 } from "@frontmcp/sdk";
+var rememberThisInputSchema = {
+  key: z5.string().min(1).describe('What to call this memory (e.g., "user_preference", "last_action")'),
+  value: z5.unknown().describe("The value to remember (any JSON-serializable data)"),
+  scope: z5.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION),
+  ttl: z5.number().positive().optional().describe("Forget after this many seconds"),
+  brand: z5.enum(["preference", "cache", "state", "conversation", "custom"]).optional().describe("Type hint for the stored value")
+};
+var rememberThisOutputSchema = z5.object({
+  success: z5.boolean(),
+  key: z5.string(),
+  scope: z5.string(),
+  expiresAt: z5.number().optional()
+});
+function rememberThisDescription(names = rememberToolNames()) {
+  return `Remember something for later: store a value under a key that ${names.recall} can read back, in the scope you choose (this session by default; user scope for the signed-in user across sessions). It lasts until it is forgotten or its ttl runs out. Use this when the user asks you to remember preferences, settings, or any information they want to persist.`;
+}
+function rememberThisToolMetadata(names = rememberToolNames()) {
+  return {
+    name: names.rememberThis,
+    description: rememberThisDescription(names),
+    inputSchema: rememberThisInputSchema,
+    outputSchema: rememberThisOutputSchema,
+    annotations: { readOnlyHint: false }
+  };
+}
+var RememberThisTool = class extends ToolContext4 {
+  async execute(input) {
+    const remember = this.get(RememberAccessorToken);
+    const config = this.get(RememberConfigToken);
+    const scope = input.scope ?? "session";
+    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
+    if (!allowedScopes.includes(scope)) {
+      throw this.fail(new RememberScopeNotAllowedError(scope, allowedScopes));
+    }
+    await remember.set(input.key, input.value, {
+      scope,
+      ttl: input.ttl,
+      brand: input.brand
+    });
+    const expiresAt = input.ttl ? Date.now() + input.ttl * 1e3 : void 0;
+    return {
+      success: true,
+      key: input.key,
+      scope,
+      expiresAt
+    };
+  }
+};
+RememberThisTool = __decorateClass([
+  Tool4(rememberThisToolMetadata())
+], RememberThisTool);
+
+// plugins/plugin-remember/src/tools/remember-tools.factory.ts
+function createRememberTools(prefix = "") {
+  if (!prefix) return [RememberThisTool, RecallTool, ForgetTool, ListMemoriesTool];
+  const names = rememberToolNames(prefix);
+  let PrefixedRememberThisTool = class extends RememberThisTool {
+  };
+  PrefixedRememberThisTool = __decorateClass([
+    Tool5(rememberThisToolMetadata(names))
+  ], PrefixedRememberThisTool);
+  let PrefixedRecallTool = class extends RecallTool {
+  };
+  PrefixedRecallTool = __decorateClass([
+    Tool5(recallToolMetadata(names))
+  ], PrefixedRecallTool);
+  let PrefixedForgetTool = class extends ForgetTool {
+  };
+  PrefixedForgetTool = __decorateClass([
+    Tool5(forgetToolMetadata(names))
+  ], PrefixedForgetTool);
+  let PrefixedListMemoriesTool = class extends ListMemoriesTool {
+  };
+  PrefixedListMemoriesTool = __decorateClass([
+    Tool5(listMemoriesToolMetadata(names))
+  ], PrefixedListMemoriesTool);
+  return [PrefixedRememberThisTool, PrefixedRecallTool, PrefixedForgetTool, PrefixedListMemoriesTool];
+}
+
 // plugins/plugin-remember/src/remember.plugin.ts
 var RememberPlugin = class extends DynamicPlugin {
   options;
@@ -1145,6 +1414,11 @@ __publicField(RememberPlugin, "defaultOptions", {
   keyPrefix: "remember:",
   encryption: { enabled: true }
 });
+/**
+ * The memory tools, when `tools.enabled` is set: `remember_this`, `recall`, `forget` and
+ * `list_memories`, under `tools.prefix`.
+ */
+__publicField(RememberPlugin, "dynamicTools", (options) => options.tools?.enabled ? createRememberTools(options.tools.prefix) : []);
 /**
  * Dynamic providers based on plugin options.
  */
@@ -1276,222 +1550,19 @@ RememberPlugin = __decorateClass([
 ], RememberPlugin);
 
 // plugins/plugin-remember/src/remember.types.ts
-import { z as z2 } from "@frontmcp/lazy-zod";
-var rememberScopeSchema = z2.enum(["session", "user", "tool", "global"]);
+import { z as z6 } from "@frontmcp/lazy-zod";
+var rememberScopeSchema = z6.enum(["session", "user", "tool", "global"]);
 function brand(data, _brand) {
   return data;
 }
-var rememberEntrySchema = z2.object({
-  value: z2.unknown(),
-  brand: z2.enum(["approval", "preference", "cache", "state", "conversation", "custom"]).optional(),
-  createdAt: z2.number(),
-  updatedAt: z2.number(),
-  expiresAt: z2.number().optional(),
-  metadata: z2.record(z2.string(), z2.unknown()).optional()
-});
-
-// plugins/plugin-remember/src/tools/remember-this.tool.ts
-import { z as z3 } from "@frontmcp/lazy-zod";
-import { Tool, ToolContext } from "@frontmcp/sdk";
-
-// plugins/plugin-remember/src/tools/remember-scope.description.ts
-var REMEMBER_SCOPE_DESCRIPTION = "Whose memory to use (default: session). session: this session; without one (stateless HTTP, MCP 2026-07-28), the signed-in caller across its requests. user: the signed-in caller, across all of its sessions. tool: the tool running the call, for the same caller as session; each memory tool has its own, so the other memory tools do not see what one of them stores in tool scope. global: shared by every caller. An anonymous caller cannot use user scope, nor session or tool scope without a session.";
-
-// plugins/plugin-remember/src/tools/remember-this.tool.ts
-var rememberThisInputSchema = {
-  key: z3.string().min(1).describe('What to call this memory (e.g., "user_preference", "last_action")'),
-  value: z3.unknown().describe("The value to remember (any JSON-serializable data)"),
-  scope: z3.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION),
-  ttl: z3.number().positive().optional().describe("Forget after this many seconds"),
-  brand: z3.enum(["preference", "cache", "state", "conversation", "custom"]).optional().describe("Type hint for the stored value")
-};
-var rememberThisOutputSchema = z3.object({
-  success: z3.boolean(),
-  key: z3.string(),
-  scope: z3.string(),
-  expiresAt: z3.number().optional()
-});
-var RememberThisTool = class extends ToolContext {
-  async execute(input) {
-    const remember = this.get(RememberAccessorToken);
-    const config = this.get(RememberConfigToken);
-    const scope = input.scope ?? "session";
-    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
-    if (!allowedScopes.includes(scope)) {
-      throw this.fail(new Error(`Scope '${scope}' is not allowed. Allowed scopes: ${allowedScopes.join(", ")}`));
-    }
-    await remember.set(input.key, input.value, {
-      scope,
-      ttl: input.ttl,
-      brand: input.brand
-    });
-    const expiresAt = input.ttl ? Date.now() + input.ttl * 1e3 : void 0;
-    return {
-      success: true,
-      key: input.key,
-      scope,
-      expiresAt
-    };
-  }
-};
-RememberThisTool = __decorateClass([
-  Tool({
-    name: "remember_this",
-    description: "Remember something for later: store a value under a key that recall can read back, in the scope you choose (this session by default; user scope for the signed-in user across sessions). It lasts until it is forgotten or its ttl runs out. Use this when the user asks you to remember preferences, settings, or any information they want to persist.",
-    inputSchema: rememberThisInputSchema,
-    outputSchema: rememberThisOutputSchema,
-    annotations: {
-      readOnlyHint: false
-    }
-  })
-], RememberThisTool);
-
-// plugins/plugin-remember/src/tools/recall.tool.ts
-import { z as z4 } from "@frontmcp/lazy-zod";
-import { Tool as Tool2, ToolContext as ToolContext2 } from "@frontmcp/sdk";
-var recallInputSchema = {
-  key: z4.string().min(1).describe("What memory to recall"),
-  scope: z4.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION)
-};
-var recallOutputSchema = z4.object({
-  found: z4.boolean(),
-  key: z4.string(),
-  value: z4.unknown().optional(),
-  scope: z4.string(),
-  createdAt: z4.number().optional(),
-  expiresAt: z4.number().optional()
-});
-var RecallTool = class extends ToolContext2 {
-  async execute(input) {
-    const remember = this.get(RememberAccessorToken);
-    const config = this.get(RememberConfigToken);
-    const scope = input.scope ?? "session";
-    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
-    if (!allowedScopes.includes(scope)) {
-      this.fail(new Error(`Scope '${scope}' is not allowed. Allowed scopes: ${allowedScopes.join(", ")}`));
-    }
-    const entry = await remember.getEntry(input.key, { scope });
-    if (!entry) {
-      return {
-        found: false,
-        key: input.key,
-        scope
-      };
-    }
-    return {
-      found: true,
-      key: input.key,
-      value: entry.value,
-      scope,
-      createdAt: entry.createdAt,
-      expiresAt: entry.expiresAt
-    };
-  }
-};
-RecallTool = __decorateClass([
-  Tool2({
-    name: "recall",
-    description: "Recall something that was previously remembered. Use this to retrieve stored preferences, settings, or any information that was saved with remember_this.",
-    inputSchema: recallInputSchema,
-    outputSchema: recallOutputSchema,
-    annotations: {
-      readOnlyHint: true
-    }
-  })
-], RecallTool);
-
-// plugins/plugin-remember/src/tools/forget.tool.ts
-import { z as z5 } from "@frontmcp/lazy-zod";
-import { Tool as Tool3, ToolContext as ToolContext3 } from "@frontmcp/sdk";
-var forgetInputSchema = {
-  key: z5.string().min(1).describe("What memory to forget"),
-  scope: z5.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION)
-};
-var forgetOutputSchema = z5.object({
-  success: z5.boolean(),
-  key: z5.string(),
-  scope: z5.string(),
-  existed: z5.boolean()
-});
-var ForgetTool = class extends ToolContext3 {
-  async execute(input) {
-    const remember = this.get(RememberAccessorToken);
-    const config = this.get(RememberConfigToken);
-    const scope = input.scope ?? "session";
-    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
-    if (!allowedScopes.includes(scope)) {
-      throw this.fail(new Error(`Scope '${scope}' is not allowed. Allowed scopes: ${allowedScopes.join(", ")}`));
-    }
-    const existed = await remember.knows(input.key, { scope });
-    await remember.forget(input.key, { scope });
-    return {
-      success: true,
-      key: input.key,
-      scope,
-      existed
-    };
-  }
-};
-ForgetTool = __decorateClass([
-  Tool3({
-    name: "forget",
-    description: "Forget a previously remembered value. Use this when the user wants to delete stored preferences or information.",
-    inputSchema: forgetInputSchema,
-    outputSchema: forgetOutputSchema,
-    annotations: {
-      readOnlyHint: false
-    }
-  })
-], ForgetTool);
-
-// plugins/plugin-remember/src/tools/list-memories.tool.ts
-import { z as z6 } from "@frontmcp/lazy-zod";
-import { Tool as Tool4, ToolContext as ToolContext4 } from "@frontmcp/sdk";
-var listMemoriesInputSchema = {
-  scope: z6.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION),
-  pattern: z6.string().optional().describe('Pattern to filter keys (e.g., "user_*")'),
-  limit: z6.number().positive().max(100).optional().describe("Maximum number of keys to return (default: 50)")
-};
-var listMemoriesOutputSchema = z6.object({
-  keys: z6.array(z6.string()),
-  scope: z6.string(),
-  count: z6.number(),
-  truncated: z6.boolean()
+var rememberEntrySchema = z6.object({
+  value: z6.unknown(),
+  brand: z6.enum(["approval", "preference", "cache", "state", "conversation", "custom"]).optional(),
+  createdAt: z6.number(),
+  updatedAt: z6.number(),
+  expiresAt: z6.number().optional(),
+  metadata: z6.record(z6.string(), z6.unknown()).optional()
 });
-var ListMemoriesTool = class extends ToolContext4 {
-  async execute(input) {
-    const remember = this.get(RememberAccessorToken);
-    const config = this.get(RememberConfigToken);
-    const scope = input.scope ?? "session";
-    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
-    if (!allowedScopes.includes(scope)) {
-      throw this.fail(new Error(`Scope '${scope}' is not allowed. Allowed scopes: ${allowedScopes.join(", ")}`));
-    }
-    const limit = input.limit ?? 50;
-    let keys = await remember.list({ scope, pattern: input.pattern });
-    const truncated = keys.length > limit;
-    if (truncated) {
-      keys = keys.slice(0, limit);
-    }
-    return {
-      keys,
-      scope,
-      count: keys.length,
-      truncated
-    };
-  }
-};
-ListMemoriesTool = __decorateClass([
-  Tool4({
-    name: "list_memories",
-    description: "List the remembered keys in one scope (default: session). Use this to see what memories are stored before you recall or forget one.",
-    inputSchema: listMemoriesInputSchema,
-    outputSchema: listMemoriesOutputSchema,
-    annotations: {
-      readOnlyHint: true
-    }
-  })
-], ListMemoriesTool);
 
 // plugins/plugin-remember/src/remember.context-extension.ts
 function getRemember(ctx) {
@@ -1514,6 +1585,7 @@ export {
   RememberMemoryProvider,
   RememberPlugin,
   RememberRedisProvider,
+  RememberScopeNotAllowedError,
   RememberStoreToken,
   RememberThisTool,
   RememberVercelKvProvider,

package/esm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontmcp/plugin-remember",
-  "version": "1.8.6",
+  "version": "1.8.7",
   "description": "Remember plugin for FrontMCP - encrypted session memory with approval system for secure tool authorization",
   "author": "AgentFront <info@agentfront.dev>",
   "license": "Apache-2.0",
@@ -49,12 +49,12 @@
     }
   },
   "dependencies": {
-    "@frontmcp/sdk": "1.8.6",
-    "@frontmcp/utils": "1.8.6",
+    "@frontmcp/sdk": "1.8.7",
+    "@frontmcp/utils": "1.8.7",
     "ioredis": "^5.8.0"
   },
   "peerDependencies": {
-    "@frontmcp/lazy-zod": "1.8.6",
+    "@frontmcp/lazy-zod": "1.8.7",
     "@vercel/kv": "^2.0.0 || ^3.0.0"
   },
   "peerDependenciesMeta": {

package/index.d.ts

@@ -45,7 +45,7 @@ export type { RememberScope, RememberEntry, RememberPluginOptions, RememberPlugi
 export { brand } from './remember.types';
 export type { RememberStoreInterface } from './providers/remember-store.interface';
 export { RememberAccessor } from './providers/remember-accessor.provider';
-export { RememberIdentityError } from './remember.errors';
+export { RememberIdentityError, RememberScopeNotAllowedError } from './remember.errors';
 export { default as RememberMemoryProvider } from './providers/remember-memory.provider';
 export { default as RememberRedisProvider } from './providers/remember-redis.provider';
 export { default as RememberVercelKvProvider } from './providers/remember-vercel-kv.provider';

package/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAGH,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGvE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAGpG,YAAY,EACV,aAAa,EACb,aAAa,EACb,qBAAqB,EACrB,0BAA0B,EAC1B,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,mBAAmB,EACnB,aAAa,EACb,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAGzC,YAAY,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AACzF,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AAG9F,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAKrF,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAGH,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGvE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAGpG,YAAY,EACV,aAAa,EACb,aAAa,EACb,qBAAqB,EACrB,0BAA0B,EAC1B,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,mBAAmB,EACnB,aAAa,EACb,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAGzC,YAAY,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AACxF,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AACzF,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AAG9F,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAKrF,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC"}