langchain 0.3.31 → 1.0.0-alpha.2

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

@@ -1,5 +1,9 @@
-import { NodeHandler } from "./base.js";
 import { ParsedType } from "./types.js";
+import { CallExpression, ExpressionNode } from "../../types/expression-parser.js";
+import { NodeHandler } from "./base.js";
+
+//#region src/output_parsers/expression_type_handlers/factory.d.ts
+
 /**
  * The MasterHandler class is responsible for managing a collection of
  * node handlers in the LangChain Expression Language. Each node handler
@@ -7,22 +11,25 @@ import { ParsedType } from "./types.js";
  * language. The MasterHandler class uses these node handlers to process
  * nodes in the expression language.
  */
-export declare class MasterHandler extends NodeHandler {
-    nodeHandlers: NodeHandler[];
-    accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;
-    /**
-     * This method is responsible for handling a node. It iterates over the
-     * collection of node handlers and uses the first handler that accepts the
-     * node to handle it. If no handler accepts the node, the method throws an
-     * error.
-     * @param node The node to be handled.
-     * @returns The result of the node handling, or throws an error if no handler can handle the node.
-     */
-    handle(node: CallExpression): Promise<ParsedType>;
-    /**
-     * This static method creates an instance of the MasterHandler class and
-     * initializes it with instances of all the node handlers.
-     * @returns An instance of the MasterHandler class.
-     */
-    static createMasterHandler(): MasterHandler;
+declare class MasterHandler extends NodeHandler {
+  nodeHandlers: NodeHandler[];
+  accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;
+  /**
+   * This method is responsible for handling a node. It iterates over the
+   * collection of node handlers and uses the first handler that accepts the
+   * node to handle it. If no handler accepts the node, the method throws an
+   * error.
+   * @param node The node to be handled.
+   * @returns The result of the node handling, or throws an error if no handler can handle the node.
+   */
+  handle(node: CallExpression): Promise<ParsedType>;
+  /**
+   * This static method creates an instance of the MasterHandler class and
+   * initializes it with instances of all the node handlers.
+   * @returns An instance of the MasterHandler class.
+   */
+  static createMasterHandler(): MasterHandler;
 }
+//#endregion
+export { MasterHandler };
+//# sourceMappingURL=factory.d.ts.map

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

@@ -0,0 +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"],"mappings":";;;;;;;;AAUA;;;;;AAEmCK,cAFdD,aAAAA,SAAsBJ,WAAAA,CAERK;EAAO,YASzBF,EAVCH,WAUDG,EAAAA;EAAc,OAAWF,CAAAA,IAAAA,EATxBC,cASwBD,CAAAA,EATPI,OASOJ,CATCC,cASDD,GAAAA,OAAAA,CAAAA;EAAU;;;AAXE;;;;;eAWrCE,iBAAiBE,QAAQJ;;;;;;gCAMRG"}

package/dist/output_parsers/expression_type_handlers/factory.js

@@ -3,70 +3,66 @@ import { ArrayLiteralExpressionHandler } from "./array_literal_expression_handle
 import { BooleanLiteralHandler } from "./boolean_literal_handler.js";
 import { CallExpressionHandler } from "./call_expression_handler.js";
 import { NumericLiteralHandler } from "./numeric_literal_handler.js";
-import { ObjectLiteralExpressionHandler } from "./object_literal_expression_handler.js";
 import { PropertyAssignmentHandler } from "./property_assignment_handler.js";
+import { ObjectLiteralExpressionHandler } from "./object_literal_expression_handler.js";
 import { StringLiteralHandler } from "./string_literal_handler.js";
 import { IdentifierHandler } from "./identifier_handler.js";
 import { MemberExpressionHandler } from "./member_expression_handler.js";
+
+//#region src/output_parsers/expression_type_handlers/factory.ts
 const handlers = [
-    ArrayLiteralExpressionHandler,
-    BooleanLiteralHandler,
-    CallExpressionHandler,
-    NumericLiteralHandler,
-    ObjectLiteralExpressionHandler,
-    MemberExpressionHandler,
-    PropertyAssignmentHandler,
-    StringLiteralHandler,
-    IdentifierHandler,
+	ArrayLiteralExpressionHandler,
+	BooleanLiteralHandler,
+	CallExpressionHandler,
+	NumericLiteralHandler,
+	ObjectLiteralExpressionHandler,
+	MemberExpressionHandler,
+	PropertyAssignmentHandler,
+	StringLiteralHandler,
+	IdentifierHandler
 ];
 /**
- * The MasterHandler class is responsible for managing a collection of
- * node handlers in the LangChain Expression Language. Each node handler
- * is capable of handling a specific type of node in the expression
- * language. The MasterHandler class uses these node handlers to process
- * nodes in the expression language.
- */
-export class MasterHandler extends NodeHandler {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "nodeHandlers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-    }
-    async accepts(node) {
-        throw new Error(`Master handler does not accept any nodes: ${node}`);
-    }
-    /**
-     * This method is responsible for handling a node. It iterates over the
-     * collection of node handlers and uses the first handler that accepts the
-     * node to handle it. If no handler accepts the node, the method throws an
-     * error.
-     * @param node The node to be handled.
-     * @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);
-            }
-        }
-        throw new Error(`No handler found for node: ${node}`);
-    }
-    /**
-     * This static method creates an instance of the MasterHandler class and
-     * initializes it with instances of all the node handlers.
-     * @returns An instance of the MasterHandler class.
-     */
-    static createMasterHandler() {
-        const masterHandler = new MasterHandler();
-        handlers.forEach((Handler) => {
-            const handlerInstance = new Handler(masterHandler);
-            masterHandler.nodeHandlers.push(handlerInstance);
-        });
-        return masterHandler;
-    }
-}
+* The MasterHandler class is responsible for managing a collection of
+* node handlers in the LangChain Expression Language. Each node handler
+* is capable of handling a specific type of node in the expression
+* language. The MasterHandler class uses these node handlers to process
+* nodes in the expression language.
+*/
+var MasterHandler = class MasterHandler extends NodeHandler {
+	nodeHandlers = [];
+	async accepts(node) {
+		throw new Error(`Master handler does not accept any nodes: ${node}`);
+	}
+	/**
+	* This method is responsible for handling a node. It iterates over the
+	* collection of node handlers and uses the first handler that accepts the
+	* node to handle it. If no handler accepts the node, the method throws an
+	* error.
+	* @param node The node to be handled.
+	* @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);
+		}
+		throw new Error(`No handler found for node: ${node}`);
+	}
+	/**
+	* This static method creates an instance of the MasterHandler class and
+	* initializes it with instances of all the node handlers.
+	* @returns An instance of the MasterHandler class.
+	*/
+	static createMasterHandler() {
+		const masterHandler = new MasterHandler();
+		handlers.forEach((Handler) => {
+			const handlerInstance = new Handler(masterHandler);
+			masterHandler.nodeHandlers.push(handlerInstance);
+		});
+		return masterHandler;
+	}
+};
+
+//#endregion
+export { MasterHandler };
+//# sourceMappingURL=factory.js.map

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

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

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

@@ -1,19 +1,18 @@
-"use strict";
+
+//#region src/output_parsers/expression_type_handlers/grammar/parser_grammar.ts
 /**
- * Here's the main parser for our expression parser. It's a pared down
- * Javascript parser with a whole lot of rules removed, leaving only
- * rules for parsing literals (i.e. string literal,numeric literal,
- * boolean literal, array literal, object literal and null literal),
- * identifiers, and expressions (i.e. call expression, member expression,
- * array expression and object expression).
- *
- * For more information see:
- * https://peggyjs.org/documentation.html
- * https://github.com/peggyjs/peggy/blob/main/examples/javascript.pegjs
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GRAMMAR = void 0;
-exports.GRAMMAR = `{{
+* Here's the main parser for our expression parser. It's a pared down
+* Javascript parser with a whole lot of rules removed, leaving only
+* rules for parsing literals (i.e. string literal,numeric literal,
+* boolean literal, array literal, object literal and null literal),
+* identifiers, and expressions (i.e. call expression, member expression,
+* array expression and object expression).
+*
+* For more information see:
+* https://peggyjs.org/documentation.html
+* https://github.com/peggyjs/peggy/blob/main/examples/javascript.pegjs
+*/
+const GRAMMAR = `{{
     var TYPES_TO_PROPERTY_NAMES = {
       CallExpression:   "callee",
       MemberExpression: "object",
@@ -294,3 +293,7 @@ exports.GRAMMAR = `{{
           body: exp
         };
       };`;
+
+//#endregion
+exports.GRAMMAR = GRAMMAR;
+//# sourceMappingURL=parser_grammar.cjs.map

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

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

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

@@ -1,16 +1,17 @@
+//#region src/output_parsers/expression_type_handlers/grammar/parser_grammar.ts
 /**
- * Here's the main parser for our expression parser. It's a pared down
- * Javascript parser with a whole lot of rules removed, leaving only
- * rules for parsing literals (i.e. string literal,numeric literal,
- * boolean literal, array literal, object literal and null literal),
- * identifiers, and expressions (i.e. call expression, member expression,
- * array expression and object expression).
- *
- * For more information see:
- * https://peggyjs.org/documentation.html
- * https://github.com/peggyjs/peggy/blob/main/examples/javascript.pegjs
- */
-export const GRAMMAR = `{{
+* Here's the main parser for our expression parser. It's a pared down
+* Javascript parser with a whole lot of rules removed, leaving only
+* rules for parsing literals (i.e. string literal,numeric literal,
+* boolean literal, array literal, object literal and null literal),
+* identifiers, and expressions (i.e. call expression, member expression,
+* array expression and object expression).
+*
+* For more information see:
+* https://peggyjs.org/documentation.html
+* https://github.com/peggyjs/peggy/blob/main/examples/javascript.pegjs
+*/
+const GRAMMAR = `{{
     var TYPES_TO_PROPERTY_NAMES = {
       CallExpression:   "callee",
       MemberExpression: "object",
@@ -291,3 +292,7 @@ export const GRAMMAR = `{{
           body: exp
         };
       };`;
+
+//#endregion
+export { GRAMMAR };
+//# sourceMappingURL=parser_grammar.js.map

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

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

package/dist/output_parsers/expression_type_handlers/identifier_handler.cjs

@@ -1,41 +1,40 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IdentifierHandler = void 0;
-const base_js_1 = require("./base.cjs");
+const require_base = require('./base.cjs');
+
+//#region src/output_parsers/expression_type_handlers/identifier_handler.ts
 /**
- * Handles identifiers in the LangChain Expression Language. Extends the
- * NodeHandler class.
- */
-class IdentifierHandler extends base_js_1.NodeHandler {
-    /**
-     * Checks if a given node is an identifier. If it is, it returns the node;
-     * otherwise, it returns false.
-     * @param node The node to check.
-     * @returns The node if it is an identifier, or false otherwise.
-     */
-    async accepts(node) {
-        if (base_js_1.ASTParser.isIdentifier(node)) {
-            return node;
-        }
-        else {
-            return false;
-        }
-    }
-    /**
-     * Processes the identifier node. If the handler does not have a parent
-     * handler, it throws an error. Otherwise, it extracts the name of the
-     * identifier, removes any enclosing quotes, and returns an object of type
-     * IdentifierType with the type set to "identifier" and the value set to
-     * the extracted name.
-     * @param node The identifier node to process.
-     * @returns An object of type IdentifierType with the type set to "identifier" and the value set to the extracted name.
-     */
-    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 };
-    }
-}
+* Handles identifiers in the LangChain Expression Language. Extends the
+* NodeHandler class.
+*/
+var IdentifierHandler = class extends require_base.NodeHandler {
+	/**
+	* Checks if a given node is an identifier. If it is, it returns the node;
+	* otherwise, it returns false.
+	* @param node The node to check.
+	* @returns The node if it is an identifier, or false otherwise.
+	*/
+	async accepts(node) {
+		if (require_base.ASTParser.isIdentifier(node)) return node;
+		else return false;
+	}
+	/**
+	* Processes the identifier node. If the handler does not have a parent
+	* handler, it throws an error. Otherwise, it extracts the name of the
+	* identifier, removes any enclosing quotes, and returns an object of type
+	* IdentifierType with the type set to "identifier" and the value set to
+	* the extracted name.
+	* @param node The identifier node to process.
+	* @returns An object of type IdentifierType with the type set to "identifier" and the value set to the extracted name.
+	*/
+	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
+		};
+	}
+};
+
+//#endregion
 exports.IdentifierHandler = IdentifierHandler;
+//# sourceMappingURL=identifier_handler.cjs.map

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

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

package/dist/output_parsers/expression_type_handlers/identifier_handler.js

@@ -1,37 +1,40 @@
-import { NodeHandler, ASTParser } from "./base.js";
+import { ASTParser, NodeHandler } from "./base.js";
+
+//#region src/output_parsers/expression_type_handlers/identifier_handler.ts
 /**
- * Handles identifiers in the LangChain Expression Language. Extends the
- * NodeHandler class.
- */
-export class IdentifierHandler extends NodeHandler {
-    /**
-     * Checks if a given node is an identifier. If it is, it returns the node;
-     * otherwise, it returns false.
-     * @param node The node to check.
-     * @returns The node if it is an identifier, or false otherwise.
-     */
-    async accepts(node) {
-        if (ASTParser.isIdentifier(node)) {
-            return node;
-        }
-        else {
-            return false;
-        }
-    }
-    /**
-     * Processes the identifier node. If the handler does not have a parent
-     * handler, it throws an error. Otherwise, it extracts the name of the
-     * identifier, removes any enclosing quotes, and returns an object of type
-     * IdentifierType with the type set to "identifier" and the value set to
-     * the extracted name.
-     * @param node The identifier node to process.
-     * @returns An object of type IdentifierType with the type set to "identifier" and the value set to the extracted name.
-     */
-    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 };
-    }
-}
+* Handles identifiers in the LangChain Expression Language. Extends the
+* NodeHandler class.
+*/
+var IdentifierHandler = class extends NodeHandler {
+	/**
+	* Checks if a given node is an identifier. If it is, it returns the node;
+	* otherwise, it returns false.
+	* @param node The node to check.
+	* @returns The node if it is an identifier, or false otherwise.
+	*/
+	async accepts(node) {
+		if (ASTParser.isIdentifier(node)) return node;
+		else return false;
+	}
+	/**
+	* Processes the identifier node. If the handler does not have a parent
+	* handler, it throws an error. Otherwise, it extracts the name of the
+	* identifier, removes any enclosing quotes, and returns an object of type
+	* IdentifierType with the type set to "identifier" and the value set to
+	* the extracted name.
+	* @param node The identifier node to process.
+	* @returns An object of type IdentifierType with the type set to "identifier" and the value set to the extracted name.
+	*/
+	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
+		};
+	}
+};
+
+//#endregion
+export { IdentifierHandler };
+//# sourceMappingURL=identifier_handler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"identifier_handler.js","names":["node: ExpressionNode","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,cAAuC,YAAY;;;;;;;CAOjD,MAAM,QAAQA,MAAqD;AACjE,MAAI,UAAU,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"}

package/dist/output_parsers/expression_type_handlers/member_expression_handler.cjs

@@ -1,62 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemberExpressionHandler = void 0;
-const base_js_1 = require("./base.cjs");
+const require_base = require('./base.cjs');
+
+//#region src/output_parsers/expression_type_handlers/member_expression_handler.ts
 /**
- * Handles member expressions in the LangChain Expression Language (LCEL).
- * Extends the NodeHandler base class.
- */
-class MemberExpressionHandler extends base_js_1.NodeHandler {
-    /**
-     * Checks if a given node is a member expression. If it is, the method
-     * returns the node; otherwise, it returns false.
-     * @param node The node to check.
-     * @returns The node if it is a member expression, or false otherwise.
-     */
-    async accepts(node) {
-        if (base_js_1.ASTParser.isMemberExpression(node)) {
-            return node;
-        }
-        else {
-            return false;
-        }
-    }
-    /**
-     * Processes a member expression node. It extracts the object and property
-     * from the node, validates their types, and returns an object with the
-     * type of the expression, the identifier, and the property.
-     * @param node The member expression node to process.
-     * @returns An object with the type of the expression, the identifier, and the property.
-     */
-    async handle(node) {
-        if (!this.parentHandler) {
-            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-        }
-        const { object, property } = node;
-        let prop;
-        if (base_js_1.ASTParser.isIdentifier(property)) {
-            prop = property.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
-        }
-        else if (base_js_1.ASTParser.isStringLiteral(property)) {
-            prop = `${property.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
-        }
-        else {
-            throw new Error("Invalid property key type");
-        }
-        let identifier;
-        if (base_js_1.ASTParser.isIdentifier(object)) {
-            identifier = object.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
-        }
-        else if (base_js_1.ASTParser.isStringLiteral(object)) {
-            identifier = `${object.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
-        }
-        else {
-            throw new Error("Invalid object type");
-        }
-        if (object.type !== "Identifier" && object.type !== "StringLiteral") {
-            throw new Error("ArrayExpression is not supported");
-        }
-        return { type: "member_expression", identifier, property: prop };
-    }
-}
+* Handles member expressions in the LangChain Expression Language (LCEL).
+* Extends the NodeHandler base class.
+*/
+var MemberExpressionHandler = class extends require_base.NodeHandler {
+	/**
+	* Checks if a given node is a member expression. If it is, the method
+	* returns the node; otherwise, it returns false.
+	* @param node The node to check.
+	* @returns The node if it is a member expression, or false otherwise.
+	*/
+	async accepts(node) {
+		if (require_base.ASTParser.isMemberExpression(node)) return node;
+		else return false;
+	}
+	/**
+	* Processes a member expression node. It extracts the object and property
+	* from the node, validates their types, and returns an object with the
+	* type of the expression, the identifier, and the property.
+	* @param node The member expression node to process.
+	* @returns An object with the type of the expression, the identifier, and the property.
+	*/
+	async handle(node) {
+		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+		const { object, property } = node;
+		let prop;
+		if (require_base.ASTParser.isIdentifier(property)) prop = property.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+		else if (require_base.ASTParser.isStringLiteral(property)) prop = `${property.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+		else throw new Error("Invalid property key type");
+		let identifier;
+		if (require_base.ASTParser.isIdentifier(object)) identifier = object.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+		else if (require_base.ASTParser.isStringLiteral(object)) identifier = `${object.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+		else throw new Error("Invalid object type");
+		if (object.type !== "Identifier" && object.type !== "StringLiteral") throw new Error("ArrayExpression is not supported");
+		return {
+			type: "member_expression",
+			identifier,
+			property: prop
+		};
+	}
+};
+
+//#endregion
 exports.MemberExpressionHandler = MemberExpressionHandler;
+//# sourceMappingURL=member_expression_handler.cjs.map