@langchain/classic 1.0.17 → 1.0.18

package/dist/output_parsers/expression.js

@@ -1,11 +1,10 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { ASTParser } from "./expression_type_handlers/base.js";
 import { MasterHandler } from "./expression_type_handlers/factory.js";
 import { BaseOutputParser } from "@langchain/core/output_parsers";
 
 //#region src/output_parsers/expression.ts
-var expression_exports = {};
-__export(expression_exports, {
+var expression_exports = /* @__PURE__ */ __exportAll({
 	ExpressionParser: () => ExpressionParser,
 	MasterHandler: () => MasterHandler
 });
@@ -53,13 +52,11 @@ var ExpressionParser = class extends BaseOutputParser {
 	async parse(text) {
 		await this.ensureParser();
 		try {
-			const program = this.parser(text);
-			const node = program.body;
+			const node = this.parser(text).body;
 			if (!ASTParser.isExpressionStatement(node)) throw new Error(`Expected ExpressionStatement, got ${node.type}`);
 			const { expression: expressionStatement } = node;
 			if (!ASTParser.isCallExpression(expressionStatement)) throw new Error("Expected CallExpression");
-			const masterHandler = MasterHandler.createMasterHandler();
-			return await masterHandler.handle(expressionStatement);
+			return await MasterHandler.createMasterHandler().handle(expressionStatement);
 		} catch (err) {
 			throw new Error(`Error parsing ${err}: ${text}`);
 		}

package/dist/output_parsers/expression.js.map

@@ -1 +1 @@
-{"version":3,"file":"expression.js","names":["text: string"],"sources":["../../src/output_parsers/expression.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport { MasterHandler } from \"./expression_type_handlers/factory.js\";\nimport { ParsedType } from \"./expression_type_handlers/types.js\";\nimport { ASTParser } from \"./expression_type_handlers/base.js\";\nimport type { ExpressionNode } from \"../types/expression-parser.js\";\n\nexport type ParseFunction = Awaited<\n  ReturnType<typeof ASTParser.importASTParser>\n>;\n\n/**\n * We need to be able to handle the following cases:\n * ExpressionStatement\n *  CallExpression\n *      Identifier | MemberExpression\n *      ExpressionLiterals: [\n *          CallExpression\n *          StringLiteral\n *          NumericLiteral\n *          ArrayLiteralExpression\n *              ExpressionLiterals\n *          ObjectLiteralExpression\n *              PropertyAssignment\n *                  Identifier\n *                  ExpressionLiterals\n *      ]\n */\n\nexport class ExpressionParser extends BaseOutputParser<ParsedType> {\n  lc_namespace = [\"langchain\", \"output_parsers\", \"expression\"];\n\n  parser: ParseFunction;\n\n  /**\n   * We should separate loading the parser into its own function\n   * because loading the grammar takes some time. If there are\n   * multiple concurrent parse calls, it's faster to just wait\n   * for building the parser once and then use it for all\n   * subsequent calls. See expression.test.ts for an example.\n   */\n  async ensureParser() {\n    if (!this.parser) {\n      this.parser = await ASTParser.importASTParser();\n    }\n  }\n\n  /**\n   * Parses the given text. It first ensures the parser is loaded, then\n   * tries to parse the text. If the parsing fails, it throws an error. If\n   * the parsing is successful, it returns the parsed expression.\n   * @param text The text to be parsed.\n   * @returns The parsed expression\n   */\n  async parse(text: string) {\n    await this.ensureParser();\n\n    try {\n      const program = this.parser(text);\n\n      const node = program.body;\n      if (!ASTParser.isExpressionStatement(node)) {\n        throw new Error(\n          `Expected ExpressionStatement, got ${(node as ExpressionNode).type}`\n        );\n      }\n\n      const { expression: expressionStatement } = node;\n      if (!ASTParser.isCallExpression(expressionStatement)) {\n        throw new Error(\"Expected CallExpression\");\n      }\n      const masterHandler = MasterHandler.createMasterHandler();\n      return await masterHandler.handle(expressionStatement);\n    } catch (err) {\n      throw new Error(`Error parsing ${err}: ${text}`);\n    }\n  }\n\n  /**\n   * This method is currently empty, but it could be used to provide\n   * instructions on the format of the input text.\n   * @returns string\n   */\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n\nexport * from \"./expression_type_handlers/types.js\";\n\nexport { MasterHandler } from \"./expression_type_handlers/factory.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,mBAAb,cAAsC,iBAA6B;CACjE,eAAe;EAAC;EAAa;EAAkB;CAAa;CAE5D;;;;;;;;CASA,MAAM,eAAe;AACnB,MAAI,CAAC,KAAK,QACR,KAAK,SAAS,MAAM,UAAU,iBAAiB;CAElD;;;;;;;;CASD,MAAM,MAAMA,MAAc;EACxB,MAAM,KAAK,cAAc;AAEzB,MAAI;GACF,MAAM,UAAU,KAAK,OAAO,KAAK;GAEjC,MAAM,OAAO,QAAQ;AACrB,OAAI,CAAC,UAAU,sBAAsB,KAAK,CACxC,OAAM,IAAI,MACR,CAAC,kCAAkC,EAAG,KAAwB,MAAM;GAIxE,MAAM,EAAE,YAAY,qBAAqB,GAAG;AAC5C,OAAI,CAAC,UAAU,iBAAiB,oBAAoB,CAClD,OAAM,IAAI,MAAM;GAElB,MAAM,gBAAgB,cAAc,qBAAqB;AACzD,UAAO,MAAM,cAAc,OAAO,oBAAoB;EACvD,SAAQ,KAAK;AACZ,SAAM,IAAI,MAAM,CAAC,cAAc,EAAE,IAAI,EAAE,EAAE,MAAM;EAChD;CACF;;;;;;CAOD,wBAAgC;AAC9B,SAAO;CACR;AACF"}
+{"version":3,"file":"expression.js","names":[],"sources":["../../src/output_parsers/expression.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport { MasterHandler } from \"./expression_type_handlers/factory.js\";\nimport { ParsedType } from \"./expression_type_handlers/types.js\";\nimport { ASTParser } from \"./expression_type_handlers/base.js\";\nimport type { ExpressionNode } from \"../types/expression-parser.js\";\n\nexport type ParseFunction = Awaited<\n  ReturnType<typeof ASTParser.importASTParser>\n>;\n\n/**\n * We need to be able to handle the following cases:\n * ExpressionStatement\n *  CallExpression\n *      Identifier | MemberExpression\n *      ExpressionLiterals: [\n *          CallExpression\n *          StringLiteral\n *          NumericLiteral\n *          ArrayLiteralExpression\n *              ExpressionLiterals\n *          ObjectLiteralExpression\n *              PropertyAssignment\n *                  Identifier\n *                  ExpressionLiterals\n *      ]\n */\n\nexport class ExpressionParser extends BaseOutputParser<ParsedType> {\n  lc_namespace = [\"langchain\", \"output_parsers\", \"expression\"];\n\n  parser: ParseFunction;\n\n  /**\n   * We should separate loading the parser into its own function\n   * because loading the grammar takes some time. If there are\n   * multiple concurrent parse calls, it's faster to just wait\n   * for building the parser once and then use it for all\n   * subsequent calls. See expression.test.ts for an example.\n   */\n  async ensureParser() {\n    if (!this.parser) {\n      this.parser = await ASTParser.importASTParser();\n    }\n  }\n\n  /**\n   * Parses the given text. It first ensures the parser is loaded, then\n   * tries to parse the text. If the parsing fails, it throws an error. If\n   * the parsing is successful, it returns the parsed expression.\n   * @param text The text to be parsed.\n   * @returns The parsed expression\n   */\n  async parse(text: string) {\n    await this.ensureParser();\n\n    try {\n      const program = this.parser(text);\n\n      const node = program.body;\n      if (!ASTParser.isExpressionStatement(node)) {\n        throw new Error(\n          `Expected ExpressionStatement, got ${(node as ExpressionNode).type}`\n        );\n      }\n\n      const { expression: expressionStatement } = node;\n      if (!ASTParser.isCallExpression(expressionStatement)) {\n        throw new Error(\"Expected CallExpression\");\n      }\n      const masterHandler = MasterHandler.createMasterHandler();\n      return await masterHandler.handle(expressionStatement);\n    } catch (err) {\n      throw new Error(`Error parsing ${err}: ${text}`);\n    }\n  }\n\n  /**\n   * This method is currently empty, but it could be used to provide\n   * instructions on the format of the input text.\n   * @returns string\n   */\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n\nexport * from \"./expression_type_handlers/types.js\";\n\nexport { MasterHandler } from \"./expression_type_handlers/factory.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,mBAAb,cAAsC,iBAA6B;CACjE,eAAe;EAAC;EAAa;EAAkB;EAAa;CAE5D;;;;;;;;CASA,MAAM,eAAe;AACnB,MAAI,CAAC,KAAK,OACR,MAAK,SAAS,MAAM,UAAU,iBAAiB;;;;;;;;;CAWnD,MAAM,MAAM,MAAc;AACxB,QAAM,KAAK,cAAc;AAEzB,MAAI;GAGF,MAAM,OAFU,KAAK,OAAO,KAAK,CAEZ;AACrB,OAAI,CAAC,UAAU,sBAAsB,KAAK,CACxC,OAAM,IAAI,MACR,qCAAsC,KAAwB,OAC/D;GAGH,MAAM,EAAE,YAAY,wBAAwB;AAC5C,OAAI,CAAC,UAAU,iBAAiB,oBAAoB,CAClD,OAAM,IAAI,MAAM,0BAA0B;AAG5C,UAAO,MADe,cAAc,qBAAqB,CAC9B,OAAO,oBAAoB;WAC/C,KAAK;AACZ,SAAM,IAAI,MAAM,iBAAiB,IAAI,IAAI,OAAO;;;;;;;;CASpD,wBAAgC;AAC9B,SAAO"}

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","node: ExpressionNode","ASTParser","node: ArrayExpression"],"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,yBAAY;;;;;;;CAO7D,MAAM,QAAQC,MAA0D;AACtE,MAAIC,uBAAU,kBAAkB,KAAK,CACnC,QAAO;MAEP,QAAO;CAEV;;;;;;;;CASD,MAAM,OAAOC,MAAkD;AAC7D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;AAGJ,SAAO;GACL,MAAM;GACN,QAAQ,MAAM,QAAQ,IACpB,KAAK,SAAS,IAAI,CAAC,cACjB,KAAK,cAAe,OAAO,UAA4B,CACxD,CACF;EACF;CACF;AACF"}
+{"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,yBAAY;;;;;;;CAO7D,MAAM,QAAQ,MAA0D;AACtE,MAAIC,uBAAU,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"}

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

@@ -1 +1 @@
-{"version":3,"file":"array_literal_expression_handler.js","names":["node: ExpressionNode","node: ArrayExpression"],"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,QAAQA,MAA0D;AACtE,MAAI,UAAU,kBAAkB,KAAK,CACnC,QAAO;MAEP,QAAO;CAEV;;;;;;;;CASD,MAAM,OAAOC,MAAkD;AAC7D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;AAGJ,SAAO;GACL,MAAM;GACN,QAAQ,MAAM,QAAQ,IACpB,KAAK,SAAS,IAAI,CAAC,cACjB,KAAK,cAAe,OAAO,UAA4B,CACxD,CACF;EACF;CACF;AACF"}
+{"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"}

package/dist/output_parsers/expression_type_handlers/base.cjs

@@ -25,8 +25,7 @@ var ASTParser = class ASTParser {
 		try {
 			if (!ASTParser.astParseInstance) {
 				const { default: peggy } = await import("peggy");
-				const parser = peggy.generate(require_parser_grammar.GRAMMAR);
-				const { parse } = parser;
+				const { parse } = peggy.generate(require_parser_grammar.GRAMMAR);
 				ASTParser.astParseInstance = parse;
 			}
 			return ASTParser.astParseInstance;

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":["ExpressionNode","Program","ExpressionStatement","CallExpression","StringLiteral","NumericLiteral","BooleanLiteral","Identifier","ObjectExpression","ArrayExpression","PropertyAssignment","MemberExpression","ParseFunction","NodeHandler","Promise","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/base.d.ts"],"sourcesContent":["import type { ExpressionNode, Program, ExpressionStatement, CallExpression, StringLiteral, NumericLiteral, BooleanLiteral, Identifier, ObjectExpression, ArrayExpression, PropertyAssignment, MemberExpression, ParseFunction } from \"../../types/expression-parser.js\";\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport declare abstract class NodeHandler {\n    protected parentHandler?: NodeHandler | undefined;\n    constructor(parentHandler?: NodeHandler | undefined);\n    /**\n     * Determines whether the given node is acceptable.\n     * @param node The node to be checked.\n     * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.\n     */\n    abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n    /**\n     * Handles the given node. The specifics of how the node is handled are\n     * determined by the subclass implementation.\n     * @param node The node to be handled.\n     * @returns A Promise that resolves to the result of handling the node.\n     */\n    abstract handle(node: ExpressionNode): Promise<any>;\n}\n/**\n * Utility class for parsing Abstract Syntax Trees (ASTs). Contains\n * methods for identifying the type of a given node and a method for\n * importing and generating a parser using the Peggy library.\n */\nexport declare class ASTParser {\n    static astParseInstance: ParseFunction;\n    /**\n     * Imports and generates a parser using the Peggy library.\n     * @returns A Promise that resolves to the parser instance.\n     */\n    static importASTParser(): Promise<ParseFunction>;\n    /**\n     * Checks if the given node is a Program node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a Program node.\n     */\n    static isProgram(node: ExpressionNode): node is Program;\n    /**\n     * Checks if the given node is an ExpressionStatement node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is an ExpressionStatement node.\n     */\n    static isExpressionStatement(node: ExpressionNode): node is ExpressionStatement;\n    /**\n     * Checks if the given node is a CallExpression node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a CallExpression node.\n     */\n    static isCallExpression(node: ExpressionNode): node is CallExpression;\n    /**\n     * Checks if the given node is a StringLiteral node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a StringLiteral node.\n     */\n    static isStringLiteral(node: ExpressionNode): node is StringLiteral;\n    /**\n     * Checks if the given node is a NumericLiteral node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a NumericLiteral node.\n     */\n    static isNumericLiteral(node: ExpressionNode): node is NumericLiteral;\n    /**\n     * Checks if the given node is a BooleanLiteral node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a BooleanLiteral node.\n     */\n    static isBooleanLiteral(node: ExpressionNode): node is BooleanLiteral;\n    /**\n     * Checks if the given node is an Identifier node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is an Identifier node.\n     */\n    static isIdentifier(node: ExpressionNode): node is Identifier;\n    /**\n     * Checks if the given node is an ObjectExpression node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is an ObjectExpression node.\n     */\n    static isObjectExpression(node: ExpressionNode): node is ObjectExpression;\n    /**\n     * Checks if the given node is an ArrayExpression node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is an ArrayExpression node.\n     */\n    static isArrayExpression(node: ExpressionNode): node is ArrayExpression;\n    /**\n     * Checks if the given node is a PropertyAssignment node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a PropertyAssignment node.\n     */\n    static isPropertyAssignment(node: ExpressionNode): node is PropertyAssignment;\n    /**\n     * Checks if the given node is a MemberExpression node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a MemberExpression node.\n     */\n    static isMemberExpression(node: ExpressionNode): node is MemberExpression;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AAEgCa,uBAFFA,WAAAA,CAEEA;EAMLb,UAAAA,aAAAA,CAAAA,EAPGa,WAOHb,GAAAA,SAAAA;EAAyBA,WAAAA,CAAAA,aAAAA,CAAAA,EANpBa,WAMoBb,GAAAA,SAAAA;EAARc;;;AAOM;AAOlD;EAC6BF,SAAAA,OAAAA,CAAAA,IAAAA,EAfFZ,cAeEY,CAAAA,EAfeE,OAefF,CAfuBZ,cAevBY,GAAAA,OAAAA,CAAAA;EAKSA;;;;;;EAkBJZ,SAAAA,MAAAA,CAAAA,IAAAA,EA/BRA,cA+BQA,CAAAA,EA/BSc,OA+BTd,CAAAA,GAAAA,CAAAA;;;;;;;AAkByBM,cA1CtCS,SAAAA,CA0CsCT;EAM7BN,OAAAA,gBAAAA,EA/CDY,aA+CCZ;EAAyBO;;;;EAYKE,OAAAA,eAAAA,CAAAA,CAAAA,EAtD9BK,OAsD8BL,CAtDtBG,aAsDsBH,CAAAA;EAMtBT;;;;AAMuC;yBA5DlDA,yBAAyBC;;;;;;qCAMbD,yBAAyBE;;;;;;gCAM9BF,yBAAyBG;;;;;;+BAM1BH,yBAAyBI;;;;;;gCAMxBJ,yBAAyBK;;;;;;gCAMzBL,yBAAyBM;;;;;;4BAM7BN,yBAAyBO;;;;;;kCAMnBP,yBAAyBQ;;;;;;iCAM1BR,yBAAyBS;;;;;;oCAMtBT,yBAAyBU;;;;;;kCAM3BV,yBAAyBW"}
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"mappings":";;;;;AAqBA;;uBAAsB,WAAA;EAAA,UACE,aAAA,GAAc,WAAA;EAApC,WAAA,CAAsB,aAAA,GAAc,WAAA;EAOb;;;;;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"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":["ExpressionNode","Program","ExpressionStatement","CallExpression","StringLiteral","NumericLiteral","BooleanLiteral","Identifier","ObjectExpression","ArrayExpression","PropertyAssignment","MemberExpression","ParseFunction","NodeHandler","Promise","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/base.d.ts"],"sourcesContent":["import type { ExpressionNode, Program, ExpressionStatement, CallExpression, StringLiteral, NumericLiteral, BooleanLiteral, Identifier, ObjectExpression, ArrayExpression, PropertyAssignment, MemberExpression, ParseFunction } from \"../../types/expression-parser.js\";\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport declare abstract class NodeHandler {\n    protected parentHandler?: NodeHandler | undefined;\n    constructor(parentHandler?: NodeHandler | undefined);\n    /**\n     * Determines whether the given node is acceptable.\n     * @param node The node to be checked.\n     * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.\n     */\n    abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n    /**\n     * Handles the given node. The specifics of how the node is handled are\n     * determined by the subclass implementation.\n     * @param node The node to be handled.\n     * @returns A Promise that resolves to the result of handling the node.\n     */\n    abstract handle(node: ExpressionNode): Promise<any>;\n}\n/**\n * Utility class for parsing Abstract Syntax Trees (ASTs). Contains\n * methods for identifying the type of a given node and a method for\n * importing and generating a parser using the Peggy library.\n */\nexport declare class ASTParser {\n    static astParseInstance: ParseFunction;\n    /**\n     * Imports and generates a parser using the Peggy library.\n     * @returns A Promise that resolves to the parser instance.\n     */\n    static importASTParser(): Promise<ParseFunction>;\n    /**\n     * Checks if the given node is a Program node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a Program node.\n     */\n    static isProgram(node: ExpressionNode): node is Program;\n    /**\n     * Checks if the given node is an ExpressionStatement node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is an ExpressionStatement node.\n     */\n    static isExpressionStatement(node: ExpressionNode): node is ExpressionStatement;\n    /**\n     * Checks if the given node is a CallExpression node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a CallExpression node.\n     */\n    static isCallExpression(node: ExpressionNode): node is CallExpression;\n    /**\n     * Checks if the given node is a StringLiteral node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a StringLiteral node.\n     */\n    static isStringLiteral(node: ExpressionNode): node is StringLiteral;\n    /**\n     * Checks if the given node is a NumericLiteral node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a NumericLiteral node.\n     */\n    static isNumericLiteral(node: ExpressionNode): node is NumericLiteral;\n    /**\n     * Checks if the given node is a BooleanLiteral node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a BooleanLiteral node.\n     */\n    static isBooleanLiteral(node: ExpressionNode): node is BooleanLiteral;\n    /**\n     * Checks if the given node is an Identifier node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is an Identifier node.\n     */\n    static isIdentifier(node: ExpressionNode): node is Identifier;\n    /**\n     * Checks if the given node is an ObjectExpression node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is an ObjectExpression node.\n     */\n    static isObjectExpression(node: ExpressionNode): node is ObjectExpression;\n    /**\n     * Checks if the given node is an ArrayExpression node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is an ArrayExpression node.\n     */\n    static isArrayExpression(node: ExpressionNode): node is ArrayExpression;\n    /**\n     * Checks if the given node is a PropertyAssignment node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a PropertyAssignment node.\n     */\n    static isPropertyAssignment(node: ExpressionNode): node is PropertyAssignment;\n    /**\n     * Checks if the given node is a MemberExpression node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a MemberExpression node.\n     */\n    static isMemberExpression(node: ExpressionNode): node is MemberExpression;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AAEgCa,uBAFFA,WAAAA,CAEEA;EAMLb,UAAAA,aAAAA,CAAAA,EAPGa,WAOHb,GAAAA,SAAAA;EAAyBA,WAAAA,CAAAA,aAAAA,CAAAA,EANpBa,WAMoBb,GAAAA,SAAAA;EAARc;;;AAOM;AAOlD;EAC6BF,SAAAA,OAAAA,CAAAA,IAAAA,EAfFZ,cAeEY,CAAAA,EAfeE,OAefF,CAfuBZ,cAevBY,GAAAA,OAAAA,CAAAA;EAKSA;;;;;;EAkBJZ,SAAAA,MAAAA,CAAAA,IAAAA,EA/BRA,cA+BQA,CAAAA,EA/BSc,OA+BTd,CAAAA,GAAAA,CAAAA;;;;;;;AAkByBM,cA1CtCS,SAAAA,CA0CsCT;EAM7BN,OAAAA,gBAAAA,EA/CDY,aA+CCZ;EAAyBO;;;;EAYKE,OAAAA,eAAAA,CAAAA,CAAAA,EAtD9BK,OAsD8BL,CAtDtBG,aAsDsBH,CAAAA;EAMtBT;;;;AAMuC;yBA5DlDA,yBAAyBC;;;;;;qCAMbD,yBAAyBE;;;;;;gCAM9BF,yBAAyBG;;;;;;+BAM1BH,yBAAyBI;;;;;;gCAMxBJ,yBAAyBK;;;;;;gCAMzBL,yBAAyBM;;;;;;4BAM7BN,yBAAyBO;;;;;;kCAMnBP,yBAAyBQ;;;;;;iCAM1BR,yBAAyBS;;;;;;oCAMtBT,yBAAyBU;;;;;;kCAM3BV,yBAAyBW"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"mappings":";;;;;AAqBA;;uBAAsB,WAAA;EAAA,UACE,aAAA,GAAc,WAAA;EAApC,WAAA,CAAsB,aAAA,GAAc,WAAA;EAOb;;;;;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"}

package/dist/output_parsers/expression_type_handlers/base.js

@@ -25,8 +25,7 @@ var ASTParser = class ASTParser {
 		try {
 			if (!ASTParser.astParseInstance) {
 				const { default: peggy } = await import("peggy");
-				const parser = peggy.generate(GRAMMAR);
-				const { parse } = parser;
+				const { parse } = peggy.generate(GRAMMAR);
 				ASTParser.astParseInstance = parse;
 			}
 			return ASTParser.astParseInstance;

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

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

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

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

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

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

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

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

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

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

package/dist/output_parsers/expression_type_handlers/factory.cjs

@@ -42,10 +42,7 @@ var MasterHandler = class MasterHandler extends require_base.NodeHandler {
 	* @returns The result of the node handling, or throws an error if no handler can handle the node.
 	*/
 	async handle(node) {
-		for (const handler of this.nodeHandlers) {
-			const accepts = await handler.accepts(node);
-			if (accepts) return handler.handle(node);
-		}
+		for (const handler of this.nodeHandlers) if (await handler.accepts(node)) return handler.handle(node);
 		throw new Error(`No handler found for node: ${node}`);
 	}
 	/**

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

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

@@ -3,7 +3,6 @@ import { CallExpression, ExpressionNode } from "../../types/expression-parser.cj
 import { NodeHandler } from "./base.cjs";
 
 //#region src/output_parsers/expression_type_handlers/factory.d.ts
-
 /**
  * The MasterHandler class is responsible for managing a collection of
  * node handlers in the LangChain Expression Language. Each node handler

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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.cts","names":["NodeHandler","ParsedType","ExpressionNode","CallExpression","MasterHandler","Promise"],"sources":["../../../src/output_parsers/expression_type_handlers/factory.d.ts"],"sourcesContent":["import { NodeHandler } from \"./base.js\";\nimport { ParsedType } from \"./types.js\";\nimport type { ExpressionNode, CallExpression } from \"../../types/expression-parser.js\";\n/**\n * The MasterHandler class is responsible for managing a collection of\n * node handlers in the LangChain Expression Language. Each node handler\n * is capable of handling a specific type of node in the expression\n * language. The MasterHandler class uses these node handlers to process\n * nodes in the expression language.\n */\nexport declare class MasterHandler extends NodeHandler {\n    nodeHandlers: NodeHandler[];\n    accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n    /**\n     * This method is responsible for handling a node. It iterates over the\n     * collection of node handlers and uses the first handler that accepts the\n     * node to handle it. If no handler accepts the node, the method throws an\n     * error.\n     * @param node The node to be handled.\n     * @returns The result of the node handling, or throws an error if no handler can handle the node.\n     */\n    handle(node: CallExpression): Promise<ParsedType>;\n    /**\n     * This static method creates an instance of the MasterHandler class and\n     * initializes it with instances of all the node handlers.\n     * @returns An instance of the MasterHandler class.\n     */\n    static createMasterHandler(): MasterHandler;\n}\n//# sourceMappingURL=factory.d.ts.map"],"mappings":";;;;;;;;AAUA;;;;;AAWiBG,cAXIC,aAAAA,SAAsBJ,WAAAA,CAW1BG;EAAyBF,YAAAA,EAVxBD,WAUwBC,EAAAA;EAARI,OAAAA,CAAAA,IAAAA,EAThBH,cASgBG,CAAAA,EATCA,OASDA,CATSH,cASTG,GAAAA,OAAAA,CAAAA;EAMAD;;AAjBoB;;;;;;eAWrCD,iBAAiBE,QAAQJ;;;;;;gCAMRG"}
+{"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"}

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

@@ -3,7 +3,6 @@ import { CallExpression, ExpressionNode } from "../../types/expression-parser.js
 import { NodeHandler } from "./base.js";
 
 //#region src/output_parsers/expression_type_handlers/factory.d.ts
-
 /**
  * The MasterHandler class is responsible for managing a collection of
  * node handlers in the LangChain Expression Language. Each node handler

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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","names":["NodeHandler","ParsedType","ExpressionNode","CallExpression","MasterHandler","Promise"],"sources":["../../../src/output_parsers/expression_type_handlers/factory.d.ts"],"sourcesContent":["import { NodeHandler } from \"./base.js\";\nimport { ParsedType } from \"./types.js\";\nimport type { ExpressionNode, CallExpression } from \"../../types/expression-parser.js\";\n/**\n * The MasterHandler class is responsible for managing a collection of\n * node handlers in the LangChain Expression Language. Each node handler\n * is capable of handling a specific type of node in the expression\n * language. The MasterHandler class uses these node handlers to process\n * nodes in the expression language.\n */\nexport declare class MasterHandler extends NodeHandler {\n    nodeHandlers: NodeHandler[];\n    accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n    /**\n     * This method is responsible for handling a node. It iterates over the\n     * collection of node handlers and uses the first handler that accepts the\n     * node to handle it. If no handler accepts the node, the method throws an\n     * error.\n     * @param node The node to be handled.\n     * @returns The result of the node handling, or throws an error if no handler can handle the node.\n     */\n    handle(node: CallExpression): Promise<ParsedType>;\n    /**\n     * This static method creates an instance of the MasterHandler class and\n     * initializes it with instances of all the node handlers.\n     * @returns An instance of the MasterHandler class.\n     */\n    static createMasterHandler(): MasterHandler;\n}\n//# sourceMappingURL=factory.d.ts.map"],"mappings":";;;;;;;;AAUA;;;;;AAWiBG,cAXIC,aAAAA,SAAsBJ,WAAAA,CAW1BG;EAAyBF,YAAAA,EAVxBD,WAUwBC,EAAAA;EAARI,OAAAA,CAAAA,IAAAA,EAThBH,cASgBG,CAAAA,EATCA,OASDA,CATSH,cASTG,GAAAA,OAAAA,CAAAA;EAMAD;;AAjBoB;;;;;;eAWrCD,iBAAiBE,QAAQJ;;;;;;gCAMRG"}
+{"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"}

package/dist/output_parsers/expression_type_handlers/factory.js

@@ -42,10 +42,7 @@ var MasterHandler = class MasterHandler extends NodeHandler {
 	* @returns The result of the node handling, or throws an error if no handler can handle the node.
 	*/
 	async handle(node) {
-		for (const handler of this.nodeHandlers) {
-			const accepts = await handler.accepts(node);
-			if (accepts) return handler.handle(node);
-		}
+		for (const handler of this.nodeHandlers) if (await handler.accepts(node)) return handler.handle(node);
 		throw new Error(`No handler found for node: ${node}`);
 	}
 	/**

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

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

package/dist/output_parsers/expression_type_handlers/grammar/parser_grammar.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parser_grammar.cjs","names":[],"sources":["../../../../src/output_parsers/expression_type_handlers/grammar/parser_grammar.ts"],"sourcesContent":["/**\n * Here's the main parser for our expression parser. It's a pared down\n * Javascript parser with a whole lot of rules removed, leaving only\n * rules for parsing literals (i.e. string literal,numeric literal,\n * boolean literal, array literal, object literal and null literal),\n * identifiers, and expressions (i.e. call expression, member expression,\n * array expression and object expression).\n *\n * For more information see:\n * https://peggyjs.org/documentation.html\n * https://github.com/peggyjs/peggy/blob/main/examples/javascript.pegjs\n */\n\nexport const GRAMMAR = `{{\n    var TYPES_TO_PROPERTY_NAMES = {\n      CallExpression:   \"callee\",\n      MemberExpression: \"object\",\n    };\n  \n    function extractOptional(optional, index) {\n      return optional ? optional[index] : null;\n    };\n  \n    function extractList(list, index) {\n      return list.map(function(element) { return element[index]; });\n    };\n  \n    function buildList(head, tail, index) {\n      return [head].concat(extractList(tail, index));\n    };\n  \n    function optionalList(value) {\n      return value !== null ? value : [];\n    };\n  }}\n  \n  Start\n    = __ program:Program __ { return program; };\n  \n  SourceCharacter\n    = .;\n  \n  WhiteSpace\n    = \"\\\\t\"\n    / \"\\\\v\"\n    / \"\\\\f\"\n    / \" \"\n    / \"\\\\u00A0\"\n    / \"\\\\uFEFF\";\n  \n  Identifier\n    = !ReservedWord name:IdentifierName { return name; };\n  \n  IdentifierName\n    = head:IdentifierStart tail:IdentifierPart* {\n        return {\n          type: \"Identifier\",\n          name: head + tail.join(\"\")\n        };\n      };\n  \n  IdentifierStart\n    = UnicodeLetter\n    / \"$\"\n    / \"_\";\n  \n  IdentifierPart\n    = IdentifierStart\n    / Nd\n    / \"\\\\u200C\"\n    / \"\\\\u200D\";\n  \n  UnicodeLetter\n    = Lu\n    / Ll;\n  \n  ReservedWord\n    = NullToken\n    / TrueToken\n    / FalseToken;\n  \n  Literal\n    = NullLiteral\n    / BooleanLiteral\n    / NumericLiteral\n    / StringLiteral;\n  \n  NullLiteral\n    = NullToken { return { type: \"NullLiteral\", value: null }; };\n  \n  BooleanLiteral\n    = TrueToken { return { type: \"BooleanLiteral\", value: true  }; }\n    / FalseToken { return { type: \"BooleanLiteral\", value: false }; };\n  \n  NumericLiteral\n    = literal:DecimalLiteral !(IdentifierStart / DecimalDigit) {\n        return literal;\n      };\n  \n  DecimalLiteral\n    = DecimalIntegerLiteral \".\" DecimalDigit* {\n        return { type: \"NumericLiteral\", value: parseFloat(text()) };\n      }\n    / \".\" DecimalDigit+ {\n        return { type: \"NumericLiteral\", value: parseFloat(text()) };\n      }\n    / DecimalIntegerLiteral {\n        return { type: \"NumericLiteral\", value: parseFloat(text()) };\n      };\n  \n  DecimalIntegerLiteral\n    = \"0\"\n    / NonZeroDigit DecimalDigit*;\n  \n  DecimalDigit\n    = [0-9];\n  \n  NonZeroDigit\n    = [1-9];\n  \n  StringLiteral\n    = '\"' chars:DoubleStringCharacter* '\"' {\n        return { type: \"StringLiteral\", value: chars.join(\"\") };\n      }\n    / \"'\" chars:SingleStringCharacter* \"'\" {\n        return { type: \"StringLiteral\", value: chars.join(\"\") };\n      };\n  \n  DoubleStringCharacter\n    = !('\"' / \"\\\\\\\\\") SourceCharacter { return text(); };\n  \n  SingleStringCharacter\n    = !(\"'\" / \"\\\\\\\\\") SourceCharacter { return text(); };\n  \n  SingleEscapeCharacter\n    = \"'\"\n    / '\"';\n  \n  Ll = [a-z];\n  Lu = [A-Z];\n  Nd = [0-9];\n  \n  FalseToken = \"false\" !IdentifierPart;\n  TrueToken = \"true\" !IdentifierPart;\n  NullToken = \"null\" !IdentifierPart;\n  \n  __ = WhiteSpace*;\n  \n  PrimaryExpression\n    = Identifier\n    / Literal\n    / ArrayExpression\n    / ObjectExpression\n    / \"(\" __ expression:Expression __ \")\" { return expression; };\n  \n  ArrayExpression\n    = \"[\" __ \"]\" { return { type: \"ArrayExpression\", elements: [] }; }\n    / \"[\" __ elements:ElementList __ \"]\" {\n        return {\n          type: \"ArrayExpression\",\n          elements: elements\n        };\n      };\n  \n  ElementList\n    = head:(\n        element:Expression {\n          return element;\n        }\n      )\n      tail:(\n        __ \",\" __ element:Expression {\n          return element;\n        }\n      )*\n      { return Array.prototype.concat.apply(head, tail); };\n  \n  ObjectExpression\n    = \"{\" __ \"}\" { return { type: \"ObjectExpression\", properties: [] }; }\n    / \"{\" __ properties:PropertyNameAndValueList __ \"}\" {\n         return { type: \"ObjectExpression\", properties: properties };\n       }\n    / \"{\" __ properties:PropertyNameAndValueList __ \",\" __ \"}\" {\n         return { type: \"ObjectExpression\", properties: properties };\n       };\n  PropertyNameAndValueList\n    = head:PropertyAssignment tail:(__ \",\" __ PropertyAssignment)* {\n        return buildList(head, tail, 3);\n      };\n  \n  PropertyAssignment\n    = key:PropertyName __ \":\" __ value:Expression {\n        return { type: \"PropertyAssignment\", key: key, value: value, kind: \"init\" };\n      };\n  \n  PropertyName\n    = IdentifierName\n    / StringLiteral\n    / NumericLiteral;\n  \n  Node\n    = ArrayExpression \n    / BooleanLiteral \n    / CallExpression \n    / Identifier \n    / MemberExpression \n    / NumericLiteral \n    / ObjectExpression \n    / PropertyAssignment \n    / StringLiteral\n  \n  MemberExpression\n    = head:(PrimaryExpression)\n      tail:(\n          __ \"[\" __ property:Expression __ \"]\" {\n            return { property: property, computed: true };\n          }\n        / __ \".\" __ property:IdentifierName {\n            return { property: property, computed: false };\n          }\n      )*\n      {\n        return tail.reduce(function(result, element) {\n          return {\n            type: \"MemberExpression\",\n            object: result,\n            property: element.property,\n            computed: element.computed\n          };\n        }, head);\n      };\n  \n  CallExpression\n    = head:(\n        callee:MemberExpression __ args:Arguments {\n          return { type: \"CallExpression\", callee: callee, arguments: args };\n        }\n      )\n      tail:(\n          __ args:Arguments {\n            return { type: \"CallExpression\", arguments: args };\n          }\n        / __ \"[\" __ property:Expression __ \"]\" {\n            return {\n              type: \"MemberExpression\",\n              property: property,\n              computed: true\n            };\n          }\n        / __ \".\" __ property:IdentifierName {\n            return {\n              type: \"MemberExpression\",\n              property: property,\n              computed: false\n            };\n          }\n      )*\n      {\n        return tail.reduce(function(result, element) {\n          element[TYPES_TO_PROPERTY_NAMES[element.type]] = result;\n  \n          return element;\n        }, head);\n      };\n  \n  Arguments\n    = \"(\" __ args:(ArgumentList __)? \")\" {\n        return optionalList(extractOptional(args, 0));\n      };\n  \n  ArgumentList\n    = head:Expression tail:(__ \",\" __ Expression)* {\n        return buildList(head, tail, 3);\n      };\n  \n  Expression\n    = CallExpression\n    / MemberExpression;\n  \n  ExpressionStatement\n    = expression:Expression {\n        return {\n          type: \"ExpressionStatement\",\n          expression: expression\n        };\n      };\n  \n  Program\n    = exp:ExpressionStatement {\n        return {\n          type: \"Program\",\n          body: exp\n        };\n      };`;\n"],"mappings":";;;;;;;;;;;;;;AAaA,MAAa,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwRhB,CAAC"}
+{"version":3,"file":"parser_grammar.cjs","names":[],"sources":["../../../../src/output_parsers/expression_type_handlers/grammar/parser_grammar.ts"],"sourcesContent":["/**\n * Here's the main parser for our expression parser. It's a pared down\n * Javascript parser with a whole lot of rules removed, leaving only\n * rules for parsing literals (i.e. string literal,numeric literal,\n * boolean literal, array literal, object literal and null literal),\n * identifiers, and expressions (i.e. call expression, member expression,\n * array expression and object expression).\n *\n * For more information see:\n * https://peggyjs.org/documentation.html\n * https://github.com/peggyjs/peggy/blob/main/examples/javascript.pegjs\n */\n\nexport const GRAMMAR = `{{\n    var TYPES_TO_PROPERTY_NAMES = {\n      CallExpression:   \"callee\",\n      MemberExpression: \"object\",\n    };\n  \n    function extractOptional(optional, index) {\n      return optional ? optional[index] : null;\n    };\n  \n    function extractList(list, index) {\n      return list.map(function(element) { return element[index]; });\n    };\n  \n    function buildList(head, tail, index) {\n      return [head].concat(extractList(tail, index));\n    };\n  \n    function optionalList(value) {\n      return value !== null ? value : [];\n    };\n  }}\n  \n  Start\n    = __ program:Program __ { return program; };\n  \n  SourceCharacter\n    = .;\n  \n  WhiteSpace\n    = \"\\\\t\"\n    / \"\\\\v\"\n    / \"\\\\f\"\n    / \" \"\n    / \"\\\\u00A0\"\n    / \"\\\\uFEFF\";\n  \n  Identifier\n    = !ReservedWord name:IdentifierName { return name; };\n  \n  IdentifierName\n    = head:IdentifierStart tail:IdentifierPart* {\n        return {\n          type: \"Identifier\",\n          name: head + tail.join(\"\")\n        };\n      };\n  \n  IdentifierStart\n    = UnicodeLetter\n    / \"$\"\n    / \"_\";\n  \n  IdentifierPart\n    = IdentifierStart\n    / Nd\n    / \"\\\\u200C\"\n    / \"\\\\u200D\";\n  \n  UnicodeLetter\n    = Lu\n    / Ll;\n  \n  ReservedWord\n    = NullToken\n    / TrueToken\n    / FalseToken;\n  \n  Literal\n    = NullLiteral\n    / BooleanLiteral\n    / NumericLiteral\n    / StringLiteral;\n  \n  NullLiteral\n    = NullToken { return { type: \"NullLiteral\", value: null }; };\n  \n  BooleanLiteral\n    = TrueToken { return { type: \"BooleanLiteral\", value: true  }; }\n    / FalseToken { return { type: \"BooleanLiteral\", value: false }; };\n  \n  NumericLiteral\n    = literal:DecimalLiteral !(IdentifierStart / DecimalDigit) {\n        return literal;\n      };\n  \n  DecimalLiteral\n    = DecimalIntegerLiteral \".\" DecimalDigit* {\n        return { type: \"NumericLiteral\", value: parseFloat(text()) };\n      }\n    / \".\" DecimalDigit+ {\n        return { type: \"NumericLiteral\", value: parseFloat(text()) };\n      }\n    / DecimalIntegerLiteral {\n        return { type: \"NumericLiteral\", value: parseFloat(text()) };\n      };\n  \n  DecimalIntegerLiteral\n    = \"0\"\n    / NonZeroDigit DecimalDigit*;\n  \n  DecimalDigit\n    = [0-9];\n  \n  NonZeroDigit\n    = [1-9];\n  \n  StringLiteral\n    = '\"' chars:DoubleStringCharacter* '\"' {\n        return { type: \"StringLiteral\", value: chars.join(\"\") };\n      }\n    / \"'\" chars:SingleStringCharacter* \"'\" {\n        return { type: \"StringLiteral\", value: chars.join(\"\") };\n      };\n  \n  DoubleStringCharacter\n    = !('\"' / \"\\\\\\\\\") SourceCharacter { return text(); };\n  \n  SingleStringCharacter\n    = !(\"'\" / \"\\\\\\\\\") SourceCharacter { return text(); };\n  \n  SingleEscapeCharacter\n    = \"'\"\n    / '\"';\n  \n  Ll = [a-z];\n  Lu = [A-Z];\n  Nd = [0-9];\n  \n  FalseToken = \"false\" !IdentifierPart;\n  TrueToken = \"true\" !IdentifierPart;\n  NullToken = \"null\" !IdentifierPart;\n  \n  __ = WhiteSpace*;\n  \n  PrimaryExpression\n    = Identifier\n    / Literal\n    / ArrayExpression\n    / ObjectExpression\n    / \"(\" __ expression:Expression __ \")\" { return expression; };\n  \n  ArrayExpression\n    = \"[\" __ \"]\" { return { type: \"ArrayExpression\", elements: [] }; }\n    / \"[\" __ elements:ElementList __ \"]\" {\n        return {\n          type: \"ArrayExpression\",\n          elements: elements\n        };\n      };\n  \n  ElementList\n    = head:(\n        element:Expression {\n          return element;\n        }\n      )\n      tail:(\n        __ \",\" __ element:Expression {\n          return element;\n        }\n      )*\n      { return Array.prototype.concat.apply(head, tail); };\n  \n  ObjectExpression\n    = \"{\" __ \"}\" { return { type: \"ObjectExpression\", properties: [] }; }\n    / \"{\" __ properties:PropertyNameAndValueList __ \"}\" {\n         return { type: \"ObjectExpression\", properties: properties };\n       }\n    / \"{\" __ properties:PropertyNameAndValueList __ \",\" __ \"}\" {\n         return { type: \"ObjectExpression\", properties: properties };\n       };\n  PropertyNameAndValueList\n    = head:PropertyAssignment tail:(__ \",\" __ PropertyAssignment)* {\n        return buildList(head, tail, 3);\n      };\n  \n  PropertyAssignment\n    = key:PropertyName __ \":\" __ value:Expression {\n        return { type: \"PropertyAssignment\", key: key, value: value, kind: \"init\" };\n      };\n  \n  PropertyName\n    = IdentifierName\n    / StringLiteral\n    / NumericLiteral;\n  \n  Node\n    = ArrayExpression \n    / BooleanLiteral \n    / CallExpression \n    / Identifier \n    / MemberExpression \n    / NumericLiteral \n    / ObjectExpression \n    / PropertyAssignment \n    / StringLiteral\n  \n  MemberExpression\n    = head:(PrimaryExpression)\n      tail:(\n          __ \"[\" __ property:Expression __ \"]\" {\n            return { property: property, computed: true };\n          }\n        / __ \".\" __ property:IdentifierName {\n            return { property: property, computed: false };\n          }\n      )*\n      {\n        return tail.reduce(function(result, element) {\n          return {\n            type: \"MemberExpression\",\n            object: result,\n            property: element.property,\n            computed: element.computed\n          };\n        }, head);\n      };\n  \n  CallExpression\n    = head:(\n        callee:MemberExpression __ args:Arguments {\n          return { type: \"CallExpression\", callee: callee, arguments: args };\n        }\n      )\n      tail:(\n          __ args:Arguments {\n            return { type: \"CallExpression\", arguments: args };\n          }\n        / __ \"[\" __ property:Expression __ \"]\" {\n            return {\n              type: \"MemberExpression\",\n              property: property,\n              computed: true\n            };\n          }\n        / __ \".\" __ property:IdentifierName {\n            return {\n              type: \"MemberExpression\",\n              property: property,\n              computed: false\n            };\n          }\n      )*\n      {\n        return tail.reduce(function(result, element) {\n          element[TYPES_TO_PROPERTY_NAMES[element.type]] = result;\n  \n          return element;\n        }, head);\n      };\n  \n  Arguments\n    = \"(\" __ args:(ArgumentList __)? \")\" {\n        return optionalList(extractOptional(args, 0));\n      };\n  \n  ArgumentList\n    = head:Expression tail:(__ \",\" __ Expression)* {\n        return buildList(head, tail, 3);\n      };\n  \n  Expression\n    = CallExpression\n    / MemberExpression;\n  \n  ExpressionStatement\n    = expression:Expression {\n        return {\n          type: \"ExpressionStatement\",\n          expression: expression\n        };\n      };\n  \n  Program\n    = exp:ExpressionStatement {\n        return {\n          type: \"Program\",\n          body: exp\n        };\n      };`;\n"],"mappings":";;;;;;;;;;;;;;AAaA,MAAa,UAAU"}

package/dist/output_parsers/expression_type_handlers/grammar/parser_grammar.js.map

@@ -1 +1 @@
-{"version":3,"file":"parser_grammar.js","names":[],"sources":["../../../../src/output_parsers/expression_type_handlers/grammar/parser_grammar.ts"],"sourcesContent":["/**\n * Here's the main parser for our expression parser. It's a pared down\n * Javascript parser with a whole lot of rules removed, leaving only\n * rules for parsing literals (i.e. string literal,numeric literal,\n * boolean literal, array literal, object literal and null literal),\n * identifiers, and expressions (i.e. call expression, member expression,\n * array expression and object expression).\n *\n * For more information see:\n * https://peggyjs.org/documentation.html\n * https://github.com/peggyjs/peggy/blob/main/examples/javascript.pegjs\n */\n\nexport const GRAMMAR = `{{\n    var TYPES_TO_PROPERTY_NAMES = {\n      CallExpression:   \"callee\",\n      MemberExpression: \"object\",\n    };\n  \n    function extractOptional(optional, index) {\n      return optional ? optional[index] : null;\n    };\n  \n    function extractList(list, index) {\n      return list.map(function(element) { return element[index]; });\n    };\n  \n    function buildList(head, tail, index) {\n      return [head].concat(extractList(tail, index));\n    };\n  \n    function optionalList(value) {\n      return value !== null ? value : [];\n    };\n  }}\n  \n  Start\n    = __ program:Program __ { return program; };\n  \n  SourceCharacter\n    = .;\n  \n  WhiteSpace\n    = \"\\\\t\"\n    / \"\\\\v\"\n    / \"\\\\f\"\n    / \" \"\n    / \"\\\\u00A0\"\n    / \"\\\\uFEFF\";\n  \n  Identifier\n    = !ReservedWord name:IdentifierName { return name; };\n  \n  IdentifierName\n    = head:IdentifierStart tail:IdentifierPart* {\n        return {\n          type: \"Identifier\",\n          name: head + tail.join(\"\")\n        };\n      };\n  \n  IdentifierStart\n    = UnicodeLetter\n    / \"$\"\n    / \"_\";\n  \n  IdentifierPart\n    = IdentifierStart\n    / Nd\n    / \"\\\\u200C\"\n    / \"\\\\u200D\";\n  \n  UnicodeLetter\n    = Lu\n    / Ll;\n  \n  ReservedWord\n    = NullToken\n    / TrueToken\n    / FalseToken;\n  \n  Literal\n    = NullLiteral\n    / BooleanLiteral\n    / NumericLiteral\n    / StringLiteral;\n  \n  NullLiteral\n    = NullToken { return { type: \"NullLiteral\", value: null }; };\n  \n  BooleanLiteral\n    = TrueToken { return { type: \"BooleanLiteral\", value: true  }; }\n    / FalseToken { return { type: \"BooleanLiteral\", value: false }; };\n  \n  NumericLiteral\n    = literal:DecimalLiteral !(IdentifierStart / DecimalDigit) {\n        return literal;\n      };\n  \n  DecimalLiteral\n    = DecimalIntegerLiteral \".\" DecimalDigit* {\n        return { type: \"NumericLiteral\", value: parseFloat(text()) };\n      }\n    / \".\" DecimalDigit+ {\n        return { type: \"NumericLiteral\", value: parseFloat(text()) };\n      }\n    / DecimalIntegerLiteral {\n        return { type: \"NumericLiteral\", value: parseFloat(text()) };\n      };\n  \n  DecimalIntegerLiteral\n    = \"0\"\n    / NonZeroDigit DecimalDigit*;\n  \n  DecimalDigit\n    = [0-9];\n  \n  NonZeroDigit\n    = [1-9];\n  \n  StringLiteral\n    = '\"' chars:DoubleStringCharacter* '\"' {\n        return { type: \"StringLiteral\", value: chars.join(\"\") };\n      }\n    / \"'\" chars:SingleStringCharacter* \"'\" {\n        return { type: \"StringLiteral\", value: chars.join(\"\") };\n      };\n  \n  DoubleStringCharacter\n    = !('\"' / \"\\\\\\\\\") SourceCharacter { return text(); };\n  \n  SingleStringCharacter\n    = !(\"'\" / \"\\\\\\\\\") SourceCharacter { return text(); };\n  \n  SingleEscapeCharacter\n    = \"'\"\n    / '\"';\n  \n  Ll = [a-z];\n  Lu = [A-Z];\n  Nd = [0-9];\n  \n  FalseToken = \"false\" !IdentifierPart;\n  TrueToken = \"true\" !IdentifierPart;\n  NullToken = \"null\" !IdentifierPart;\n  \n  __ = WhiteSpace*;\n  \n  PrimaryExpression\n    = Identifier\n    / Literal\n    / ArrayExpression\n    / ObjectExpression\n    / \"(\" __ expression:Expression __ \")\" { return expression; };\n  \n  ArrayExpression\n    = \"[\" __ \"]\" { return { type: \"ArrayExpression\", elements: [] }; }\n    / \"[\" __ elements:ElementList __ \"]\" {\n        return {\n          type: \"ArrayExpression\",\n          elements: elements\n        };\n      };\n  \n  ElementList\n    = head:(\n        element:Expression {\n          return element;\n        }\n      )\n      tail:(\n        __ \",\" __ element:Expression {\n          return element;\n        }\n      )*\n      { return Array.prototype.concat.apply(head, tail); };\n  \n  ObjectExpression\n    = \"{\" __ \"}\" { return { type: \"ObjectExpression\", properties: [] }; }\n    / \"{\" __ properties:PropertyNameAndValueList __ \"}\" {\n         return { type: \"ObjectExpression\", properties: properties };\n       }\n    / \"{\" __ properties:PropertyNameAndValueList __ \",\" __ \"}\" {\n         return { type: \"ObjectExpression\", properties: properties };\n       };\n  PropertyNameAndValueList\n    = head:PropertyAssignment tail:(__ \",\" __ PropertyAssignment)* {\n        return buildList(head, tail, 3);\n      };\n  \n  PropertyAssignment\n    = key:PropertyName __ \":\" __ value:Expression {\n        return { type: \"PropertyAssignment\", key: key, value: value, kind: \"init\" };\n      };\n  \n  PropertyName\n    = IdentifierName\n    / StringLiteral\n    / NumericLiteral;\n  \n  Node\n    = ArrayExpression \n    / BooleanLiteral \n    / CallExpression \n    / Identifier \n    / MemberExpression \n    / NumericLiteral \n    / ObjectExpression \n    / PropertyAssignment \n    / StringLiteral\n  \n  MemberExpression\n    = head:(PrimaryExpression)\n      tail:(\n          __ \"[\" __ property:Expression __ \"]\" {\n            return { property: property, computed: true };\n          }\n        / __ \".\" __ property:IdentifierName {\n            return { property: property, computed: false };\n          }\n      )*\n      {\n        return tail.reduce(function(result, element) {\n          return {\n            type: \"MemberExpression\",\n            object: result,\n            property: element.property,\n            computed: element.computed\n          };\n        }, head);\n      };\n  \n  CallExpression\n    = head:(\n        callee:MemberExpression __ args:Arguments {\n          return { type: \"CallExpression\", callee: callee, arguments: args };\n        }\n      )\n      tail:(\n          __ args:Arguments {\n            return { type: \"CallExpression\", arguments: args };\n          }\n        / __ \"[\" __ property:Expression __ \"]\" {\n            return {\n              type: \"MemberExpression\",\n              property: property,\n              computed: true\n            };\n          }\n        / __ \".\" __ property:IdentifierName {\n            return {\n              type: \"MemberExpression\",\n              property: property,\n              computed: false\n            };\n          }\n      )*\n      {\n        return tail.reduce(function(result, element) {\n          element[TYPES_TO_PROPERTY_NAMES[element.type]] = result;\n  \n          return element;\n        }, head);\n      };\n  \n  Arguments\n    = \"(\" __ args:(ArgumentList __)? \")\" {\n        return optionalList(extractOptional(args, 0));\n      };\n  \n  ArgumentList\n    = head:Expression tail:(__ \",\" __ Expression)* {\n        return buildList(head, tail, 3);\n      };\n  \n  Expression\n    = CallExpression\n    / MemberExpression;\n  \n  ExpressionStatement\n    = expression:Expression {\n        return {\n          type: \"ExpressionStatement\",\n          expression: expression\n        };\n      };\n  \n  Program\n    = exp:ExpressionStatement {\n        return {\n          type: \"Program\",\n          body: exp\n        };\n      };`;\n"],"mappings":";;;;;;;;;;;;;AAaA,MAAa,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwRhB,CAAC"}
+{"version":3,"file":"parser_grammar.js","names":[],"sources":["../../../../src/output_parsers/expression_type_handlers/grammar/parser_grammar.ts"],"sourcesContent":["/**\n * Here's the main parser for our expression parser. It's a pared down\n * Javascript parser with a whole lot of rules removed, leaving only\n * rules for parsing literals (i.e. string literal,numeric literal,\n * boolean literal, array literal, object literal and null literal),\n * identifiers, and expressions (i.e. call expression, member expression,\n * array expression and object expression).\n *\n * For more information see:\n * https://peggyjs.org/documentation.html\n * https://github.com/peggyjs/peggy/blob/main/examples/javascript.pegjs\n */\n\nexport const GRAMMAR = `{{\n    var TYPES_TO_PROPERTY_NAMES = {\n      CallExpression:   \"callee\",\n      MemberExpression: \"object\",\n    };\n  \n    function extractOptional(optional, index) {\n      return optional ? optional[index] : null;\n    };\n  \n    function extractList(list, index) {\n      return list.map(function(element) { return element[index]; });\n    };\n  \n    function buildList(head, tail, index) {\n      return [head].concat(extractList(tail, index));\n    };\n  \n    function optionalList(value) {\n      return value !== null ? value : [];\n    };\n  }}\n  \n  Start\n    = __ program:Program __ { return program; };\n  \n  SourceCharacter\n    = .;\n  \n  WhiteSpace\n    = \"\\\\t\"\n    / \"\\\\v\"\n    / \"\\\\f\"\n    / \" \"\n    / \"\\\\u00A0\"\n    / \"\\\\uFEFF\";\n  \n  Identifier\n    = !ReservedWord name:IdentifierName { return name; };\n  \n  IdentifierName\n    = head:IdentifierStart tail:IdentifierPart* {\n        return {\n          type: \"Identifier\",\n          name: head + tail.join(\"\")\n        };\n      };\n  \n  IdentifierStart\n    = UnicodeLetter\n    / \"$\"\n    / \"_\";\n  \n  IdentifierPart\n    = IdentifierStart\n    / Nd\n    / \"\\\\u200C\"\n    / \"\\\\u200D\";\n  \n  UnicodeLetter\n    = Lu\n    / Ll;\n  \n  ReservedWord\n    = NullToken\n    / TrueToken\n    / FalseToken;\n  \n  Literal\n    = NullLiteral\n    / BooleanLiteral\n    / NumericLiteral\n    / StringLiteral;\n  \n  NullLiteral\n    = NullToken { return { type: \"NullLiteral\", value: null }; };\n  \n  BooleanLiteral\n    = TrueToken { return { type: \"BooleanLiteral\", value: true  }; }\n    / FalseToken { return { type: \"BooleanLiteral\", value: false }; };\n  \n  NumericLiteral\n    = literal:DecimalLiteral !(IdentifierStart / DecimalDigit) {\n        return literal;\n      };\n  \n  DecimalLiteral\n    = DecimalIntegerLiteral \".\" DecimalDigit* {\n        return { type: \"NumericLiteral\", value: parseFloat(text()) };\n      }\n    / \".\" DecimalDigit+ {\n        return { type: \"NumericLiteral\", value: parseFloat(text()) };\n      }\n    / DecimalIntegerLiteral {\n        return { type: \"NumericLiteral\", value: parseFloat(text()) };\n      };\n  \n  DecimalIntegerLiteral\n    = \"0\"\n    / NonZeroDigit DecimalDigit*;\n  \n  DecimalDigit\n    = [0-9];\n  \n  NonZeroDigit\n    = [1-9];\n  \n  StringLiteral\n    = '\"' chars:DoubleStringCharacter* '\"' {\n        return { type: \"StringLiteral\", value: chars.join(\"\") };\n      }\n    / \"'\" chars:SingleStringCharacter* \"'\" {\n        return { type: \"StringLiteral\", value: chars.join(\"\") };\n      };\n  \n  DoubleStringCharacter\n    = !('\"' / \"\\\\\\\\\") SourceCharacter { return text(); };\n  \n  SingleStringCharacter\n    = !(\"'\" / \"\\\\\\\\\") SourceCharacter { return text(); };\n  \n  SingleEscapeCharacter\n    = \"'\"\n    / '\"';\n  \n  Ll = [a-z];\n  Lu = [A-Z];\n  Nd = [0-9];\n  \n  FalseToken = \"false\" !IdentifierPart;\n  TrueToken = \"true\" !IdentifierPart;\n  NullToken = \"null\" !IdentifierPart;\n  \n  __ = WhiteSpace*;\n  \n  PrimaryExpression\n    = Identifier\n    / Literal\n    / ArrayExpression\n    / ObjectExpression\n    / \"(\" __ expression:Expression __ \")\" { return expression; };\n  \n  ArrayExpression\n    = \"[\" __ \"]\" { return { type: \"ArrayExpression\", elements: [] }; }\n    / \"[\" __ elements:ElementList __ \"]\" {\n        return {\n          type: \"ArrayExpression\",\n          elements: elements\n        };\n      };\n  \n  ElementList\n    = head:(\n        element:Expression {\n          return element;\n        }\n      )\n      tail:(\n        __ \",\" __ element:Expression {\n          return element;\n        }\n      )*\n      { return Array.prototype.concat.apply(head, tail); };\n  \n  ObjectExpression\n    = \"{\" __ \"}\" { return { type: \"ObjectExpression\", properties: [] }; }\n    / \"{\" __ properties:PropertyNameAndValueList __ \"}\" {\n         return { type: \"ObjectExpression\", properties: properties };\n       }\n    / \"{\" __ properties:PropertyNameAndValueList __ \",\" __ \"}\" {\n         return { type: \"ObjectExpression\", properties: properties };\n       };\n  PropertyNameAndValueList\n    = head:PropertyAssignment tail:(__ \",\" __ PropertyAssignment)* {\n        return buildList(head, tail, 3);\n      };\n  \n  PropertyAssignment\n    = key:PropertyName __ \":\" __ value:Expression {\n        return { type: \"PropertyAssignment\", key: key, value: value, kind: \"init\" };\n      };\n  \n  PropertyName\n    = IdentifierName\n    / StringLiteral\n    / NumericLiteral;\n  \n  Node\n    = ArrayExpression \n    / BooleanLiteral \n    / CallExpression \n    / Identifier \n    / MemberExpression \n    / NumericLiteral \n    / ObjectExpression \n    / PropertyAssignment \n    / StringLiteral\n  \n  MemberExpression\n    = head:(PrimaryExpression)\n      tail:(\n          __ \"[\" __ property:Expression __ \"]\" {\n            return { property: property, computed: true };\n          }\n        / __ \".\" __ property:IdentifierName {\n            return { property: property, computed: false };\n          }\n      )*\n      {\n        return tail.reduce(function(result, element) {\n          return {\n            type: \"MemberExpression\",\n            object: result,\n            property: element.property,\n            computed: element.computed\n          };\n        }, head);\n      };\n  \n  CallExpression\n    = head:(\n        callee:MemberExpression __ args:Arguments {\n          return { type: \"CallExpression\", callee: callee, arguments: args };\n        }\n      )\n      tail:(\n          __ args:Arguments {\n            return { type: \"CallExpression\", arguments: args };\n          }\n        / __ \"[\" __ property:Expression __ \"]\" {\n            return {\n              type: \"MemberExpression\",\n              property: property,\n              computed: true\n            };\n          }\n        / __ \".\" __ property:IdentifierName {\n            return {\n              type: \"MemberExpression\",\n              property: property,\n              computed: false\n            };\n          }\n      )*\n      {\n        return tail.reduce(function(result, element) {\n          element[TYPES_TO_PROPERTY_NAMES[element.type]] = result;\n  \n          return element;\n        }, head);\n      };\n  \n  Arguments\n    = \"(\" __ args:(ArgumentList __)? \")\" {\n        return optionalList(extractOptional(args, 0));\n      };\n  \n  ArgumentList\n    = head:Expression tail:(__ \",\" __ Expression)* {\n        return buildList(head, tail, 3);\n      };\n  \n  Expression\n    = CallExpression\n    / MemberExpression;\n  \n  ExpressionStatement\n    = expression:Expression {\n        return {\n          type: \"ExpressionStatement\",\n          expression: expression\n        };\n      };\n  \n  Program\n    = exp:ExpressionStatement {\n        return {\n          type: \"Program\",\n          body: exp\n        };\n      };`;\n"],"mappings":";;;;;;;;;;;;;AAaA,MAAa,UAAU"}

package/dist/output_parsers/expression_type_handlers/identifier_handler.cjs

@@ -27,10 +27,9 @@ var IdentifierHandler = class extends require_base.NodeHandler {
 	*/
 	async handle(node) {
 		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		const text = node.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
 		return {
 			type: "identifier",
-			value: text
+			value: node.name.replace(/^["'](.+(?=["']$))["']$/, "$1")
 		};
 	}
 };

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

@@ -1 +1 @@
-{"version":3,"file":"identifier_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: Identifier"],"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,yBAAY;;;;;;;CAOjD,MAAM,QAAQC,MAAqD;AACjE,MAAIC,uBAAU,aAAa,KAAK,CAC9B,QAAO;MAEP,QAAO;CAEV;;;;;;;;;;CAWD,MAAM,OAAOC,MAA2C;AACtD,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAM,OAAO,KAAK,KAAK,QAAQ,2BAA2B,KAAK;AAC/D,SAAO;GAAE,MAAM;GAAc,OAAO;EAAM;CAC3C;AACF"}
+{"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,yBAAY;;;;;;;CAOjD,MAAM,QAAQ,MAAqD;AACjE,MAAIC,uBAAU,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,KAAK;GACrB"}

package/dist/output_parsers/expression_type_handlers/identifier_handler.js

@@ -27,10 +27,9 @@ var IdentifierHandler = class extends NodeHandler {
 	*/
 	async handle(node) {
 		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		const text = node.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
 		return {
 			type: "identifier",
-			value: text
+			value: node.name.replace(/^["'](.+(?=["']$))["']$/, "$1")
 		};
 	}
 };