@langchain/classic 1.0.0-alpha.1

package/dist/output_parsers/datetime.d.ts

@@ -0,0 +1,33 @@
+import { BaseOutputParser } from "@langchain/core/output_parsers";
+
+//#region src/output_parsers/datetime.d.ts
+
+/**
+ * Class to parse the output of an LLM call to a date.
+ * @augments BaseOutputParser
+ */
+declare class DatetimeOutputParser extends BaseOutputParser<Date> {
+  static lc_name(): string;
+  lc_namespace: string[];
+  lc_serializable: boolean;
+  /**
+   * ISO 8601 date time standard.
+   */
+  format: string;
+  /**
+   * Parses the given text into a Date.
+   * If the parsing fails, throws an OutputParserException.
+   * @param text The text to parse.
+   * @returns A date object.
+   */
+  parse(text: string): Promise<Date>;
+  /**
+   * Provides instructions on the expected format of the response for the
+   * CommaSeparatedListOutputParser.
+   * @returns A string containing instructions on the expected format of the response.
+   */
+  getFormatInstructions(): string;
+}
+//#endregion
+export { DatetimeOutputParser };
+//# sourceMappingURL=datetime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"datetime.d.ts","names":["BaseOutputParser","DatetimeOutputParser","Date","Promise"],"sources":["../../src/output_parsers/datetime.d.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\n/**\n * Class to parse the output of an LLM call to a date.\n * @augments BaseOutputParser\n */\nexport declare class DatetimeOutputParser extends BaseOutputParser<Date> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /**\n     * ISO 8601 date time standard.\n     */\n    format: string;\n    /**\n     * Parses the given text into a Date.\n     * If the parsing fails, throws an OutputParserException.\n     * @param text The text to parse.\n     * @returns A date object.\n     */\n    parse(text: string): Promise<Date>;\n    /**\n     * Provides instructions on the expected format of the response for the\n     * CommaSeparatedListOutputParser.\n     * @returns A string containing instructions on the expected format of the response.\n     */\n    getFormatInstructions(): string;\n}\n"],"mappings":";;;;;;AAKA;;AAAmEE,cAA9CD,oBAAAA,SAA6BD,gBAAiBE,CAAAA,IAAAA,CAAAA,CAAAA;EAAI,OActCA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAI,YAAZC,EAAAA,MAAAA,EAAAA;EAAO,eAdkBH,EAAAA,OAAAA;EAAgB;;;;;;;;;;uBAczCG,QAAQD"}

package/dist/output_parsers/datetime.js

@@ -0,0 +1,45 @@
+import { BaseOutputParser, OutputParserException } from "@langchain/core/output_parsers";
+
+//#region src/output_parsers/datetime.ts
+/**
+* Class to parse the output of an LLM call to a date.
+* @augments BaseOutputParser
+*/
+var DatetimeOutputParser = class extends BaseOutputParser {
+	static lc_name() {
+		return "DatetimeOutputParser";
+	}
+	lc_namespace = ["langchain", "output_parsers"];
+	lc_serializable = true;
+	/**
+	* ISO 8601 date time standard.
+	*/
+	format = "YYYY-MM-DDTHH:mm:ssZ";
+	/**
+	* Parses the given text into a Date.
+	* If the parsing fails, throws an OutputParserException.
+	* @param text The text to parse.
+	* @returns A date object.
+	*/
+	async parse(text) {
+		const parsedDate = new Date(text.trim());
+		if (Number.isNaN(parsedDate.getTime())) throw new OutputParserException(`Could not parse output: ${text}`, text);
+		return parsedDate;
+	}
+	/**
+	* Provides instructions on the expected format of the response for the
+	* CommaSeparatedListOutputParser.
+	* @returns A string containing instructions on the expected format of the response.
+	*/
+	getFormatInstructions() {
+		return [
+			`Your response should be a datetime string that matches the following pattern: "${this.format}".`,
+			`Examples: 2011-10-05T14:48:00Z, 2019-01-01T00:00:00Z, 1932-04-21T04:42:23Z`,
+			`Return ONLY this string, no other words!`
+		].join("\n\n");
+	}
+};
+
+//#endregion
+export { DatetimeOutputParser };
+//# sourceMappingURL=datetime.js.map

package/dist/output_parsers/datetime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datetime.js","names":["text: string"],"sources":["../../src/output_parsers/datetime.ts"],"sourcesContent":["import {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\n\n/**\n * Class to parse the output of an LLM call to a date.\n * @augments BaseOutputParser\n */\nexport class DatetimeOutputParser extends BaseOutputParser<Date> {\n  static lc_name() {\n    return \"DatetimeOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\"];\n\n  lc_serializable = true;\n\n  /**\n   * ISO 8601 date time standard.\n   */\n  format = \"YYYY-MM-DDTHH:mm:ssZ\";\n\n  /**\n   * Parses the given text into a Date.\n   * If the parsing fails, throws an OutputParserException.\n   * @param text The text to parse.\n   * @returns A date object.\n   */\n  async parse(text: string): Promise<Date> {\n    const parsedDate = new Date(text.trim());\n    if (Number.isNaN(parsedDate.getTime())) {\n      throw new OutputParserException(`Could not parse output: ${text}`, text);\n    }\n    return parsedDate;\n  }\n\n  /**\n   * Provides instructions on the expected format of the response for the\n   * CommaSeparatedListOutputParser.\n   * @returns A string containing instructions on the expected format of the response.\n   */\n  getFormatInstructions(): string {\n    return [\n      `Your response should be a datetime string that matches the following pattern: \"${this.format}\".`,\n      `Examples: 2011-10-05T14:48:00Z, 2019-01-01T00:00:00Z, 1932-04-21T04:42:23Z`,\n      `Return ONLY this string, no other words!`,\n    ].join(\"\\n\\n\");\n  }\n}\n"],"mappings":";;;;;;;AASA,IAAa,uBAAb,cAA0C,iBAAuB;CAC/D,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe,CAAC,aAAa,gBAAiB;CAE9C,kBAAkB;;;;CAKlB,SAAS;;;;;;;CAQT,MAAM,MAAMA,MAA6B;EACvC,MAAM,aAAa,IAAI,KAAK,KAAK,MAAM;AACvC,MAAI,OAAO,MAAM,WAAW,SAAS,CAAC,CACpC,OAAM,IAAI,sBAAsB,CAAC,wBAAwB,EAAE,MAAM,EAAE;AAErE,SAAO;CACR;;;;;;CAOD,wBAAgC;AAC9B,SAAO;GACL,CAAC,+EAA+E,EAAE,KAAK,OAAO,EAAE,CAAC;GACjG,CAAC,0EAA0E,CAAC;GAC5E,CAAC,wCAAwC,CAAC;EAC3C,EAAC,KAAK,OAAO;CACf;AACF"}

package/dist/output_parsers/expression.cjs

@@ -0,0 +1,86 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_base = require('./expression_type_handlers/base.cjs');
+const require_factory = require('./expression_type_handlers/factory.cjs');
+const __langchain_core_output_parsers = require_rolldown_runtime.__toESM(require("@langchain/core/output_parsers"));
+
+//#region src/output_parsers/expression.ts
+var expression_exports = {};
+require_rolldown_runtime.__export(expression_exports, {
+	ExpressionParser: () => ExpressionParser,
+	MasterHandler: () => require_factory.MasterHandler
+});
+/**
+* We need to be able to handle the following cases:
+* ExpressionStatement
+*  CallExpression
+*      Identifier | MemberExpression
+*      ExpressionLiterals: [
+*          CallExpression
+*          StringLiteral
+*          NumericLiteral
+*          ArrayLiteralExpression
+*              ExpressionLiterals
+*          ObjectLiteralExpression
+*              PropertyAssignment
+*                  Identifier
+*                  ExpressionLiterals
+*      ]
+*/
+var ExpressionParser = class extends __langchain_core_output_parsers.BaseOutputParser {
+	lc_namespace = [
+		"langchain",
+		"output_parsers",
+		"expression"
+	];
+	parser;
+	/**
+	* We should separate loading the parser into its own function
+	* because loading the grammar takes some time. If there are
+	* multiple concurrent parse calls, it's faster to just wait
+	* for building the parser once and then use it for all
+	* subsequent calls. See expression.test.ts for an example.
+	*/
+	async ensureParser() {
+		if (!this.parser) this.parser = await require_base.ASTParser.importASTParser();
+	}
+	/**
+	* Parses the given text. It first ensures the parser is loaded, then
+	* tries to parse the text. If the parsing fails, it throws an error. If
+	* the parsing is successful, it returns the parsed expression.
+	* @param text The text to be parsed.
+	* @returns The parsed expression
+	*/
+	async parse(text) {
+		await this.ensureParser();
+		try {
+			const program = this.parser(text);
+			const node = program.body;
+			if (!require_base.ASTParser.isExpressionStatement(node)) throw new Error(`Expected ExpressionStatement, got ${node.type}`);
+			const { expression: expressionStatement } = node;
+			if (!require_base.ASTParser.isCallExpression(expressionStatement)) throw new Error("Expected CallExpression");
+			const masterHandler = require_factory.MasterHandler.createMasterHandler();
+			return await masterHandler.handle(expressionStatement);
+		} catch (err) {
+			throw new Error(`Error parsing ${err}: ${text}`);
+		}
+	}
+	/**
+	* This method is currently empty, but it could be used to provide
+	* instructions on the format of the input text.
+	* @returns string
+	*/
+	getFormatInstructions() {
+		return "";
+	}
+};
+
+//#endregion
+exports.ExpressionParser = ExpressionParser;
+exports.MasterHandler = require_factory.MasterHandler;
+Object.defineProperty(exports, 'expression_exports', {
+  enumerable: true,
+  get: function () {
+    return expression_exports;
+  }
+});
+//# sourceMappingURL=expression.cjs.map

package/dist/output_parsers/expression.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.cjs","names":["BaseOutputParser","ASTParser","text: string","MasterHandler"],"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,cAAsCA,iDAA6B;CACjE,eAAe;EAAC;EAAa;EAAkB;CAAa;CAE5D;;;;;;;;CASA,MAAM,eAAe;AACnB,MAAI,CAAC,KAAK,QACR,KAAK,SAAS,MAAMC,uBAAU,iBAAiB;CAElD;;;;;;;;CASD,MAAM,MAAMC,MAAc;EACxB,MAAM,KAAK,cAAc;AAEzB,MAAI;GACF,MAAM,UAAU,KAAK,OAAO,KAAK;GAEjC,MAAM,OAAO,QAAQ;AACrB,OAAI,CAACD,uBAAU,sBAAsB,KAAK,CACxC,OAAM,IAAI,MACR,CAAC,kCAAkC,EAAG,KAAwB,MAAM;GAIxE,MAAM,EAAE,YAAY,qBAAqB,GAAG;AAC5C,OAAI,CAACA,uBAAU,iBAAiB,oBAAoB,CAClD,OAAM,IAAI,MAAM;GAElB,MAAM,gBAAgBE,8BAAc,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"}

package/dist/output_parsers/expression.d.cts

@@ -0,0 +1,53 @@
+import { ArgumentsType, ArrayLiteralType, BooleanLiteralType, CallExpressionType, IdentifierType, MemberExpressionType, NumericLiteralType, ObjectLiteralType, ParsedType, PropertyAssignmentType, StringLiteralType } from "./expression_type_handlers/types.cjs";
+import { ASTParser } from "./expression_type_handlers/base.cjs";
+import { MasterHandler } from "./expression_type_handlers/factory.cjs";
+import { BaseOutputParser } from "@langchain/core/output_parsers";
+
+//#region src/output_parsers/expression.d.ts
+type ParseFunction = Awaited<ReturnType<typeof ASTParser.importASTParser>>;
+/**
+ * We need to be able to handle the following cases:
+ * ExpressionStatement
+ *  CallExpression
+ *      Identifier | MemberExpression
+ *      ExpressionLiterals: [
+ *          CallExpression
+ *          StringLiteral
+ *          NumericLiteral
+ *          ArrayLiteralExpression
+ *              ExpressionLiterals
+ *          ObjectLiteralExpression
+ *              PropertyAssignment
+ *                  Identifier
+ *                  ExpressionLiterals
+ *      ]
+ */
+declare class ExpressionParser extends BaseOutputParser<ParsedType> {
+  lc_namespace: string[];
+  parser: ParseFunction;
+  /**
+   * We should separate loading the parser into its own function
+   * because loading the grammar takes some time. If there are
+   * multiple concurrent parse calls, it's faster to just wait
+   * for building the parser once and then use it for all
+   * subsequent calls. See expression.test.ts for an example.
+   */
+  ensureParser(): Promise<void>;
+  /**
+   * Parses the given text. It first ensures the parser is loaded, then
+   * tries to parse the text. If the parsing fails, it throws an error. If
+   * the parsing is successful, it returns the parsed expression.
+   * @param text The text to be parsed.
+   * @returns The parsed expression
+   */
+  parse(text: string): Promise<ParsedType>;
+  /**
+   * This method is currently empty, but it could be used to provide
+   * instructions on the format of the input text.
+   * @returns string
+   */
+  getFormatInstructions(): string;
+}
+//#endregion
+export { ArgumentsType, ArrayLiteralType, BooleanLiteralType, CallExpressionType, ExpressionParser, IdentifierType, MasterHandler, MemberExpressionType, NumericLiteralType, ObjectLiteralType, ParseFunction, ParsedType, PropertyAssignmentType, StringLiteralType };
+//# sourceMappingURL=expression.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.cts","names":["BaseOutputParser","ParsedType","ASTParser","ParseFunction","importASTParser","ReturnType","Awaited","ExpressionParser","Promise","MasterHandler"],"sources":["../../src/output_parsers/expression.d.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport { ParsedType } from \"./expression_type_handlers/types.js\";\nimport { ASTParser } from \"./expression_type_handlers/base.js\";\nexport type ParseFunction = Awaited<ReturnType<typeof ASTParser.importASTParser>>;\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 */\nexport declare class ExpressionParser extends BaseOutputParser<ParsedType> {\n    lc_namespace: string[];\n    parser: ParseFunction;\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    ensureParser(): Promise<void>;\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    parse(text: string): Promise<ParsedType>;\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}\nexport * from \"./expression_type_handlers/types.js\";\nexport { MasterHandler } from \"./expression_type_handlers/factory.js\";\n"],"mappings":";;;;;;KAGYG,aAAAA,GAAgBG,QAAQD,kBAAkBH,SAAAA,CAAUE;;;AAAhE;;;;;AAAmC;AAkBnC;;;;;;;;AAA8D;cAAzCG,gBAAAA,SAAyBP,iBAAiBC;;UAEnDE;;;;;;;;kBAQQK;;;;;;;;uBAQKA,QAAQP"}

package/dist/output_parsers/expression.d.ts

@@ -0,0 +1,53 @@
+import { ArgumentsType, ArrayLiteralType, BooleanLiteralType, CallExpressionType, IdentifierType, MemberExpressionType, NumericLiteralType, ObjectLiteralType, ParsedType, PropertyAssignmentType, StringLiteralType } from "./expression_type_handlers/types.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.d.ts
+type ParseFunction = Awaited<ReturnType<typeof ASTParser.importASTParser>>;
+/**
+ * We need to be able to handle the following cases:
+ * ExpressionStatement
+ *  CallExpression
+ *      Identifier | MemberExpression
+ *      ExpressionLiterals: [
+ *          CallExpression
+ *          StringLiteral
+ *          NumericLiteral
+ *          ArrayLiteralExpression
+ *              ExpressionLiterals
+ *          ObjectLiteralExpression
+ *              PropertyAssignment
+ *                  Identifier
+ *                  ExpressionLiterals
+ *      ]
+ */
+declare class ExpressionParser extends BaseOutputParser<ParsedType> {
+  lc_namespace: string[];
+  parser: ParseFunction;
+  /**
+   * We should separate loading the parser into its own function
+   * because loading the grammar takes some time. If there are
+   * multiple concurrent parse calls, it's faster to just wait
+   * for building the parser once and then use it for all
+   * subsequent calls. See expression.test.ts for an example.
+   */
+  ensureParser(): Promise<void>;
+  /**
+   * Parses the given text. It first ensures the parser is loaded, then
+   * tries to parse the text. If the parsing fails, it throws an error. If
+   * the parsing is successful, it returns the parsed expression.
+   * @param text The text to be parsed.
+   * @returns The parsed expression
+   */
+  parse(text: string): Promise<ParsedType>;
+  /**
+   * This method is currently empty, but it could be used to provide
+   * instructions on the format of the input text.
+   * @returns string
+   */
+  getFormatInstructions(): string;
+}
+//#endregion
+export { ArgumentsType, ArrayLiteralType, BooleanLiteralType, CallExpressionType, ExpressionParser, IdentifierType, MasterHandler, MemberExpressionType, NumericLiteralType, ObjectLiteralType, ParseFunction, ParsedType, PropertyAssignmentType, StringLiteralType };
+//# sourceMappingURL=expression.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","names":["BaseOutputParser","ParsedType","ASTParser","ParseFunction","importASTParser","ReturnType","Awaited","ExpressionParser","Promise","MasterHandler"],"sources":["../../src/output_parsers/expression.d.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport { ParsedType } from \"./expression_type_handlers/types.js\";\nimport { ASTParser } from \"./expression_type_handlers/base.js\";\nexport type ParseFunction = Awaited<ReturnType<typeof ASTParser.importASTParser>>;\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 */\nexport declare class ExpressionParser extends BaseOutputParser<ParsedType> {\n    lc_namespace: string[];\n    parser: ParseFunction;\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    ensureParser(): Promise<void>;\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    parse(text: string): Promise<ParsedType>;\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}\nexport * from \"./expression_type_handlers/types.js\";\nexport { MasterHandler } from \"./expression_type_handlers/factory.js\";\n"],"mappings":";;;;;;KAGYG,aAAAA,GAAgBG,QAAQD,kBAAkBH,SAAAA,CAAUE;;;AAAhE;;;;;AAAmC;AAkBnC;;;;;;;;AAA8D;cAAzCG,gBAAAA,SAAyBP,iBAAiBC;;UAEnDE;;;;;;;;kBAQQK;;;;;;;;uBAQKA,QAAQP"}

package/dist/output_parsers/expression.js

@@ -0,0 +1,79 @@
+import { __export } 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, {
+	ExpressionParser: () => ExpressionParser,
+	MasterHandler: () => MasterHandler
+});
+/**
+* We need to be able to handle the following cases:
+* ExpressionStatement
+*  CallExpression
+*      Identifier | MemberExpression
+*      ExpressionLiterals: [
+*          CallExpression
+*          StringLiteral
+*          NumericLiteral
+*          ArrayLiteralExpression
+*              ExpressionLiterals
+*          ObjectLiteralExpression
+*              PropertyAssignment
+*                  Identifier
+*                  ExpressionLiterals
+*      ]
+*/
+var ExpressionParser = class extends BaseOutputParser {
+	lc_namespace = [
+		"langchain",
+		"output_parsers",
+		"expression"
+	];
+	parser;
+	/**
+	* We should separate loading the parser into its own function
+	* because loading the grammar takes some time. If there are
+	* multiple concurrent parse calls, it's faster to just wait
+	* for building the parser once and then use it for all
+	* subsequent calls. See expression.test.ts for an example.
+	*/
+	async ensureParser() {
+		if (!this.parser) this.parser = await ASTParser.importASTParser();
+	}
+	/**
+	* Parses the given text. It first ensures the parser is loaded, then
+	* tries to parse the text. If the parsing fails, it throws an error. If
+	* the parsing is successful, it returns the parsed expression.
+	* @param text The text to be parsed.
+	* @returns The parsed expression
+	*/
+	async parse(text) {
+		await this.ensureParser();
+		try {
+			const program = this.parser(text);
+			const node = program.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);
+		} catch (err) {
+			throw new Error(`Error parsing ${err}: ${text}`);
+		}
+	}
+	/**
+	* This method is currently empty, but it could be used to provide
+	* instructions on the format of the input text.
+	* @returns string
+	*/
+	getFormatInstructions() {
+		return "";
+	}
+};
+
+//#endregion
+export { ExpressionParser, MasterHandler, expression_exports };
+//# sourceMappingURL=expression.js.map

package/dist/output_parsers/expression.js.map

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

package/dist/output_parsers/expression_type_handlers/array_literal_expression_handler.cjs

@@ -0,0 +1,38 @@
+const require_base = require('./base.cjs');
+
+//#region src/output_parsers/expression_type_handlers/array_literal_expression_handler.ts
+/**
+* Handles array expressions in the LangChain Expression Language (LCEL).
+* It extends the NodeHandler base class, providing functionality to
+* accept and handle array expressions.
+*/
+var ArrayLiteralExpressionHandler = class extends require_base.NodeHandler {
+	/**
+	* Checks if the given node is an array expression. If it is, the method
+	* returns the node; otherwise, it returns false.
+	* @param node The ExpressionNode to check.
+	* @returns A Promise that resolves to either the ArrayExpression node if the node is an array expression, or false otherwise.
+	*/
+	async accepts(node) {
+		if (require_base.ASTParser.isArrayExpression(node)) return node;
+		else return false;
+	}
+	/**
+	* Handles the given array expression node. If the handler doesn't have a
+	* parent handler, it throws an error. Otherwise, it returns an object
+	* representing the array literal.
+	* @param node The ArrayExpression node to handle.
+	* @returns A Promise that resolves to an object representing the array literal.
+	*/
+	async handle(node) {
+		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+		return {
+			type: "array_literal",
+			values: await Promise.all(node.elements.map((innerNode) => this.parentHandler.handle(innerNode)))
+		};
+	}
+};
+
+//#endregion
+exports.ArrayLiteralExpressionHandler = ArrayLiteralExpressionHandler;
+//# sourceMappingURL=array_literal_expression_handler.cjs.map

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

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

package/dist/output_parsers/expression_type_handlers/array_literal_expression_handler.js

@@ -0,0 +1,38 @@
+import { ASTParser, NodeHandler } from "./base.js";
+
+//#region src/output_parsers/expression_type_handlers/array_literal_expression_handler.ts
+/**
+* Handles array expressions in the LangChain Expression Language (LCEL).
+* It extends the NodeHandler base class, providing functionality to
+* accept and handle array expressions.
+*/
+var ArrayLiteralExpressionHandler = class extends NodeHandler {
+	/**
+	* Checks if the given node is an array expression. If it is, the method
+	* returns the node; otherwise, it returns false.
+	* @param node The ExpressionNode to check.
+	* @returns A Promise that resolves to either the ArrayExpression node if the node is an array expression, or false otherwise.
+	*/
+	async accepts(node) {
+		if (ASTParser.isArrayExpression(node)) return node;
+		else return false;
+	}
+	/**
+	* Handles the given array expression node. If the handler doesn't have a
+	* parent handler, it throws an error. Otherwise, it returns an object
+	* representing the array literal.
+	* @param node The ArrayExpression node to handle.
+	* @returns A Promise that resolves to an object representing the array literal.
+	*/
+	async handle(node) {
+		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+		return {
+			type: "array_literal",
+			values: await Promise.all(node.elements.map((innerNode) => this.parentHandler.handle(innerNode)))
+		};
+	}
+};
+
+//#endregion
+export { ArrayLiteralExpressionHandler };
+//# sourceMappingURL=array_literal_expression_handler.js.map

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

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

package/dist/output_parsers/expression_type_handlers/base.cjs

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

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

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