@langchain/classic 1.0.40 → 1.0.42

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

@@ -1 +1 @@
-{"version":3,"file":"array_literal_expression_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/array_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { ArrayLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ArrayExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles array expressions in the LangChain Expression Language (LCEL).\n * It extends the NodeHandler base class, providing functionality to\n * accept and handle array expressions.\n */\nexport class ArrayLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if the given node is an array expression. 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 either the ArrayExpression node if the node is an array expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<ArrayExpression | boolean> {\n    if (ASTParser.isArrayExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Handles the given array expression node. If the handler doesn't have a\n   * parent handler, it throws an error. Otherwise, it returns an object\n   * representing the array literal.\n   * @param node The ArrayExpression node to handle.\n   * @returns A Promise that resolves to an object representing the array literal.\n   */\n  async handle(node: ArrayExpression): Promise<ArrayLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"array_literal\",\n      values: await Promise.all(\n        node.elements.map((innerNode) =>\n          this.parentHandler!.handle(innerNode as ExpressionNode)\n        )\n      ),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,gCAAb,cAAmDA,aAAAA,YAAY;;;;;;;CAO7D,MAAM,QAAQ,MAA0D;AACtE,MAAIC,aAAAA,UAAU,kBAAkB,KAAK,CACnC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAAkD;AAC7D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,QAAQ,MAAM,QAAQ,IACpB,KAAK,SAAS,KAAK,cACjB,KAAK,cAAe,OAAO,UAA4B,CACxD,CACF;GACF"}
+{"version":3,"file":"array_literal_expression_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/array_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { ArrayLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ArrayExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles array expressions in the LangChain Expression Language (LCEL).\n * It extends the NodeHandler base class, providing functionality to\n * accept and handle array expressions.\n */\nexport class ArrayLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if the given node is an array expression. 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 either the ArrayExpression node if the node is an array expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<ArrayExpression | boolean> {\n    if (ASTParser.isArrayExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Handles the given array expression node. If the handler doesn't have a\n   * parent handler, it throws an error. Otherwise, it returns an object\n   * representing the array literal.\n   * @param node The ArrayExpression node to handle.\n   * @returns A Promise that resolves to an object representing the array literal.\n   */\n  async handle(node: ArrayExpression): Promise<ArrayLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"array_literal\",\n      values: await Promise.all(\n        node.elements.map((innerNode) =>\n          this.parentHandler!.handle(innerNode as ExpressionNode)\n        )\n      ),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,gCAAb,cAAmDA,aAAAA,YAAY;;;;;;;CAO7D,MAAM,QAAQ,MAA0D;EACtE,IAAIC,aAAAA,UAAU,kBAAkB,IAAI,GAClC,OAAO;OAEP,OAAO;CAEX;;;;;;;;CASA,MAAM,OAAO,MAAkD;EAC7D,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,OAAO;GACL,MAAM;GACN,QAAQ,MAAM,QAAQ,IACpB,KAAK,SAAS,KAAK,cACjB,KAAK,cAAe,OAAO,SAA2B,CACxD,CACF;EACF;CACF;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"array_literal_expression_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/array_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { ArrayLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ArrayExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles array expressions in the LangChain Expression Language (LCEL).\n * It extends the NodeHandler base class, providing functionality to\n * accept and handle array expressions.\n */\nexport class ArrayLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if the given node is an array expression. 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 either the ArrayExpression node if the node is an array expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<ArrayExpression | boolean> {\n    if (ASTParser.isArrayExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Handles the given array expression node. If the handler doesn't have a\n   * parent handler, it throws an error. Otherwise, it returns an object\n   * representing the array literal.\n   * @param node The ArrayExpression node to handle.\n   * @returns A Promise that resolves to an object representing the array literal.\n   */\n  async handle(node: ArrayExpression): Promise<ArrayLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"array_literal\",\n      values: await Promise.all(\n        node.elements.map((innerNode) =>\n          this.parentHandler!.handle(innerNode as ExpressionNode)\n        )\n      ),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,gCAAb,cAAmD,YAAY;;;;;;;CAO7D,MAAM,QAAQ,MAA0D;AACtE,MAAI,UAAU,kBAAkB,KAAK,CACnC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAAkD;AAC7D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,QAAQ,MAAM,QAAQ,IACpB,KAAK,SAAS,KAAK,cACjB,KAAK,cAAe,OAAO,UAA4B,CACxD,CACF;GACF"}
+{"version":3,"file":"array_literal_expression_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/array_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { ArrayLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ArrayExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles array expressions in the LangChain Expression Language (LCEL).\n * It extends the NodeHandler base class, providing functionality to\n * accept and handle array expressions.\n */\nexport class ArrayLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if the given node is an array expression. 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 either the ArrayExpression node if the node is an array expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<ArrayExpression | boolean> {\n    if (ASTParser.isArrayExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Handles the given array expression node. If the handler doesn't have a\n   * parent handler, it throws an error. Otherwise, it returns an object\n   * representing the array literal.\n   * @param node The ArrayExpression node to handle.\n   * @returns A Promise that resolves to an object representing the array literal.\n   */\n  async handle(node: ArrayExpression): Promise<ArrayLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"array_literal\",\n      values: await Promise.all(\n        node.elements.map((innerNode) =>\n          this.parentHandler!.handle(innerNode as ExpressionNode)\n        )\n      ),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,gCAAb,cAAmD,YAAY;;;;;;;CAO7D,MAAM,QAAQ,MAA0D;EACtE,IAAI,UAAU,kBAAkB,IAAI,GAClC,OAAO;OAEP,OAAO;CAEX;;;;;;;;CASA,MAAM,OAAO,MAAkD;EAC7D,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,OAAO;GACL,MAAM;GACN,QAAQ,MAAM,QAAQ,IACpB,KAAK,SAAS,KAAK,cACjB,KAAK,cAAe,OAAO,SAA2B,CACxD,CACF;EACF;CACF;AACF"}

package/dist/output_parsers/expression_type_handlers/base.cjs

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

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

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":["GRAMMAR"],"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,SAASA,uBAAAA,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.cjs","names":["GRAMMAR"],"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,SAASA,uBAAAA,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/base.d.cts

@@ -1,5 +1,4 @@
 import { ArrayExpression, BooleanLiteral, CallExpression, ExpressionNode, ExpressionStatement, Identifier, MemberExpression, NumericLiteral, ObjectExpression, ParseFunction, Program, PropertyAssignment, StringLiteral } from "../../types/expression-parser.cjs";
-
 //#region src/output_parsers/expression_type_handlers/base.d.ts
 /**
  * Abstract class for handling nodes in an expression language. Subclasses

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"mappings":";;;;;AAqBA;;uBAAsB,WAAA;EAAA,UACE,aAAA,GAAgB,WAAA;EAAtC,WAAA,CAAsB,aAAA,GAAgB,WAAA;EAOf;;;;;EAAA,SAAd,OAAA,CAAQ,IAAA,EAAM,cAAA,GAAiB,OAAA,CAAQ,cAAA;EASF;;;;;;EAAA,SAArC,MAAA,CAAO,IAAA,EAAM,cAAA,GAAiB,OAAA;AAAA;;;;;;cAQ5B,SAAA;EAAA,OACJ,gBAAA,EAAkB,aAAA;EATqB;;AAQhD;;EARgD,OAejC,eAAA,CAAA,GAAe,OAAA,CAAA,aAAA;EANH;;;;;EAAA,OA2BlB,SAAA,CAAU,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,OAAA;EAWrC;;;;;EAAA,OAFJ,qBAAA,CACL,IAAA,EAAM,cAAA,GACL,IAAA,IAAQ,mBAAA;EA2B4C;;;;;EAAA,OAlBhD,gBAAA,CAAiB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,cAAA;EA6CE;;;;;EAAA,OApClD,eAAA,CAAgB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,aAAA;EAiEG;;;;;EAAA,OAxDlD,gBAAA,CAAiB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,cAAA;EA3D3B;;;;;EAAA,OAoErB,gBAAA,CAAiB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,cAAA;EA/CP;;;;;EAAA,OAwDzC,YAAA,CAAa,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,UAAA;EApC5C;;;;;EAAA,OA6CA,kBAAA,CAAmB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,gBAAA;EApC5B;;;;;EAAA,OA6CtB,iBAAA,CAAkB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,eAAA;EApChC;;;;;EAAA,OA6CjB,oBAAA,CACL,IAAA,EAAM,cAAA,GACL,IAAA,IAAQ,kBAAA;EAtCoC;;;;;EAAA,OA+CxC,kBAAA,CAAmB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,gBAAA;AAAA"}
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"mappings":";;;;;;uBAqBsB;YACE,gBAAgB;EAAtC,YAAsB,gBAAgB;;;;;;WAO7B,QAAQ,MAAM,iBAAiB,QAAQ;;;;;;;WASvC,OAAO,MAAM,iBAAiB;;;;;;;cAQ5B;SACJ,kBAAkB;;;;;SAMZ,mBAAe,QAAA;;;;;;SAqBrB,UAAU,MAAM,iBAAiB,QAAQ;;;;;;SASzC,sBACL,MAAM,iBACL,QAAQ;;;;;;SASJ,iBAAiB,MAAM,iBAAiB,QAAQ;;;;;;SAShD,gBAAgB,MAAM,iBAAiB,QAAQ;;;;;;SAS/C,iBAAiB,MAAM,iBAAiB,QAAQ;;;;;;SAShD,iBAAiB,MAAM,iBAAiB,QAAQ;;;;;;SAShD,aAAa,MAAM,iBAAiB,QAAQ;;;;;;SAS5C,mBAAmB,MAAM,iBAAiB,QAAQ;;;;;;SASlD,kBAAkB,MAAM,iBAAiB,QAAQ;;;;;;SASjD,qBACL,MAAM,iBACL,QAAQ;;;;;;SASJ,mBAAmB,MAAM,iBAAiB,QAAQ"}

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

@@ -1,5 +1,4 @@
 import { ArrayExpression, BooleanLiteral, CallExpression, ExpressionNode, ExpressionStatement, Identifier, MemberExpression, NumericLiteral, ObjectExpression, ParseFunction, Program, PropertyAssignment, StringLiteral } from "../../types/expression-parser.js";
-
 //#region src/output_parsers/expression_type_handlers/base.d.ts
 /**
  * Abstract class for handling nodes in an expression language. Subclasses

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"mappings":";;;;;AAqBA;;uBAAsB,WAAA;EAAA,UACE,aAAA,GAAgB,WAAA;EAAtC,WAAA,CAAsB,aAAA,GAAgB,WAAA;EAOf;;;;;EAAA,SAAd,OAAA,CAAQ,IAAA,EAAM,cAAA,GAAiB,OAAA,CAAQ,cAAA;EASF;;;;;;EAAA,SAArC,MAAA,CAAO,IAAA,EAAM,cAAA,GAAiB,OAAA;AAAA;;;;;;cAQ5B,SAAA;EAAA,OACJ,gBAAA,EAAkB,aAAA;EATqB;;AAQhD;;EARgD,OAejC,eAAA,CAAA,GAAe,OAAA,CAAA,aAAA;EANH;;;;;EAAA,OA2BlB,SAAA,CAAU,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,OAAA;EAWrC;;;;;EAAA,OAFJ,qBAAA,CACL,IAAA,EAAM,cAAA,GACL,IAAA,IAAQ,mBAAA;EA2B4C;;;;;EAAA,OAlBhD,gBAAA,CAAiB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,cAAA;EA6CE;;;;;EAAA,OApClD,eAAA,CAAgB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,aAAA;EAiEG;;;;;EAAA,OAxDlD,gBAAA,CAAiB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,cAAA;EA3D3B;;;;;EAAA,OAoErB,gBAAA,CAAiB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,cAAA;EA/CP;;;;;EAAA,OAwDzC,YAAA,CAAa,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,UAAA;EApC5C;;;;;EAAA,OA6CA,kBAAA,CAAmB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,gBAAA;EApC5B;;;;;EAAA,OA6CtB,iBAAA,CAAkB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,eAAA;EApChC;;;;;EAAA,OA6CjB,oBAAA,CACL,IAAA,EAAM,cAAA,GACL,IAAA,IAAQ,kBAAA;EAtCoC;;;;;EAAA,OA+CxC,kBAAA,CAAmB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,gBAAA;AAAA"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"mappings":";;;;;;uBAqBsB;YACE,gBAAgB;EAAtC,YAAsB,gBAAgB;;;;;;WAO7B,QAAQ,MAAM,iBAAiB,QAAQ;;;;;;;WASvC,OAAO,MAAM,iBAAiB;;;;;;;cAQ5B;SACJ,kBAAkB;;;;;SAMZ,mBAAe,QAAA;;;;;;SAqBrB,UAAU,MAAM,iBAAiB,QAAQ;;;;;;SASzC,sBACL,MAAM,iBACL,QAAQ;;;;;;SASJ,iBAAiB,MAAM,iBAAiB,QAAQ;;;;;;SAShD,gBAAgB,MAAM,iBAAiB,QAAQ;;;;;;SAS/C,iBAAiB,MAAM,iBAAiB,QAAQ;;;;;;SAShD,iBAAiB,MAAM,iBAAiB,QAAQ;;;;;;SAShD,aAAa,MAAM,iBAAiB,QAAQ;;;;;;SAS5C,mBAAmB,MAAM,iBAAiB,QAAQ;;;;;;SASlD,kBAAkB,MAAM,iBAAiB,QAAQ;;;;;;SASjD,qBACL,MAAM,iBACL,QAAQ;;;;;;SASJ,mBAAmB,MAAM,iBAAiB,QAAQ"}

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"}