@langchain/classic 1.0.0-alpha.1

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

@@ -0,0 +1,108 @@
+import { ArrayExpression, BooleanLiteral, CallExpression, ExpressionNode, ExpressionStatement, Identifier, MemberExpression, NumericLiteral, ObjectExpression, ParseFunction, Program, PropertyAssignment, StringLiteral } from "../../types/expression-parser.cjs";
+
+//#region src/output_parsers/expression_type_handlers/base.d.ts
+
+/**
+ * Abstract class for handling nodes in an expression language. Subclasses
+ * must implement the `accepts` and `handle` methods.
+ */
+declare abstract class NodeHandler {
+  protected parentHandler?: NodeHandler | undefined;
+  constructor(parentHandler?: NodeHandler | undefined);
+  /**
+   * Determines whether the given node is acceptable.
+   * @param node The node to be checked.
+   * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.
+   */
+  abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;
+  /**
+   * Handles the given node. The specifics of how the node is handled are
+   * determined by the subclass implementation.
+   * @param node The node to be handled.
+   * @returns A Promise that resolves to the result of handling the node.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  abstract handle(node: ExpressionNode): Promise<any>;
+}
+/**
+ * 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.
+ */
+declare class ASTParser {
+  static astParseInstance: ParseFunction;
+  /**
+   * Imports and generates a parser using the Peggy library.
+   * @returns A Promise that resolves to the parser instance.
+   */
+  static importASTParser(): Promise<ParseFunction>;
+  /**
+   * 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: ExpressionNode): node is 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: ExpressionNode): node is 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: ExpressionNode): node is 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: ExpressionNode): node is StringLiteral;
+  /**
+   * 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: ExpressionNode): node is NumericLiteral;
+  /**
+   * 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: ExpressionNode): node is BooleanLiteral;
+  /**
+   * 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: ExpressionNode): node is 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: ExpressionNode): node is 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: ExpressionNode): node is 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: ExpressionNode): node is 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: ExpressionNode): node is MemberExpression;
+}
+//#endregion
+export { ASTParser, NodeHandler };
+//# sourceMappingURL=base.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["ExpressionNode","Program","ExpressionStatement","CallExpression","StringLiteral","NumericLiteral","BooleanLiteral","Identifier","ObjectExpression","ArrayExpression","PropertyAssignment","MemberExpression","ParseFunction","NodeHandler","Promise","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/base.d.ts"],"sourcesContent":["import type { ExpressionNode, Program, ExpressionStatement, CallExpression, StringLiteral, NumericLiteral, BooleanLiteral, Identifier, ObjectExpression, ArrayExpression, PropertyAssignment, MemberExpression, ParseFunction } from \"../../types/expression-parser.js\";\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport declare abstract class NodeHandler {\n    protected parentHandler?: NodeHandler | undefined;\n    constructor(parentHandler?: NodeHandler | undefined);\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     * 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 * 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 declare class ASTParser {\n    static astParseInstance: ParseFunction;\n    /**\n     * Imports and generates a parser using the Peggy library.\n     * @returns A Promise that resolves to the parser instance.\n     */\n    static importASTParser(): Promise<ParseFunction>;\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    /**\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(node: ExpressionNode): node is ExpressionStatement;\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    /**\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    /**\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    /**\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    /**\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    /**\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    /**\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    /**\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(node: ExpressionNode): node is PropertyAssignment;\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}\n"],"mappings":";;;;;;AAKA;;AAC8Ba,uBADAA,WAAAA,CACAA;EAAW,UACTA,aAAAA,CAAAA,EADFA,WACEA,GAAAA,SAAAA;EAAW,WAMhBb,CAAAA,aAAAA,CAAAA,EANKa,WAMLb,GAAAA,SAAAA;EAAc;;;;AAQS;EAO7Be,SAAAA,OAAS,CAAA,IAAA,EAfHf,cAeG,CAAA,EAfcc,OAed,CAfsBd,cAetB,GAAA,OAAA,CAAA;EAAA;;;;;;EAY6B;EAMN,SAAWE,MAAAA,CAAAA,IAAAA,EAzBtCF,cAyBsCE,CAAAA,EAzBrBY,OAyBqBZ,CAAAA,GAAAA,CAAAA;;;;;;;AAwB9BF,cA1Cbe,SAAAA,CA0Caf;EAAc,OAAWM,gBAAAA,EAzC9BM,aAyC8BN;EAAc;;;;EAYI,OAM1CN,eAAAA,CAAAA,CAAAA,EAtDLc,OAsDKd,CAtDGY,aAsDHZ,CAAAA;EAAc;;;;;EAY4B,OAAA,SAAA,CAAA,IAAA,EA5DlDA,cA4DkD,CAAA,EAAA,IAAA,IA5DzBC,OA4DyB;;;;;;qCAtDtCD,yBAAyBE;;;;;;gCAM9BF,yBAAyBG;;;;;;+BAM1BH,yBAAyBI;;;;;;gCAMxBJ,yBAAyBK;;;;;;gCAMzBL,yBAAyBM;;;;;;4BAM7BN,yBAAyBO;;;;;;kCAMnBP,yBAAyBQ;;;;;;iCAM1BR,yBAAyBS;;;;;;oCAMtBT,yBAAyBU;;;;;;kCAM3BV,yBAAyBW"}

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

@@ -0,0 +1,108 @@
+import { ArrayExpression, BooleanLiteral, CallExpression, ExpressionNode, ExpressionStatement, Identifier, MemberExpression, NumericLiteral, ObjectExpression, ParseFunction, Program, PropertyAssignment, StringLiteral } from "../../types/expression-parser.js";
+
+//#region src/output_parsers/expression_type_handlers/base.d.ts
+
+/**
+ * Abstract class for handling nodes in an expression language. Subclasses
+ * must implement the `accepts` and `handle` methods.
+ */
+declare abstract class NodeHandler {
+  protected parentHandler?: NodeHandler | undefined;
+  constructor(parentHandler?: NodeHandler | undefined);
+  /**
+   * Determines whether the given node is acceptable.
+   * @param node The node to be checked.
+   * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.
+   */
+  abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;
+  /**
+   * Handles the given node. The specifics of how the node is handled are
+   * determined by the subclass implementation.
+   * @param node The node to be handled.
+   * @returns A Promise that resolves to the result of handling the node.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  abstract handle(node: ExpressionNode): Promise<any>;
+}
+/**
+ * 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.
+ */
+declare class ASTParser {
+  static astParseInstance: ParseFunction;
+  /**
+   * Imports and generates a parser using the Peggy library.
+   * @returns A Promise that resolves to the parser instance.
+   */
+  static importASTParser(): Promise<ParseFunction>;
+  /**
+   * 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: ExpressionNode): node is 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: ExpressionNode): node is 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: ExpressionNode): node is 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: ExpressionNode): node is StringLiteral;
+  /**
+   * 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: ExpressionNode): node is NumericLiteral;
+  /**
+   * 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: ExpressionNode): node is BooleanLiteral;
+  /**
+   * 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: ExpressionNode): node is 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: ExpressionNode): node is 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: ExpressionNode): node is 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: ExpressionNode): node is 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: ExpressionNode): node is MemberExpression;
+}
+//#endregion
+export { ASTParser, NodeHandler };
+//# sourceMappingURL=base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["ExpressionNode","Program","ExpressionStatement","CallExpression","StringLiteral","NumericLiteral","BooleanLiteral","Identifier","ObjectExpression","ArrayExpression","PropertyAssignment","MemberExpression","ParseFunction","NodeHandler","Promise","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/base.d.ts"],"sourcesContent":["import type { ExpressionNode, Program, ExpressionStatement, CallExpression, StringLiteral, NumericLiteral, BooleanLiteral, Identifier, ObjectExpression, ArrayExpression, PropertyAssignment, MemberExpression, ParseFunction } from \"../../types/expression-parser.js\";\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport declare abstract class NodeHandler {\n    protected parentHandler?: NodeHandler | undefined;\n    constructor(parentHandler?: NodeHandler | undefined);\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     * 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 * 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 declare class ASTParser {\n    static astParseInstance: ParseFunction;\n    /**\n     * Imports and generates a parser using the Peggy library.\n     * @returns A Promise that resolves to the parser instance.\n     */\n    static importASTParser(): Promise<ParseFunction>;\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    /**\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(node: ExpressionNode): node is ExpressionStatement;\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    /**\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    /**\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    /**\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    /**\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    /**\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    /**\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    /**\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(node: ExpressionNode): node is PropertyAssignment;\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}\n"],"mappings":";;;;;;AAKA;;AAC8Ba,uBADAA,WAAAA,CACAA;EAAW,UACTA,aAAAA,CAAAA,EADFA,WACEA,GAAAA,SAAAA;EAAW,WAMhBb,CAAAA,aAAAA,CAAAA,EANKa,WAMLb,GAAAA,SAAAA;EAAc;;;;AAQS;EAO7Be,SAAAA,OAAS,CAAA,IAAA,EAfHf,cAeG,CAAA,EAfcc,OAed,CAfsBd,cAetB,GAAA,OAAA,CAAA;EAAA;;;;;;EAY6B;EAMN,SAAWE,MAAAA,CAAAA,IAAAA,EAzBtCF,cAyBsCE,CAAAA,EAzBrBY,OAyBqBZ,CAAAA,GAAAA,CAAAA;;;;;;;AAwB9BF,cA1Cbe,SAAAA,CA0Caf;EAAc,OAAWM,gBAAAA,EAzC9BM,aAyC8BN;EAAc;;;;EAYI,OAM1CN,eAAAA,CAAAA,CAAAA,EAtDLc,OAsDKd,CAtDGY,aAsDHZ,CAAAA;EAAc;;;;;EAY4B,OAAA,SAAA,CAAA,IAAA,EA5DlDA,cA4DkD,CAAA,EAAA,IAAA,IA5DzBC,OA4DyB;;;;;;qCAtDtCD,yBAAyBE;;;;;;gCAM9BF,yBAAyBG;;;;;;+BAM1BH,yBAAyBI;;;;;;gCAMxBJ,yBAAyBK;;;;;;gCAMzBL,yBAAyBM;;;;;;4BAM7BN,yBAAyBO;;;;;;kCAMnBP,yBAAyBQ;;;;;;iCAM1BR,yBAAyBS;;;;;;oCAMtBT,yBAAyBU;;;;;;kCAM3BV,yBAAyBW"}

package/dist/output_parsers/expression_type_handlers/base.js

@@ -0,0 +1,129 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1 @@
+{"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"}