@langchain/core 1.2.0-dev-1765937705265 → 1.2.0

package/dist/singletons/index.cjs

@@ -1,23 +1,22 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_globals = require('./async_local_storage/globals.cjs');
-const require_index = require('./async_local_storage/index.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_globals = require("./async_local_storage/globals.cjs");
+const require_index = require("./async_local_storage/index.cjs");
 //#region src/singletons/index.ts
-var singletons_exports = {};
-require_rolldown_runtime.__export(singletons_exports, {
+var singletons_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	AsyncLocalStorageProviderSingleton: () => require_index.AsyncLocalStorageProviderSingleton,
 	MockAsyncLocalStorage: () => require_index.MockAsyncLocalStorage,
 	_CONTEXT_VARIABLES_KEY: () => require_globals._CONTEXT_VARIABLES_KEY
 });
-
 //#endregion
 exports.AsyncLocalStorageProviderSingleton = require_index.AsyncLocalStorageProviderSingleton;
 exports.MockAsyncLocalStorage = require_index.MockAsyncLocalStorage;
 exports._CONTEXT_VARIABLES_KEY = require_globals._CONTEXT_VARIABLES_KEY;
-Object.defineProperty(exports, 'singletons_exports', {
-  enumerable: true,
-  get: function () {
-    return singletons_exports;
-  }
+Object.defineProperty(exports, "singletons_exports", {
+	enumerable: true,
+	get: function() {
+		return singletons_exports;
+	}
 });
+
 //# sourceMappingURL=index.cjs.map

package/dist/singletons/index.js

@@ -1,15 +1,13 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { _CONTEXT_VARIABLES_KEY } from "./async_local_storage/globals.js";
 import { AsyncLocalStorageProviderSingleton, MockAsyncLocalStorage } from "./async_local_storage/index.js";
-
 //#region src/singletons/index.ts
-var singletons_exports = {};
-__export(singletons_exports, {
+var singletons_exports = /* @__PURE__ */ __exportAll({
 	AsyncLocalStorageProviderSingleton: () => AsyncLocalStorageProviderSingleton,
 	MockAsyncLocalStorage: () => MockAsyncLocalStorage,
 	_CONTEXT_VARIABLES_KEY: () => _CONTEXT_VARIABLES_KEY
 });
-
 //#endregion
 export { AsyncLocalStorageProviderSingleton, MockAsyncLocalStorage, _CONTEXT_VARIABLES_KEY, singletons_exports };
+
 //# sourceMappingURL=index.js.map

package/dist/singletons/tracer.cjs

@@ -1,17 +1,13 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_utils_env = require('../utils/env.cjs');
-const langsmith = require_rolldown_runtime.__toESM(require("langsmith"));
-
+require("../_virtual/_rolldown/runtime.cjs");
+const require_utils_env = require("../utils/env.cjs");
+let langsmith = require("langsmith");
 //#region src/singletons/tracer.ts
 let client;
 const getDefaultLangChainClientSingleton = () => {
-	if (client === void 0) {
-		const clientParams = require_utils_env.getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false" ? { blockOnRootRunFinalization: true } : {};
-		client = new langsmith.Client(clientParams);
-	}
+	if (client === void 0) client = new langsmith.Client(require_utils_env.getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false" ? { blockOnRootRunFinalization: true } : {});
 	return client;
 };
-
 //#endregion
 exports.getDefaultLangChainClientSingleton = getDefaultLangChainClientSingleton;
+
 //# sourceMappingURL=tracer.cjs.map

package/dist/singletons/tracer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"tracer.cjs","names":["client: Client","getEnvironmentVariable","Client"],"sources":["../../src/singletons/tracer.ts"],"sourcesContent":["import { Client } from \"langsmith\";\nimport { getEnvironmentVariable } from \"../utils/env.js\";\n\nlet client: Client;\n\nexport const getDefaultLangChainClientSingleton = () => {\n  if (client === undefined) {\n    const clientParams =\n      getEnvironmentVariable(\"LANGCHAIN_CALLBACKS_BACKGROUND\") === \"false\"\n        ? {\n            // LangSmith has its own backgrounding system\n            blockOnRootRunFinalization: true,\n          }\n        : {};\n    client = new Client(clientParams);\n  }\n  return client;\n};\n\nexport const setDefaultLangChainClientSingleton = (newClient: Client) => {\n  client = newClient;\n};\n"],"mappings":";;;;;AAGA,IAAIA;AAEJ,MAAa,qCAAqC,MAAM;AACtD,KAAI,WAAW,QAAW;EACxB,MAAM,eACJC,yCAAuB,iCAAiC,KAAK,UACzD,EAEE,4BAA4B,KAC7B,IACD,CAAE;EACR,SAAS,IAAIC,iBAAO;CACrB;AACD,QAAO;AACR"}
+{"version":3,"file":"tracer.cjs","names":["Client","getEnvironmentVariable"],"sources":["../../src/singletons/tracer.ts"],"sourcesContent":["import { Client } from \"langsmith\";\nimport { getEnvironmentVariable } from \"../utils/env.js\";\n\nlet client: Client;\n\nexport const getDefaultLangChainClientSingleton = () => {\n  if (client === undefined) {\n    const clientParams =\n      getEnvironmentVariable(\"LANGCHAIN_CALLBACKS_BACKGROUND\") === \"false\"\n        ? {\n            // LangSmith has its own backgrounding system\n            blockOnRootRunFinalization: true,\n          }\n        : {};\n    client = new Client(clientParams);\n  }\n  return client;\n};\n\nexport const setDefaultLangChainClientSingleton = (newClient: Client) => {\n  client = newClient;\n};\n"],"mappings":";;;;AAGA,IAAI;AAEJ,MAAa,2CAA2C;AACtD,KAAI,WAAW,KAAA,EAQb,UAAS,IAAIA,UAAAA,OANXC,kBAAAA,uBAAuB,iCAAiC,KAAK,UACzD,EAEE,4BAA4B,MAC7B,GACD,EAAE,CACyB;AAEnC,QAAO"}

package/dist/singletons/tracer.js

@@ -1,16 +1,12 @@
 import { getEnvironmentVariable } from "../utils/env.js";
 import { Client } from "langsmith";
-
 //#region src/singletons/tracer.ts
 let client;
 const getDefaultLangChainClientSingleton = () => {
-	if (client === void 0) {
-		const clientParams = getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false" ? { blockOnRootRunFinalization: true } : {};
-		client = new Client(clientParams);
-	}
+	if (client === void 0) client = new Client(getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false" ? { blockOnRootRunFinalization: true } : {});
 	return client;
 };
-
 //#endregion
 export { getDefaultLangChainClientSingleton };
+
 //# sourceMappingURL=tracer.js.map

package/dist/singletons/tracer.js.map

@@ -1 +1 @@
-{"version":3,"file":"tracer.js","names":["client: Client"],"sources":["../../src/singletons/tracer.ts"],"sourcesContent":["import { Client } from \"langsmith\";\nimport { getEnvironmentVariable } from \"../utils/env.js\";\n\nlet client: Client;\n\nexport const getDefaultLangChainClientSingleton = () => {\n  if (client === undefined) {\n    const clientParams =\n      getEnvironmentVariable(\"LANGCHAIN_CALLBACKS_BACKGROUND\") === \"false\"\n        ? {\n            // LangSmith has its own backgrounding system\n            blockOnRootRunFinalization: true,\n          }\n        : {};\n    client = new Client(clientParams);\n  }\n  return client;\n};\n\nexport const setDefaultLangChainClientSingleton = (newClient: Client) => {\n  client = newClient;\n};\n"],"mappings":";;;;AAGA,IAAIA;AAEJ,MAAa,qCAAqC,MAAM;AACtD,KAAI,WAAW,QAAW;EACxB,MAAM,eACJ,uBAAuB,iCAAiC,KAAK,UACzD,EAEE,4BAA4B,KAC7B,IACD,CAAE;EACR,SAAS,IAAI,OAAO;CACrB;AACD,QAAO;AACR"}
+{"version":3,"file":"tracer.js","names":[],"sources":["../../src/singletons/tracer.ts"],"sourcesContent":["import { Client } from \"langsmith\";\nimport { getEnvironmentVariable } from \"../utils/env.js\";\n\nlet client: Client;\n\nexport const getDefaultLangChainClientSingleton = () => {\n  if (client === undefined) {\n    const clientParams =\n      getEnvironmentVariable(\"LANGCHAIN_CALLBACKS_BACKGROUND\") === \"false\"\n        ? {\n            // LangSmith has its own backgrounding system\n            blockOnRootRunFinalization: true,\n          }\n        : {};\n    client = new Client(clientParams);\n  }\n  return client;\n};\n\nexport const setDefaultLangChainClientSingleton = (newClient: Client) => {\n  client = newClient;\n};\n"],"mappings":";;;AAGA,IAAI;AAEJ,MAAa,2CAA2C;AACtD,KAAI,WAAW,KAAA,EAQb,UAAS,IAAI,OANX,uBAAuB,iCAAiC,KAAK,UACzD,EAEE,4BAA4B,MAC7B,GACD,EAAE,CACyB;AAEnC,QAAO"}

package/dist/stores.cjs

@@ -1,9 +1,8 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-const require_load_serializable = require('./load/serializable.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_load_serializable = require("./load/serializable.cjs");
 //#region src/stores.ts
-var stores_exports = {};
-require_rolldown_runtime.__export(stores_exports, {
+var stores_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	BaseStore: () => BaseStore,
 	InMemoryStore: () => InMemoryStore
 });
@@ -68,14 +67,14 @@ var InMemoryStore = class extends BaseStore {
 		for (const key of keys) if (prefix === void 0 || key.startsWith(prefix)) yield key;
 	}
 };
-
 //#endregion
 exports.BaseStore = BaseStore;
 exports.InMemoryStore = InMemoryStore;
-Object.defineProperty(exports, 'stores_exports', {
-  enumerable: true,
-  get: function () {
-    return stores_exports;
-  }
+Object.defineProperty(exports, "stores_exports", {
+	enumerable: true,
+	get: function() {
+		return stores_exports;
+	}
 });
+
 //# sourceMappingURL=stores.cjs.map

package/dist/stores.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"stores.cjs","names":["Serializable","keys: string[]","keyValuePairs: [string, T][]","prefix?: string | undefined"],"sources":["../src/stores.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n\n/**\n * Abstract interface for a key-value store.\n */\nexport abstract class BaseStore<K, V> extends Serializable {\n  /**\n   * Abstract method to get multiple values for a set of keys.\n   * @param {K[]} keys - An array of keys.\n   * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n   */\n  abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n\n  /**\n   * Abstract method to set a value for multiple keys.\n   * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n\n  /**\n   * Abstract method to delete multiple keys.\n   * @param {K[]} keys - An array of keys to delete.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mdelete(keys: K[]): Promise<void>;\n\n  /**\n   * Abstract method to yield keys optionally based on a prefix.\n   * @param {string} prefix - Optional prefix to filter keys.\n   * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n   */\n  abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class InMemoryStore<T = any> extends BaseStore<string, T> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  protected store: Record<string, T> = {};\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    return keys.map((key) => this.store[key]);\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, T][]): Promise<void> {\n    for (const [key, value] of keyValuePairs) {\n      this.store[key] = value;\n    }\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    for (const key of keys) {\n      delete this.store[key];\n    }\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string | undefined): AsyncGenerator<string> {\n    const keys = Object.keys(this.store);\n    for (const key of keys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAKA,IAAsB,YAAtB,cAA8CA,uCAAa,CA4B1D;;;;;;;;;;;;;;;;;;;;AAsBD,IAAa,gBAAb,cAA4C,UAAqB;CAC/D,eAAe,CAAC,aAAa,SAAU;CAEvC,AAAU,QAA2B,CAAE;;;;;;CAOvC,MAAM,KAAKC,MAAgB;AACzB,SAAO,KAAK,IAAI,CAAC,QAAQ,KAAK,MAAM,KAAK;CAC1C;;;;;;CAOD,MAAM,KAAKC,eAA6C;AACtD,OAAK,MAAM,CAAC,KAAK,MAAM,IAAI,eACzB,KAAK,MAAM,OAAO;CAErB;;;;;;CAOD,MAAM,QAAQD,MAA+B;AAC3C,OAAK,MAAM,OAAO,MAChB,OAAO,KAAK,MAAM;CAErB;;;;;;;CAQD,OAAO,UAAUE,QAAqD;EACpE,MAAM,OAAO,OAAO,KAAK,KAAK,MAAM;AACpC,OAAK,MAAM,OAAO,KAChB,KAAI,WAAW,UAAa,IAAI,WAAW,OAAO,EAChD,MAAM;CAGX;AACF"}
+{"version":3,"file":"stores.cjs","names":["Serializable"],"sources":["../src/stores.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n\n/**\n * Abstract interface for a key-value store.\n */\nexport abstract class BaseStore<K, V> extends Serializable {\n  /**\n   * Abstract method to get multiple values for a set of keys.\n   * @param {K[]} keys - An array of keys.\n   * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n   */\n  abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n\n  /**\n   * Abstract method to set a value for multiple keys.\n   * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n\n  /**\n   * Abstract method to delete multiple keys.\n   * @param {K[]} keys - An array of keys to delete.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mdelete(keys: K[]): Promise<void>;\n\n  /**\n   * Abstract method to yield keys optionally based on a prefix.\n   * @param {string} prefix - Optional prefix to filter keys.\n   * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n   */\n  abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport class InMemoryStore<T = any> extends BaseStore<string, T> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  protected store: Record<string, T> = {};\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    return keys.map((key) => this.store[key]);\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, T][]): Promise<void> {\n    for (const [key, value] of keyValuePairs) {\n      this.store[key] = value;\n    }\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    for (const key of keys) {\n      delete this.store[key];\n    }\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string | undefined): AsyncGenerator<string> {\n    const keys = Object.keys(this.store);\n    for (const key of keys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAKA,IAAsB,YAAtB,cAA8CA,0BAAAA,aAAa;;;;;;;;;;;;;;;;;;;;AAkD3D,IAAa,gBAAb,cAA4C,UAAqB;CAC/D,eAAe,CAAC,aAAa,UAAU;CAEvC,QAAqC,EAAE;;;;;;CAOvC,MAAM,KAAK,MAAgB;AACzB,SAAO,KAAK,KAAK,QAAQ,KAAK,MAAM,KAAK;;;;;;;CAQ3C,MAAM,KAAK,eAA6C;AACtD,OAAK,MAAM,CAAC,KAAK,UAAU,cACzB,MAAK,MAAM,OAAO;;;;;;;CAStB,MAAM,QAAQ,MAA+B;AAC3C,OAAK,MAAM,OAAO,KAChB,QAAO,KAAK,MAAM;;;;;;;;CAUtB,OAAO,UAAU,QAAqD;EACpE,MAAM,OAAO,OAAO,KAAK,KAAK,MAAM;AACpC,OAAK,MAAM,OAAO,KAChB,KAAI,WAAW,KAAA,KAAa,IAAI,WAAW,OAAO,CAChD,OAAM"}

package/dist/stores.d.cts

@@ -1,7 +1,6 @@
 import { Serializable } from "./load/serializable.cjs";
 
 //#region src/stores.d.ts
-
 /**
  * Abstract interface for a key-value store.
  */

package/dist/stores.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"stores.d.cts","names":["Serializable","BaseStore","K","V","Promise","AsyncGenerator","InMemoryStore","T","Record"],"sources":["../src/stores.d.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n/**\n * Abstract interface for a key-value store.\n */\nexport declare abstract class BaseStore<K, V> extends Serializable {\n    /**\n     * Abstract method to get multiple values for a set of keys.\n     * @param {K[]} keys - An array of keys.\n     * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n     */\n    abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n    /**\n     * Abstract method to set a value for multiple keys.\n     * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n     */\n    abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n    /**\n     * Abstract method to delete multiple keys.\n     * @param {K[]} keys - An array of keys to delete.\n     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n     */\n    abstract mdelete(keys: K[]): Promise<void>;\n    /**\n     * Abstract method to yield keys optionally based on a prefix.\n     * @param {string} prefix - Optional prefix to filter keys.\n     * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n     */\n    abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\nexport declare class InMemoryStore<T = any> extends BaseStore<string, T> {\n    lc_namespace: string[];\n    protected store: Record<string, T>;\n    /**\n     * Retrieves the values associated with the given keys from the store.\n     * @param keys Keys to retrieve values for.\n     * @returns Array of values associated with the given keys.\n     */\n    mget(keys: string[]): Promise<T[]>;\n    /**\n     * Sets the values for the given keys in the store.\n     * @param keyValuePairs Array of key-value pairs to set in the store.\n     * @returns Promise that resolves when all key-value pairs have been set.\n     */\n    mset(keyValuePairs: [string, T][]): Promise<void>;\n    /**\n     * Deletes the given keys and their associated values from the store.\n     * @param keys Keys to delete from the store.\n     * @returns Promise that resolves when all keys have been deleted.\n     */\n    mdelete(keys: string[]): Promise<void>;\n    /**\n     * Asynchronous generator that yields keys from the store. If a prefix is\n     * provided, it only yields keys that start with the prefix.\n     * @param prefix Optional prefix to filter keys.\n     * @returns AsyncGenerator that yields keys from the store.\n     */\n    yieldKeys(prefix?: string | undefined): AsyncGenerator<string>;\n}\n//# sourceMappingURL=stores.d.ts.map"],"mappings":";;;;;;AAIA;AAMwBE,uBANMD,SAMNC,CAAAA,CAAAA,EAAAA,CAAAA,CAAAA,SAN8BF,YAAAA,CAM9BE;EAAeC;;;;;EAYZD,SAAAA,IAAAA,CAAAA,IAAAA,EAZHA,CAYGA,EAAAA,CAAAA,EAZGE,OAYHF,CAAAA,CAZYC,CAYZD,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAME;;;;AAlBiC;EA6C7CE,SAAAA,IAAAA,CAAAA,aAAa,EAAA,CAjCAJ,CAiCA,EAjCGC,CAiCH,CAAA,EAAA,CAAA,EAjCUC,OAiCV,CAAA,IAAA,CAAA;EAAoCG;;;;;EAcrCA,SAAAA,OAAAA,CAAAA,IAAAA,EAzCNL,CAyCMK,EAAAA,CAAAA,EAzCAH,OAyCAG,CAAAA,IAAAA,CAAAA;EAAOH;;;;AAdqB;uCArBpBC,eAAeH;;;;;;;;;;;;;;;;;;;;;cAqBnCI,+BAA+BL,kBAAkBM;;mBAEjDC,eAAeD;;;;;;wBAMVH,QAAQG;;;;;;+BAMDA,OAAOH;;;;;;2BAMXA;;;;;;;0CAOeC"}
+{"version":3,"file":"stores.d.cts","names":[],"sources":["../src/stores.ts"],"mappings":";;;;;AAKA;uBAAsB,SAAA,eAAwB,YAAA;EAAf;;;;;EAAA,SAMpB,IAAA,CAAK,IAAA,EAAM,CAAA,KAAM,OAAA,EAAS,CAAA;EAOK;;;;;EAAA,SAA/B,IAAA,CAAK,aAAA,GAAgB,CAAA,EAAG,CAAA,MAAO,OAAA;EAbgB;;;;;EAAA,SAoB/C,OAAA,CAAQ,IAAA,EAAM,CAAA,KAAM,OAAA;EAdT;;;;;EAAA,SAqBX,SAAA,CAAU,MAAA,YAAkB,cAAA,CAAe,CAAA;AAAA;;;;;;;;;;;;;AAuBtD;;;;;;;cAAa,aAAA,kBAA+B,SAAA,SAAkB,CAAA;EAC5D,YAAA;EAAA,UAEU,KAAA,EAAO,MAAA,SAAe,CAAA;EA2BD;;;;;EApBzB,IAAA,CAAK,IAAA,aAAc,OAAA,CAAA,CAAA;EAViB;;;;;EAmBpC,IAAA,CAAK,aAAA,WAAwB,CAAA,MAAO,OAAA;EATpC;;;;;EAoBA,OAAA,CAAQ,IAAA,aAAiB,OAAA;EAXpB;;;;;;EAuBJ,SAAA,CAAU,MAAA,wBAA8B,cAAA;AAAA"}

package/dist/stores.d.ts

@@ -1,7 +1,6 @@
 import { Serializable } from "./load/serializable.js";
 
 //#region src/stores.d.ts
-
 /**
  * Abstract interface for a key-value store.
  */

package/dist/stores.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stores.d.ts","names":["Serializable","BaseStore","K","V","Promise","AsyncGenerator","InMemoryStore","T","Record"],"sources":["../src/stores.d.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n/**\n * Abstract interface for a key-value store.\n */\nexport declare abstract class BaseStore<K, V> extends Serializable {\n    /**\n     * Abstract method to get multiple values for a set of keys.\n     * @param {K[]} keys - An array of keys.\n     * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n     */\n    abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n    /**\n     * Abstract method to set a value for multiple keys.\n     * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n     */\n    abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n    /**\n     * Abstract method to delete multiple keys.\n     * @param {K[]} keys - An array of keys to delete.\n     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n     */\n    abstract mdelete(keys: K[]): Promise<void>;\n    /**\n     * Abstract method to yield keys optionally based on a prefix.\n     * @param {string} prefix - Optional prefix to filter keys.\n     * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n     */\n    abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\nexport declare class InMemoryStore<T = any> extends BaseStore<string, T> {\n    lc_namespace: string[];\n    protected store: Record<string, T>;\n    /**\n     * Retrieves the values associated with the given keys from the store.\n     * @param keys Keys to retrieve values for.\n     * @returns Array of values associated with the given keys.\n     */\n    mget(keys: string[]): Promise<T[]>;\n    /**\n     * Sets the values for the given keys in the store.\n     * @param keyValuePairs Array of key-value pairs to set in the store.\n     * @returns Promise that resolves when all key-value pairs have been set.\n     */\n    mset(keyValuePairs: [string, T][]): Promise<void>;\n    /**\n     * Deletes the given keys and their associated values from the store.\n     * @param keys Keys to delete from the store.\n     * @returns Promise that resolves when all keys have been deleted.\n     */\n    mdelete(keys: string[]): Promise<void>;\n    /**\n     * Asynchronous generator that yields keys from the store. If a prefix is\n     * provided, it only yields keys that start with the prefix.\n     * @param prefix Optional prefix to filter keys.\n     * @returns AsyncGenerator that yields keys from the store.\n     */\n    yieldKeys(prefix?: string | undefined): AsyncGenerator<string>;\n}\n//# sourceMappingURL=stores.d.ts.map"],"mappings":";;;;;;AAIA;AAMwBE,uBANMD,SAMNC,CAAAA,CAAAA,EAAAA,CAAAA,CAAAA,SAN8BF,YAAAA,CAM9BE;EAAeC;;;;;EAYZD,SAAAA,IAAAA,CAAAA,IAAAA,EAZHA,CAYGA,EAAAA,CAAAA,EAZGE,OAYHF,CAAAA,CAZYC,CAYZD,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAME;;;;AAlBiC;EA6C7CE,SAAAA,IAAAA,CAAAA,aAAa,EAAA,CAjCAJ,CAiCA,EAjCGC,CAiCH,CAAA,EAAA,CAAA,EAjCUC,OAiCV,CAAA,IAAA,CAAA;EAAoCG;;;;;EAcrCA,SAAAA,OAAAA,CAAAA,IAAAA,EAzCNL,CAyCMK,EAAAA,CAAAA,EAzCAH,OAyCAG,CAAAA,IAAAA,CAAAA;EAAOH;;;;AAdqB;uCArBpBC,eAAeH;;;;;;;;;;;;;;;;;;;;;cAqBnCI,+BAA+BL,kBAAkBM;;mBAEjDC,eAAeD;;;;;;wBAMVH,QAAQG;;;;;;+BAMDA,OAAOH;;;;;;2BAMXA;;;;;;;0CAOeC"}
+{"version":3,"file":"stores.d.ts","names":[],"sources":["../src/stores.ts"],"mappings":";;;;;AAKA;uBAAsB,SAAA,eAAwB,YAAA;EAAf;;;;;EAAA,SAMpB,IAAA,CAAK,IAAA,EAAM,CAAA,KAAM,OAAA,EAAS,CAAA;EAOK;;;;;EAAA,SAA/B,IAAA,CAAK,aAAA,GAAgB,CAAA,EAAG,CAAA,MAAO,OAAA;EAbgB;;;;;EAAA,SAoB/C,OAAA,CAAQ,IAAA,EAAM,CAAA,KAAM,OAAA;EAdT;;;;;EAAA,SAqBX,SAAA,CAAU,MAAA,YAAkB,cAAA,CAAe,CAAA;AAAA;;;;;;;;;;;;;AAuBtD;;;;;;;cAAa,aAAA,kBAA+B,SAAA,SAAkB,CAAA;EAC5D,YAAA;EAAA,UAEU,KAAA,EAAO,MAAA,SAAe,CAAA;EA2BD;;;;;EApBzB,IAAA,CAAK,IAAA,aAAc,OAAA,CAAA,CAAA;EAViB;;;;;EAmBpC,IAAA,CAAK,aAAA,WAAwB,CAAA,MAAO,OAAA;EATpC;;;;;EAoBA,OAAA,CAAQ,IAAA,aAAiB,OAAA;EAXpB;;;;;;EAuBJ,SAAA,CAAU,MAAA,wBAA8B,cAAA;AAAA"}

package/dist/stores.js

@@ -1,9 +1,7 @@
-import { __export } from "./_virtual/rolldown_runtime.js";
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { Serializable } from "./load/serializable.js";
-
 //#region src/stores.ts
-var stores_exports = {};
-__export(stores_exports, {
+var stores_exports = /* @__PURE__ */ __exportAll({
 	BaseStore: () => BaseStore,
 	InMemoryStore: () => InMemoryStore
 });
@@ -68,7 +66,7 @@ var InMemoryStore = class extends BaseStore {
 		for (const key of keys) if (prefix === void 0 || key.startsWith(prefix)) yield key;
 	}
 };
-
 //#endregion
 export { BaseStore, InMemoryStore, stores_exports };
+
 //# sourceMappingURL=stores.js.map

package/dist/stores.js.map

@@ -1 +1 @@
-{"version":3,"file":"stores.js","names":["keys: string[]","keyValuePairs: [string, T][]","prefix?: string | undefined"],"sources":["../src/stores.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n\n/**\n * Abstract interface for a key-value store.\n */\nexport abstract class BaseStore<K, V> extends Serializable {\n  /**\n   * Abstract method to get multiple values for a set of keys.\n   * @param {K[]} keys - An array of keys.\n   * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n   */\n  abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n\n  /**\n   * Abstract method to set a value for multiple keys.\n   * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n\n  /**\n   * Abstract method to delete multiple keys.\n   * @param {K[]} keys - An array of keys to delete.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mdelete(keys: K[]): Promise<void>;\n\n  /**\n   * Abstract method to yield keys optionally based on a prefix.\n   * @param {string} prefix - Optional prefix to filter keys.\n   * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n   */\n  abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class InMemoryStore<T = any> extends BaseStore<string, T> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  protected store: Record<string, T> = {};\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    return keys.map((key) => this.store[key]);\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, T][]): Promise<void> {\n    for (const [key, value] of keyValuePairs) {\n      this.store[key] = value;\n    }\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    for (const key of keys) {\n      delete this.store[key];\n    }\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string | undefined): AsyncGenerator<string> {\n    const keys = Object.keys(this.store);\n    for (const key of keys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAKA,IAAsB,YAAtB,cAA8C,aAAa,CA4B1D;;;;;;;;;;;;;;;;;;;;AAsBD,IAAa,gBAAb,cAA4C,UAAqB;CAC/D,eAAe,CAAC,aAAa,SAAU;CAEvC,AAAU,QAA2B,CAAE;;;;;;CAOvC,MAAM,KAAKA,MAAgB;AACzB,SAAO,KAAK,IAAI,CAAC,QAAQ,KAAK,MAAM,KAAK;CAC1C;;;;;;CAOD,MAAM,KAAKC,eAA6C;AACtD,OAAK,MAAM,CAAC,KAAK,MAAM,IAAI,eACzB,KAAK,MAAM,OAAO;CAErB;;;;;;CAOD,MAAM,QAAQD,MAA+B;AAC3C,OAAK,MAAM,OAAO,MAChB,OAAO,KAAK,MAAM;CAErB;;;;;;;CAQD,OAAO,UAAUE,QAAqD;EACpE,MAAM,OAAO,OAAO,KAAK,KAAK,MAAM;AACpC,OAAK,MAAM,OAAO,KAChB,KAAI,WAAW,UAAa,IAAI,WAAW,OAAO,EAChD,MAAM;CAGX;AACF"}
+{"version":3,"file":"stores.js","names":[],"sources":["../src/stores.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n\n/**\n * Abstract interface for a key-value store.\n */\nexport abstract class BaseStore<K, V> extends Serializable {\n  /**\n   * Abstract method to get multiple values for a set of keys.\n   * @param {K[]} keys - An array of keys.\n   * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n   */\n  abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n\n  /**\n   * Abstract method to set a value for multiple keys.\n   * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n\n  /**\n   * Abstract method to delete multiple keys.\n   * @param {K[]} keys - An array of keys to delete.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mdelete(keys: K[]): Promise<void>;\n\n  /**\n   * Abstract method to yield keys optionally based on a prefix.\n   * @param {string} prefix - Optional prefix to filter keys.\n   * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n   */\n  abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport class InMemoryStore<T = any> extends BaseStore<string, T> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  protected store: Record<string, T> = {};\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    return keys.map((key) => this.store[key]);\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, T][]): Promise<void> {\n    for (const [key, value] of keyValuePairs) {\n      this.store[key] = value;\n    }\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    for (const key of keys) {\n      delete this.store[key];\n    }\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string | undefined): AsyncGenerator<string> {\n    const keys = Object.keys(this.store);\n    for (const key of keys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;AAKA,IAAsB,YAAtB,cAA8C,aAAa;;;;;;;;;;;;;;;;;;;;AAkD3D,IAAa,gBAAb,cAA4C,UAAqB;CAC/D,eAAe,CAAC,aAAa,UAAU;CAEvC,QAAqC,EAAE;;;;;;CAOvC,MAAM,KAAK,MAAgB;AACzB,SAAO,KAAK,KAAK,QAAQ,KAAK,MAAM,KAAK;;;;;;;CAQ3C,MAAM,KAAK,eAA6C;AACtD,OAAK,MAAM,CAAC,KAAK,UAAU,cACzB,MAAK,MAAM,OAAO;;;;;;;CAStB,MAAM,QAAQ,MAA+B;AAC3C,OAAK,MAAM,OAAO,KAChB,QAAO,KAAK,MAAM;;;;;;;;CAUtB,OAAO,UAAU,QAAqD;EACpE,MAAM,OAAO,OAAO,KAAK,KAAK,MAAM;AACpC,OAAK,MAAM,OAAO,KAChB,KAAI,WAAW,KAAA,KAAa,IAAI,WAAW,OAAO,CAChD,OAAM"}

package/dist/structured_query/base.cjs

@@ -1,6 +1,5 @@
-const require_ir = require('./ir.cjs');
-const require_utils = require('./utils.cjs');
-
+const require_ir = require("./ir.cjs");
+const require_utils = require("./utils.cjs");
 //#region src/structured_query/base.ts
 /**
 * Abstract class that provides a blueprint for creating specific
@@ -67,14 +66,14 @@ var BasicTranslator = class extends BaseTranslator {
 		return nextArg;
 	}
 	mergeFilters(defaultFilter, generatedFilter, mergeType = "and", forceDefaultFilter = false) {
-		if (require_utils.isFilterEmpty(defaultFilter) && require_utils.isFilterEmpty(generatedFilter)) return void 0;
+		if (require_utils.isFilterEmpty(defaultFilter) && require_utils.isFilterEmpty(generatedFilter)) return;
 		if (require_utils.isFilterEmpty(defaultFilter) || mergeType === "replace") {
-			if (require_utils.isFilterEmpty(generatedFilter)) return void 0;
+			if (require_utils.isFilterEmpty(generatedFilter)) return;
 			return generatedFilter;
 		}
 		if (require_utils.isFilterEmpty(generatedFilter)) {
 			if (forceDefaultFilter) return defaultFilter;
-			if (mergeType === "and") return void 0;
+			if (mergeType === "and") return;
 			return defaultFilter;
 		}
 		if (mergeType === "and") return { $and: [defaultFilter, generatedFilter] };
@@ -82,8 +81,8 @@ var BasicTranslator = class extends BaseTranslator {
 		else throw new Error("Unknown merge type");
 	}
 };
-
 //#endregion
 exports.BaseTranslator = BaseTranslator;
 exports.BasicTranslator = BasicTranslator;
+
 //# sourceMappingURL=base.cjs.map

package/dist/structured_query/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":["Visitor","opts?: TranslatorOpts","Operators","Comparators","func: Operator | Comparator","operation: Operation","comparison: Comparison","castValue","query: StructuredQuery","defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined","generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined","isFilterEmpty"],"sources":["../../src/structured_query/base.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n  Visitor,\n  VisitorComparisonResult,\n  VisitorOperationResult,\n  VisitorResult,\n  VisitorStructuredQueryResult,\n} from \"./ir.js\";\nimport { isFilterEmpty, castValue } from \"./utils.js\";\n\n/**\n * Options object for the BasicTranslator class. Specifies the allowed\n * operators and comparators.\n */\nexport type TranslatorOpts = {\n  allowedOperators: Operator[];\n  allowedComparators: Comparator[];\n};\n\n/**\n * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport abstract class BaseTranslator<\n  T extends VectorStore = VectorStore\n> extends Visitor<T> {\n  /**\n   * Formats a given function (either an operator or a comparator) into a\n   * string.\n   * @param func The function to format.\n   * @returns Formatted string representation of the function.\n   */\n  abstract formatFunction(func: Operator | Comparator): string;\n\n  /**\n   * Merges two filters into one, using a specified merge type.\n   * @param defaultFilter The default filter.\n   * @param generatedFilter The generated filter.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.\n   * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.\n   * @returns The merged filter, or undefined if both filters are empty.\n   */\n  abstract mergeFilters(\n    defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    mergeType?: \"and\" | \"or\" | \"replace\",\n    forceDefaultFilter?: boolean\n  ): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\n}\n\n/**\n * Class that extends the BaseTranslator class and provides concrete\n * implementations for the abstract methods. Also declares three types:\n * VisitOperationOutput, VisitComparisonOutput, and\n * VisitStructuredQueryOutput, which are used as the return types for the\n * visitOperation, visitComparison, and visitStructuredQuery methods\n * respectively.\n */\nexport class BasicTranslator<\n  T extends VectorStore = VectorStore\n> extends BaseTranslator<T> {\n  declare VisitOperationOutput: VisitorOperationResult;\n\n  declare VisitComparisonOutput: VisitorComparisonResult;\n\n  declare VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n\n  allowedOperators: Operator[];\n\n  allowedComparators: Comparator[];\n\n  constructor(opts?: TranslatorOpts) {\n    super();\n    this.allowedOperators = opts?.allowedOperators ?? [\n      Operators.and,\n      Operators.or,\n    ];\n    this.allowedComparators = opts?.allowedComparators ?? [\n      Comparators.eq,\n      Comparators.ne,\n      Comparators.gt,\n      Comparators.gte,\n      Comparators.lt,\n      Comparators.lte,\n    ];\n  }\n\n  formatFunction(func: Operator | Comparator): string {\n    if (func in Comparators) {\n      if (\n        this.allowedComparators.length > 0 &&\n        this.allowedComparators.indexOf(func as Comparator) === -1\n      ) {\n        throw new Error(\n          `Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else if (func in Operators) {\n      if (\n        this.allowedOperators.length > 0 &&\n        this.allowedOperators.indexOf(func as Operator) === -1\n      ) {\n        throw new Error(\n          `Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else {\n      throw new Error(\"Unknown comparator or operator\");\n    }\n    return `$${func}`;\n  }\n\n  /**\n   * Visits an operation and returns a result.\n   * @param operation The operation to visit.\n   * @returns The result of visiting the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const args = operation.args?.map((arg) =>\n      arg.accept(this)\n    ) as VisitorResult[];\n    return {\n      [this.formatFunction(operation.operator)]: args,\n    };\n  }\n\n  /**\n   * Visits a comparison and returns a result.\n   * @param comparison The comparison to visit.\n   * @returns The result of visiting the comparison.\n   */\n  visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"] {\n    return {\n      [comparison.attribute]: {\n        [this.formatFunction(comparison.comparator)]: castValue(\n          comparison.value\n        ),\n      },\n    };\n  }\n\n  /**\n   * Visits a structured query and returns a result.\n   * @param query The structured query to visit.\n   * @returns The result of visiting the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    let nextArg = {};\n    if (query.filter) {\n      nextArg = {\n        filter: query.filter.accept(this),\n      };\n    }\n    return nextArg;\n  }\n\n  mergeFilters(\n    defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    mergeType = \"and\",\n    forceDefaultFilter = false\n  ): VisitorStructuredQueryResult[\"filter\"] | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (forceDefaultFilter) {\n        return defaultFilter;\n      }\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n    if (mergeType === \"and\") {\n      return {\n        $and: [defaultFilter, generatedFilter],\n      };\n    } else if (mergeType === \"or\") {\n      return {\n        $or: [defaultFilter, generatedFilter],\n      };\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":";;;;;;;;;AA+BA,IAAsB,iBAAtB,cAEUA,mBAAW,CAuBpB;;;;;;;;;AAUD,IAAa,kBAAb,cAEU,eAAkB;CAO1B;CAEA;CAEA,YAAYC,MAAuB;EACjC,OAAO;EACP,KAAK,mBAAmB,MAAM,oBAAoB,CAChDC,qBAAU,KACVA,qBAAU,EACX;EACD,KAAK,qBAAqB,MAAM,sBAAsB;GACpDC,uBAAY;GACZA,uBAAY;GACZA,uBAAY;GACZA,uBAAY;GACZA,uBAAY;GACZA,uBAAY;EACb;CACF;CAED,eAAeC,MAAqC;AAClD,MAAI,QAAQD,wBACV;OACE,KAAK,mBAAmB,SAAS,KACjC,KAAK,mBAAmB,QAAQ,KAAmB,KAAK,GAExD,OAAM,IAAI,MACR,CAAC,WAAW,EAAE,KAAK,mCAAmC,EAAE,KAAK,mBAAmB,KAC9E,KACD,EAAE;EAEN,WACQ,QAAQD,sBACjB;OACE,KAAK,iBAAiB,SAAS,KAC/B,KAAK,iBAAiB,QAAQ,KAAiB,KAAK,GAEpD,OAAM,IAAI,MACR,CAAC,SAAS,EAAE,KAAK,iCAAiC,EAAE,KAAK,iBAAiB,KACxE,KACD,EAAE;EAEN,MAED,OAAM,IAAI,MAAM;AAElB,SAAO,CAAC,CAAC,EAAE,MAAM;CAClB;;;;;;CAOD,eAAeG,WAAoD;EACjE,MAAM,OAAO,UAAU,MAAM,IAAI,CAAC,QAChC,IAAI,OAAO,KAAK,CACjB;AACD,SAAO,GACJ,KAAK,eAAe,UAAU,SAAS,GAAG,KAC5C;CACF;;;;;;CAOD,gBAAgBC,YAAuD;AACrE,SAAO,GACJ,WAAW,YAAY,GACrB,KAAK,eAAe,WAAW,WAAW,GAAGC,wBAC5C,WAAW,MACZ,CACF,EACF;CACF;;;;;;CAOD,qBACEC,OACoC;EACpC,IAAI,UAAU,CAAE;AAChB,MAAI,MAAM,QACR,UAAU,EACR,QAAQ,MAAM,OAAO,OAAO,KAAK,CAClC;AAEH,SAAO;CACR;CAED,aACEC,eACAC,iBACA,YAAY,OACZ,qBAAqB,OAC+B;AACpD,MAAIC,4BAAc,cAAc,IAAIA,4BAAc,gBAAgB,CAChE,QAAO;AAET,MAAIA,4BAAc,cAAc,IAAI,cAAc,WAAW;AAC3D,OAAIA,4BAAc,gBAAgB,CAChC,QAAO;AAET,UAAO;EACR;AACD,MAAIA,4BAAc,gBAAgB,EAAE;AAClC,OAAI,mBACF,QAAO;AAET,OAAI,cAAc,MAChB,QAAO;AAET,UAAO;EACR;AACD,MAAI,cAAc,MAChB,QAAO,EACL,MAAM,CAAC,eAAe,eAAgB,EACvC;WACQ,cAAc,KACvB,QAAO,EACL,KAAK,CAAC,eAAe,eAAgB,EACtC;MAED,OAAM,IAAI,MAAM;CAEnB;AACF"}
+{"version":3,"file":"base.cjs","names":["Visitor","Operators","Comparators","castValue","isFilterEmpty"],"sources":["../../src/structured_query/base.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n  Visitor,\n  VisitorComparisonResult,\n  VisitorOperationResult,\n  VisitorResult,\n  VisitorStructuredQueryResult,\n} from \"./ir.js\";\nimport { isFilterEmpty, castValue } from \"./utils.js\";\n\n/**\n * Options object for the BasicTranslator class. Specifies the allowed\n * operators and comparators.\n */\nexport type TranslatorOpts = {\n  allowedOperators: Operator[];\n  allowedComparators: Comparator[];\n};\n\n/**\n * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport abstract class BaseTranslator<\n  T extends VectorStore = VectorStore,\n> extends Visitor<T> {\n  /**\n   * Formats a given function (either an operator or a comparator) into a\n   * string.\n   * @param func The function to format.\n   * @returns Formatted string representation of the function.\n   */\n  abstract formatFunction(func: Operator | Comparator): string;\n\n  /**\n   * Merges two filters into one, using a specified merge type.\n   * @param defaultFilter The default filter.\n   * @param generatedFilter The generated filter.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.\n   * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.\n   * @returns The merged filter, or undefined if both filters are empty.\n   */\n  abstract mergeFilters(\n    defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    mergeType?: \"and\" | \"or\" | \"replace\",\n    forceDefaultFilter?: boolean\n  ): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\n}\n\n/**\n * Class that extends the BaseTranslator class and provides concrete\n * implementations for the abstract methods. Also declares three types:\n * VisitOperationOutput, VisitComparisonOutput, and\n * VisitStructuredQueryOutput, which are used as the return types for the\n * visitOperation, visitComparison, and visitStructuredQuery methods\n * respectively.\n */\nexport class BasicTranslator<\n  T extends VectorStore = VectorStore,\n> extends BaseTranslator<T> {\n  declare VisitOperationOutput: VisitorOperationResult;\n\n  declare VisitComparisonOutput: VisitorComparisonResult;\n\n  declare VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n\n  allowedOperators: Operator[];\n\n  allowedComparators: Comparator[];\n\n  constructor(opts?: TranslatorOpts) {\n    super();\n    this.allowedOperators = opts?.allowedOperators ?? [\n      Operators.and,\n      Operators.or,\n    ];\n    this.allowedComparators = opts?.allowedComparators ?? [\n      Comparators.eq,\n      Comparators.ne,\n      Comparators.gt,\n      Comparators.gte,\n      Comparators.lt,\n      Comparators.lte,\n    ];\n  }\n\n  formatFunction(func: Operator | Comparator): string {\n    if (func in Comparators) {\n      if (\n        this.allowedComparators.length > 0 &&\n        this.allowedComparators.indexOf(func as Comparator) === -1\n      ) {\n        throw new Error(\n          `Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else if (func in Operators) {\n      if (\n        this.allowedOperators.length > 0 &&\n        this.allowedOperators.indexOf(func as Operator) === -1\n      ) {\n        throw new Error(\n          `Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else {\n      throw new Error(\"Unknown comparator or operator\");\n    }\n    return `$${func}`;\n  }\n\n  /**\n   * Visits an operation and returns a result.\n   * @param operation The operation to visit.\n   * @returns The result of visiting the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const args = operation.args?.map((arg) =>\n      arg.accept(this)\n    ) as VisitorResult[];\n    return {\n      [this.formatFunction(operation.operator)]: args,\n    };\n  }\n\n  /**\n   * Visits a comparison and returns a result.\n   * @param comparison The comparison to visit.\n   * @returns The result of visiting the comparison.\n   */\n  visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"] {\n    return {\n      [comparison.attribute]: {\n        [this.formatFunction(comparison.comparator)]: castValue(\n          comparison.value\n        ),\n      },\n    };\n  }\n\n  /**\n   * Visits a structured query and returns a result.\n   * @param query The structured query to visit.\n   * @returns The result of visiting the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    let nextArg = {};\n    if (query.filter) {\n      nextArg = {\n        filter: query.filter.accept(this),\n      };\n    }\n    return nextArg;\n  }\n\n  mergeFilters(\n    defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    mergeType = \"and\",\n    forceDefaultFilter = false\n  ): VisitorStructuredQueryResult[\"filter\"] | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (forceDefaultFilter) {\n        return defaultFilter;\n      }\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n    if (mergeType === \"and\") {\n      return {\n        $and: [defaultFilter, generatedFilter],\n      };\n    } else if (mergeType === \"or\") {\n      return {\n        $or: [defaultFilter, generatedFilter],\n      };\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":";;;;;;;;AA+BA,IAAsB,iBAAtB,cAEUA,WAAAA,QAAW;;;;;;;;;AAiCrB,IAAa,kBAAb,cAEU,eAAkB;CAO1B;CAEA;CAEA,YAAY,MAAuB;AACjC,SAAO;AACP,OAAK,mBAAmB,MAAM,oBAAoB,CAChDC,WAAAA,UAAU,KACVA,WAAAA,UAAU,GACX;AACD,OAAK,qBAAqB,MAAM,sBAAsB;GACpDC,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACb;;CAGH,eAAe,MAAqC;AAClD,MAAI,QAAQA,WAAAA;OAER,KAAK,mBAAmB,SAAS,KACjC,KAAK,mBAAmB,QAAQ,KAAmB,KAAK,GAExD,OAAM,IAAI,MACR,cAAc,KAAK,qCAAqC,KAAK,mBAAmB,KAC9E,KACD,GACF;aAEM,QAAQD,WAAAA;OAEf,KAAK,iBAAiB,SAAS,KAC/B,KAAK,iBAAiB,QAAQ,KAAiB,KAAK,GAEpD,OAAM,IAAI,MACR,YAAY,KAAK,mCAAmC,KAAK,iBAAiB,KACxE,KACD,GACF;QAGH,OAAM,IAAI,MAAM,iCAAiC;AAEnD,SAAO,IAAI;;;;;;;CAQb,eAAe,WAAoD;EACjE,MAAM,OAAO,UAAU,MAAM,KAAK,QAChC,IAAI,OAAO,KAAK,CACjB;AACD,SAAO,GACJ,KAAK,eAAe,UAAU,SAAS,GAAG,MAC5C;;;;;;;CAQH,gBAAgB,YAAuD;AACrE,SAAO,GACJ,WAAW,YAAY,GACrB,KAAK,eAAe,WAAW,WAAW,GAAGE,cAAAA,UAC5C,WAAW,MACZ,EACF,EACF;;;;;;;CAQH,qBACE,OACoC;EACpC,IAAI,UAAU,EAAE;AAChB,MAAI,MAAM,OACR,WAAU,EACR,QAAQ,MAAM,OAAO,OAAO,KAAK,EAClC;AAEH,SAAO;;CAGT,aACE,eACA,iBACA,YAAY,OACZ,qBAAqB,OAC+B;AACpD,MAAIC,cAAAA,cAAc,cAAc,IAAIA,cAAAA,cAAc,gBAAgB,CAChE;AAEF,MAAIA,cAAAA,cAAc,cAAc,IAAI,cAAc,WAAW;AAC3D,OAAIA,cAAAA,cAAc,gBAAgB,CAChC;AAEF,UAAO;;AAET,MAAIA,cAAAA,cAAc,gBAAgB,EAAE;AAClC,OAAI,mBACF,QAAO;AAET,OAAI,cAAc,MAChB;AAEF,UAAO;;AAET,MAAI,cAAc,MAChB,QAAO,EACL,MAAM,CAAC,eAAe,gBAAgB,EACvC;WACQ,cAAc,KACvB,QAAO,EACL,KAAK,CAAC,eAAe,gBAAgB,EACtC;MAED,OAAM,IAAI,MAAM,qBAAqB"}

package/dist/structured_query/base.d.cts

@@ -2,7 +2,6 @@ import { VectorStore } from "../vectorstores.cjs";
 import { Comparator, Comparison, Operation, Operator, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorStructuredQueryResult } from "./ir.cjs";
 
 //#region src/structured_query/base.d.ts
-
 /**
  * Options object for the BasicTranslator class. Specifies the allowed
  * operators and comparators.

package/dist/structured_query/base.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":["VectorStore","Comparator","Comparison","Operation","Operator","StructuredQuery","Visitor","VisitorComparisonResult","VisitorOperationResult","VisitorStructuredQueryResult","TranslatorOpts","BaseTranslator","T","BasicTranslator"],"sources":["../../src/structured_query/base.d.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport { Comparator, Comparison, Operation, Operator, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorStructuredQueryResult } from \"./ir.js\";\n/**\n * Options object for the BasicTranslator class. Specifies the allowed\n * operators and comparators.\n */\nexport type TranslatorOpts = {\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n};\n/**\n * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport declare abstract class BaseTranslator<T extends VectorStore = VectorStore> extends Visitor<T> {\n    /**\n     * Formats a given function (either an operator or a comparator) into a\n     * string.\n     * @param func The function to format.\n     * @returns Formatted string representation of the function.\n     */\n    abstract formatFunction(func: Operator | Comparator): string;\n    /**\n     * Merges two filters into one, using a specified merge type.\n     * @param defaultFilter The default filter.\n     * @param generatedFilter The generated filter.\n     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.\n     * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.\n     * @returns The merged filter, or undefined if both filters are empty.\n     */\n    abstract mergeFilters(defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined, generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined, mergeType?: \"and\" | \"or\" | \"replace\", forceDefaultFilter?: boolean): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\n}\n/**\n * Class that extends the BaseTranslator class and provides concrete\n * implementations for the abstract methods. Also declares three types:\n * VisitOperationOutput, VisitComparisonOutput, and\n * VisitStructuredQueryOutput, which are used as the return types for the\n * visitOperation, visitComparison, and visitStructuredQuery methods\n * respectively.\n */\nexport declare class BasicTranslator<T extends VectorStore = VectorStore> extends BaseTranslator<T> {\n    VisitOperationOutput: VisitorOperationResult;\n    VisitComparisonOutput: VisitorComparisonResult;\n    VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n    constructor(opts?: TranslatorOpts);\n    formatFunction(func: Operator | Comparator): string;\n    /**\n     * Visits an operation and returns a result.\n     * @param operation The operation to visit.\n     * @returns The result of visiting the operation.\n     */\n    visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    /**\n     * Visits a comparison and returns a result.\n     * @param comparison The comparison to visit.\n     * @returns The result of visiting the comparison.\n     */\n    visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"];\n    /**\n     * Visits a structured query and returns a result.\n     * @param query The structured query to visit.\n     * @returns The result of visiting the structured query.\n     */\n    visitStructuredQuery(query: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n    mergeFilters(defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined, generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined, mergeType?: string, forceDefaultFilter?: boolean): VisitorStructuredQueryResult[\"filter\"] | undefined;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;;AAMA;AASA;AAAuDA,KAT3CU,cAAAA,GAS2CV;EAAcA,gBAAAA,EAR/CI,QAQ+CJ,EAAAA;EAA6BY,kBAAAA,EAP1EX,UAO0EW,EAAAA;CAOhER;;;AAP+D;AA0BjG;;AAA6DJ,uBA1B/BW,cA0B+BX,CAAAA,UA1BNA,WA0BMA,GA1BQA,WA0BRA,CAAAA,SA1B6BM,OA0B7BN,CA1BqCY,CA0BrCZ,CAAAA,CAAAA;EAAoCY;;;;;;EAM1EF,SAAAA,cAAAA,CAAAA,IAAAA,EAzBWN,QAyBXM,GAzBsBT,UAyBtBS,CAAAA,EAAAA,MAAAA;EACEN;;;;;;;;EAPyDO,SAAAA,YAAAA,CAAAA,aAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA,EAAAA,eAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA,EAAAA,SAAAA,CAAAA,EAAAA,KAAAA,GAAAA,IAAAA,GAAAA,SAAAA,EAAAA,kBAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA;AAAc;;;;;;;;;cAA3EE,0BAA0Bb,cAAcA,qBAAqBW,eAAeC;wBACvEJ;yBACCD;8BACKE;oBACVL;sBACEH;qBACDS;uBACEN,WAAWH;;;;;;4BAMNE;;;;;;8BAMED;;;;;;8BAMAG;8BACAI,qEAAqEA,uGAAuGA"}
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/structured_query/base.ts"],"mappings":";;;;;;AAqBA;;KAAY,cAAA;EACV,gBAAA,EAAkB,QAAA;EAClB,kBAAA,EAAoB,UAAA;AAAA;;;;;AAQtB;uBAAsB,cAAA,WACV,WAAA,GAAc,WAAA,UAChB,OAAA,CAAQ,CAAA;EAFkB;;;;;;EAAA,SASzB,cAAA,CAAe,IAAA,EAAM,QAAA,GAAW,UAAA;EAP1B;;;;;;;;EAAA,SAiBN,YAAA,CACP,aAAA,4DACA,eAAA,4DACA,SAAA,6BACA,kBAAA;AAAA;;;;;;;;;cAYS,eAAA,WACD,WAAA,GAAc,WAAA,UAChB,cAAA,CAAe,CAAA;EACf,oBAAA,EAAsB,sBAAA;EAEtB,qBAAA,EAAuB,uBAAA;EAEvB,0BAAA,EAA4B,4BAAA;EAEpC,gBAAA,EAAkB,QAAA;EAElB,kBAAA,EAAoB,UAAA;EAEpB,WAAA,CAAY,IAAA,GAAO,cAAA;EAgBnB,cAAA,CAAe,IAAA,EAAM,QAAA,GAAW,UAAA;EAtBI;;;;;EAwDpC,cAAA,CAAe,SAAA,EAAW,SAAA;EAAA;;;;;EAc1B,eAAA,CAAgB,UAAA,EAAY,UAAA;EA3EpB;;;;;EA0FR,oBAAA,CACE,KAAA,EAAO,eAAA;EAWT,YAAA,CACE,aAAA,EAAe,4BAAA,wBACf,eAAA,EAAiB,4BAAA,wBACjB,SAAA,WACA,kBAAA,aACC,4BAAA;AAAA"}

package/dist/structured_query/base.d.ts

@@ -2,7 +2,6 @@ import { VectorStore } from "../vectorstores.js";
 import { Comparator, Comparison, Operation, Operator, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorStructuredQueryResult } from "./ir.js";
 
 //#region src/structured_query/base.d.ts
-
 /**
  * Options object for the BasicTranslator class. Specifies the allowed
  * operators and comparators.

package/dist/structured_query/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":["VectorStore","Comparator","Comparison","Operation","Operator","StructuredQuery","Visitor","VisitorComparisonResult","VisitorOperationResult","VisitorStructuredQueryResult","TranslatorOpts","BaseTranslator","T","BasicTranslator"],"sources":["../../src/structured_query/base.d.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport { Comparator, Comparison, Operation, Operator, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorStructuredQueryResult } from \"./ir.js\";\n/**\n * Options object for the BasicTranslator class. Specifies the allowed\n * operators and comparators.\n */\nexport type TranslatorOpts = {\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n};\n/**\n * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport declare abstract class BaseTranslator<T extends VectorStore = VectorStore> extends Visitor<T> {\n    /**\n     * Formats a given function (either an operator or a comparator) into a\n     * string.\n     * @param func The function to format.\n     * @returns Formatted string representation of the function.\n     */\n    abstract formatFunction(func: Operator | Comparator): string;\n    /**\n     * Merges two filters into one, using a specified merge type.\n     * @param defaultFilter The default filter.\n     * @param generatedFilter The generated filter.\n     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.\n     * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.\n     * @returns The merged filter, or undefined if both filters are empty.\n     */\n    abstract mergeFilters(defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined, generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined, mergeType?: \"and\" | \"or\" | \"replace\", forceDefaultFilter?: boolean): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\n}\n/**\n * Class that extends the BaseTranslator class and provides concrete\n * implementations for the abstract methods. Also declares three types:\n * VisitOperationOutput, VisitComparisonOutput, and\n * VisitStructuredQueryOutput, which are used as the return types for the\n * visitOperation, visitComparison, and visitStructuredQuery methods\n * respectively.\n */\nexport declare class BasicTranslator<T extends VectorStore = VectorStore> extends BaseTranslator<T> {\n    VisitOperationOutput: VisitorOperationResult;\n    VisitComparisonOutput: VisitorComparisonResult;\n    VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n    constructor(opts?: TranslatorOpts);\n    formatFunction(func: Operator | Comparator): string;\n    /**\n     * Visits an operation and returns a result.\n     * @param operation The operation to visit.\n     * @returns The result of visiting the operation.\n     */\n    visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    /**\n     * Visits a comparison and returns a result.\n     * @param comparison The comparison to visit.\n     * @returns The result of visiting the comparison.\n     */\n    visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"];\n    /**\n     * Visits a structured query and returns a result.\n     * @param query The structured query to visit.\n     * @returns The result of visiting the structured query.\n     */\n    visitStructuredQuery(query: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n    mergeFilters(defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined, generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined, mergeType?: string, forceDefaultFilter?: boolean): VisitorStructuredQueryResult[\"filter\"] | undefined;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;;AAMA;AASA;AAAuDA,KAT3CU,cAAAA,GAS2CV;EAAcA,gBAAAA,EAR/CI,QAQ+CJ,EAAAA;EAA6BY,kBAAAA,EAP1EX,UAO0EW,EAAAA;CAOhER;;;AAP+D;AA0BjG;;AAA6DJ,uBA1B/BW,cA0B+BX,CAAAA,UA1BNA,WA0BMA,GA1BQA,WA0BRA,CAAAA,SA1B6BM,OA0B7BN,CA1BqCY,CA0BrCZ,CAAAA,CAAAA;EAAoCY;;;;;;EAM1EF,SAAAA,cAAAA,CAAAA,IAAAA,EAzBWN,QAyBXM,GAzBsBT,UAyBtBS,CAAAA,EAAAA,MAAAA;EACEN;;;;;;;;EAPyDO,SAAAA,YAAAA,CAAAA,aAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA,EAAAA,eAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA,EAAAA,SAAAA,CAAAA,EAAAA,KAAAA,GAAAA,IAAAA,GAAAA,SAAAA,EAAAA,kBAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA;AAAc;;;;;;;;;cAA3EE,0BAA0Bb,cAAcA,qBAAqBW,eAAeC;wBACvEJ;yBACCD;8BACKE;oBACVL;sBACEH;qBACDS;uBACEN,WAAWH;;;;;;4BAMNE;;;;;;8BAMED;;;;;;8BAMAG;8BACAI,qEAAqEA,uGAAuGA"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../src/structured_query/base.ts"],"mappings":";;;;;;AAqBA;;KAAY,cAAA;EACV,gBAAA,EAAkB,QAAA;EAClB,kBAAA,EAAoB,UAAA;AAAA;;;;;AAQtB;uBAAsB,cAAA,WACV,WAAA,GAAc,WAAA,UAChB,OAAA,CAAQ,CAAA;EAFkB;;;;;;EAAA,SASzB,cAAA,CAAe,IAAA,EAAM,QAAA,GAAW,UAAA;EAP1B;;;;;;;;EAAA,SAiBN,YAAA,CACP,aAAA,4DACA,eAAA,4DACA,SAAA,6BACA,kBAAA;AAAA;;;;;;;;;cAYS,eAAA,WACD,WAAA,GAAc,WAAA,UAChB,cAAA,CAAe,CAAA;EACf,oBAAA,EAAsB,sBAAA;EAEtB,qBAAA,EAAuB,uBAAA;EAEvB,0BAAA,EAA4B,4BAAA;EAEpC,gBAAA,EAAkB,QAAA;EAElB,kBAAA,EAAoB,UAAA;EAEpB,WAAA,CAAY,IAAA,GAAO,cAAA;EAgBnB,cAAA,CAAe,IAAA,EAAM,QAAA,GAAW,UAAA;EAtBI;;;;;EAwDpC,cAAA,CAAe,SAAA,EAAW,SAAA;EAAA;;;;;EAc1B,eAAA,CAAgB,UAAA,EAAY,UAAA;EA3EpB;;;;;EA0FR,oBAAA,CACE,KAAA,EAAO,eAAA;EAWT,YAAA,CACE,aAAA,EAAe,4BAAA,wBACf,eAAA,EAAiB,4BAAA,wBACjB,SAAA,WACA,kBAAA,aACC,4BAAA;AAAA"}

package/dist/structured_query/base.js

@@ -1,6 +1,5 @@
 import { Comparators, Operators, Visitor } from "./ir.js";
 import { castValue, isFilterEmpty } from "./utils.js";
-
 //#region src/structured_query/base.ts
 /**
 * Abstract class that provides a blueprint for creating specific
@@ -67,14 +66,14 @@ var BasicTranslator = class extends BaseTranslator {
 		return nextArg;
 	}
 	mergeFilters(defaultFilter, generatedFilter, mergeType = "and", forceDefaultFilter = false) {
-		if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) return void 0;
+		if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) return;
 		if (isFilterEmpty(defaultFilter) || mergeType === "replace") {
-			if (isFilterEmpty(generatedFilter)) return void 0;
+			if (isFilterEmpty(generatedFilter)) return;
 			return generatedFilter;
 		}
 		if (isFilterEmpty(generatedFilter)) {
 			if (forceDefaultFilter) return defaultFilter;
-			if (mergeType === "and") return void 0;
+			if (mergeType === "and") return;
 			return defaultFilter;
 		}
 		if (mergeType === "and") return { $and: [defaultFilter, generatedFilter] };
@@ -82,7 +81,7 @@ var BasicTranslator = class extends BaseTranslator {
 		else throw new Error("Unknown merge type");
 	}
 };
-
 //#endregion
 export { BaseTranslator, BasicTranslator };
+
 //# sourceMappingURL=base.js.map

package/dist/structured_query/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":["opts?: TranslatorOpts","func: Operator | Comparator","operation: Operation","comparison: Comparison","query: StructuredQuery","defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined","generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined"],"sources":["../../src/structured_query/base.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n  Visitor,\n  VisitorComparisonResult,\n  VisitorOperationResult,\n  VisitorResult,\n  VisitorStructuredQueryResult,\n} from \"./ir.js\";\nimport { isFilterEmpty, castValue } from \"./utils.js\";\n\n/**\n * Options object for the BasicTranslator class. Specifies the allowed\n * operators and comparators.\n */\nexport type TranslatorOpts = {\n  allowedOperators: Operator[];\n  allowedComparators: Comparator[];\n};\n\n/**\n * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport abstract class BaseTranslator<\n  T extends VectorStore = VectorStore\n> extends Visitor<T> {\n  /**\n   * Formats a given function (either an operator or a comparator) into a\n   * string.\n   * @param func The function to format.\n   * @returns Formatted string representation of the function.\n   */\n  abstract formatFunction(func: Operator | Comparator): string;\n\n  /**\n   * Merges two filters into one, using a specified merge type.\n   * @param defaultFilter The default filter.\n   * @param generatedFilter The generated filter.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.\n   * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.\n   * @returns The merged filter, or undefined if both filters are empty.\n   */\n  abstract mergeFilters(\n    defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    mergeType?: \"and\" | \"or\" | \"replace\",\n    forceDefaultFilter?: boolean\n  ): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\n}\n\n/**\n * Class that extends the BaseTranslator class and provides concrete\n * implementations for the abstract methods. Also declares three types:\n * VisitOperationOutput, VisitComparisonOutput, and\n * VisitStructuredQueryOutput, which are used as the return types for the\n * visitOperation, visitComparison, and visitStructuredQuery methods\n * respectively.\n */\nexport class BasicTranslator<\n  T extends VectorStore = VectorStore\n> extends BaseTranslator<T> {\n  declare VisitOperationOutput: VisitorOperationResult;\n\n  declare VisitComparisonOutput: VisitorComparisonResult;\n\n  declare VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n\n  allowedOperators: Operator[];\n\n  allowedComparators: Comparator[];\n\n  constructor(opts?: TranslatorOpts) {\n    super();\n    this.allowedOperators = opts?.allowedOperators ?? [\n      Operators.and,\n      Operators.or,\n    ];\n    this.allowedComparators = opts?.allowedComparators ?? [\n      Comparators.eq,\n      Comparators.ne,\n      Comparators.gt,\n      Comparators.gte,\n      Comparators.lt,\n      Comparators.lte,\n    ];\n  }\n\n  formatFunction(func: Operator | Comparator): string {\n    if (func in Comparators) {\n      if (\n        this.allowedComparators.length > 0 &&\n        this.allowedComparators.indexOf(func as Comparator) === -1\n      ) {\n        throw new Error(\n          `Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else if (func in Operators) {\n      if (\n        this.allowedOperators.length > 0 &&\n        this.allowedOperators.indexOf(func as Operator) === -1\n      ) {\n        throw new Error(\n          `Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else {\n      throw new Error(\"Unknown comparator or operator\");\n    }\n    return `$${func}`;\n  }\n\n  /**\n   * Visits an operation and returns a result.\n   * @param operation The operation to visit.\n   * @returns The result of visiting the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const args = operation.args?.map((arg) =>\n      arg.accept(this)\n    ) as VisitorResult[];\n    return {\n      [this.formatFunction(operation.operator)]: args,\n    };\n  }\n\n  /**\n   * Visits a comparison and returns a result.\n   * @param comparison The comparison to visit.\n   * @returns The result of visiting the comparison.\n   */\n  visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"] {\n    return {\n      [comparison.attribute]: {\n        [this.formatFunction(comparison.comparator)]: castValue(\n          comparison.value\n        ),\n      },\n    };\n  }\n\n  /**\n   * Visits a structured query and returns a result.\n   * @param query The structured query to visit.\n   * @returns The result of visiting the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    let nextArg = {};\n    if (query.filter) {\n      nextArg = {\n        filter: query.filter.accept(this),\n      };\n    }\n    return nextArg;\n  }\n\n  mergeFilters(\n    defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    mergeType = \"and\",\n    forceDefaultFilter = false\n  ): VisitorStructuredQueryResult[\"filter\"] | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (forceDefaultFilter) {\n        return defaultFilter;\n      }\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n    if (mergeType === \"and\") {\n      return {\n        $and: [defaultFilter, generatedFilter],\n      };\n    } else if (mergeType === \"or\") {\n      return {\n        $or: [defaultFilter, generatedFilter],\n      };\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":";;;;;;;;;AA+BA,IAAsB,iBAAtB,cAEU,QAAW,CAuBpB;;;;;;;;;AAUD,IAAa,kBAAb,cAEU,eAAkB;CAO1B;CAEA;CAEA,YAAYA,MAAuB;EACjC,OAAO;EACP,KAAK,mBAAmB,MAAM,oBAAoB,CAChD,UAAU,KACV,UAAU,EACX;EACD,KAAK,qBAAqB,MAAM,sBAAsB;GACpD,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,YAAY;EACb;CACF;CAED,eAAeC,MAAqC;AAClD,MAAI,QAAQ,aACV;OACE,KAAK,mBAAmB,SAAS,KACjC,KAAK,mBAAmB,QAAQ,KAAmB,KAAK,GAExD,OAAM,IAAI,MACR,CAAC,WAAW,EAAE,KAAK,mCAAmC,EAAE,KAAK,mBAAmB,KAC9E,KACD,EAAE;EAEN,WACQ,QAAQ,WACjB;OACE,KAAK,iBAAiB,SAAS,KAC/B,KAAK,iBAAiB,QAAQ,KAAiB,KAAK,GAEpD,OAAM,IAAI,MACR,CAAC,SAAS,EAAE,KAAK,iCAAiC,EAAE,KAAK,iBAAiB,KACxE,KACD,EAAE;EAEN,MAED,OAAM,IAAI,MAAM;AAElB,SAAO,CAAC,CAAC,EAAE,MAAM;CAClB;;;;;;CAOD,eAAeC,WAAoD;EACjE,MAAM,OAAO,UAAU,MAAM,IAAI,CAAC,QAChC,IAAI,OAAO,KAAK,CACjB;AACD,SAAO,GACJ,KAAK,eAAe,UAAU,SAAS,GAAG,KAC5C;CACF;;;;;;CAOD,gBAAgBC,YAAuD;AACrE,SAAO,GACJ,WAAW,YAAY,GACrB,KAAK,eAAe,WAAW,WAAW,GAAG,UAC5C,WAAW,MACZ,CACF,EACF;CACF;;;;;;CAOD,qBACEC,OACoC;EACpC,IAAI,UAAU,CAAE;AAChB,MAAI,MAAM,QACR,UAAU,EACR,QAAQ,MAAM,OAAO,OAAO,KAAK,CAClC;AAEH,SAAO;CACR;CAED,aACEC,eACAC,iBACA,YAAY,OACZ,qBAAqB,OAC+B;AACpD,MAAI,cAAc,cAAc,IAAI,cAAc,gBAAgB,CAChE,QAAO;AAET,MAAI,cAAc,cAAc,IAAI,cAAc,WAAW;AAC3D,OAAI,cAAc,gBAAgB,CAChC,QAAO;AAET,UAAO;EACR;AACD,MAAI,cAAc,gBAAgB,EAAE;AAClC,OAAI,mBACF,QAAO;AAET,OAAI,cAAc,MAChB,QAAO;AAET,UAAO;EACR;AACD,MAAI,cAAc,MAChB,QAAO,EACL,MAAM,CAAC,eAAe,eAAgB,EACvC;WACQ,cAAc,KACvB,QAAO,EACL,KAAK,CAAC,eAAe,eAAgB,EACtC;MAED,OAAM,IAAI,MAAM;CAEnB;AACF"}
+{"version":3,"file":"base.js","names":[],"sources":["../../src/structured_query/base.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n  Visitor,\n  VisitorComparisonResult,\n  VisitorOperationResult,\n  VisitorResult,\n  VisitorStructuredQueryResult,\n} from \"./ir.js\";\nimport { isFilterEmpty, castValue } from \"./utils.js\";\n\n/**\n * Options object for the BasicTranslator class. Specifies the allowed\n * operators and comparators.\n */\nexport type TranslatorOpts = {\n  allowedOperators: Operator[];\n  allowedComparators: Comparator[];\n};\n\n/**\n * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport abstract class BaseTranslator<\n  T extends VectorStore = VectorStore,\n> extends Visitor<T> {\n  /**\n   * Formats a given function (either an operator or a comparator) into a\n   * string.\n   * @param func The function to format.\n   * @returns Formatted string representation of the function.\n   */\n  abstract formatFunction(func: Operator | Comparator): string;\n\n  /**\n   * Merges two filters into one, using a specified merge type.\n   * @param defaultFilter The default filter.\n   * @param generatedFilter The generated filter.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.\n   * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.\n   * @returns The merged filter, or undefined if both filters are empty.\n   */\n  abstract mergeFilters(\n    defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    mergeType?: \"and\" | \"or\" | \"replace\",\n    forceDefaultFilter?: boolean\n  ): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\n}\n\n/**\n * Class that extends the BaseTranslator class and provides concrete\n * implementations for the abstract methods. Also declares three types:\n * VisitOperationOutput, VisitComparisonOutput, and\n * VisitStructuredQueryOutput, which are used as the return types for the\n * visitOperation, visitComparison, and visitStructuredQuery methods\n * respectively.\n */\nexport class BasicTranslator<\n  T extends VectorStore = VectorStore,\n> extends BaseTranslator<T> {\n  declare VisitOperationOutput: VisitorOperationResult;\n\n  declare VisitComparisonOutput: VisitorComparisonResult;\n\n  declare VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n\n  allowedOperators: Operator[];\n\n  allowedComparators: Comparator[];\n\n  constructor(opts?: TranslatorOpts) {\n    super();\n    this.allowedOperators = opts?.allowedOperators ?? [\n      Operators.and,\n      Operators.or,\n    ];\n    this.allowedComparators = opts?.allowedComparators ?? [\n      Comparators.eq,\n      Comparators.ne,\n      Comparators.gt,\n      Comparators.gte,\n      Comparators.lt,\n      Comparators.lte,\n    ];\n  }\n\n  formatFunction(func: Operator | Comparator): string {\n    if (func in Comparators) {\n      if (\n        this.allowedComparators.length > 0 &&\n        this.allowedComparators.indexOf(func as Comparator) === -1\n      ) {\n        throw new Error(\n          `Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else if (func in Operators) {\n      if (\n        this.allowedOperators.length > 0 &&\n        this.allowedOperators.indexOf(func as Operator) === -1\n      ) {\n        throw new Error(\n          `Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else {\n      throw new Error(\"Unknown comparator or operator\");\n    }\n    return `$${func}`;\n  }\n\n  /**\n   * Visits an operation and returns a result.\n   * @param operation The operation to visit.\n   * @returns The result of visiting the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const args = operation.args?.map((arg) =>\n      arg.accept(this)\n    ) as VisitorResult[];\n    return {\n      [this.formatFunction(operation.operator)]: args,\n    };\n  }\n\n  /**\n   * Visits a comparison and returns a result.\n   * @param comparison The comparison to visit.\n   * @returns The result of visiting the comparison.\n   */\n  visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"] {\n    return {\n      [comparison.attribute]: {\n        [this.formatFunction(comparison.comparator)]: castValue(\n          comparison.value\n        ),\n      },\n    };\n  }\n\n  /**\n   * Visits a structured query and returns a result.\n   * @param query The structured query to visit.\n   * @returns The result of visiting the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    let nextArg = {};\n    if (query.filter) {\n      nextArg = {\n        filter: query.filter.accept(this),\n      };\n    }\n    return nextArg;\n  }\n\n  mergeFilters(\n    defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    mergeType = \"and\",\n    forceDefaultFilter = false\n  ): VisitorStructuredQueryResult[\"filter\"] | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (forceDefaultFilter) {\n        return defaultFilter;\n      }\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n    if (mergeType === \"and\") {\n      return {\n        $and: [defaultFilter, generatedFilter],\n      };\n    } else if (mergeType === \"or\") {\n      return {\n        $or: [defaultFilter, generatedFilter],\n      };\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":";;;;;;;;AA+BA,IAAsB,iBAAtB,cAEU,QAAW;;;;;;;;;AAiCrB,IAAa,kBAAb,cAEU,eAAkB;CAO1B;CAEA;CAEA,YAAY,MAAuB;AACjC,SAAO;AACP,OAAK,mBAAmB,MAAM,oBAAoB,CAChD,UAAU,KACV,UAAU,GACX;AACD,OAAK,qBAAqB,MAAM,sBAAsB;GACpD,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,YAAY;GACb;;CAGH,eAAe,MAAqC;AAClD,MAAI,QAAQ;OAER,KAAK,mBAAmB,SAAS,KACjC,KAAK,mBAAmB,QAAQ,KAAmB,KAAK,GAExD,OAAM,IAAI,MACR,cAAc,KAAK,qCAAqC,KAAK,mBAAmB,KAC9E,KACD,GACF;aAEM,QAAQ;OAEf,KAAK,iBAAiB,SAAS,KAC/B,KAAK,iBAAiB,QAAQ,KAAiB,KAAK,GAEpD,OAAM,IAAI,MACR,YAAY,KAAK,mCAAmC,KAAK,iBAAiB,KACxE,KACD,GACF;QAGH,OAAM,IAAI,MAAM,iCAAiC;AAEnD,SAAO,IAAI;;;;;;;CAQb,eAAe,WAAoD;EACjE,MAAM,OAAO,UAAU,MAAM,KAAK,QAChC,IAAI,OAAO,KAAK,CACjB;AACD,SAAO,GACJ,KAAK,eAAe,UAAU,SAAS,GAAG,MAC5C;;;;;;;CAQH,gBAAgB,YAAuD;AACrE,SAAO,GACJ,WAAW,YAAY,GACrB,KAAK,eAAe,WAAW,WAAW,GAAG,UAC5C,WAAW,MACZ,EACF,EACF;;;;;;;CAQH,qBACE,OACoC;EACpC,IAAI,UAAU,EAAE;AAChB,MAAI,MAAM,OACR,WAAU,EACR,QAAQ,MAAM,OAAO,OAAO,KAAK,EAClC;AAEH,SAAO;;CAGT,aACE,eACA,iBACA,YAAY,OACZ,qBAAqB,OAC+B;AACpD,MAAI,cAAc,cAAc,IAAI,cAAc,gBAAgB,CAChE;AAEF,MAAI,cAAc,cAAc,IAAI,cAAc,WAAW;AAC3D,OAAI,cAAc,gBAAgB,CAChC;AAEF,UAAO;;AAET,MAAI,cAAc,gBAAgB,EAAE;AAClC,OAAI,mBACF,QAAO;AAET,OAAI,cAAc,MAChB;AAEF,UAAO;;AAET,MAAI,cAAc,MAChB,QAAO,EACL,MAAM,CAAC,eAAe,gBAAgB,EACvC;WACQ,cAAc,KACvB,QAAO,EACL,KAAK,CAAC,eAAe,gBAAgB,EACtC;MAED,OAAM,IAAI,MAAM,qBAAqB"}

package/dist/structured_query/functional.cjs

@@ -1,7 +1,6 @@
-const require_ir = require('./ir.cjs');
-const require_utils = require('./utils.cjs');
-const require_base = require('./base.cjs');
-
+const require_ir = require("./ir.cjs");
+const require_utils = require("./utils.cjs");
+const require_base = require("./base.cjs");
 //#region src/structured_query/functional.ts
 /**
 * A class that extends `BaseTranslator` to translate structured queries
@@ -145,13 +144,13 @@ var FunctionalTranslator = class extends require_base.BaseTranslator {
 	* @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.
 	*/
 	mergeFilters(defaultFilter, generatedFilter, mergeType = "and") {
-		if (require_utils.isFilterEmpty(defaultFilter) && require_utils.isFilterEmpty(generatedFilter)) return void 0;
+		if (require_utils.isFilterEmpty(defaultFilter) && require_utils.isFilterEmpty(generatedFilter)) return;
 		if (require_utils.isFilterEmpty(defaultFilter) || mergeType === "replace") {
-			if (require_utils.isFilterEmpty(generatedFilter)) return void 0;
+			if (require_utils.isFilterEmpty(generatedFilter)) return;
 			return generatedFilter;
 		}
 		if (require_utils.isFilterEmpty(generatedFilter)) {
-			if (mergeType === "and") return void 0;
+			if (mergeType === "and") return;
 			return defaultFilter;
 		}
 		if (mergeType === "and") return (document) => defaultFilter(document) && generatedFilter(document);
@@ -159,7 +158,7 @@ var FunctionalTranslator = class extends require_base.BaseTranslator {
 		else throw new Error("Unknown merge type");
 	}
 };
-
 //#endregion
 exports.FunctionalTranslator = FunctionalTranslator;
+
 //# sourceMappingURL=functional.cjs.map