@langchain/classic 1.0.39 → 1.0.41

package/dist/output_parsers/expression_type_handlers/base.js

@@ -5,6 +5,7 @@ import { GRAMMAR } from "./grammar/parser_grammar.js";
 * must implement the `accepts` and `handle` methods.
 */
 var NodeHandler = class {
+	parentHandler;
 	constructor(parentHandler) {
 		this.parentHandler = parentHandler;
 	}

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

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":[],"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  // oxlint-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,YAAY,eAAuC;AAA7B,OAAA,gBAAA;;;;;;;;AAwBxB,IAAa,YAAb,MAAa,UAAU;CACrB,OAAO;;;;;CAMP,aAAa,kBAAkB;AAC7B,MAAI;AACF,OAAI,CAAC,UAAU,kBAAkB;IAC/B,MAAM,EAAE,SAAS,UAAU,MAAM,OAAO;IAExC,MAAM,EAAE,UADO,MAAM,SAAS,QACN;AACxB,cAAU,mBAAmB;;AAE/B,UAAO,UAAU;UACX;AACN,SAAM,IAAI,MACR,mGACD;;;;;;;;CASL,OAAO,UAAU,MAAuC;AACtD,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,sBACL,MAC6B;AAC7B,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,gBAAgB,MAA6C;AAClE,SAAO,KAAK,SAAS,mBAAmB,OAAO,KAAK,UAAU;;;;;;;CAQhE,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;;;;;;;CAQjE,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;;;;;;;CAQjE,OAAO,aAAa,MAA0C;AAC5D,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,mBAAmB,MAAgD;AACxE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,kBAAkB,MAA+C;AACtE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,qBACL,MAC4B;AAC5B,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,mBAAmB,MAAgD;AACxE,SAAO,KAAK,SAAS"}
+{"version":3,"file":"base.js","names":[],"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  // oxlint-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;CACV;CAAtB,YAAY,eAAuC;EAA7B,KAAA,gBAAA;CAA8B;AAiBtD;;;;;;AAOA,IAAa,YAAb,MAAa,UAAU;CACrB,OAAO;;;;;CAMP,aAAa,kBAAkB;EAC7B,IAAI;GACF,IAAI,CAAC,UAAU,kBAAkB;IAC/B,MAAM,EAAE,SAAS,UAAU,MAAM,OAAO;IAExC,MAAM,EAAE,UADO,MAAM,SAAS,OACP;IACvB,UAAU,mBAAmB;GAC/B;GACA,OAAO,UAAU;EACnB,QAAQ;GACN,MAAM,IAAI,MACR,kGACF;EACF;CACF;;;;;;CAOA,OAAO,UAAU,MAAuC;EACtD,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,sBACL,MAC6B;EAC7B,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,iBAAiB,MAA8C;EACpE,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,gBAAgB,MAA6C;EAClE,OAAO,KAAK,SAAS,mBAAmB,OAAO,KAAK,UAAU;CAChE;;;;;;CAOA,OAAO,iBAAiB,MAA8C;EACpE,OAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;CACjE;;;;;;CAOA,OAAO,iBAAiB,MAA8C;EACpE,OAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;CACjE;;;;;;CAOA,OAAO,aAAa,MAA0C;EAC5D,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,mBAAmB,MAAgD;EACxE,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,kBAAkB,MAA+C;EACtE,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,qBACL,MAC4B;EAC5B,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,mBAAmB,MAAgD;EACxE,OAAO,KAAK,SAAS;CACvB;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"boolean_literal_handler.cjs","names":["NodeHandler","ASTParser"],"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,aAAAA,YAAY;;;;;;;CAOrD,MAAM,QAAQ,MAAyD;AACrE,MAAIC,aAAAA,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;;;;;;;;;;CAYX,MAAM,OAAO,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,OAAO,KAAK;GACb"}
+{"version":3,"file":"boolean_literal_handler.cjs","names":["NodeHandler","ASTParser"],"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,aAAAA,YAAY;;;;;;;CAOrD,MAAM,QAAQ,MAAyD;EACrE,IAAIC,aAAAA,UAAU,iBAAiB,IAAI,GACjC,OAAO;OAEP,OAAO;CAEX;;;;;;;;;CAUA,MAAM,OAAO,MAAmD;EAC9D,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,OAAO;GACL,MAAM;GACN,OAAO,KAAK;EACd;CACF;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"boolean_literal_handler.js","names":[],"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,QAAQ,MAAyD;AACrE,MAAI,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;;;;;;;;;;CAYX,MAAM,OAAO,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,OAAO,KAAK;GACb"}
+{"version":3,"file":"boolean_literal_handler.js","names":[],"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,QAAQ,MAAyD;EACrE,IAAI,UAAU,iBAAiB,IAAI,GACjC,OAAO;OAEP,OAAO;CAEX;;;;;;;;;CAUA,MAAM,OAAO,MAAmD;EAC9D,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,OAAO;GACL,MAAM;GACN,OAAO,KAAK;EACd;CACF;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"call_expression_handler.cjs","names":["NodeHandler","ASTParser"],"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,aAAAA,YAAY;;;;;;;CAOrD,MAAM,QAAQ,MAAyD;AACrE,MAAIC,aAAAA,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;;;;;;;;;;;;;CAeX,MAAM,OAAO,MAAmD;EAC9D,SAAS,gCAAgC,KAA8B;AACrE,UAAO;IACLA,aAAAA,UAAU;IACVA,aAAAA,UAAU;IACVA,aAAAA,UAAU;IACVA,aAAAA,UAAU;IACVA,aAAAA,UAAU;IACVA,aAAAA,UAAU;IACVA,aAAAA,UAAU;IACX,CAAC,QAAQ,KAAK,SAAS,OAAO,KAAK,IAAI,EAAE,MAAM;;AAElD,MAAI,KAAK,kBAAkB,KAAA,EACzB,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,EAAE,WAAW;EACnB,IAAI;AACJ,MAAIA,aAAAA,UAAU,aAAa,OAAO,CAChC,YAAW,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACtDA,aAAAA,UAAU,mBAAmB,OAAO,CAC7C,YAAY,MAAM,KAAK,cAAc,OACnC,OACD;MAED,OAAM,IAAI,MAAM,0BAA0B;EAG5C,MAAM,OAAO,MAAM,QAAQ,IACzB,KAAK,UAAU,KAAK,QAAQ;AAC1B,OAAI,CAAC,gCAAgC,IAAI,CACvC,OAAM,IAAI,MAAM,wBAAwB;AAE1C,OAAI,CAAC,KAAK,cACR,OAAM,IAAI,MAAM,mDAAmD;AAErE,UAAO,KAAK,cAAc,OAAO,IAAsB;IACvD,CACH;AACD,SAAO;GAAE,MAAM;GAAmB;GAAU;GAAM"}
+{"version":3,"file":"call_expression_handler.cjs","names":["NodeHandler","ASTParser"],"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,aAAAA,YAAY;;;;;;;CAOrD,MAAM,QAAQ,MAAyD;EACrE,IAAIC,aAAAA,UAAU,iBAAiB,IAAI,GACjC,OAAO;OAEP,OAAO;CAEX;;;;;;;;;;;;CAaA,MAAM,OAAO,MAAmD;EAC9D,SAAS,gCAAgC,KAA8B;GACrE,OAAO;IACLA,aAAAA,UAAU;IACVA,aAAAA,UAAU;IACVA,aAAAA,UAAU;IACVA,aAAAA,UAAU;IACVA,aAAAA,UAAU;IACVA,aAAAA,UAAU;IACVA,aAAAA,UAAU;GACZ,CAAC,CAAC,QAAQ,KAAK,SAAS,OAAO,KAAK,GAAG,GAAG,KAAK;EACjD;EACA,IAAI,KAAK,kBAAkB,KAAA,GACzB,MAAM,IAAI,MACR,0DACF;EAEF,MAAM,EAAE,WAAW;EACnB,IAAI;EACJ,IAAIA,aAAAA,UAAU,aAAa,MAAM,GAC/B,WAAW,OAAO,KAAK,QAAQ,2BAA2B,IAAI;OACzD,IAAIA,aAAAA,UAAU,mBAAmB,MAAM,GAC5C,WAAY,MAAM,KAAK,cAAc,OACnC,MACF;OAEA,MAAM,IAAI,MAAM,yBAAyB;EAG3C,MAAM,OAAO,MAAM,QAAQ,IACzB,KAAK,UAAU,KAAK,QAAQ;GAC1B,IAAI,CAAC,gCAAgC,GAAG,GACtC,MAAM,IAAI,MAAM,uBAAuB;GAEzC,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MAAM,kDAAkD;GAEpE,OAAO,KAAK,cAAc,OAAO,GAAqB;EACxD,CAAC,CACH;EACA,OAAO;GAAE,MAAM;GAAmB;GAAU;EAAK;CACnD;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"call_expression_handler.js","names":[],"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,QAAQ,MAAyD;AACrE,MAAI,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;;;;;;;;;;;;;CAeX,MAAM,OAAO,MAAmD;EAC9D,SAAS,gCAAgC,KAA8B;AACrE,UAAO;IACL,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACX,CAAC,QAAQ,KAAK,SAAS,OAAO,KAAK,IAAI,EAAE,MAAM;;AAElD,MAAI,KAAK,kBAAkB,KAAA,EACzB,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,EAAE,WAAW;EACnB,IAAI;AACJ,MAAI,UAAU,aAAa,OAAO,CAChC,YAAW,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACtD,UAAU,mBAAmB,OAAO,CAC7C,YAAY,MAAM,KAAK,cAAc,OACnC,OACD;MAED,OAAM,IAAI,MAAM,0BAA0B;EAG5C,MAAM,OAAO,MAAM,QAAQ,IACzB,KAAK,UAAU,KAAK,QAAQ;AAC1B,OAAI,CAAC,gCAAgC,IAAI,CACvC,OAAM,IAAI,MAAM,wBAAwB;AAE1C,OAAI,CAAC,KAAK,cACR,OAAM,IAAI,MAAM,mDAAmD;AAErE,UAAO,KAAK,cAAc,OAAO,IAAsB;IACvD,CACH;AACD,SAAO;GAAE,MAAM;GAAmB;GAAU;GAAM"}
+{"version":3,"file":"call_expression_handler.js","names":[],"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,QAAQ,MAAyD;EACrE,IAAI,UAAU,iBAAiB,IAAI,GACjC,OAAO;OAEP,OAAO;CAEX;;;;;;;;;;;;CAaA,MAAM,OAAO,MAAmD;EAC9D,SAAS,gCAAgC,KAA8B;GACrE,OAAO;IACL,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;GACZ,CAAC,CAAC,QAAQ,KAAK,SAAS,OAAO,KAAK,GAAG,GAAG,KAAK;EACjD;EACA,IAAI,KAAK,kBAAkB,KAAA,GACzB,MAAM,IAAI,MACR,0DACF;EAEF,MAAM,EAAE,WAAW;EACnB,IAAI;EACJ,IAAI,UAAU,aAAa,MAAM,GAC/B,WAAW,OAAO,KAAK,QAAQ,2BAA2B,IAAI;OACzD,IAAI,UAAU,mBAAmB,MAAM,GAC5C,WAAY,MAAM,KAAK,cAAc,OACnC,MACF;OAEA,MAAM,IAAI,MAAM,yBAAyB;EAG3C,MAAM,OAAO,MAAM,QAAQ,IACzB,KAAK,UAAU,KAAK,QAAQ;GAC1B,IAAI,CAAC,gCAAgC,GAAG,GACtC,MAAM,IAAI,MAAM,uBAAuB;GAEzC,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MAAM,kDAAkD;GAEpE,OAAO,KAAK,cAAc,OAAO,GAAqB;EACxD,CAAC,CACH;EACA,OAAO;GAAE,MAAM;GAAmB;GAAU;EAAK;CACnD;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"factory.cjs","names":["ArrayLiteralExpressionHandler","BooleanLiteralHandler","CallExpressionHandler","NumericLiteralHandler","ObjectLiteralExpressionHandler","MemberExpressionHandler","PropertyAssignmentHandler","StringLiteralHandler","IdentifierHandler","NodeHandler"],"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,yCAAAA;CACAC,gCAAAA;CACAC,gCAAAA;CACAC,gCAAAA;CACAC,0CAAAA;CACAC,kCAAAA;CACAC,oCAAAA;CACAC,+BAAAA;CACAC,2BAAAA;CACD;;;;;;;;AASD,IAAa,gBAAb,MAAa,sBAAsBC,aAAAA,YAAY;CAC7C,eAA8B,EAAE;CAEhC,MAAM,QAAQ,MAAyD;AACrE,QAAM,IAAI,MAAM,6CAA6C,OAAO;;;;;;;;;;CAWtE,MAAM,OAAO,MAA2C;AACtD,OAAK,MAAM,WAAW,KAAK,aAEzB,KAAI,MADkB,QAAQ,QAAQ,KAAK,CAEzC,QAAO,QAAQ,OAAO,KAAK;AAI/B,QAAM,IAAI,MAAM,8BAA8B,OAAO;;;;;;;CAQvD,OAAO,sBAAqC;EAC1C,MAAM,gBAAgB,IAAI,eAAe;AACzC,WAAS,SAAS,YAAY;GAC5B,MAAM,kBAAkB,IAAI,QAAQ,cAAc;AAClD,iBAAc,aAAa,KAAK,gBAAgB;IAChD;AACF,SAAO"}
+{"version":3,"file":"factory.cjs","names":["ArrayLiteralExpressionHandler","BooleanLiteralHandler","CallExpressionHandler","NumericLiteralHandler","ObjectLiteralExpressionHandler","MemberExpressionHandler","PropertyAssignmentHandler","StringLiteralHandler","IdentifierHandler","NodeHandler"],"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,yCAAAA;CACAC,gCAAAA;CACAC,gCAAAA;CACAC,gCAAAA;CACAC,0CAAAA;CACAC,kCAAAA;CACAC,oCAAAA;CACAC,+BAAAA;CACAC,2BAAAA;AACF;;;;;;;;AASA,IAAa,gBAAb,MAAa,sBAAsBC,aAAAA,YAAY;CAC7C,eAA8B,CAAC;CAE/B,MAAM,QAAQ,MAAyD;EACrE,MAAM,IAAI,MAAM,6CAA6C,MAAM;CACrE;;;;;;;;;CAUA,MAAM,OAAO,MAA2C;EACtD,KAAK,MAAM,WAAW,KAAK,cAEzB,IAAI,MADkB,QAAQ,QAAQ,IAAI,GAExC,OAAO,QAAQ,OAAO,IAAI;EAI9B,MAAM,IAAI,MAAM,8BAA8B,MAAM;CACtD;;;;;;CAOA,OAAO,sBAAqC;EAC1C,MAAM,gBAAgB,IAAI,cAAc;EACxC,SAAS,SAAS,YAAY;GAC5B,MAAM,kBAAkB,IAAI,QAAQ,aAAa;GACjD,cAAc,aAAa,KAAK,eAAe;EACjD,CAAC;EACD,OAAO;CACT;AACF"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.cts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/factory.ts"],"mappings":";;;;;;;AAmCA;;;;;cAAa,aAAA,SAAsB,WAAA;EACjC,YAAA,EAAc,WAAA;EAER,OAAA,CAAQ,IAAA,EAAM,cAAA,GAAiB,OAAA,CAAQ,cAAA;EAYD;;;;;;;;EAAtC,MAAA,CAAO,IAAA,EAAM,cAAA,GAAiB,OAAA,CAAQ,UAAA;EAZtC;;;;;EAAA,OA4BC,mBAAA,CAAA,GAAuB,aAAA;AAAA"}
+{"version":3,"file":"factory.d.cts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/factory.ts"],"mappings":";;;;;;;;;;;cAmCa,sBAAsB;EACjC,cAAc;EAER,QAAQ,MAAM,iBAAiB,QAAQ;;;;;;;;;EAYvC,OAAO,MAAM,iBAAiB,QAAQ;;;;;;SAgBrC,uBAAuB"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/factory.ts"],"mappings":";;;;;;;AAmCA;;;;;cAAa,aAAA,SAAsB,WAAA;EACjC,YAAA,EAAc,WAAA;EAER,OAAA,CAAQ,IAAA,EAAM,cAAA,GAAiB,OAAA,CAAQ,cAAA;EAYD;;;;;;;;EAAtC,MAAA,CAAO,IAAA,EAAM,cAAA,GAAiB,OAAA,CAAQ,UAAA;EAZtC;;;;;EAAA,OA4BC,mBAAA,CAAA,GAAuB,aAAA;AAAA"}
+{"version":3,"file":"factory.d.ts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/factory.ts"],"mappings":";;;;;;;;;;;cAmCa,sBAAsB;EACjC,cAAc;EAER,QAAQ,MAAM,iBAAiB,QAAQ;;;;;;;;;EAYvC,OAAO,MAAM,iBAAiB,QAAQ;;;;;;SAgBrC,uBAAuB"}

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

@@ -1 +1 @@
-{"version":3,"file":"factory.js","names":[],"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;CACD;;;;;;;;AASD,IAAa,gBAAb,MAAa,sBAAsB,YAAY;CAC7C,eAA8B,EAAE;CAEhC,MAAM,QAAQ,MAAyD;AACrE,QAAM,IAAI,MAAM,6CAA6C,OAAO;;;;;;;;;;CAWtE,MAAM,OAAO,MAA2C;AACtD,OAAK,MAAM,WAAW,KAAK,aAEzB,KAAI,MADkB,QAAQ,QAAQ,KAAK,CAEzC,QAAO,QAAQ,OAAO,KAAK;AAI/B,QAAM,IAAI,MAAM,8BAA8B,OAAO;;;;;;;CAQvD,OAAO,sBAAqC;EAC1C,MAAM,gBAAgB,IAAI,eAAe;AACzC,WAAS,SAAS,YAAY;GAC5B,MAAM,kBAAkB,IAAI,QAAQ,cAAc;AAClD,iBAAc,aAAa,KAAK,gBAAgB;IAChD;AACF,SAAO"}
+{"version":3,"file":"factory.js","names":[],"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;AACF;;;;;;;;AASA,IAAa,gBAAb,MAAa,sBAAsB,YAAY;CAC7C,eAA8B,CAAC;CAE/B,MAAM,QAAQ,MAAyD;EACrE,MAAM,IAAI,MAAM,6CAA6C,MAAM;CACrE;;;;;;;;;CAUA,MAAM,OAAO,MAA2C;EACtD,KAAK,MAAM,WAAW,KAAK,cAEzB,IAAI,MADkB,QAAQ,QAAQ,IAAI,GAExC,OAAO,QAAQ,OAAO,IAAI;EAI9B,MAAM,IAAI,MAAM,8BAA8B,MAAM;CACtD;;;;;;CAOA,OAAO,sBAAqC;EAC1C,MAAM,gBAAgB,IAAI,cAAc;EACxC,SAAS,SAAS,YAAY;GAC5B,MAAM,kBAAkB,IAAI,QAAQ,aAAa;GACjD,cAAc,aAAa,KAAK,eAAe;EACjD,CAAC;EACD,OAAO;CACT;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"identifier_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/identifier_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { IdentifierType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  Identifier,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles identifiers in the LangChain Expression Language. Extends the\n * NodeHandler class.\n */\nexport class IdentifierHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an identifier. If it is, it returns the node;\n   * otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is an identifier, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<Identifier | boolean> {\n    if (ASTParser.isIdentifier(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the identifier node. If the handler does not have a parent\n   * handler, it throws an error. Otherwise, it extracts the name of the\n   * identifier, removes any enclosing quotes, and returns an object of type\n   * IdentifierType with the type set to \"identifier\" and the value set to\n   * the extracted name.\n   * @param node The identifier node to process.\n   * @returns An object of type IdentifierType with the type set to \"identifier\" and the value set to the extracted name.\n   */\n  async handle(node: Identifier): Promise<IdentifierType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = node.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    return { type: \"identifier\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,oBAAb,cAAuCA,aAAAA,YAAY;;;;;;;CAOjD,MAAM,QAAQ,MAAqD;AACjE,MAAIC,aAAAA,UAAU,aAAa,KAAK,CAC9B,QAAO;MAEP,QAAO;;;;;;;;;;;CAaX,MAAM,OAAO,MAA2C;AACtD,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAGH,SAAO;GAAE,MAAM;GAAc,OADhB,KAAK,KAAK,QAAQ,2BAA2B,KAClB;GAAE"}
+{"version":3,"file":"identifier_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/identifier_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { IdentifierType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  Identifier,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles identifiers in the LangChain Expression Language. Extends the\n * NodeHandler class.\n */\nexport class IdentifierHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an identifier. If it is, it returns the node;\n   * otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is an identifier, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<Identifier | boolean> {\n    if (ASTParser.isIdentifier(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the identifier node. If the handler does not have a parent\n   * handler, it throws an error. Otherwise, it extracts the name of the\n   * identifier, removes any enclosing quotes, and returns an object of type\n   * IdentifierType with the type set to \"identifier\" and the value set to\n   * the extracted name.\n   * @param node The identifier node to process.\n   * @returns An object of type IdentifierType with the type set to \"identifier\" and the value set to the extracted name.\n   */\n  async handle(node: Identifier): Promise<IdentifierType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = node.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    return { type: \"identifier\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,oBAAb,cAAuCA,aAAAA,YAAY;;;;;;;CAOjD,MAAM,QAAQ,MAAqD;EACjE,IAAIC,aAAAA,UAAU,aAAa,IAAI,GAC7B,OAAO;OAEP,OAAO;CAEX;;;;;;;;;;CAWA,MAAM,OAAO,MAA2C;EACtD,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAGF,OAAO;GAAE,MAAM;GAAc,OADhB,KAAK,KAAK,QAAQ,2BAA2B,IACnB;EAAE;CAC3C;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"identifier_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/identifier_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { IdentifierType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  Identifier,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles identifiers in the LangChain Expression Language. Extends the\n * NodeHandler class.\n */\nexport class IdentifierHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an identifier. If it is, it returns the node;\n   * otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is an identifier, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<Identifier | boolean> {\n    if (ASTParser.isIdentifier(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the identifier node. If the handler does not have a parent\n   * handler, it throws an error. Otherwise, it extracts the name of the\n   * identifier, removes any enclosing quotes, and returns an object of type\n   * IdentifierType with the type set to \"identifier\" and the value set to\n   * the extracted name.\n   * @param node The identifier node to process.\n   * @returns An object of type IdentifierType with the type set to \"identifier\" and the value set to the extracted name.\n   */\n  async handle(node: Identifier): Promise<IdentifierType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = node.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    return { type: \"identifier\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,oBAAb,cAAuC,YAAY;;;;;;;CAOjD,MAAM,QAAQ,MAAqD;AACjE,MAAI,UAAU,aAAa,KAAK,CAC9B,QAAO;MAEP,QAAO;;;;;;;;;;;CAaX,MAAM,OAAO,MAA2C;AACtD,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAGH,SAAO;GAAE,MAAM;GAAc,OADhB,KAAK,KAAK,QAAQ,2BAA2B,KAClB;GAAE"}
+{"version":3,"file":"identifier_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/identifier_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { IdentifierType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  Identifier,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles identifiers in the LangChain Expression Language. Extends the\n * NodeHandler class.\n */\nexport class IdentifierHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an identifier. If it is, it returns the node;\n   * otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is an identifier, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<Identifier | boolean> {\n    if (ASTParser.isIdentifier(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the identifier node. If the handler does not have a parent\n   * handler, it throws an error. Otherwise, it extracts the name of the\n   * identifier, removes any enclosing quotes, and returns an object of type\n   * IdentifierType with the type set to \"identifier\" and the value set to\n   * the extracted name.\n   * @param node The identifier node to process.\n   * @returns An object of type IdentifierType with the type set to \"identifier\" and the value set to the extracted name.\n   */\n  async handle(node: Identifier): Promise<IdentifierType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = node.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    return { type: \"identifier\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,oBAAb,cAAuC,YAAY;;;;;;;CAOjD,MAAM,QAAQ,MAAqD;EACjE,IAAI,UAAU,aAAa,IAAI,GAC7B,OAAO;OAEP,OAAO;CAEX;;;;;;;;;;CAWA,MAAM,OAAO,MAA2C;EACtD,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAGF,OAAO;GAAE,MAAM;GAAc,OADhB,KAAK,KAAK,QAAQ,2BAA2B,IACnB;EAAE;CAC3C;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"member_expression_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/member_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { MemberExpressionType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  MemberExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles member expressions in the LangChain Expression Language (LCEL).\n * Extends the NodeHandler base class.\n */\nexport class MemberExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a member expression. 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 member expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<MemberExpression | boolean> {\n    if (ASTParser.isMemberExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a member expression node. It extracts the object and property\n   * from the node, validates their types, and returns an object with the\n   * type of the expression, the identifier, and the property.\n   * @param node The member expression node to process.\n   * @returns An object with the type of the expression, the identifier, and the property.\n   */\n  async handle(node: MemberExpression): Promise<MemberExpressionType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const { object, property } = node;\n    let prop: string;\n    if (ASTParser.isIdentifier(property)) {\n      prop = property.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(property)) {\n      prop = (`${property.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    let identifier: string;\n    if (ASTParser.isIdentifier(object)) {\n      identifier = object.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(object)) {\n      identifier = (`${object.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid object type\");\n    }\n    if (object.type !== \"Identifier\" && object.type !== \"StringLiteral\") {\n      throw new Error(\"ArrayExpression is not supported\");\n    }\n\n    return { type: \"member_expression\", identifier, property: prop };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,0BAAb,cAA6CA,aAAAA,YAAY;;;;;;;CAOvD,MAAM,QAAQ,MAA2D;AACvE,MAAIC,aAAAA,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAAuD;AAClE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,EAAE,QAAQ,aAAa;EAC7B,IAAI;AACJ,MAAIA,aAAAA,UAAU,aAAa,SAAS,CAClC,QAAO,SAAS,KAAK,QAAQ,2BAA2B,KAAK;WACpDA,aAAAA,UAAU,gBAAgB,SAAS,CAC5C,QAAQ,GAAG,SAAS,QAAmB,QACrC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,4BAA4B;EAE9C,IAAI;AACJ,MAAIA,aAAAA,UAAU,aAAa,OAAO,CAChC,cAAa,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACxDA,aAAAA,UAAU,gBAAgB,OAAO,CAC1C,cAAc,GAAG,OAAO,QAAmB,QACzC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,sBAAsB;AAExC,MAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,gBAClD,OAAM,IAAI,MAAM,mCAAmC;AAGrD,SAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;GAAM"}
+{"version":3,"file":"member_expression_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/member_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { MemberExpressionType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  MemberExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles member expressions in the LangChain Expression Language (LCEL).\n * Extends the NodeHandler base class.\n */\nexport class MemberExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a member expression. 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 member expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<MemberExpression | boolean> {\n    if (ASTParser.isMemberExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a member expression node. It extracts the object and property\n   * from the node, validates their types, and returns an object with the\n   * type of the expression, the identifier, and the property.\n   * @param node The member expression node to process.\n   * @returns An object with the type of the expression, the identifier, and the property.\n   */\n  async handle(node: MemberExpression): Promise<MemberExpressionType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const { object, property } = node;\n    let prop: string;\n    if (ASTParser.isIdentifier(property)) {\n      prop = property.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(property)) {\n      prop = (`${property.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    let identifier: string;\n    if (ASTParser.isIdentifier(object)) {\n      identifier = object.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(object)) {\n      identifier = (`${object.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid object type\");\n    }\n    if (object.type !== \"Identifier\" && object.type !== \"StringLiteral\") {\n      throw new Error(\"ArrayExpression is not supported\");\n    }\n\n    return { type: \"member_expression\", identifier, property: prop };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,0BAAb,cAA6CA,aAAAA,YAAY;;;;;;;CAOvD,MAAM,QAAQ,MAA2D;EACvE,IAAIC,aAAAA,UAAU,mBAAmB,IAAI,GACnC,OAAO;OAEP,OAAO;CAEX;;;;;;;;CASA,MAAM,OAAO,MAAuD;EAClE,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,MAAM,EAAE,QAAQ,aAAa;EAC7B,IAAI;EACJ,IAAIA,aAAAA,UAAU,aAAa,QAAQ,GACjC,OAAO,SAAS,KAAK,QAAQ,2BAA2B,IAAI;OACvD,IAAIA,aAAAA,UAAU,gBAAgB,QAAQ,GAC3C,OAAQ,GAAG,SAAS,QAAmB,QACrC,2BACA,IACF;OAEA,MAAM,IAAI,MAAM,2BAA2B;EAE7C,IAAI;EACJ,IAAIA,aAAAA,UAAU,aAAa,MAAM,GAC/B,aAAa,OAAO,KAAK,QAAQ,2BAA2B,IAAI;OAC3D,IAAIA,aAAAA,UAAU,gBAAgB,MAAM,GACzC,aAAc,GAAG,OAAO,QAAmB,QACzC,2BACA,IACF;OAEA,MAAM,IAAI,MAAM,qBAAqB;EAEvC,IAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,iBAClD,MAAM,IAAI,MAAM,kCAAkC;EAGpD,OAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;EAAK;CACjE;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"member_expression_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/member_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { MemberExpressionType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  MemberExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles member expressions in the LangChain Expression Language (LCEL).\n * Extends the NodeHandler base class.\n */\nexport class MemberExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a member expression. 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 member expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<MemberExpression | boolean> {\n    if (ASTParser.isMemberExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a member expression node. It extracts the object and property\n   * from the node, validates their types, and returns an object with the\n   * type of the expression, the identifier, and the property.\n   * @param node The member expression node to process.\n   * @returns An object with the type of the expression, the identifier, and the property.\n   */\n  async handle(node: MemberExpression): Promise<MemberExpressionType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const { object, property } = node;\n    let prop: string;\n    if (ASTParser.isIdentifier(property)) {\n      prop = property.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(property)) {\n      prop = (`${property.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    let identifier: string;\n    if (ASTParser.isIdentifier(object)) {\n      identifier = object.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(object)) {\n      identifier = (`${object.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid object type\");\n    }\n    if (object.type !== \"Identifier\" && object.type !== \"StringLiteral\") {\n      throw new Error(\"ArrayExpression is not supported\");\n    }\n\n    return { type: \"member_expression\", identifier, property: prop };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,0BAAb,cAA6C,YAAY;;;;;;;CAOvD,MAAM,QAAQ,MAA2D;AACvE,MAAI,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAAuD;AAClE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,EAAE,QAAQ,aAAa;EAC7B,IAAI;AACJ,MAAI,UAAU,aAAa,SAAS,CAClC,QAAO,SAAS,KAAK,QAAQ,2BAA2B,KAAK;WACpD,UAAU,gBAAgB,SAAS,CAC5C,QAAQ,GAAG,SAAS,QAAmB,QACrC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,4BAA4B;EAE9C,IAAI;AACJ,MAAI,UAAU,aAAa,OAAO,CAChC,cAAa,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACxD,UAAU,gBAAgB,OAAO,CAC1C,cAAc,GAAG,OAAO,QAAmB,QACzC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,sBAAsB;AAExC,MAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,gBAClD,OAAM,IAAI,MAAM,mCAAmC;AAGrD,SAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;GAAM"}
+{"version":3,"file":"member_expression_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/member_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { MemberExpressionType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  MemberExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles member expressions in the LangChain Expression Language (LCEL).\n * Extends the NodeHandler base class.\n */\nexport class MemberExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a member expression. 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 member expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<MemberExpression | boolean> {\n    if (ASTParser.isMemberExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a member expression node. It extracts the object and property\n   * from the node, validates their types, and returns an object with the\n   * type of the expression, the identifier, and the property.\n   * @param node The member expression node to process.\n   * @returns An object with the type of the expression, the identifier, and the property.\n   */\n  async handle(node: MemberExpression): Promise<MemberExpressionType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const { object, property } = node;\n    let prop: string;\n    if (ASTParser.isIdentifier(property)) {\n      prop = property.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(property)) {\n      prop = (`${property.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    let identifier: string;\n    if (ASTParser.isIdentifier(object)) {\n      identifier = object.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(object)) {\n      identifier = (`${object.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid object type\");\n    }\n    if (object.type !== \"Identifier\" && object.type !== \"StringLiteral\") {\n      throw new Error(\"ArrayExpression is not supported\");\n    }\n\n    return { type: \"member_expression\", identifier, property: prop };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,0BAAb,cAA6C,YAAY;;;;;;;CAOvD,MAAM,QAAQ,MAA2D;EACvE,IAAI,UAAU,mBAAmB,IAAI,GACnC,OAAO;OAEP,OAAO;CAEX;;;;;;;;CASA,MAAM,OAAO,MAAuD;EAClE,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,MAAM,EAAE,QAAQ,aAAa;EAC7B,IAAI;EACJ,IAAI,UAAU,aAAa,QAAQ,GACjC,OAAO,SAAS,KAAK,QAAQ,2BAA2B,IAAI;OACvD,IAAI,UAAU,gBAAgB,QAAQ,GAC3C,OAAQ,GAAG,SAAS,QAAmB,QACrC,2BACA,IACF;OAEA,MAAM,IAAI,MAAM,2BAA2B;EAE7C,IAAI;EACJ,IAAI,UAAU,aAAa,MAAM,GAC/B,aAAa,OAAO,KAAK,QAAQ,2BAA2B,IAAI;OAC3D,IAAI,UAAU,gBAAgB,MAAM,GACzC,aAAc,GAAG,OAAO,QAAmB,QACzC,2BACA,IACF;OAEA,MAAM,IAAI,MAAM,qBAAqB;EAEvC,IAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,iBAClD,MAAM,IAAI,MAAM,kCAAkC;EAGpD,OAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;EAAK;CACjE;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"numeric_literal_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/numeric_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { NumericLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  NumericLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for numeric literal nodes in an abstract syntax tree (AST).\n * Extends the NodeHandler class.\n */\nexport class NumericLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a numeric literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<NumericLiteral | boolean> {\n    if (ASTParser.isNumericLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a numeric literal node and returns a NumericLiteralType\n   * object representing it.\n   * @param node The numeric literal node to process.\n   * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.\n   */\n  async handle(node: NumericLiteral): Promise<NumericLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"numeric_literal\",\n      value: Number(node.value),\n    };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,wBAAb,cAA2CA,aAAAA,YAAY;;;;;;;CAOrD,MAAM,QAAQ,MAAyD;AACrE,MAAIC,aAAAA,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,MAAM;GAC1B"}
+{"version":3,"file":"numeric_literal_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/numeric_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { NumericLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  NumericLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for numeric literal nodes in an abstract syntax tree (AST).\n * Extends the NodeHandler class.\n */\nexport class NumericLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a numeric literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<NumericLiteral | boolean> {\n    if (ASTParser.isNumericLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a numeric literal node and returns a NumericLiteralType\n   * object representing it.\n   * @param node The numeric literal node to process.\n   * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.\n   */\n  async handle(node: NumericLiteral): Promise<NumericLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"numeric_literal\",\n      value: Number(node.value),\n    };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,wBAAb,cAA2CA,aAAAA,YAAY;;;;;;;CAOrD,MAAM,QAAQ,MAAyD;EACrE,IAAIC,aAAAA,UAAU,iBAAiB,IAAI,GACjC,OAAO;OAEP,OAAO;CAEX;;;;;;;CAQA,MAAM,OAAO,MAAmD;EAC9D,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,OAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,KAAK;EAC1B;CACF;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"numeric_literal_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/numeric_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { NumericLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  NumericLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for numeric literal nodes in an abstract syntax tree (AST).\n * Extends the NodeHandler class.\n */\nexport class NumericLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a numeric literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<NumericLiteral | boolean> {\n    if (ASTParser.isNumericLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a numeric literal node and returns a NumericLiteralType\n   * object representing it.\n   * @param node The numeric literal node to process.\n   * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.\n   */\n  async handle(node: NumericLiteral): Promise<NumericLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"numeric_literal\",\n      value: Number(node.value),\n    };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,wBAAb,cAA2C,YAAY;;;;;;;CAOrD,MAAM,QAAQ,MAAyD;AACrE,MAAI,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,MAAM;GAC1B"}
+{"version":3,"file":"numeric_literal_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/numeric_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { NumericLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  NumericLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for numeric literal nodes in an abstract syntax tree (AST).\n * Extends the NodeHandler class.\n */\nexport class NumericLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a numeric literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<NumericLiteral | boolean> {\n    if (ASTParser.isNumericLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a numeric literal node and returns a NumericLiteralType\n   * object representing it.\n   * @param node The numeric literal node to process.\n   * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.\n   */\n  async handle(node: NumericLiteral): Promise<NumericLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"numeric_literal\",\n      value: Number(node.value),\n    };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,wBAAb,cAA2C,YAAY;;;;;;;CAOrD,MAAM,QAAQ,MAAyD;EACrE,IAAI,UAAU,iBAAiB,IAAI,GACjC,OAAO;OAEP,OAAO;CAEX;;;;;;;CAQA,MAAM,OAAO,MAAmD;EAC9D,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,OAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,KAAK;EAC1B;CACF;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"object_literal_expression_handler.cjs","names":["NodeHandler","ASTParser","PropertyAssignmentHandler"],"sources":["../../../src/output_parsers/expression_type_handlers/object_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { ObjectLiteralType, PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ObjectExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles object literal expressions in the LangChain Expression\n * Language. Extends the NodeHandler class.\n */\nexport class ObjectLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an object expression. Returns the node if it\n   * is, otherwise returns false.\n   * @param node The node to check.\n   * @returns The node if it is an object expression, otherwise false.\n   */\n  async accepts(node: ExpressionNode): Promise<ObjectExpression | boolean> {\n    if (ASTParser.isObjectExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the object expression node and returns an object of type\n   * ObjectLiteralType. Throws an error if the parent handler is not set.\n   * @param node The object expression node to process.\n   * @returns An object of type ObjectLiteralType.\n   */\n  async handle(node: ObjectExpression): Promise<ObjectLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const values: PropertyAssignmentType[] = [];\n    const { properties } = node;\n    for (const property of properties) {\n      if (ASTParser.isPropertyAssignment(property)) {\n        values.push(\n          await new PropertyAssignmentHandler(this.parentHandler).handle(\n            property\n          )\n        );\n      }\n    }\n    return { type: \"object_literal\", values };\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,iCAAb,cAAoDA,aAAAA,YAAY;;;;;;;CAO9D,MAAM,QAAQ,MAA2D;AACvE,MAAIC,aAAAA,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAoD;AAC/D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,SAAmC,EAAE;EAC3C,MAAM,EAAE,eAAe;AACvB,OAAK,MAAM,YAAY,WACrB,KAAIA,aAAAA,UAAU,qBAAqB,SAAS,CAC1C,QAAO,KACL,MAAM,IAAIC,oCAAAA,0BAA0B,KAAK,cAAc,CAAC,OACtD,SACD,CACF;AAGL,SAAO;GAAE,MAAM;GAAkB;GAAQ"}
+{"version":3,"file":"object_literal_expression_handler.cjs","names":["NodeHandler","ASTParser","PropertyAssignmentHandler"],"sources":["../../../src/output_parsers/expression_type_handlers/object_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { ObjectLiteralType, PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ObjectExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles object literal expressions in the LangChain Expression\n * Language. Extends the NodeHandler class.\n */\nexport class ObjectLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an object expression. Returns the node if it\n   * is, otherwise returns false.\n   * @param node The node to check.\n   * @returns The node if it is an object expression, otherwise false.\n   */\n  async accepts(node: ExpressionNode): Promise<ObjectExpression | boolean> {\n    if (ASTParser.isObjectExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the object expression node and returns an object of type\n   * ObjectLiteralType. Throws an error if the parent handler is not set.\n   * @param node The object expression node to process.\n   * @returns An object of type ObjectLiteralType.\n   */\n  async handle(node: ObjectExpression): Promise<ObjectLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const values: PropertyAssignmentType[] = [];\n    const { properties } = node;\n    for (const property of properties) {\n      if (ASTParser.isPropertyAssignment(property)) {\n        values.push(\n          await new PropertyAssignmentHandler(this.parentHandler).handle(\n            property\n          )\n        );\n      }\n    }\n    return { type: \"object_literal\", values };\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,iCAAb,cAAoDA,aAAAA,YAAY;;;;;;;CAO9D,MAAM,QAAQ,MAA2D;EACvE,IAAIC,aAAAA,UAAU,mBAAmB,IAAI,GACnC,OAAO;OAEP,OAAO;CAEX;;;;;;;CAQA,MAAM,OAAO,MAAoD;EAC/D,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,MAAM,SAAmC,CAAC;EAC1C,MAAM,EAAE,eAAe;EACvB,KAAK,MAAM,YAAY,YACrB,IAAIA,aAAAA,UAAU,qBAAqB,QAAQ,GACzC,OAAO,KACL,MAAM,IAAIC,oCAAAA,0BAA0B,KAAK,aAAa,CAAC,CAAC,OACtD,QACF,CACF;EAGJ,OAAO;GAAE,MAAM;GAAkB;EAAO;CAC1C;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"object_literal_expression_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/object_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { ObjectLiteralType, PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ObjectExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles object literal expressions in the LangChain Expression\n * Language. Extends the NodeHandler class.\n */\nexport class ObjectLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an object expression. Returns the node if it\n   * is, otherwise returns false.\n   * @param node The node to check.\n   * @returns The node if it is an object expression, otherwise false.\n   */\n  async accepts(node: ExpressionNode): Promise<ObjectExpression | boolean> {\n    if (ASTParser.isObjectExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the object expression node and returns an object of type\n   * ObjectLiteralType. Throws an error if the parent handler is not set.\n   * @param node The object expression node to process.\n   * @returns An object of type ObjectLiteralType.\n   */\n  async handle(node: ObjectExpression): Promise<ObjectLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const values: PropertyAssignmentType[] = [];\n    const { properties } = node;\n    for (const property of properties) {\n      if (ASTParser.isPropertyAssignment(property)) {\n        values.push(\n          await new PropertyAssignmentHandler(this.parentHandler).handle(\n            property\n          )\n        );\n      }\n    }\n    return { type: \"object_literal\", values };\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,iCAAb,cAAoD,YAAY;;;;;;;CAO9D,MAAM,QAAQ,MAA2D;AACvE,MAAI,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAoD;AAC/D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,SAAmC,EAAE;EAC3C,MAAM,EAAE,eAAe;AACvB,OAAK,MAAM,YAAY,WACrB,KAAI,UAAU,qBAAqB,SAAS,CAC1C,QAAO,KACL,MAAM,IAAI,0BAA0B,KAAK,cAAc,CAAC,OACtD,SACD,CACF;AAGL,SAAO;GAAE,MAAM;GAAkB;GAAQ"}
+{"version":3,"file":"object_literal_expression_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/object_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { ObjectLiteralType, PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ObjectExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles object literal expressions in the LangChain Expression\n * Language. Extends the NodeHandler class.\n */\nexport class ObjectLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an object expression. Returns the node if it\n   * is, otherwise returns false.\n   * @param node The node to check.\n   * @returns The node if it is an object expression, otherwise false.\n   */\n  async accepts(node: ExpressionNode): Promise<ObjectExpression | boolean> {\n    if (ASTParser.isObjectExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the object expression node and returns an object of type\n   * ObjectLiteralType. Throws an error if the parent handler is not set.\n   * @param node The object expression node to process.\n   * @returns An object of type ObjectLiteralType.\n   */\n  async handle(node: ObjectExpression): Promise<ObjectLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const values: PropertyAssignmentType[] = [];\n    const { properties } = node;\n    for (const property of properties) {\n      if (ASTParser.isPropertyAssignment(property)) {\n        values.push(\n          await new PropertyAssignmentHandler(this.parentHandler).handle(\n            property\n          )\n        );\n      }\n    }\n    return { type: \"object_literal\", values };\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,iCAAb,cAAoD,YAAY;;;;;;;CAO9D,MAAM,QAAQ,MAA2D;EACvE,IAAI,UAAU,mBAAmB,IAAI,GACnC,OAAO;OAEP,OAAO;CAEX;;;;;;;CAQA,MAAM,OAAO,MAAoD;EAC/D,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,MAAM,SAAmC,CAAC;EAC1C,MAAM,EAAE,eAAe;EACvB,KAAK,MAAM,YAAY,YACrB,IAAI,UAAU,qBAAqB,QAAQ,GACzC,OAAO,KACL,MAAM,IAAI,0BAA0B,KAAK,aAAa,CAAC,CAAC,OACtD,QACF,CACF;EAGJ,OAAO;GAAE,MAAM;GAAkB;EAAO;CAC1C;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"property_assignment_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/property_assignment_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  PropertyAssignment,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for `PropertyAssignment` nodes in an AST. Extends the\n * `NodeHandler` base class.\n */\nexport class PropertyAssignmentHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a `PropertyAssignment` and returns the node\n   * if true, or false otherwise.\n   * @param node The node to check.\n   * @returns The node if it is a `PropertyAssignment`, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<PropertyAssignment | boolean> {\n    if (ASTParser.isPropertyAssignment(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a `PropertyAssignment` node. Extracts the key and value of\n   * the property assignment and returns an object of type\n   * `PropertyAssignmentType` with the extracted identifier and value.\n   * @param node The `PropertyAssignment` node to process.\n   * @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.\n   */\n  async handle(node: PropertyAssignment): Promise<PropertyAssignmentType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    let name;\n    if (ASTParser.isIdentifier(node.key)) {\n      name = node.key.name;\n    } else if (ASTParser.isStringLiteral(node.key)) {\n      name = node.key.value;\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    if (!name) {\n      throw new Error(\"Invalid property key\");\n    }\n    const identifier = (`${name}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    const value = await this.parentHandler.handle(node.value);\n    return { type: \"property_assignment\", identifier, value };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,4BAAb,cAA+CA,aAAAA,YAAY;;;;;;;CAOzD,MAAM,QAAQ,MAA6D;AACzE,MAAIC,aAAAA,UAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,IAAI;AACJ,MAAIA,aAAAA,UAAU,aAAa,KAAK,IAAI,CAClC,QAAO,KAAK,IAAI;WACPA,aAAAA,UAAU,gBAAgB,KAAK,IAAI,CAC5C,QAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM,4BAA4B;AAE9C,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,uBAAuB;AAOzC,SAAO;GAAE,MAAM;GAAuB,YALlB,GAAG,OAAkB,QACvC,2BACA,KAG8C;GAAE,OAAA,MAD9B,KAAK,cAAc,OAAO,KAAK,MAAM;GACA"}
+{"version":3,"file":"property_assignment_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/property_assignment_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  PropertyAssignment,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for `PropertyAssignment` nodes in an AST. Extends the\n * `NodeHandler` base class.\n */\nexport class PropertyAssignmentHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a `PropertyAssignment` and returns the node\n   * if true, or false otherwise.\n   * @param node The node to check.\n   * @returns The node if it is a `PropertyAssignment`, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<PropertyAssignment | boolean> {\n    if (ASTParser.isPropertyAssignment(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a `PropertyAssignment` node. Extracts the key and value of\n   * the property assignment and returns an object of type\n   * `PropertyAssignmentType` with the extracted identifier and value.\n   * @param node The `PropertyAssignment` node to process.\n   * @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.\n   */\n  async handle(node: PropertyAssignment): Promise<PropertyAssignmentType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    let name;\n    if (ASTParser.isIdentifier(node.key)) {\n      name = node.key.name;\n    } else if (ASTParser.isStringLiteral(node.key)) {\n      name = node.key.value;\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    if (!name) {\n      throw new Error(\"Invalid property key\");\n    }\n    const identifier = (`${name}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    const value = await this.parentHandler.handle(node.value);\n    return { type: \"property_assignment\", identifier, value };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,4BAAb,cAA+CA,aAAAA,YAAY;;;;;;;CAOzD,MAAM,QAAQ,MAA6D;EACzE,IAAIC,aAAAA,UAAU,qBAAqB,IAAI,GACrC,OAAO;OAEP,OAAO;CAEX;;;;;;;;CASA,MAAM,OAAO,MAA2D;EACtE,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,IAAI;EACJ,IAAIA,aAAAA,UAAU,aAAa,KAAK,GAAG,GACjC,OAAO,KAAK,IAAI;OACX,IAAIA,aAAAA,UAAU,gBAAgB,KAAK,GAAG,GAC3C,OAAO,KAAK,IAAI;OAEhB,MAAM,IAAI,MAAM,2BAA2B;EAE7C,IAAI,CAAC,MACH,MAAM,IAAI,MAAM,sBAAsB;EAOxC,OAAO;GAAE,MAAM;GAAuB,YALlB,GAAG,OAAkB,QACvC,2BACA,IAG6C;GAAG,OAAA,MAD9B,KAAK,cAAc,OAAO,KAAK,KAAK;EACA;CAC1D;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"property_assignment_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/property_assignment_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  PropertyAssignment,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for `PropertyAssignment` nodes in an AST. Extends the\n * `NodeHandler` base class.\n */\nexport class PropertyAssignmentHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a `PropertyAssignment` and returns the node\n   * if true, or false otherwise.\n   * @param node The node to check.\n   * @returns The node if it is a `PropertyAssignment`, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<PropertyAssignment | boolean> {\n    if (ASTParser.isPropertyAssignment(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a `PropertyAssignment` node. Extracts the key and value of\n   * the property assignment and returns an object of type\n   * `PropertyAssignmentType` with the extracted identifier and value.\n   * @param node The `PropertyAssignment` node to process.\n   * @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.\n   */\n  async handle(node: PropertyAssignment): Promise<PropertyAssignmentType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    let name;\n    if (ASTParser.isIdentifier(node.key)) {\n      name = node.key.name;\n    } else if (ASTParser.isStringLiteral(node.key)) {\n      name = node.key.value;\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    if (!name) {\n      throw new Error(\"Invalid property key\");\n    }\n    const identifier = (`${name}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    const value = await this.parentHandler.handle(node.value);\n    return { type: \"property_assignment\", identifier, value };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,4BAAb,cAA+C,YAAY;;;;;;;CAOzD,MAAM,QAAQ,MAA6D;AACzE,MAAI,UAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,IAAI;AACJ,MAAI,UAAU,aAAa,KAAK,IAAI,CAClC,QAAO,KAAK,IAAI;WACP,UAAU,gBAAgB,KAAK,IAAI,CAC5C,QAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM,4BAA4B;AAE9C,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,uBAAuB;AAOzC,SAAO;GAAE,MAAM;GAAuB,YALlB,GAAG,OAAkB,QACvC,2BACA,KAG8C;GAAE,OAAA,MAD9B,KAAK,cAAc,OAAO,KAAK,MAAM;GACA"}
+{"version":3,"file":"property_assignment_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/property_assignment_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  PropertyAssignment,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for `PropertyAssignment` nodes in an AST. Extends the\n * `NodeHandler` base class.\n */\nexport class PropertyAssignmentHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a `PropertyAssignment` and returns the node\n   * if true, or false otherwise.\n   * @param node The node to check.\n   * @returns The node if it is a `PropertyAssignment`, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<PropertyAssignment | boolean> {\n    if (ASTParser.isPropertyAssignment(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a `PropertyAssignment` node. Extracts the key and value of\n   * the property assignment and returns an object of type\n   * `PropertyAssignmentType` with the extracted identifier and value.\n   * @param node The `PropertyAssignment` node to process.\n   * @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.\n   */\n  async handle(node: PropertyAssignment): Promise<PropertyAssignmentType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    let name;\n    if (ASTParser.isIdentifier(node.key)) {\n      name = node.key.name;\n    } else if (ASTParser.isStringLiteral(node.key)) {\n      name = node.key.value;\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    if (!name) {\n      throw new Error(\"Invalid property key\");\n    }\n    const identifier = (`${name}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    const value = await this.parentHandler.handle(node.value);\n    return { type: \"property_assignment\", identifier, value };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,4BAAb,cAA+C,YAAY;;;;;;;CAOzD,MAAM,QAAQ,MAA6D;EACzE,IAAI,UAAU,qBAAqB,IAAI,GACrC,OAAO;OAEP,OAAO;CAEX;;;;;;;;CASA,MAAM,OAAO,MAA2D;EACtE,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,IAAI;EACJ,IAAI,UAAU,aAAa,KAAK,GAAG,GACjC,OAAO,KAAK,IAAI;OACX,IAAI,UAAU,gBAAgB,KAAK,GAAG,GAC3C,OAAO,KAAK,IAAI;OAEhB,MAAM,IAAI,MAAM,2BAA2B;EAE7C,IAAI,CAAC,MACH,MAAM,IAAI,MAAM,sBAAsB;EAOxC,OAAO;GAAE,MAAM;GAAuB,YALlB,GAAG,OAAkB,QACvC,2BACA,IAG6C;GAAG,OAAA,MAD9B,KAAK,cAAc,OAAO,KAAK,KAAK;EACA;CAC1D;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"string_literal_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/string_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { StringLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  StringLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for string literal nodes in the LangChain Expression Language.\n * Extends the NodeHandler base class.\n */\nexport class StringLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a string literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<StringLiteral | boolean> {\n    if (ASTParser.isStringLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a string literal node to extract its value. Throws an error\n   * if the handler does not have a parent handler.\n   * @param node The StringLiteral node to process.\n   * @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.\n   */\n  async handle(node: StringLiteral): Promise<StringLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = (`${node.value}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    return { type: \"string_literal\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,uBAAb,cAA0CA,aAAAA,YAAY;;;;;;;CAOpD,MAAM,QAAQ,MAAwD;AACpE,MAAIC,aAAAA,UAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAMH,SAAO;GAAE,MAAM;GAAkB,OAJnB,GAAG,KAAK,QAAmB,QACvC,2BACA,KAE0C;GAAE"}
+{"version":3,"file":"string_literal_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/string_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { StringLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  StringLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for string literal nodes in the LangChain Expression Language.\n * Extends the NodeHandler base class.\n */\nexport class StringLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a string literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<StringLiteral | boolean> {\n    if (ASTParser.isStringLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a string literal node to extract its value. Throws an error\n   * if the handler does not have a parent handler.\n   * @param node The StringLiteral node to process.\n   * @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.\n   */\n  async handle(node: StringLiteral): Promise<StringLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = (`${node.value}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    return { type: \"string_literal\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,uBAAb,cAA0CA,aAAAA,YAAY;;;;;;;CAOpD,MAAM,QAAQ,MAAwD;EACpE,IAAIC,aAAAA,UAAU,gBAAgB,IAAI,GAChC,OAAO;OAEP,OAAO;CAEX;;;;;;;CAQA,MAAM,OAAO,MAAiD;EAC5D,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAMF,OAAO;GAAE,MAAM;GAAkB,OAJnB,GAAG,KAAK,QAAmB,QACvC,2BACA,IAEyC;EAAE;CAC/C;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"string_literal_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/string_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { StringLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  StringLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for string literal nodes in the LangChain Expression Language.\n * Extends the NodeHandler base class.\n */\nexport class StringLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a string literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<StringLiteral | boolean> {\n    if (ASTParser.isStringLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a string literal node to extract its value. Throws an error\n   * if the handler does not have a parent handler.\n   * @param node The StringLiteral node to process.\n   * @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.\n   */\n  async handle(node: StringLiteral): Promise<StringLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = (`${node.value}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    return { type: \"string_literal\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,uBAAb,cAA0C,YAAY;;;;;;;CAOpD,MAAM,QAAQ,MAAwD;AACpE,MAAI,UAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAMH,SAAO;GAAE,MAAM;GAAkB,OAJnB,GAAG,KAAK,QAAmB,QACvC,2BACA,KAE0C;GAAE"}
+{"version":3,"file":"string_literal_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/string_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { StringLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  StringLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for string literal nodes in the LangChain Expression Language.\n * Extends the NodeHandler base class.\n */\nexport class StringLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a string literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<StringLiteral | boolean> {\n    if (ASTParser.isStringLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a string literal node to extract its value. Throws an error\n   * if the handler does not have a parent handler.\n   * @param node The StringLiteral node to process.\n   * @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.\n   */\n  async handle(node: StringLiteral): Promise<StringLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = (`${node.value}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    return { type: \"string_literal\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,uBAAb,cAA0C,YAAY;;;;;;;CAOpD,MAAM,QAAQ,MAAwD;EACpE,IAAI,UAAU,gBAAgB,IAAI,GAChC,OAAO;OAEP,OAAO;CAEX;;;;;;;CAQA,MAAM,OAAO,MAAiD;EAC5D,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAMF,OAAO;GAAE,MAAM;GAAkB,OAJnB,GAAG,KAAK,QAAmB,QACvC,2BACA,IAEyC;EAAE;CAC/C;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/types.ts"],"mappings":";;AAIA;;;KAAY,aAAA,GACR,cAAA,GACA,iBAAA,GACA,kBAAA,GACA,gBAAA,GACA,iBAAA,GACA,kBAAA,GACA,kBAAA;;;;;KAMQ,UAAA,GAAa,aAAA,GAAgB,sBAAA;;;;;;KAO7B,gBAAA;EACV,IAAA;EACA,MAAA,EAAQ,aAAA;AAAA;;;;AATV;KAgBY,kBAAA;EACV,IAAA;EACA,KAAA;AAAA;AAXF;;;;;;AAAA,KAoBY,kBAAA;EACV,IAAA;EACA,QAAA,WAAmB,oBAAA;EACnB,IAAA,GAAO,aAAA;AAAA;;;;AAHT;KAUY,kBAAA;EACV,IAAA;EACA,KAAA;AAAA;;;;;;KAQU,iBAAA;EACV,IAAA;EACA,MAAA,EAAQ,sBAAA;AAAA;;;AAFV;;;KAUY,oBAAA;EACV,IAAA;EACA,UAAA;EACA,QAAA;AAAA;;AAHF;;;;KAWY,sBAAA;EACV,IAAA;EACA,UAAA;EACA,KAAA,EAAO,aAAA;AAAA;AAHT;;;;AAAA,KAUY,iBAAA;EACV,IAAA;EACA,KAAA;AAAA;;;AAFF;;KASY,cAAA;EACV,IAAA;EACA,KAAA;AAAA"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/types.ts"],"mappings":";;;;;KAIY,gBACR,iBACA,oBACA,qBACA,mBACA,oBACA,qBACA;;;;;KAMQ,aAAa,gBAAgB;;;;;;KAO7B;EACV;EACA,QAAQ;;;;;;KAOE;EACV;EACA;;;;;;;;KASU;EACV;EACA,mBAAmB;EACnB,OAAO;;;;;;KAOG;EACV;EACA;;;;;;;KAQU;EACV;EACA,QAAQ;;;;;;;KAQE;EACV;EACA;EACA;;;;;;;KAQU;EACV;EACA;EACA,OAAO;;;;;;KAOG;EACV;EACA;;;;;;KAOU;EACV;EACA"}

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/types.ts"],"mappings":";;AAIA;;;KAAY,aAAA,GACR,cAAA,GACA,iBAAA,GACA,kBAAA,GACA,gBAAA,GACA,iBAAA,GACA,kBAAA,GACA,kBAAA;;;;;KAMQ,UAAA,GAAa,aAAA,GAAgB,sBAAA;;;;;;KAO7B,gBAAA;EACV,IAAA;EACA,MAAA,EAAQ,aAAA;AAAA;;;;AATV;KAgBY,kBAAA;EACV,IAAA;EACA,KAAA;AAAA;AAXF;;;;;;AAAA,KAoBY,kBAAA;EACV,IAAA;EACA,QAAA,WAAmB,oBAAA;EACnB,IAAA,GAAO,aAAA;AAAA;;;;AAHT;KAUY,kBAAA;EACV,IAAA;EACA,KAAA;AAAA;;;;;;KAQU,iBAAA;EACV,IAAA;EACA,MAAA,EAAQ,sBAAA;AAAA;;;AAFV;;;KAUY,oBAAA;EACV,IAAA;EACA,UAAA;EACA,QAAA;AAAA;;AAHF;;;;KAWY,sBAAA;EACV,IAAA;EACA,UAAA;EACA,KAAA,EAAO,aAAA;AAAA;AAHT;;;;AAAA,KAUY,iBAAA;EACV,IAAA;EACA,KAAA;AAAA;;;AAFF;;KASY,cAAA;EACV,IAAA;EACA,KAAA;AAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/types.ts"],"mappings":";;;;;KAIY,gBACR,iBACA,oBACA,qBACA,mBACA,oBACA,qBACA;;;;;KAMQ,aAAa,gBAAgB;;;;;;KAO7B;EACV;EACA,QAAQ;;;;;;KAOE;EACV;EACA;;;;;;;;KASU;EACV;EACA,mBAAmB;EACnB,OAAO;;;;;;KAOG;EACV;EACA;;;;;;;KAQU;EACV;EACA,QAAQ;;;;;;;KAQE;EACV;EACA;EACA;;;;;;;KAQU;EACV;EACA;EACA,OAAO;;;;;;KAOG;EACV;EACA;;;;;;KAOU;EACV;EACA"}

package/dist/output_parsers/fix.cjs

@@ -1,4 +1,3 @@
-require("../_virtual/_rolldown/runtime.cjs");
 const require_llm_chain = require("../chains/llm_chain.cjs");
 const require_prompts = require("./prompts.cjs");
 let _langchain_core_output_parsers = require("@langchain/core/output_parsers");
@@ -32,12 +31,13 @@ var OutputFixingParser = class OutputFixingParser extends _langchain_core_output
 	* @returns A new instance of OutputFixingParser.
 	*/
 	static fromLLM(llm, parser, fields) {
+		const chain = new require_llm_chain.LLMChain({
+			llm,
+			prompt: fields?.prompt ?? require_prompts.NAIVE_FIX_PROMPT
+		});
 		return new OutputFixingParser({
 			parser,
-			retryChain: new require_llm_chain.LLMChain({
-				llm,
-				prompt: fields?.prompt ?? require_prompts.NAIVE_FIX_PROMPT
-			})
+			retryChain: chain
 		});
 	}
 	constructor({ parser, retryChain }) {

package/dist/output_parsers/fix.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"fix.cjs","names":["BaseOutputParser","LLMChain","NAIVE_FIX_PROMPT","OutputParserException"],"sources":["../../src/output_parsers/fix.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { NAIVE_FIX_PROMPT } from \"./prompts.js\";\n\ninterface OutputFixingParserRetryInput {\n  instructions: string;\n  completion: string;\n  error: OutputParserException;\n}\n\nfunction isLLMChain<T>(\n  x: LLMChain | Runnable<OutputFixingParserRetryInput, T>\n): x is LLMChain {\n  return (\n    (x as LLMChain).prompt !== undefined && (x as LLMChain).llm !== undefined\n  );\n}\n\n/**\n * Class that extends the BaseOutputParser to handle situations where the\n * initial parsing attempt fails. It contains a retryChain for retrying\n * the parsing process in case of a failure.\n */\nexport class OutputFixingParser<T> extends BaseOutputParser<T> {\n  static lc_name() {\n    return \"OutputFixingParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"fix\"];\n\n  lc_serializable = true;\n\n  parser: BaseOutputParser<T>;\n\n  retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n\n  /**\n   * Static method to create a new instance of OutputFixingParser using a\n   * given language model, parser, and optional fields.\n   * @param llm The language model to be used.\n   * @param parser The parser to be used.\n   * @param fields Optional fields which may contain a prompt.\n   * @returns A new instance of OutputFixingParser.\n   */\n  static fromLLM<T>(\n    llm: BaseLanguageModelInterface,\n    parser: BaseOutputParser<T>,\n    fields?: {\n      prompt?: BasePromptTemplate;\n    }\n  ) {\n    const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;\n    const chain = new LLMChain({ llm, prompt });\n    return new OutputFixingParser<T>({ parser, retryChain: chain });\n  }\n\n  constructor({\n    parser,\n    retryChain,\n  }: {\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n  }) {\n    super(...arguments);\n    this.parser = parser;\n    this.retryChain = retryChain;\n  }\n\n  /**\n   * Method to parse the completion using the parser. If the initial parsing\n   * fails, it uses the retryChain to attempt to fix the output and retry\n   * the parsing process.\n   * @param completion The completion to be parsed.\n   * @param callbacks Optional callbacks to be used during parsing.\n   * @returns The parsed output.\n   */\n  async parse(completion: string, callbacks?: Callbacks) {\n    try {\n      return await this.parser.parse(completion, callbacks);\n    } catch (e) {\n      // oxlint-disable-next-line no-instanceof/no-instanceof\n      if (e instanceof OutputParserException) {\n        const retryInput = {\n          instructions: this.parser.getFormatInstructions(),\n          completion,\n          error: e,\n        };\n\n        if (isLLMChain(this.retryChain)) {\n          const result = await this.retryChain.call(retryInput, callbacks);\n          const newCompletion: string = result[this.retryChain.outputKey];\n          return this.parser.parse(newCompletion, callbacks);\n        } else {\n          const result = await this.retryChain.invoke(retryInput, {\n            callbacks,\n          });\n          return result;\n        }\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Method to get the format instructions for the parser.\n   * @returns The format instructions for the parser.\n   */\n  getFormatInstructions() {\n    return this.parser.getFormatInstructions();\n  }\n}\n"],"mappings":";;;;;AAiBA,SAAS,WACP,GACe;AACf,QACG,EAAe,WAAW,KAAA,KAAc,EAAe,QAAQ,KAAA;;;;;;;AASpE,IAAa,qBAAb,MAAa,2BAA8BA,+BAAAA,iBAAoB;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAM;CAErD,kBAAkB;CAElB;CAEA;;;;;;;;;CAUA,OAAO,QACL,KACA,QACA,QAGA;AAGA,SAAO,IAAI,mBAAsB;GAAE;GAAQ,YAAY,IADrCC,kBAAAA,SAAS;IAAE;IAAK,QADnB,QAAQ,UAAUC,gBAAAA;IACS,CACkB;GAAE,CAAC;;CAGjE,YAAY,EACV,QACA,cAIC;AACD,QAAM,GAAG,UAAU;AACnB,OAAK,SAAS;AACd,OAAK,aAAa;;;;;;;;;;CAWpB,MAAM,MAAM,YAAoB,WAAuB;AACrD,MAAI;AACF,UAAO,MAAM,KAAK,OAAO,MAAM,YAAY,UAAU;WAC9C,GAAG;AAEV,OAAI,aAAaC,+BAAAA,uBAAuB;IACtC,MAAM,aAAa;KACjB,cAAc,KAAK,OAAO,uBAAuB;KACjD;KACA,OAAO;KACR;AAED,QAAI,WAAW,KAAK,WAAW,EAAE;KAE/B,MAAM,iBAAwB,MADT,KAAK,WAAW,KAAK,YAAY,UAAU,EAC3B,KAAK,WAAW;AACrD,YAAO,KAAK,OAAO,MAAM,eAAe,UAAU;UAKlD,QAAO,MAHc,KAAK,WAAW,OAAO,YAAY,EACtD,WACD,CAAC;;AAIN,SAAM;;;;;;;CAQV,wBAAwB;AACtB,SAAO,KAAK,OAAO,uBAAuB"}
+{"version":3,"file":"fix.cjs","names":["BaseOutputParser","LLMChain","NAIVE_FIX_PROMPT","OutputParserException"],"sources":["../../src/output_parsers/fix.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { NAIVE_FIX_PROMPT } from \"./prompts.js\";\n\ninterface OutputFixingParserRetryInput {\n  instructions: string;\n  completion: string;\n  error: OutputParserException;\n}\n\nfunction isLLMChain<T>(\n  x: LLMChain | Runnable<OutputFixingParserRetryInput, T>\n): x is LLMChain {\n  return (\n    (x as LLMChain).prompt !== undefined && (x as LLMChain).llm !== undefined\n  );\n}\n\n/**\n * Class that extends the BaseOutputParser to handle situations where the\n * initial parsing attempt fails. It contains a retryChain for retrying\n * the parsing process in case of a failure.\n */\nexport class OutputFixingParser<T> extends BaseOutputParser<T> {\n  static lc_name() {\n    return \"OutputFixingParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"fix\"];\n\n  lc_serializable = true;\n\n  parser: BaseOutputParser<T>;\n\n  retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n\n  /**\n   * Static method to create a new instance of OutputFixingParser using a\n   * given language model, parser, and optional fields.\n   * @param llm The language model to be used.\n   * @param parser The parser to be used.\n   * @param fields Optional fields which may contain a prompt.\n   * @returns A new instance of OutputFixingParser.\n   */\n  static fromLLM<T>(\n    llm: BaseLanguageModelInterface,\n    parser: BaseOutputParser<T>,\n    fields?: {\n      prompt?: BasePromptTemplate;\n    }\n  ) {\n    const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;\n    const chain = new LLMChain({ llm, prompt });\n    return new OutputFixingParser<T>({ parser, retryChain: chain });\n  }\n\n  constructor({\n    parser,\n    retryChain,\n  }: {\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n  }) {\n    super(...arguments);\n    this.parser = parser;\n    this.retryChain = retryChain;\n  }\n\n  /**\n   * Method to parse the completion using the parser. If the initial parsing\n   * fails, it uses the retryChain to attempt to fix the output and retry\n   * the parsing process.\n   * @param completion The completion to be parsed.\n   * @param callbacks Optional callbacks to be used during parsing.\n   * @returns The parsed output.\n   */\n  async parse(completion: string, callbacks?: Callbacks) {\n    try {\n      return await this.parser.parse(completion, callbacks);\n    } catch (e) {\n      // oxlint-disable-next-line no-instanceof/no-instanceof\n      if (e instanceof OutputParserException) {\n        const retryInput = {\n          instructions: this.parser.getFormatInstructions(),\n          completion,\n          error: e,\n        };\n\n        if (isLLMChain(this.retryChain)) {\n          const result = await this.retryChain.call(retryInput, callbacks);\n          const newCompletion: string = result[this.retryChain.outputKey];\n          return this.parser.parse(newCompletion, callbacks);\n        } else {\n          const result = await this.retryChain.invoke(retryInput, {\n            callbacks,\n          });\n          return result;\n        }\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Method to get the format instructions for the parser.\n   * @returns The format instructions for the parser.\n   */\n  getFormatInstructions() {\n    return this.parser.getFormatInstructions();\n  }\n}\n"],"mappings":";;;;AAiBA,SAAS,WACP,GACe;CACf,OACG,EAAe,WAAW,KAAA,KAAc,EAAe,QAAQ,KAAA;AAEpE;;;;;;AAOA,IAAa,qBAAb,MAAa,2BAA8BA,+BAAAA,iBAAoB;CAC7D,OAAO,UAAU;EACf,OAAO;CACT;CAEA,eAAe;EAAC;EAAa;EAAkB;CAAK;CAEpD,kBAAkB;CAElB;CAEA;;;;;;;;;CAUA,OAAO,QACL,KACA,QACA,QAGA;EAEA,MAAM,QAAQ,IAAIC,kBAAAA,SAAS;GAAE;GAAK,QADnB,QAAQ,UAAUC,gBAAAA;EACQ,CAAC;EAC1C,OAAO,IAAI,mBAAsB;GAAE;GAAQ,YAAY;EAAM,CAAC;CAChE;CAEA,YAAY,EACV,QACA,cAIC;EACD,MAAM,GAAG,SAAS;EAClB,KAAK,SAAS;EACd,KAAK,aAAa;CACpB;;;;;;;;;CAUA,MAAM,MAAM,YAAoB,WAAuB;EACrD,IAAI;GACF,OAAO,MAAM,KAAK,OAAO,MAAM,YAAY,SAAS;EACtD,SAAS,GAAG;GAEV,IAAI,aAAaC,+BAAAA,uBAAuB;IACtC,MAAM,aAAa;KACjB,cAAc,KAAK,OAAO,sBAAsB;KAChD;KACA,OAAO;IACT;IAEA,IAAI,WAAW,KAAK,UAAU,GAAG;KAE/B,MAAM,iBAAwB,MADT,KAAK,WAAW,KAAK,YAAY,SAAS,EAAA,CAC1B,KAAK,WAAW;KACrD,OAAO,KAAK,OAAO,MAAM,eAAe,SAAS;IACnD,OAIE,OAAO,MAHc,KAAK,WAAW,OAAO,YAAY,EACtD,UACF,CAAC;GAGL;GACA,MAAM;EACR;CACF;;;;;CAMA,wBAAwB;EACtB,OAAO,KAAK,OAAO,sBAAsB;CAC3C;AACF"}

package/dist/output_parsers/fix.d.cts

@@ -4,7 +4,6 @@ import { BaseOutputParser, OutputParserException } from "@langchain/core/output_
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 import { Callbacks } from "@langchain/core/callbacks/manager";
-
 //#region src/output_parsers/fix.d.ts
 interface OutputFixingParserRetryInput {
   instructions: string;
@@ -33,10 +32,7 @@ declare class OutputFixingParser<T> extends BaseOutputParser<T> {
   static fromLLM<T>(llm: BaseLanguageModelInterface, parser: BaseOutputParser<T>, fields?: {
     prompt?: BasePromptTemplate;
   }): OutputFixingParser<T>;
-  constructor({
-    parser,
-    retryChain
-  }: {
+  constructor({ parser, retryChain }: {
     parser: BaseOutputParser<T>;
     retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;
   });

package/dist/output_parsers/fix.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"fix.d.cts","names":[],"sources":["../../src/output_parsers/fix.ts"],"mappings":";;;;;;;;UAWU,4BAAA;EACR,YAAA;EACA,UAAA;EACA,KAAA,EAAO,qBAAA;AAAA;;;;;;cAgBI,kBAAA,YAA8B,gBAAA,CAAiB,CAAA;EAAA,OACnD,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAEA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;EAEzB,UAAA,EAAY,QAAA,GAAW,QAAA,CAAS,4BAAA,EAA8B,CAAA;EAFrC;;;;;;;;EAAA,OAYlB,OAAA,GAAA,CACL,GAAA,EAAK,0BAAA,EACL,MAAA,EAAQ,gBAAA,CAAiB,CAAA,GACzB,MAAA;IACE,MAAA,GAAS,kBAAA;EAAA,IACV,kBAAA,CAAA,CAAA;EAOH,WAAA,CAAA;IACE,MAAA;IACA;EAAA;IAEA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;IACzB,UAAA,EAAY,QAAA,GAAW,QAAA,CAAS,4BAAA,EAA8B,CAAA;EAAA;EADtD;;;;;;;;EAgBJ,KAAA,CAAM,UAAA,UAAoB,SAAA,GAAY,SAAA,GAAS,OAAA,CAAA,CAAA;EArDI;;;;EAoFzD,qBAAA,CAAA;AAAA"}
+{"version":3,"file":"fix.d.cts","names":[],"sources":["../../src/output_parsers/fix.ts"],"mappings":";;;;;;;UAWU;EACR;EACA;EACA,OAAO;;;;;;;cAgBI,mBAAmB,WAAW,iBAAiB;SACnD;EAIP;EAEA;EAEA,QAAQ,iBAAiB;EAEzB,YAAY,WAAW,SAAS,8BAA8B;;;;;;;;;SAUvD,QAAQ,GACb,KAAK,4BACL,QAAQ,iBAAiB,IACzB;IACE,SAAS;MACV,mBAAA;EAOH,cACE,QACA;IAEA,QAAQ,iBAAiB;IACzB,YAAY,WAAW,SAAS,8BAA8B;;;;;;;;;;EAe1D,MAAM,oBAAoB,YAAY,YAAS,QAAA;;;;;EA+BrD"}

package/dist/output_parsers/fix.d.ts

@@ -4,7 +4,6 @@ import { Runnable } from "@langchain/core/runnables";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 import { Callbacks } from "@langchain/core/callbacks/manager";
 import { BaseOutputParser, OutputParserException } from "@langchain/core/output_parsers";
-
 //#region src/output_parsers/fix.d.ts
 interface OutputFixingParserRetryInput {
   instructions: string;
@@ -33,10 +32,7 @@ declare class OutputFixingParser<T> extends BaseOutputParser<T> {
   static fromLLM<T>(llm: BaseLanguageModelInterface, parser: BaseOutputParser<T>, fields?: {
     prompt?: BasePromptTemplate;
   }): OutputFixingParser<T>;
-  constructor({
-    parser,
-    retryChain
-  }: {
+  constructor({ parser, retryChain }: {
     parser: BaseOutputParser<T>;
     retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;
   });

package/dist/output_parsers/fix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fix.d.ts","names":[],"sources":["../../src/output_parsers/fix.ts"],"mappings":";;;;;;;;UAWU,4BAAA;EACR,YAAA;EACA,UAAA;EACA,KAAA,EAAO,qBAAA;AAAA;;;;;;cAgBI,kBAAA,YAA8B,gBAAA,CAAiB,CAAA;EAAA,OACnD,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAEA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;EAEzB,UAAA,EAAY,QAAA,GAAW,QAAA,CAAS,4BAAA,EAA8B,CAAA;EAFrC;;;;;;;;EAAA,OAYlB,OAAA,GAAA,CACL,GAAA,EAAK,0BAAA,EACL,MAAA,EAAQ,gBAAA,CAAiB,CAAA,GACzB,MAAA;IACE,MAAA,GAAS,kBAAA;EAAA,IACV,kBAAA,CAAA,CAAA;EAOH,WAAA,CAAA;IACE,MAAA;IACA;EAAA;IAEA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;IACzB,UAAA,EAAY,QAAA,GAAW,QAAA,CAAS,4BAAA,EAA8B,CAAA;EAAA;EADtD;;;;;;;;EAgBJ,KAAA,CAAM,UAAA,UAAoB,SAAA,GAAY,SAAA,GAAS,OAAA,CAAA,CAAA;EArDI;;;;EAoFzD,qBAAA,CAAA;AAAA"}
+{"version":3,"file":"fix.d.ts","names":[],"sources":["../../src/output_parsers/fix.ts"],"mappings":";;;;;;;UAWU;EACR;EACA;EACA,OAAO;;;;;;;cAgBI,mBAAmB,WAAW,iBAAiB;SACnD;EAIP;EAEA;EAEA,QAAQ,iBAAiB;EAEzB,YAAY,WAAW,SAAS,8BAA8B;;;;;;;;;SAUvD,QAAQ,GACb,KAAK,4BACL,QAAQ,iBAAiB,IACzB;IACE,SAAS;MACV,mBAAA;EAOH,cACE,QACA;IAEA,QAAQ,iBAAiB;IACzB,YAAY,WAAW,SAAS,8BAA8B;;;;;;;;;;EAe1D,MAAM,oBAAoB,YAAY,YAAS,QAAA;;;;;EA+BrD"}

package/dist/output_parsers/fix.js

@@ -31,12 +31,13 @@ var OutputFixingParser = class OutputFixingParser extends BaseOutputParser {
 	* @returns A new instance of OutputFixingParser.
 	*/
 	static fromLLM(llm, parser, fields) {
+		const chain = new LLMChain({
+			llm,
+			prompt: fields?.prompt ?? NAIVE_FIX_PROMPT
+		});
 		return new OutputFixingParser({
 			parser,
-			retryChain: new LLMChain({
-				llm,
-				prompt: fields?.prompt ?? NAIVE_FIX_PROMPT
-			})
+			retryChain: chain
 		});
 	}
 	constructor({ parser, retryChain }) {