langchain 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/output_parsers/expression_type_handlers/base.js

@@ -1,129 +0,0 @@
-import { GRAMMAR } from "./grammar/parser_grammar.js";
-
-//#region src/output_parsers/expression_type_handlers/base.ts
-/**
-* Abstract class for handling nodes in an expression language. Subclasses
-* must implement the `accepts` and `handle` methods.
-*/
-var NodeHandler = class {
-	constructor(parentHandler) {
-		this.parentHandler = parentHandler;
-	}
-};
-/**
-* Utility class for parsing Abstract Syntax Trees (ASTs). Contains
-* methods for identifying the type of a given node and a method for
-* importing and generating a parser using the Peggy library.
-*/
-var ASTParser = class ASTParser {
-	static astParseInstance;
-	/**
-	* Imports and generates a parser using the Peggy library.
-	* @returns A Promise that resolves to the parser instance.
-	*/
-	static async importASTParser() {
-		try {
-			if (!ASTParser.astParseInstance) {
-				const { default: peggy } = await import("peggy");
-				const parser = peggy.generate(GRAMMAR);
-				const { parse } = parser;
-				ASTParser.astParseInstance = parse;
-			}
-			return ASTParser.astParseInstance;
-		} catch {
-			throw new Error(`Failed to import peggy. Please install peggy (i.e. "npm install peggy" or "pnpm install peggy").`);
-		}
-	}
-	/**
-	* Checks if the given node is a Program node.
-	* @param node The node to be checked.
-	* @returns A boolean indicating whether the node is a Program node.
-	*/
-	static isProgram(node) {
-		return node.type === "Program";
-	}
-	/**
-	* Checks if the given node is an ExpressionStatement node.
-	* @param node The node to be checked.
-	* @returns A boolean indicating whether the node is an ExpressionStatement node.
-	*/
-	static isExpressionStatement(node) {
-		return node.type === "ExpressionStatement";
-	}
-	/**
-	* Checks if the given node is a CallExpression node.
-	* @param node The node to be checked.
-	* @returns A boolean indicating whether the node is a CallExpression node.
-	*/
-	static isCallExpression(node) {
-		return node.type === "CallExpression";
-	}
-	/**
-	* Checks if the given node is a StringLiteral node.
-	* @param node The node to be checked.
-	* @returns A boolean indicating whether the node is a StringLiteral node.
-	*/
-	static isStringLiteral(node) {
-		return node.type === "StringLiteral" && typeof node.value === "string";
-	}
-	/**
-	* Checks if the given node is a NumericLiteral node.
-	* @param node The node to be checked.
-	* @returns A boolean indicating whether the node is a NumericLiteral node.
-	*/
-	static isNumericLiteral(node) {
-		return node.type === "NumericLiteral" && typeof node.value === "number";
-	}
-	/**
-	* Checks if the given node is a BooleanLiteral node.
-	* @param node The node to be checked.
-	* @returns A boolean indicating whether the node is a BooleanLiteral node.
-	*/
-	static isBooleanLiteral(node) {
-		return node.type === "BooleanLiteral" && typeof node.value === "boolean";
-	}
-	/**
-	* Checks if the given node is an Identifier node.
-	* @param node The node to be checked.
-	* @returns A boolean indicating whether the node is an Identifier node.
-	*/
-	static isIdentifier(node) {
-		return node.type === "Identifier";
-	}
-	/**
-	* Checks if the given node is an ObjectExpression node.
-	* @param node The node to be checked.
-	* @returns A boolean indicating whether the node is an ObjectExpression node.
-	*/
-	static isObjectExpression(node) {
-		return node.type === "ObjectExpression";
-	}
-	/**
-	* Checks if the given node is an ArrayExpression node.
-	* @param node The node to be checked.
-	* @returns A boolean indicating whether the node is an ArrayExpression node.
-	*/
-	static isArrayExpression(node) {
-		return node.type === "ArrayExpression";
-	}
-	/**
-	* Checks if the given node is a PropertyAssignment node.
-	* @param node The node to be checked.
-	* @returns A boolean indicating whether the node is a PropertyAssignment node.
-	*/
-	static isPropertyAssignment(node) {
-		return node.type === "PropertyAssignment";
-	}
-	/**
-	* Checks if the given node is a MemberExpression node.
-	* @param node The node to be checked.
-	* @returns A boolean indicating whether the node is a MemberExpression node.
-	*/
-	static isMemberExpression(node) {
-		return node.type === "MemberExpression";
-	}
-};
-
-//#endregion
-export { ASTParser, NodeHandler };
-//# sourceMappingURL=base.js.map

package/dist/output_parsers/expression_type_handlers/base.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.js","names":["parentHandler?: NodeHandler","node: ExpressionNode"],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"sourcesContent":["import { GRAMMAR } from \"./grammar/parser_grammar.js\";\nimport type {\n  ExpressionNode,\n  Program,\n  ExpressionStatement,\n  CallExpression,\n  StringLiteral,\n  NumericLiteral,\n  BooleanLiteral,\n  Identifier,\n  ObjectExpression,\n  ArrayExpression,\n  PropertyAssignment,\n  MemberExpression,\n  ParseFunction,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport abstract class NodeHandler {\n  constructor(protected parentHandler?: NodeHandler) {}\n\n  /**\n   * Determines whether the given node is acceptable.\n   * @param node The node to be checked.\n   * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.\n   */\n  abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n\n  /**\n   * Handles the given node. The specifics of how the node is handled are\n   * determined by the subclass implementation.\n   * @param node The node to be handled.\n   * @returns A Promise that resolves to the result of handling the node.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  abstract handle(node: ExpressionNode): Promise<any>;\n}\n\n/**\n * Utility class for parsing Abstract Syntax Trees (ASTs). Contains\n * methods for identifying the type of a given node and a method for\n * importing and generating a parser using the Peggy library.\n */\nexport class ASTParser {\n  static astParseInstance: ParseFunction;\n\n  /**\n   * Imports and generates a parser using the Peggy library.\n   * @returns A Promise that resolves to the parser instance.\n   */\n  static async importASTParser() {\n    try {\n      if (!ASTParser.astParseInstance) {\n        const { default: peggy } = await import(\"peggy\");\n        const parser = peggy.generate(GRAMMAR);\n        const { parse } = parser;\n        ASTParser.astParseInstance = parse as ParseFunction;\n      }\n      return ASTParser.astParseInstance;\n    } catch {\n      throw new Error(\n        `Failed to import peggy. Please install peggy (i.e. \"npm install peggy\" or \"pnpm install peggy\").`\n      );\n    }\n  }\n\n  /**\n   * Checks if the given node is a Program node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a Program node.\n   */\n  static isProgram(node: ExpressionNode): node is Program {\n    return node.type === \"Program\";\n  }\n\n  /**\n   * Checks if the given node is an ExpressionStatement node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ExpressionStatement node.\n   */\n  static isExpressionStatement(\n    node: ExpressionNode\n  ): node is ExpressionStatement {\n    return node.type === \"ExpressionStatement\";\n  }\n\n  /**\n   * Checks if the given node is a CallExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a CallExpression node.\n   */\n  static isCallExpression(node: ExpressionNode): node is CallExpression {\n    return node.type === \"CallExpression\";\n  }\n\n  /**\n   * Checks if the given node is a StringLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a StringLiteral node.\n   */\n  static isStringLiteral(node: ExpressionNode): node is StringLiteral {\n    return node.type === \"StringLiteral\" && typeof node.value === \"string\";\n  }\n\n  /**\n   * Checks if the given node is a NumericLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a NumericLiteral node.\n   */\n  static isNumericLiteral(node: ExpressionNode): node is NumericLiteral {\n    return node.type === \"NumericLiteral\" && typeof node.value === \"number\";\n  }\n\n  /**\n   * Checks if the given node is a BooleanLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a BooleanLiteral node.\n   */\n  static isBooleanLiteral(node: ExpressionNode): node is BooleanLiteral {\n    return node.type === \"BooleanLiteral\" && typeof node.value === \"boolean\";\n  }\n\n  /**\n   * Checks if the given node is an Identifier node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an Identifier node.\n   */\n  static isIdentifier(node: ExpressionNode): node is Identifier {\n    return node.type === \"Identifier\";\n  }\n\n  /**\n   * Checks if the given node is an ObjectExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ObjectExpression node.\n   */\n  static isObjectExpression(node: ExpressionNode): node is ObjectExpression {\n    return node.type === \"ObjectExpression\";\n  }\n\n  /**\n   * Checks if the given node is an ArrayExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ArrayExpression node.\n   */\n  static isArrayExpression(node: ExpressionNode): node is ArrayExpression {\n    return node.type === \"ArrayExpression\";\n  }\n\n  /**\n   * Checks if the given node is a PropertyAssignment node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a PropertyAssignment node.\n   */\n  static isPropertyAssignment(\n    node: ExpressionNode\n  ): node is PropertyAssignment {\n    return node.type === \"PropertyAssignment\";\n  }\n\n  /**\n   * Checks if the given node is a MemberExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a MemberExpression node.\n   */\n  static isMemberExpression(node: ExpressionNode): node is MemberExpression {\n    return node.type === \"MemberExpression\";\n  }\n}\n"],"mappings":";;;;;;;AAqBA,IAAsB,cAAtB,MAAkC;CAChC,YAAsBA,eAA6B;EAA7B;CAA+B;AAiBtD;;;;;;AAOD,IAAa,YAAb,MAAa,UAAU;CACrB,OAAO;;;;;CAMP,aAAa,kBAAkB;AAC7B,MAAI;AACF,OAAI,CAAC,UAAU,kBAAkB;IAC/B,MAAM,EAAE,SAAS,OAAO,GAAG,MAAM,OAAO;IACxC,MAAM,SAAS,MAAM,SAAS,QAAQ;IACtC,MAAM,EAAE,OAAO,GAAG;IAClB,UAAU,mBAAmB;GAC9B;AACD,UAAO,UAAU;EAClB,QAAO;AACN,SAAM,IAAI,MACR,CAAC,gGAAgG,CAAC;EAErG;CACF;;;;;;CAOD,OAAO,UAAUC,MAAuC;AACtD,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,sBACLA,MAC6B;AAC7B,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,iBAAiBA,MAA8C;AACpE,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,gBAAgBA,MAA6C;AAClE,SAAO,KAAK,SAAS,mBAAmB,OAAO,KAAK,UAAU;CAC/D;;;;;;CAOD,OAAO,iBAAiBA,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;CAChE;;;;;;CAOD,OAAO,iBAAiBA,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;CAChE;;;;;;CAOD,OAAO,aAAaA,MAA0C;AAC5D,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,mBAAmBA,MAAgD;AACxE,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,kBAAkBA,MAA+C;AACtE,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,qBACLA,MAC4B;AAC5B,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,mBAAmBA,MAAgD;AACxE,SAAO,KAAK,SAAS;CACtB;AACF"}

package/dist/output_parsers/expression_type_handlers/boolean_literal_handler.cjs

@@ -1,38 +0,0 @@
-const require_base = require('./base.cjs');
-
-//#region src/output_parsers/expression_type_handlers/boolean_literal_handler.ts
-/**
-* Handler for boolean literal nodes in the abstract syntax tree (AST).
-* Extends the NodeHandler class.
-*/
-var BooleanLiteralHandler = class extends require_base.NodeHandler {
-	/**
-	* Checks if a given node is a boolean literal. If it is, the method
-	* returns the node; otherwise, it returns false.
-	* @param node The node to check.
-	* @returns The node if it is a boolean literal, or false otherwise.
-	*/
-	async accepts(node) {
-		if (require_base.ASTParser.isBooleanLiteral(node)) return node;
-		else return false;
-	}
-	/**
-	* Handles the boolean literal node. Throws an error if there is no parent
-	* handler. If there is a parent handler, it returns an object of type
-	* BooleanLiteralType which includes the type of the node
-	* ("boolean_literal") and the value of the boolean literal.
-	* @param node The boolean literal node to handle.
-	* @returns An object of type BooleanLiteralType representing the handled node.
-	*/
-	async handle(node) {
-		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		return {
-			type: "boolean_literal",
-			value: node.value
-		};
-	}
-};
-
-//#endregion
-exports.BooleanLiteralHandler = BooleanLiteralHandler;
-//# sourceMappingURL=boolean_literal_handler.cjs.map

package/dist/output_parsers/expression_type_handlers/boolean_literal_handler.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"boolean_literal_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: BooleanLiteral"],"sources":["../../../src/output_parsers/expression_type_handlers/boolean_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { BooleanLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  BooleanLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for boolean literal nodes in the abstract syntax tree (AST).\n * Extends the NodeHandler class.\n */\nexport class BooleanLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a boolean literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is a boolean literal, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<BooleanLiteral | boolean> {\n    if (ASTParser.isBooleanLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Handles the boolean literal node. Throws an error if there is no parent\n   * handler. If there is a parent handler, it returns an object of type\n   * BooleanLiteralType which includes the type of the node\n   * (\"boolean_literal\") and the value of the boolean literal.\n   * @param node The boolean literal node to handle.\n   * @returns An object of type BooleanLiteralType representing the handled node.\n   */\n  async handle(node: BooleanLiteral): Promise<BooleanLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"boolean_literal\",\n      value: node.value as boolean,\n    };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,wBAAb,cAA2CA,yBAAY;;;;;;;CAOrD,MAAM,QAAQC,MAAyD;AACrE,MAAIC,uBAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;CAEV;;;;;;;;;CAUD,MAAM,OAAOC,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;AAGJ,SAAO;GACL,MAAM;GACN,OAAO,KAAK;EACb;CACF;AACF"}

package/dist/output_parsers/expression_type_handlers/boolean_literal_handler.js

@@ -1,38 +0,0 @@
-import { ASTParser, NodeHandler } from "./base.js";
-
-//#region src/output_parsers/expression_type_handlers/boolean_literal_handler.ts
-/**
-* Handler for boolean literal nodes in the abstract syntax tree (AST).
-* Extends the NodeHandler class.
-*/
-var BooleanLiteralHandler = class extends NodeHandler {
-	/**
-	* Checks if a given node is a boolean literal. If it is, the method
-	* returns the node; otherwise, it returns false.
-	* @param node The node to check.
-	* @returns The node if it is a boolean literal, or false otherwise.
-	*/
-	async accepts(node) {
-		if (ASTParser.isBooleanLiteral(node)) return node;
-		else return false;
-	}
-	/**
-	* Handles the boolean literal node. Throws an error if there is no parent
-	* handler. If there is a parent handler, it returns an object of type
-	* BooleanLiteralType which includes the type of the node
-	* ("boolean_literal") and the value of the boolean literal.
-	* @param node The boolean literal node to handle.
-	* @returns An object of type BooleanLiteralType representing the handled node.
-	*/
-	async handle(node) {
-		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		return {
-			type: "boolean_literal",
-			value: node.value
-		};
-	}
-};
-
-//#endregion
-export { BooleanLiteralHandler };
-//# sourceMappingURL=boolean_literal_handler.js.map

package/dist/output_parsers/expression_type_handlers/boolean_literal_handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"boolean_literal_handler.js","names":["node: ExpressionNode","node: BooleanLiteral"],"sources":["../../../src/output_parsers/expression_type_handlers/boolean_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { BooleanLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  BooleanLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for boolean literal nodes in the abstract syntax tree (AST).\n * Extends the NodeHandler class.\n */\nexport class BooleanLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a boolean literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is a boolean literal, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<BooleanLiteral | boolean> {\n    if (ASTParser.isBooleanLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Handles the boolean literal node. Throws an error if there is no parent\n   * handler. If there is a parent handler, it returns an object of type\n   * BooleanLiteralType which includes the type of the node\n   * (\"boolean_literal\") and the value of the boolean literal.\n   * @param node The boolean literal node to handle.\n   * @returns An object of type BooleanLiteralType representing the handled node.\n   */\n  async handle(node: BooleanLiteral): Promise<BooleanLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"boolean_literal\",\n      value: node.value as boolean,\n    };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,wBAAb,cAA2C,YAAY;;;;;;;CAOrD,MAAM,QAAQA,MAAyD;AACrE,MAAI,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;CAEV;;;;;;;;;CAUD,MAAM,OAAOC,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;AAGJ,SAAO;GACL,MAAM;GACN,OAAO,KAAK;EACb;CACF;AACF"}

package/dist/output_parsers/expression_type_handlers/call_expression_handler.cjs

@@ -1,64 +0,0 @@
-const require_base = require('./base.cjs');
-
-//#region src/output_parsers/expression_type_handlers/call_expression_handler.ts
-/**
-* Handles call expressions in the AST parsed by the `ASTParser`. This
-* class is part of the LangChain Expression Language (LCEL), a
-* declarative way to compose chains together in LangChain.
-*/
-var CallExpressionHandler = class extends require_base.NodeHandler {
-	/**
-	* Checks if a given node is a call expression. If it is, it returns the
-	* node; otherwise, it returns false.
-	* @param node The node to check.
-	* @returns The node if it is a call expression, or false otherwise.
-	*/
-	async accepts(node) {
-		if (require_base.ASTParser.isCallExpression(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes a call expression node. It checks the type of the callee (the
-	* function being called) and the arguments passed to it. If the callee is
-	* an identifier, it extracts the function name. If the callee is a member
-	* expression, it delegates handling to the parent handler. It also checks
-	* the types of the arguments and delegates their handling to the parent
-	* handler. The method returns an object representing the call expression,
-	* including the function call and its arguments.
-	* @param node The call expression node to process.
-	* @returns An object representing the call expression, including the function call and its arguments.
-	*/
-	async handle(node) {
-		function checkCallExpressionArgumentType(arg) {
-			return [
-				require_base.ASTParser.isStringLiteral,
-				require_base.ASTParser.isNumericLiteral,
-				require_base.ASTParser.isBooleanLiteral,
-				require_base.ASTParser.isArrayExpression,
-				require_base.ASTParser.isObjectExpression,
-				require_base.ASTParser.isCallExpression,
-				require_base.ASTParser.isIdentifier
-			].reduce((acc, func) => acc || func(arg), false);
-		}
-		if (this.parentHandler === void 0) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		const { callee } = node;
-		let funcCall;
-		if (require_base.ASTParser.isIdentifier(callee)) funcCall = callee.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
-		else if (require_base.ASTParser.isMemberExpression(callee)) funcCall = await this.parentHandler.handle(callee);
-		else throw new Error("Unknown expression type");
-		const args = await Promise.all(node.arguments.map((arg) => {
-			if (!checkCallExpressionArgumentType(arg)) throw new Error("Unknown argument type");
-			if (!this.parentHandler) throw new Error("CallExpressionHandler must have a parent handler");
-			return this.parentHandler.handle(arg);
-		}));
-		return {
-			type: "call_expression",
-			funcCall,
-			args
-		};
-	}
-};
-
-//#endregion
-exports.CallExpressionHandler = CallExpressionHandler;
-//# sourceMappingURL=call_expression_handler.cjs.map

package/dist/output_parsers/expression_type_handlers/call_expression_handler.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"call_expression_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: CallExpression","arg: ExpressionNode"],"sources":["../../../src/output_parsers/expression_type_handlers/call_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { CallExpressionType, MemberExpressionType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  CallExpression,\n  MemberExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles call expressions in the AST parsed by the `ASTParser`. This\n * class is part of the LangChain Expression Language (LCEL), a\n * declarative way to compose chains together in LangChain.\n */\nexport class CallExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a call expression. If it is, it returns the\n   * node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is a call expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<CallExpression | boolean> {\n    if (ASTParser.isCallExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a call expression node. It checks the type of the callee (the\n   * function being called) and the arguments passed to it. If the callee is\n   * an identifier, it extracts the function name. If the callee is a member\n   * expression, it delegates handling to the parent handler. It also checks\n   * the types of the arguments and delegates their handling to the parent\n   * handler. The method returns an object representing the call expression,\n   * including the function call and its arguments.\n   * @param node The call expression node to process.\n   * @returns An object representing the call expression, including the function call and its arguments.\n   */\n  async handle(node: CallExpression): Promise<CallExpressionType> {\n    function checkCallExpressionArgumentType(arg: ExpressionNode): boolean {\n      return [\n        ASTParser.isStringLiteral,\n        ASTParser.isNumericLiteral,\n        ASTParser.isBooleanLiteral,\n        ASTParser.isArrayExpression,\n        ASTParser.isObjectExpression,\n        ASTParser.isCallExpression,\n        ASTParser.isIdentifier,\n      ].reduce((acc, func) => acc || func(arg), false);\n    }\n    if (this.parentHandler === undefined) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const { callee } = node;\n    let funcCall;\n    if (ASTParser.isIdentifier(callee)) {\n      funcCall = callee.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isMemberExpression(callee)) {\n      funcCall = (await this.parentHandler.handle(\n        callee as MemberExpression\n      )) as MemberExpressionType;\n    } else {\n      throw new Error(\"Unknown expression type\");\n    }\n\n    const args = await Promise.all(\n      node.arguments.map((arg) => {\n        if (!checkCallExpressionArgumentType(arg)) {\n          throw new Error(\"Unknown argument type\");\n        }\n        if (!this.parentHandler) {\n          throw new Error(\"CallExpressionHandler must have a parent handler\");\n        }\n        return this.parentHandler.handle(arg as ExpressionNode);\n      })\n    );\n    return { type: \"call_expression\", funcCall, args };\n  }\n}\n"],"mappings":";;;;;;;;AAaA,IAAa,wBAAb,cAA2CA,yBAAY;;;;;;;CAOrD,MAAM,QAAQC,MAAyD;AACrE,MAAIC,uBAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;CAEV;;;;;;;;;;;;CAaD,MAAM,OAAOC,MAAmD;EAC9D,SAAS,gCAAgCC,KAA8B;AACrE,UAAO;IACLF,uBAAU;IACVA,uBAAU;IACVA,uBAAU;IACVA,uBAAU;IACVA,uBAAU;IACVA,uBAAU;IACVA,uBAAU;GACX,EAAC,OAAO,CAAC,KAAK,SAAS,OAAO,KAAK,IAAI,EAAE,MAAM;EACjD;AACD,MAAI,KAAK,kBAAkB,OACzB,OAAM,IAAI,MACR;EAGJ,MAAM,EAAE,QAAQ,GAAG;EACnB,IAAI;AACJ,MAAIA,uBAAU,aAAa,OAAO,EAChC,WAAW,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACtDA,uBAAU,mBAAmB,OAAO,EAC7C,WAAY,MAAM,KAAK,cAAc,OACnC,OACD;MAED,OAAM,IAAI,MAAM;EAGlB,MAAM,OAAO,MAAM,QAAQ,IACzB,KAAK,UAAU,IAAI,CAAC,QAAQ;AAC1B,OAAI,CAAC,gCAAgC,IAAI,CACvC,OAAM,IAAI,MAAM;AAElB,OAAI,CAAC,KAAK,cACR,OAAM,IAAI,MAAM;AAElB,UAAO,KAAK,cAAc,OAAO,IAAsB;EACxD,EAAC,CACH;AACD,SAAO;GAAE,MAAM;GAAmB;GAAU;EAAM;CACnD;AACF"}

package/dist/output_parsers/expression_type_handlers/call_expression_handler.js

@@ -1,64 +0,0 @@
-import { ASTParser, NodeHandler } from "./base.js";
-
-//#region src/output_parsers/expression_type_handlers/call_expression_handler.ts
-/**
-* Handles call expressions in the AST parsed by the `ASTParser`. This
-* class is part of the LangChain Expression Language (LCEL), a
-* declarative way to compose chains together in LangChain.
-*/
-var CallExpressionHandler = class extends NodeHandler {
-	/**
-	* Checks if a given node is a call expression. If it is, it returns the
-	* node; otherwise, it returns false.
-	* @param node The node to check.
-	* @returns The node if it is a call expression, or false otherwise.
-	*/
-	async accepts(node) {
-		if (ASTParser.isCallExpression(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes a call expression node. It checks the type of the callee (the
-	* function being called) and the arguments passed to it. If the callee is
-	* an identifier, it extracts the function name. If the callee is a member
-	* expression, it delegates handling to the parent handler. It also checks
-	* the types of the arguments and delegates their handling to the parent
-	* handler. The method returns an object representing the call expression,
-	* including the function call and its arguments.
-	* @param node The call expression node to process.
-	* @returns An object representing the call expression, including the function call and its arguments.
-	*/
-	async handle(node) {
-		function checkCallExpressionArgumentType(arg) {
-			return [
-				ASTParser.isStringLiteral,
-				ASTParser.isNumericLiteral,
-				ASTParser.isBooleanLiteral,
-				ASTParser.isArrayExpression,
-				ASTParser.isObjectExpression,
-				ASTParser.isCallExpression,
-				ASTParser.isIdentifier
-			].reduce((acc, func) => acc || func(arg), false);
-		}
-		if (this.parentHandler === void 0) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		const { callee } = node;
-		let funcCall;
-		if (ASTParser.isIdentifier(callee)) funcCall = callee.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
-		else if (ASTParser.isMemberExpression(callee)) funcCall = await this.parentHandler.handle(callee);
-		else throw new Error("Unknown expression type");
-		const args = await Promise.all(node.arguments.map((arg) => {
-			if (!checkCallExpressionArgumentType(arg)) throw new Error("Unknown argument type");
-			if (!this.parentHandler) throw new Error("CallExpressionHandler must have a parent handler");
-			return this.parentHandler.handle(arg);
-		}));
-		return {
-			type: "call_expression",
-			funcCall,
-			args
-		};
-	}
-};
-
-//#endregion
-export { CallExpressionHandler };
-//# sourceMappingURL=call_expression_handler.js.map

package/dist/output_parsers/expression_type_handlers/call_expression_handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"call_expression_handler.js","names":["node: ExpressionNode","node: CallExpression","arg: ExpressionNode"],"sources":["../../../src/output_parsers/expression_type_handlers/call_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { CallExpressionType, MemberExpressionType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  CallExpression,\n  MemberExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles call expressions in the AST parsed by the `ASTParser`. This\n * class is part of the LangChain Expression Language (LCEL), a\n * declarative way to compose chains together in LangChain.\n */\nexport class CallExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a call expression. If it is, it returns the\n   * node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is a call expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<CallExpression | boolean> {\n    if (ASTParser.isCallExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a call expression node. It checks the type of the callee (the\n   * function being called) and the arguments passed to it. If the callee is\n   * an identifier, it extracts the function name. If the callee is a member\n   * expression, it delegates handling to the parent handler. It also checks\n   * the types of the arguments and delegates their handling to the parent\n   * handler. The method returns an object representing the call expression,\n   * including the function call and its arguments.\n   * @param node The call expression node to process.\n   * @returns An object representing the call expression, including the function call and its arguments.\n   */\n  async handle(node: CallExpression): Promise<CallExpressionType> {\n    function checkCallExpressionArgumentType(arg: ExpressionNode): boolean {\n      return [\n        ASTParser.isStringLiteral,\n        ASTParser.isNumericLiteral,\n        ASTParser.isBooleanLiteral,\n        ASTParser.isArrayExpression,\n        ASTParser.isObjectExpression,\n        ASTParser.isCallExpression,\n        ASTParser.isIdentifier,\n      ].reduce((acc, func) => acc || func(arg), false);\n    }\n    if (this.parentHandler === undefined) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const { callee } = node;\n    let funcCall;\n    if (ASTParser.isIdentifier(callee)) {\n      funcCall = callee.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isMemberExpression(callee)) {\n      funcCall = (await this.parentHandler.handle(\n        callee as MemberExpression\n      )) as MemberExpressionType;\n    } else {\n      throw new Error(\"Unknown expression type\");\n    }\n\n    const args = await Promise.all(\n      node.arguments.map((arg) => {\n        if (!checkCallExpressionArgumentType(arg)) {\n          throw new Error(\"Unknown argument type\");\n        }\n        if (!this.parentHandler) {\n          throw new Error(\"CallExpressionHandler must have a parent handler\");\n        }\n        return this.parentHandler.handle(arg as ExpressionNode);\n      })\n    );\n    return { type: \"call_expression\", funcCall, args };\n  }\n}\n"],"mappings":";;;;;;;;AAaA,IAAa,wBAAb,cAA2C,YAAY;;;;;;;CAOrD,MAAM,QAAQA,MAAyD;AACrE,MAAI,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;CAEV;;;;;;;;;;;;CAaD,MAAM,OAAOC,MAAmD;EAC9D,SAAS,gCAAgCC,KAA8B;AACrE,UAAO;IACL,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;GACX,EAAC,OAAO,CAAC,KAAK,SAAS,OAAO,KAAK,IAAI,EAAE,MAAM;EACjD;AACD,MAAI,KAAK,kBAAkB,OACzB,OAAM,IAAI,MACR;EAGJ,MAAM,EAAE,QAAQ,GAAG;EACnB,IAAI;AACJ,MAAI,UAAU,aAAa,OAAO,EAChC,WAAW,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACtD,UAAU,mBAAmB,OAAO,EAC7C,WAAY,MAAM,KAAK,cAAc,OACnC,OACD;MAED,OAAM,IAAI,MAAM;EAGlB,MAAM,OAAO,MAAM,QAAQ,IACzB,KAAK,UAAU,IAAI,CAAC,QAAQ;AAC1B,OAAI,CAAC,gCAAgC,IAAI,CACvC,OAAM,IAAI,MAAM;AAElB,OAAI,CAAC,KAAK,cACR,OAAM,IAAI,MAAM;AAElB,UAAO,KAAK,cAAc,OAAO,IAAsB;EACxD,EAAC,CACH;AACD,SAAO;GAAE,MAAM;GAAmB;GAAU;EAAM;CACnD;AACF"}

package/dist/output_parsers/expression_type_handlers/factory.cjs

@@ -1,68 +0,0 @@
-const require_base = require('./base.cjs');
-const require_array_literal_expression_handler = require('./array_literal_expression_handler.cjs');
-const require_boolean_literal_handler = require('./boolean_literal_handler.cjs');
-const require_call_expression_handler = require('./call_expression_handler.cjs');
-const require_numeric_literal_handler = require('./numeric_literal_handler.cjs');
-const require_property_assignment_handler = require('./property_assignment_handler.cjs');
-const require_object_literal_expression_handler = require('./object_literal_expression_handler.cjs');
-const require_string_literal_handler = require('./string_literal_handler.cjs');
-const require_identifier_handler = require('./identifier_handler.cjs');
-const require_member_expression_handler = require('./member_expression_handler.cjs');
-
-//#region src/output_parsers/expression_type_handlers/factory.ts
-const handlers = [
-	require_array_literal_expression_handler.ArrayLiteralExpressionHandler,
-	require_boolean_literal_handler.BooleanLiteralHandler,
-	require_call_expression_handler.CallExpressionHandler,
-	require_numeric_literal_handler.NumericLiteralHandler,
-	require_object_literal_expression_handler.ObjectLiteralExpressionHandler,
-	require_member_expression_handler.MemberExpressionHandler,
-	require_property_assignment_handler.PropertyAssignmentHandler,
-	require_string_literal_handler.StringLiteralHandler,
-	require_identifier_handler.IdentifierHandler
-];
-/**
-* The MasterHandler class is responsible for managing a collection of
-* node handlers in the LangChain Expression Language. Each node handler
-* is capable of handling a specific type of node in the expression
-* language. The MasterHandler class uses these node handlers to process
-* nodes in the expression language.
-*/
-var MasterHandler = class MasterHandler extends require_base.NodeHandler {
-	nodeHandlers = [];
-	async accepts(node) {
-		throw new Error(`Master handler does not accept any nodes: ${node}`);
-	}
-	/**
-	* This method is responsible for handling a node. It iterates over the
-	* collection of node handlers and uses the first handler that accepts the
-	* node to handle it. If no handler accepts the node, the method throws an
-	* error.
-	* @param node The node to be handled.
-	* @returns The result of the node handling, or throws an error if no handler can handle the node.
-	*/
-	async handle(node) {
-		for (const handler of this.nodeHandlers) {
-			const accepts = await handler.accepts(node);
-			if (accepts) return handler.handle(node);
-		}
-		throw new Error(`No handler found for node: ${node}`);
-	}
-	/**
-	* This static method creates an instance of the MasterHandler class and
-	* initializes it with instances of all the node handlers.
-	* @returns An instance of the MasterHandler class.
-	*/
-	static createMasterHandler() {
-		const masterHandler = new MasterHandler();
-		handlers.forEach((Handler) => {
-			const handlerInstance = new Handler(masterHandler);
-			masterHandler.nodeHandlers.push(handlerInstance);
-		});
-		return masterHandler;
-	}
-};
-
-//#endregion
-exports.MasterHandler = MasterHandler;
-//# sourceMappingURL=factory.cjs.map

package/dist/output_parsers/expression_type_handlers/factory.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.cjs","names":["ArrayLiteralExpressionHandler","BooleanLiteralHandler","CallExpressionHandler","NumericLiteralHandler","ObjectLiteralExpressionHandler","MemberExpressionHandler","PropertyAssignmentHandler","StringLiteralHandler","IdentifierHandler","NodeHandler","node: ExpressionNode","node: CallExpression"],"sources":["../../../src/output_parsers/expression_type_handlers/factory.ts"],"sourcesContent":["import { NodeHandler } from \"./base.js\";\nimport { ArrayLiteralExpressionHandler } from \"./array_literal_expression_handler.js\";\nimport { BooleanLiteralHandler } from \"./boolean_literal_handler.js\";\nimport { CallExpressionHandler } from \"./call_expression_handler.js\";\nimport { NumericLiteralHandler } from \"./numeric_literal_handler.js\";\nimport { ObjectLiteralExpressionHandler } from \"./object_literal_expression_handler.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { StringLiteralHandler } from \"./string_literal_handler.js\";\nimport { IdentifierHandler } from \"./identifier_handler.js\";\nimport { MemberExpressionHandler } from \"./member_expression_handler.js\";\nimport { ParsedType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  CallExpression,\n} from \"../../types/expression-parser.js\";\n\nconst handlers = [\n  ArrayLiteralExpressionHandler,\n  BooleanLiteralHandler,\n  CallExpressionHandler,\n  NumericLiteralHandler,\n  ObjectLiteralExpressionHandler,\n  MemberExpressionHandler,\n  PropertyAssignmentHandler,\n  StringLiteralHandler,\n  IdentifierHandler,\n];\n\n/**\n * The MasterHandler class is responsible for managing a collection of\n * node handlers in the LangChain Expression Language. Each node handler\n * is capable of handling a specific type of node in the expression\n * language. The MasterHandler class uses these node handlers to process\n * nodes in the expression language.\n */\nexport class MasterHandler extends NodeHandler {\n  nodeHandlers: NodeHandler[] = [];\n\n  async accepts(node: ExpressionNode): Promise<ExpressionNode | boolean> {\n    throw new Error(`Master handler does not accept any nodes: ${node}`);\n  }\n\n  /**\n   * This method is responsible for handling a node. It iterates over the\n   * collection of node handlers and uses the first handler that accepts the\n   * node to handle it. If no handler accepts the node, the method throws an\n   * error.\n   * @param node The node to be handled.\n   * @returns The result of the node handling, or throws an error if no handler can handle the node.\n   */\n  async handle(node: CallExpression): Promise<ParsedType> {\n    for (const handler of this.nodeHandlers) {\n      const accepts = await handler.accepts(node);\n      if (accepts) {\n        return handler.handle(node);\n      }\n    }\n\n    throw new Error(`No handler found for node: ${node}`);\n  }\n\n  /**\n   * This static method creates an instance of the MasterHandler class and\n   * initializes it with instances of all the node handlers.\n   * @returns An instance of the MasterHandler class.\n   */\n  static createMasterHandler(): MasterHandler {\n    const masterHandler = new MasterHandler();\n    handlers.forEach((Handler) => {\n      const handlerInstance = new Handler(masterHandler);\n      masterHandler.nodeHandlers.push(handlerInstance);\n    });\n    return masterHandler;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,MAAM,WAAW;CACfA;CACAC;CACAC;CACAC;CACAC;CACAC;CACAC;CACAC;CACAC;AACD;;;;;;;;AASD,IAAa,gBAAb,MAAa,sBAAsBC,yBAAY;CAC7C,eAA8B,CAAE;CAEhC,MAAM,QAAQC,MAAyD;AACrE,QAAM,IAAI,MAAM,CAAC,0CAA0C,EAAE,MAAM;CACpE;;;;;;;;;CAUD,MAAM,OAAOC,MAA2C;AACtD,OAAK,MAAM,WAAW,KAAK,cAAc;GACvC,MAAM,UAAU,MAAM,QAAQ,QAAQ,KAAK;AAC3C,OAAI,QACF,QAAO,QAAQ,OAAO,KAAK;EAE9B;AAED,QAAM,IAAI,MAAM,CAAC,2BAA2B,EAAE,MAAM;CACrD;;;;;;CAOD,OAAO,sBAAqC;EAC1C,MAAM,gBAAgB,IAAI;EAC1B,SAAS,QAAQ,CAAC,YAAY;GAC5B,MAAM,kBAAkB,IAAI,QAAQ;GACpC,cAAc,aAAa,KAAK,gBAAgB;EACjD,EAAC;AACF,SAAO;CACR;AACF"}

package/dist/output_parsers/expression_type_handlers/factory.d.cts

@@ -1,35 +0,0 @@
-import { ParsedType } from "./types.cjs";
-import { CallExpression, ExpressionNode } from "../../types/expression-parser.cjs";
-import { NodeHandler } from "./base.cjs";
-
-//#region src/output_parsers/expression_type_handlers/factory.d.ts
-
-/**
- * The MasterHandler class is responsible for managing a collection of
- * node handlers in the LangChain Expression Language. Each node handler
- * is capable of handling a specific type of node in the expression
- * language. The MasterHandler class uses these node handlers to process
- * nodes in the expression language.
- */
-declare class MasterHandler extends NodeHandler {
-  nodeHandlers: NodeHandler[];
-  accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;
-  /**
-   * This method is responsible for handling a node. It iterates over the
-   * collection of node handlers and uses the first handler that accepts the
-   * node to handle it. If no handler accepts the node, the method throws an
-   * error.
-   * @param node The node to be handled.
-   * @returns The result of the node handling, or throws an error if no handler can handle the node.
-   */
-  handle(node: CallExpression): Promise<ParsedType>;
-  /**
-   * This static method creates an instance of the MasterHandler class and
-   * initializes it with instances of all the node handlers.
-   * @returns An instance of the MasterHandler class.
-   */
-  static createMasterHandler(): MasterHandler;
-}
-//#endregion
-export { MasterHandler };
-//# sourceMappingURL=factory.d.cts.map

package/dist/output_parsers/expression_type_handlers/factory.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.d.cts","names":["NodeHandler","ParsedType","ExpressionNode","CallExpression","MasterHandler","Promise"],"sources":["../../../src/output_parsers/expression_type_handlers/factory.d.ts"],"sourcesContent":["import { NodeHandler } from \"./base.js\";\nimport { ParsedType } from \"./types.js\";\nimport type { ExpressionNode, CallExpression } from \"../../types/expression-parser.js\";\n/**\n * The MasterHandler class is responsible for managing a collection of\n * node handlers in the LangChain Expression Language. Each node handler\n * is capable of handling a specific type of node in the expression\n * language. The MasterHandler class uses these node handlers to process\n * nodes in the expression language.\n */\nexport declare class MasterHandler extends NodeHandler {\n    nodeHandlers: NodeHandler[];\n    accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n    /**\n     * This method is responsible for handling a node. It iterates over the\n     * collection of node handlers and uses the first handler that accepts the\n     * node to handle it. If no handler accepts the node, the method throws an\n     * error.\n     * @param node The node to be handled.\n     * @returns The result of the node handling, or throws an error if no handler can handle the node.\n     */\n    handle(node: CallExpression): Promise<ParsedType>;\n    /**\n     * This static method creates an instance of the MasterHandler class and\n     * initializes it with instances of all the node handlers.\n     * @returns An instance of the MasterHandler class.\n     */\n    static createMasterHandler(): MasterHandler;\n}\n"],"mappings":";;;;;;;;AAUA;;;;;AAEmCK,cAFdD,aAAAA,SAAsBJ,WAAAA,CAERK;EAAO,YASzBF,EAVCH,WAUDG,EAAAA;EAAc,OAAWF,CAAAA,IAAAA,EATxBC,cASwBD,CAAAA,EATPI,OASOJ,CATCC,cASDD,GAAAA,OAAAA,CAAAA;EAAU;;;AAXE;;;;;eAWrCE,iBAAiBE,QAAQJ;;;;;;gCAMRG"}

package/dist/output_parsers/expression_type_handlers/factory.d.ts

@@ -1,35 +0,0 @@
-import { ParsedType } from "./types.js";
-import { CallExpression, ExpressionNode } from "../../types/expression-parser.js";
-import { NodeHandler } from "./base.js";
-
-//#region src/output_parsers/expression_type_handlers/factory.d.ts
-
-/**
- * The MasterHandler class is responsible for managing a collection of
- * node handlers in the LangChain Expression Language. Each node handler
- * is capable of handling a specific type of node in the expression
- * language. The MasterHandler class uses these node handlers to process
- * nodes in the expression language.
- */
-declare class MasterHandler extends NodeHandler {
-  nodeHandlers: NodeHandler[];
-  accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;
-  /**
-   * This method is responsible for handling a node. It iterates over the
-   * collection of node handlers and uses the first handler that accepts the
-   * node to handle it. If no handler accepts the node, the method throws an
-   * error.
-   * @param node The node to be handled.
-   * @returns The result of the node handling, or throws an error if no handler can handle the node.
-   */
-  handle(node: CallExpression): Promise<ParsedType>;
-  /**
-   * This static method creates an instance of the MasterHandler class and
-   * initializes it with instances of all the node handlers.
-   * @returns An instance of the MasterHandler class.
-   */
-  static createMasterHandler(): MasterHandler;
-}
-//#endregion
-export { MasterHandler };
-//# sourceMappingURL=factory.d.ts.map

package/dist/output_parsers/expression_type_handlers/factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.d.ts","names":["NodeHandler","ParsedType","ExpressionNode","CallExpression","MasterHandler","Promise"],"sources":["../../../src/output_parsers/expression_type_handlers/factory.d.ts"],"sourcesContent":["import { NodeHandler } from \"./base.js\";\nimport { ParsedType } from \"./types.js\";\nimport type { ExpressionNode, CallExpression } from \"../../types/expression-parser.js\";\n/**\n * The MasterHandler class is responsible for managing a collection of\n * node handlers in the LangChain Expression Language. Each node handler\n * is capable of handling a specific type of node in the expression\n * language. The MasterHandler class uses these node handlers to process\n * nodes in the expression language.\n */\nexport declare class MasterHandler extends NodeHandler {\n    nodeHandlers: NodeHandler[];\n    accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n    /**\n     * This method is responsible for handling a node. It iterates over the\n     * collection of node handlers and uses the first handler that accepts the\n     * node to handle it. If no handler accepts the node, the method throws an\n     * error.\n     * @param node The node to be handled.\n     * @returns The result of the node handling, or throws an error if no handler can handle the node.\n     */\n    handle(node: CallExpression): Promise<ParsedType>;\n    /**\n     * This static method creates an instance of the MasterHandler class and\n     * initializes it with instances of all the node handlers.\n     * @returns An instance of the MasterHandler class.\n     */\n    static createMasterHandler(): MasterHandler;\n}\n"],"mappings":";;;;;;;;AAUA;;;;;AAEmCK,cAFdD,aAAAA,SAAsBJ,WAAAA,CAERK;EAAO,YASzBF,EAVCH,WAUDG,EAAAA;EAAc,OAAWF,CAAAA,IAAAA,EATxBC,cASwBD,CAAAA,EATPI,OASOJ,CATCC,cASDD,GAAAA,OAAAA,CAAAA;EAAU;;;AAXE;;;;;eAWrCE,iBAAiBE,QAAQJ;;;;;;gCAMRG"}

package/dist/output_parsers/expression_type_handlers/factory.js

@@ -1,68 +0,0 @@
-import { NodeHandler } from "./base.js";
-import { ArrayLiteralExpressionHandler } from "./array_literal_expression_handler.js";
-import { BooleanLiteralHandler } from "./boolean_literal_handler.js";
-import { CallExpressionHandler } from "./call_expression_handler.js";
-import { NumericLiteralHandler } from "./numeric_literal_handler.js";
-import { PropertyAssignmentHandler } from "./property_assignment_handler.js";
-import { ObjectLiteralExpressionHandler } from "./object_literal_expression_handler.js";
-import { StringLiteralHandler } from "./string_literal_handler.js";
-import { IdentifierHandler } from "./identifier_handler.js";
-import { MemberExpressionHandler } from "./member_expression_handler.js";
-
-//#region src/output_parsers/expression_type_handlers/factory.ts
-const handlers = [
-	ArrayLiteralExpressionHandler,
-	BooleanLiteralHandler,
-	CallExpressionHandler,
-	NumericLiteralHandler,
-	ObjectLiteralExpressionHandler,
-	MemberExpressionHandler,
-	PropertyAssignmentHandler,
-	StringLiteralHandler,
-	IdentifierHandler
-];
-/**
-* The MasterHandler class is responsible for managing a collection of
-* node handlers in the LangChain Expression Language. Each node handler
-* is capable of handling a specific type of node in the expression
-* language. The MasterHandler class uses these node handlers to process
-* nodes in the expression language.
-*/
-var MasterHandler = class MasterHandler extends NodeHandler {
-	nodeHandlers = [];
-	async accepts(node) {
-		throw new Error(`Master handler does not accept any nodes: ${node}`);
-	}
-	/**
-	* This method is responsible for handling a node. It iterates over the
-	* collection of node handlers and uses the first handler that accepts the
-	* node to handle it. If no handler accepts the node, the method throws an
-	* error.
-	* @param node The node to be handled.
-	* @returns The result of the node handling, or throws an error if no handler can handle the node.
-	*/
-	async handle(node) {
-		for (const handler of this.nodeHandlers) {
-			const accepts = await handler.accepts(node);
-			if (accepts) return handler.handle(node);
-		}
-		throw new Error(`No handler found for node: ${node}`);
-	}
-	/**
-	* This static method creates an instance of the MasterHandler class and
-	* initializes it with instances of all the node handlers.
-	* @returns An instance of the MasterHandler class.
-	*/
-	static createMasterHandler() {
-		const masterHandler = new MasterHandler();
-		handlers.forEach((Handler) => {
-			const handlerInstance = new Handler(masterHandler);
-			masterHandler.nodeHandlers.push(handlerInstance);
-		});
-		return masterHandler;
-	}
-};
-
-//#endregion
-export { MasterHandler };
-//# sourceMappingURL=factory.js.map

package/dist/output_parsers/expression_type_handlers/factory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.js","names":["node: ExpressionNode","node: CallExpression"],"sources":["../../../src/output_parsers/expression_type_handlers/factory.ts"],"sourcesContent":["import { NodeHandler } from \"./base.js\";\nimport { ArrayLiteralExpressionHandler } from \"./array_literal_expression_handler.js\";\nimport { BooleanLiteralHandler } from \"./boolean_literal_handler.js\";\nimport { CallExpressionHandler } from \"./call_expression_handler.js\";\nimport { NumericLiteralHandler } from \"./numeric_literal_handler.js\";\nimport { ObjectLiteralExpressionHandler } from \"./object_literal_expression_handler.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { StringLiteralHandler } from \"./string_literal_handler.js\";\nimport { IdentifierHandler } from \"./identifier_handler.js\";\nimport { MemberExpressionHandler } from \"./member_expression_handler.js\";\nimport { ParsedType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  CallExpression,\n} from \"../../types/expression-parser.js\";\n\nconst handlers = [\n  ArrayLiteralExpressionHandler,\n  BooleanLiteralHandler,\n  CallExpressionHandler,\n  NumericLiteralHandler,\n  ObjectLiteralExpressionHandler,\n  MemberExpressionHandler,\n  PropertyAssignmentHandler,\n  StringLiteralHandler,\n  IdentifierHandler,\n];\n\n/**\n * The MasterHandler class is responsible for managing a collection of\n * node handlers in the LangChain Expression Language. Each node handler\n * is capable of handling a specific type of node in the expression\n * language. The MasterHandler class uses these node handlers to process\n * nodes in the expression language.\n */\nexport class MasterHandler extends NodeHandler {\n  nodeHandlers: NodeHandler[] = [];\n\n  async accepts(node: ExpressionNode): Promise<ExpressionNode | boolean> {\n    throw new Error(`Master handler does not accept any nodes: ${node}`);\n  }\n\n  /**\n   * This method is responsible for handling a node. It iterates over the\n   * collection of node handlers and uses the first handler that accepts the\n   * node to handle it. If no handler accepts the node, the method throws an\n   * error.\n   * @param node The node to be handled.\n   * @returns The result of the node handling, or throws an error if no handler can handle the node.\n   */\n  async handle(node: CallExpression): Promise<ParsedType> {\n    for (const handler of this.nodeHandlers) {\n      const accepts = await handler.accepts(node);\n      if (accepts) {\n        return handler.handle(node);\n      }\n    }\n\n    throw new Error(`No handler found for node: ${node}`);\n  }\n\n  /**\n   * This static method creates an instance of the MasterHandler class and\n   * initializes it with instances of all the node handlers.\n   * @returns An instance of the MasterHandler class.\n   */\n  static createMasterHandler(): MasterHandler {\n    const masterHandler = new MasterHandler();\n    handlers.forEach((Handler) => {\n      const handlerInstance = new Handler(masterHandler);\n      masterHandler.nodeHandlers.push(handlerInstance);\n    });\n    return masterHandler;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,MAAM,WAAW;CACf;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACD;;;;;;;;AASD,IAAa,gBAAb,MAAa,sBAAsB,YAAY;CAC7C,eAA8B,CAAE;CAEhC,MAAM,QAAQA,MAAyD;AACrE,QAAM,IAAI,MAAM,CAAC,0CAA0C,EAAE,MAAM;CACpE;;;;;;;;;CAUD,MAAM,OAAOC,MAA2C;AACtD,OAAK,MAAM,WAAW,KAAK,cAAc;GACvC,MAAM,UAAU,MAAM,QAAQ,QAAQ,KAAK;AAC3C,OAAI,QACF,QAAO,QAAQ,OAAO,KAAK;EAE9B;AAED,QAAM,IAAI,MAAM,CAAC,2BAA2B,EAAE,MAAM;CACrD;;;;;;CAOD,OAAO,sBAAqC;EAC1C,MAAM,gBAAgB,IAAI;EAC1B,SAAS,QAAQ,CAAC,YAAY;GAC5B,MAAM,kBAAkB,IAAI,QAAQ;GACpC,cAAc,aAAa,KAAK,gBAAgB;EACjD,EAAC;AACF,SAAO;CACR;AACF"}