langchain 0.3.31 → 1.0.0-alpha.1

package/dist/output_parsers/expression_type_handlers/array_literal_expression_handler.js

@@ -1,40 +1,38 @@
-import { NodeHandler, ASTParser } from "./base.js";
+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.
- */
-export class ArrayLiteralExpressionHandler 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) => 
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            this.parentHandler.handle(innerNode))),
-        };
-    }
-}
+* 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          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\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,cAEjB,KAAK,cAAe,OAAO,UAA4B,CACxD,CACF;EACF;CACF;AACF"}

package/dist/output_parsers/expression_type_handlers/base.cjs

@@ -1,166 +1,130 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ASTParser = exports.NodeHandler = void 0;
-const parser_grammar_js_1 = require("./grammar/parser_grammar.cjs");
+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.
- */
-class NodeHandler {
-    constructor(parentHandler) {
-        Object.defineProperty(this, "parentHandler", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: parentHandler
-        });
-    }
-}
-exports.NodeHandler = NodeHandler;
+* 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.
- */
-class ASTParser {
-    /**
-     * 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 Promise.resolve().then(() => __importStar(require("peggy")));
-                const parser = peggy.generate(parser_grammar_js_1.GRAMMAR);
-                const { parse } = parser;
-                ASTParser.astParseInstance = parse;
-            }
-            return ASTParser.astParseInstance;
-        }
-        catch (e) {
-            throw new Error(`Failed to import peggy. Please install peggy (i.e. "npm install peggy" or "yarn add 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";
-    }
-}
+* 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 (e) {
+			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 (e) {\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,SAAQ,GAAG;AACV,SAAM,IAAI,MACR,CAAC,gGAAgG,CAAC;EAErG;CACF;;;;;;CAOD,OAAO,UAAUC,MAAuC;AACtD,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,sBACLA,MAC6B;AAC7B,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,iBAAiBA,MAA8C;AACpE,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,gBAAgBA,MAA6C;AAClE,SAAO,KAAK,SAAS,mBAAmB,OAAO,KAAK,UAAU;CAC/D;;;;;;CAOD,OAAO,iBAAiBA,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;CAChE;;;;;;CAOD,OAAO,iBAAiBA,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;CAChE;;;;;;CAOD,OAAO,aAAaA,MAA0C;AAC5D,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,mBAAmBA,MAAgD;AACxE,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,kBAAkBA,MAA+C;AACtE,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,qBACLA,MAC4B;AAC5B,SAAO,KAAK,SAAS;CACtB;;;;;;CAOD,OAAO,mBAAmBA,MAAgD;AACxE,SAAO,KAAK,SAAS;CACtB;AACF"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["ExpressionNode","Program","ExpressionStatement","CallExpression","StringLiteral","NumericLiteral","BooleanLiteral","Identifier","ObjectExpression","ArrayExpression","PropertyAssignment","MemberExpression","ParseFunction","NodeHandler","Promise","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/base.d.ts"],"sourcesContent":["import type { ExpressionNode, Program, ExpressionStatement, CallExpression, StringLiteral, NumericLiteral, BooleanLiteral, Identifier, ObjectExpression, ArrayExpression, PropertyAssignment, MemberExpression, ParseFunction } from \"../../types/expression-parser.js\";\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport declare abstract class NodeHandler {\n    protected parentHandler?: NodeHandler | undefined;\n    constructor(parentHandler?: NodeHandler | undefined);\n    /**\n     * Determines whether the given node is acceptable.\n     * @param node The node to be checked.\n     * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.\n     */\n    abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n    /**\n     * Handles the given node. The specifics of how the node is handled are\n     * determined by the subclass implementation.\n     * @param node The node to be handled.\n     * @returns A Promise that resolves to the result of handling the node.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    abstract handle(node: ExpressionNode): Promise<any>;\n}\n/**\n * Utility class for parsing Abstract Syntax Trees (ASTs). Contains\n * methods for identifying the type of a given node and a method for\n * importing and generating a parser using the Peggy library.\n */\nexport declare class ASTParser {\n    static astParseInstance: ParseFunction;\n    /**\n     * Imports and generates a parser using the Peggy library.\n     * @returns A Promise that resolves to the parser instance.\n     */\n    static importASTParser(): Promise<ParseFunction>;\n    /**\n     * Checks if the given node is a Program node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a Program node.\n     */\n    static isProgram(node: ExpressionNode): node is Program;\n    /**\n     * Checks if the given node is an ExpressionStatement node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is an ExpressionStatement node.\n     */\n    static isExpressionStatement(node: ExpressionNode): node is ExpressionStatement;\n    /**\n     * Checks if the given node is a CallExpression node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a CallExpression node.\n     */\n    static isCallExpression(node: ExpressionNode): node is CallExpression;\n    /**\n     * Checks if the given node is a StringLiteral node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a StringLiteral node.\n     */\n    static isStringLiteral(node: ExpressionNode): node is StringLiteral;\n    /**\n     * Checks if the given node is a NumericLiteral node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a NumericLiteral node.\n     */\n    static isNumericLiteral(node: ExpressionNode): node is NumericLiteral;\n    /**\n     * Checks if the given node is a BooleanLiteral node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a BooleanLiteral node.\n     */\n    static isBooleanLiteral(node: ExpressionNode): node is BooleanLiteral;\n    /**\n     * Checks if the given node is an Identifier node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is an Identifier node.\n     */\n    static isIdentifier(node: ExpressionNode): node is Identifier;\n    /**\n     * Checks if the given node is an ObjectExpression node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is an ObjectExpression node.\n     */\n    static isObjectExpression(node: ExpressionNode): node is ObjectExpression;\n    /**\n     * Checks if the given node is an ArrayExpression node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is an ArrayExpression node.\n     */\n    static isArrayExpression(node: ExpressionNode): node is ArrayExpression;\n    /**\n     * Checks if the given node is a PropertyAssignment node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a PropertyAssignment node.\n     */\n    static isPropertyAssignment(node: ExpressionNode): node is PropertyAssignment;\n    /**\n     * Checks if the given node is a MemberExpression node.\n     * @param node The node to be checked.\n     * @returns A boolean indicating whether the node is a MemberExpression node.\n     */\n    static isMemberExpression(node: ExpressionNode): node is MemberExpression;\n}\n"],"mappings":";;;;;;AAKA;;AAC8Ba,uBADAA,WAAAA,CACAA;EAAW,UACTA,aAAAA,CAAAA,EADFA,WACEA,GAAAA,SAAAA;EAAW,WAMhBb,CAAAA,aAAAA,CAAAA,EANKa,WAMLb,GAAAA,SAAAA;EAAc;;;;AAQS;EAO7Be,SAAAA,OAAS,CAAA,IAAA,EAfHf,cAeG,CAAA,EAfcc,OAed,CAfsBd,cAetB,GAAA,OAAA,CAAA;EAAA;;;;;;EAY6B;EAMN,SAAWE,MAAAA,CAAAA,IAAAA,EAzBtCF,cAyBsCE,CAAAA,EAzBrBY,OAyBqBZ,CAAAA,GAAAA,CAAAA;;;;;;;AAwB9BF,cA1Cbe,SAAAA,CA0Caf;EAAc,OAAWM,gBAAAA,EAzC9BM,aAyC8BN;EAAc;;;;EAYI,OAM1CN,eAAAA,CAAAA,CAAAA,EAtDLc,OAsDKd,CAtDGY,aAsDHZ,CAAAA;EAAc;;;;;EAY4B,OAAA,SAAA,CAAA,IAAA,EA5DlDA,cA4DkD,CAAA,EAAA,IAAA,IA5DzBC,OA4DyB;;;;;;qCAtDtCD,yBAAyBE;;;;;;gCAM9BF,yBAAyBG;;;;;;+BAM1BH,yBAAyBI;;;;;;gCAMxBJ,yBAAyBK;;;;;;gCAMzBL,yBAAyBM;;;;;;4BAM7BN,yBAAyBO;;;;;;kCAMnBP,yBAAyBQ;;;;;;iCAM1BR,yBAAyBS;;;;;;oCAMtBT,yBAAyBU;;;;;;kCAM3BV,yBAAyBW"}