langchain 1.0.0-alpha.6 → 1.0.0-alpha.8

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

@@ -1,298 +0,0 @@
-//#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
-*/
-const GRAMMAR = `{{
-    var TYPES_TO_PROPERTY_NAMES = {
-      CallExpression:   "callee",
-      MemberExpression: "object",
-    };
-  
-    function extractOptional(optional, index) {
-      return optional ? optional[index] : null;
-    };
-  
-    function extractList(list, index) {
-      return list.map(function(element) { return element[index]; });
-    };
-  
-    function buildList(head, tail, index) {
-      return [head].concat(extractList(tail, index));
-    };
-  
-    function optionalList(value) {
-      return value !== null ? value : [];
-    };
-  }}
-  
-  Start
-    = __ program:Program __ { return program; };
-  
-  SourceCharacter
-    = .;
-  
-  WhiteSpace
-    = "\\t"
-    / "\\v"
-    / "\\f"
-    / " "
-    / "\\u00A0"
-    / "\\uFEFF";
-  
-  Identifier
-    = !ReservedWord name:IdentifierName { return name; };
-  
-  IdentifierName
-    = head:IdentifierStart tail:IdentifierPart* {
-        return {
-          type: "Identifier",
-          name: head + tail.join("")
-        };
-      };
-  
-  IdentifierStart
-    = UnicodeLetter
-    / "$"
-    / "_";
-  
-  IdentifierPart
-    = IdentifierStart
-    / Nd
-    / "\\u200C"
-    / "\\u200D";
-  
-  UnicodeLetter
-    = Lu
-    / Ll;
-  
-  ReservedWord
-    = NullToken
-    / TrueToken
-    / FalseToken;
-  
-  Literal
-    = NullLiteral
-    / BooleanLiteral
-    / NumericLiteral
-    / StringLiteral;
-  
-  NullLiteral
-    = NullToken { return { type: "NullLiteral", value: null }; };
-  
-  BooleanLiteral
-    = TrueToken { return { type: "BooleanLiteral", value: true  }; }
-    / FalseToken { return { type: "BooleanLiteral", value: false }; };
-  
-  NumericLiteral
-    = literal:DecimalLiteral !(IdentifierStart / DecimalDigit) {
-        return literal;
-      };
-  
-  DecimalLiteral
-    = DecimalIntegerLiteral "." DecimalDigit* {
-        return { type: "NumericLiteral", value: parseFloat(text()) };
-      }
-    / "." DecimalDigit+ {
-        return { type: "NumericLiteral", value: parseFloat(text()) };
-      }
-    / DecimalIntegerLiteral {
-        return { type: "NumericLiteral", value: parseFloat(text()) };
-      };
-  
-  DecimalIntegerLiteral
-    = "0"
-    / NonZeroDigit DecimalDigit*;
-  
-  DecimalDigit
-    = [0-9];
-  
-  NonZeroDigit
-    = [1-9];
-  
-  StringLiteral
-    = '"' chars:DoubleStringCharacter* '"' {
-        return { type: "StringLiteral", value: chars.join("") };
-      }
-    / "'" chars:SingleStringCharacter* "'" {
-        return { type: "StringLiteral", value: chars.join("") };
-      };
-  
-  DoubleStringCharacter
-    = !('"' / "\\\\") SourceCharacter { return text(); };
-  
-  SingleStringCharacter
-    = !("'" / "\\\\") SourceCharacter { return text(); };
-  
-  SingleEscapeCharacter
-    = "'"
-    / '"';
-  
-  Ll = [a-z];
-  Lu = [A-Z];
-  Nd = [0-9];
-  
-  FalseToken = "false" !IdentifierPart;
-  TrueToken = "true" !IdentifierPart;
-  NullToken = "null" !IdentifierPart;
-  
-  __ = WhiteSpace*;
-  
-  PrimaryExpression
-    = Identifier
-    / Literal
-    / ArrayExpression
-    / ObjectExpression
-    / "(" __ expression:Expression __ ")" { return expression; };
-  
-  ArrayExpression
-    = "[" __ "]" { return { type: "ArrayExpression", elements: [] }; }
-    / "[" __ elements:ElementList __ "]" {
-        return {
-          type: "ArrayExpression",
-          elements: elements
-        };
-      };
-  
-  ElementList
-    = head:(
-        element:Expression {
-          return element;
-        }
-      )
-      tail:(
-        __ "," __ element:Expression {
-          return element;
-        }
-      )*
-      { return Array.prototype.concat.apply(head, tail); };
-  
-  ObjectExpression
-    = "{" __ "}" { return { type: "ObjectExpression", properties: [] }; }
-    / "{" __ properties:PropertyNameAndValueList __ "}" {
-         return { type: "ObjectExpression", properties: properties };
-       }
-    / "{" __ properties:PropertyNameAndValueList __ "," __ "}" {
-         return { type: "ObjectExpression", properties: properties };
-       };
-  PropertyNameAndValueList
-    = head:PropertyAssignment tail:(__ "," __ PropertyAssignment)* {
-        return buildList(head, tail, 3);
-      };
-  
-  PropertyAssignment
-    = key:PropertyName __ ":" __ value:Expression {
-        return { type: "PropertyAssignment", key: key, value: value, kind: "init" };
-      };
-  
-  PropertyName
-    = IdentifierName
-    / StringLiteral
-    / NumericLiteral;
-  
-  Node
-    = ArrayExpression 
-    / BooleanLiteral 
-    / CallExpression 
-    / Identifier 
-    / MemberExpression 
-    / NumericLiteral 
-    / ObjectExpression 
-    / PropertyAssignment 
-    / StringLiteral
-  
-  MemberExpression
-    = head:(PrimaryExpression)
-      tail:(
-          __ "[" __ property:Expression __ "]" {
-            return { property: property, computed: true };
-          }
-        / __ "." __ property:IdentifierName {
-            return { property: property, computed: false };
-          }
-      )*
-      {
-        return tail.reduce(function(result, element) {
-          return {
-            type: "MemberExpression",
-            object: result,
-            property: element.property,
-            computed: element.computed
-          };
-        }, head);
-      };
-  
-  CallExpression
-    = head:(
-        callee:MemberExpression __ args:Arguments {
-          return { type: "CallExpression", callee: callee, arguments: args };
-        }
-      )
-      tail:(
-          __ args:Arguments {
-            return { type: "CallExpression", arguments: args };
-          }
-        / __ "[" __ property:Expression __ "]" {
-            return {
-              type: "MemberExpression",
-              property: property,
-              computed: true
-            };
-          }
-        / __ "." __ property:IdentifierName {
-            return {
-              type: "MemberExpression",
-              property: property,
-              computed: false
-            };
-          }
-      )*
-      {
-        return tail.reduce(function(result, element) {
-          element[TYPES_TO_PROPERTY_NAMES[element.type]] = result;
-  
-          return element;
-        }, head);
-      };
-  
-  Arguments
-    = "(" __ args:(ArgumentList __)? ")" {
-        return optionalList(extractOptional(args, 0));
-      };
-  
-  ArgumentList
-    = head:Expression tail:(__ "," __ Expression)* {
-        return buildList(head, tail, 3);
-      };
-  
-  Expression
-    = CallExpression
-    / MemberExpression;
-  
-  ExpressionStatement
-    = expression:Expression {
-        return {
-          type: "ExpressionStatement",
-          expression: expression
-        };
-      };
-  
-  Program
-    = exp:ExpressionStatement {
-        return {
-          type: "Program",
-          body: exp
-        };
-      };`;
-
-//#endregion
-export { GRAMMAR };
-//# sourceMappingURL=parser_grammar.js.map

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

@@ -1 +0,0 @@
-{"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,40 +0,0 @@
-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.
-*/
-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

@@ -1 +0,0 @@
-{"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,40 +0,0 @@
-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.
-*/
-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

@@ -1 +0,0 @@
-{"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,48 +0,0 @@
-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.
-*/
-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

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

@@ -1 +0,0 @@
-{"version":3,"file":"member_expression_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: MemberExpression","prop: string","identifier: string"],"sources":["../../../src/output_parsers/expression_type_handlers/member_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { MemberExpressionType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  MemberExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles member expressions in the LangChain Expression Language (LCEL).\n * Extends the NodeHandler base class.\n */\nexport class MemberExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a member expression. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is a member expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<MemberExpression | boolean> {\n    if (ASTParser.isMemberExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a member expression node. It extracts the object and property\n   * from the node, validates their types, and returns an object with the\n   * type of the expression, the identifier, and the property.\n   * @param node The member expression node to process.\n   * @returns An object with the type of the expression, the identifier, and the property.\n   */\n  async handle(node: MemberExpression): Promise<MemberExpressionType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const { object, property } = node;\n    let prop: string;\n    if (ASTParser.isIdentifier(property)) {\n      prop = property.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(property)) {\n      prop = (`${property.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    let identifier: string;\n    if (ASTParser.isIdentifier(object)) {\n      identifier = object.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(object)) {\n      identifier = (`${object.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid object type\");\n    }\n    if (object.type !== \"Identifier\" && object.type !== \"StringLiteral\") {\n      throw new Error(\"ArrayExpression is not supported\");\n    }\n\n    return { type: \"member_expression\", identifier, property: prop };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,0BAAb,cAA6CA,yBAAY;;;;;;;CAOvD,MAAM,QAAQC,MAA2D;AACvE,MAAIC,uBAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;CAEV;;;;;;;;CASD,MAAM,OAAOC,MAAuD;AAClE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAM,EAAE,QAAQ,UAAU,GAAG;EAC7B,IAAIC;AACJ,MAAIF,uBAAU,aAAa,SAAS,EAClC,OAAO,SAAS,KAAK,QAAQ,2BAA2B,KAAK;WACpDA,uBAAU,gBAAgB,SAAS,EAC5C,OAAQ,GAAG,SAAS,OAAO,CAAY,QACrC,2BACA,KACD;MAED,OAAM,IAAI,MAAM;EAElB,IAAIG;AACJ,MAAIH,uBAAU,aAAa,OAAO,EAChC,aAAa,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACxDA,uBAAU,gBAAgB,OAAO,EAC1C,aAAc,GAAG,OAAO,OAAO,CAAY,QACzC,2BACA,KACD;MAED,OAAM,IAAI,MAAM;AAElB,MAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,gBAClD,OAAM,IAAI,MAAM;AAGlB,SAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;EAAM;CACjE;AACF"}

package/dist/output_parsers/expression_type_handlers/member_expression_handler.js

@@ -1,48 +0,0 @@
-import { ASTParser, NodeHandler } from "./base.js";
-
-//#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.
-*/
-var MemberExpressionHandler = class extends 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 (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 (ASTParser.isIdentifier(property)) prop = property.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
-		else if (ASTParser.isStringLiteral(property)) prop = `${property.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
-		else throw new Error("Invalid property key type");
-		let identifier;
-		if (ASTParser.isIdentifier(object)) identifier = object.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
-		else if (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
-export { MemberExpressionHandler };
-//# sourceMappingURL=member_expression_handler.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"member_expression_handler.js","names":["node: ExpressionNode","node: MemberExpression","prop: string","identifier: string"],"sources":["../../../src/output_parsers/expression_type_handlers/member_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { MemberExpressionType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  MemberExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles member expressions in the LangChain Expression Language (LCEL).\n * Extends the NodeHandler base class.\n */\nexport class MemberExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a member expression. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is a member expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<MemberExpression | boolean> {\n    if (ASTParser.isMemberExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a member expression node. It extracts the object and property\n   * from the node, validates their types, and returns an object with the\n   * type of the expression, the identifier, and the property.\n   * @param node The member expression node to process.\n   * @returns An object with the type of the expression, the identifier, and the property.\n   */\n  async handle(node: MemberExpression): Promise<MemberExpressionType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const { object, property } = node;\n    let prop: string;\n    if (ASTParser.isIdentifier(property)) {\n      prop = property.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(property)) {\n      prop = (`${property.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    let identifier: string;\n    if (ASTParser.isIdentifier(object)) {\n      identifier = object.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(object)) {\n      identifier = (`${object.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid object type\");\n    }\n    if (object.type !== \"Identifier\" && object.type !== \"StringLiteral\") {\n      throw new Error(\"ArrayExpression is not supported\");\n    }\n\n    return { type: \"member_expression\", identifier, property: prop };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,0BAAb,cAA6C,YAAY;;;;;;;CAOvD,MAAM,QAAQA,MAA2D;AACvE,MAAI,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;CAEV;;;;;;;;CASD,MAAM,OAAOC,MAAuD;AAClE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAM,EAAE,QAAQ,UAAU,GAAG;EAC7B,IAAIC;AACJ,MAAI,UAAU,aAAa,SAAS,EAClC,OAAO,SAAS,KAAK,QAAQ,2BAA2B,KAAK;WACpD,UAAU,gBAAgB,SAAS,EAC5C,OAAQ,GAAG,SAAS,OAAO,CAAY,QACrC,2BACA,KACD;MAED,OAAM,IAAI,MAAM;EAElB,IAAIC;AACJ,MAAI,UAAU,aAAa,OAAO,EAChC,aAAa,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACxD,UAAU,gBAAgB,OAAO,EAC1C,aAAc,GAAG,OAAO,OAAO,CAAY,QACzC,2BACA,KACD;MAED,OAAM,IAAI,MAAM;AAElB,MAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,gBAClD,OAAM,IAAI,MAAM;AAGlB,SAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;EAAM;CACjE;AACF"}

package/dist/output_parsers/expression_type_handlers/numeric_literal_handler.cjs

@@ -1,36 +0,0 @@
-const require_base = require('./base.cjs');
-
-//#region src/output_parsers/expression_type_handlers/numeric_literal_handler.ts
-/**
-* Handler for numeric literal nodes in an abstract syntax tree (AST).
-* Extends the NodeHandler class.
-*/
-var NumericLiteralHandler = class extends require_base.NodeHandler {
-	/**
-	* Checks if a given node is a numeric literal. If it is, the method
-	* returns the node; otherwise, it returns false.
-	* @param node The node to check.
-	* @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.
-	*/
-	async accepts(node) {
-		if (require_base.ASTParser.isNumericLiteral(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes a numeric literal node and returns a NumericLiteralType
-	* object representing it.
-	* @param node The numeric literal node to process.
-	* @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.
-	*/
-	async handle(node) {
-		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		return {
-			type: "numeric_literal",
-			value: Number(node.value)
-		};
-	}
-};
-
-//#endregion
-exports.NumericLiteralHandler = NumericLiteralHandler;
-//# sourceMappingURL=numeric_literal_handler.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"numeric_literal_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: NumericLiteral"],"sources":["../../../src/output_parsers/expression_type_handlers/numeric_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { NumericLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  NumericLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for numeric literal nodes in an abstract syntax tree (AST).\n * Extends the NodeHandler class.\n */\nexport class NumericLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a numeric literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<NumericLiteral | boolean> {\n    if (ASTParser.isNumericLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a numeric literal node and returns a NumericLiteralType\n   * object representing it.\n   * @param node The numeric literal node to process.\n   * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.\n   */\n  async handle(node: NumericLiteral): Promise<NumericLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"numeric_literal\",\n      value: Number(node.value),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,wBAAb,cAA2CA,yBAAY;;;;;;;CAOrD,MAAM,QAAQC,MAAyD;AACrE,MAAIC,uBAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;CAEV;;;;;;;CAQD,MAAM,OAAOC,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;AAGJ,SAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,MAAM;EAC1B;CACF;AACF"}

package/dist/output_parsers/expression_type_handlers/numeric_literal_handler.js

@@ -1,36 +0,0 @@
-import { ASTParser, NodeHandler } from "./base.js";
-
-//#region src/output_parsers/expression_type_handlers/numeric_literal_handler.ts
-/**
-* Handler for numeric literal nodes in an abstract syntax tree (AST).
-* Extends the NodeHandler class.
-*/
-var NumericLiteralHandler = class extends NodeHandler {
-	/**
-	* Checks if a given node is a numeric literal. If it is, the method
-	* returns the node; otherwise, it returns false.
-	* @param node The node to check.
-	* @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.
-	*/
-	async accepts(node) {
-		if (ASTParser.isNumericLiteral(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes a numeric literal node and returns a NumericLiteralType
-	* object representing it.
-	* @param node The numeric literal node to process.
-	* @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.
-	*/
-	async handle(node) {
-		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		return {
-			type: "numeric_literal",
-			value: Number(node.value)
-		};
-	}
-};
-
-//#endregion
-export { NumericLiteralHandler };
-//# sourceMappingURL=numeric_literal_handler.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"numeric_literal_handler.js","names":["node: ExpressionNode","node: NumericLiteral"],"sources":["../../../src/output_parsers/expression_type_handlers/numeric_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { NumericLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  NumericLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for numeric literal nodes in an abstract syntax tree (AST).\n * Extends the NodeHandler class.\n */\nexport class NumericLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a numeric literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<NumericLiteral | boolean> {\n    if (ASTParser.isNumericLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a numeric literal node and returns a NumericLiteralType\n   * object representing it.\n   * @param node The numeric literal node to process.\n   * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.\n   */\n  async handle(node: NumericLiteral): Promise<NumericLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"numeric_literal\",\n      value: Number(node.value),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,wBAAb,cAA2C,YAAY;;;;;;;CAOrD,MAAM,QAAQA,MAAyD;AACrE,MAAI,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;CAEV;;;;;;;CAQD,MAAM,OAAOC,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;AAGJ,SAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,MAAM;EAC1B;CACF;AACF"}

package/dist/output_parsers/expression_type_handlers/object_literal_expression_handler.cjs

@@ -1,40 +0,0 @@
-const require_base = require('./base.cjs');
-const require_property_assignment_handler = require('./property_assignment_handler.cjs');
-
-//#region src/output_parsers/expression_type_handlers/object_literal_expression_handler.ts
-/**
-* Handles object literal expressions in the LangChain Expression
-* Language. Extends the NodeHandler class.
-*/
-var ObjectLiteralExpressionHandler = class extends require_base.NodeHandler {
-	/**
-	* Checks if a given node is an object expression. Returns the node if it
-	* is, otherwise returns false.
-	* @param node The node to check.
-	* @returns The node if it is an object expression, otherwise false.
-	*/
-	async accepts(node) {
-		if (require_base.ASTParser.isObjectExpression(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes the object expression node and returns an object of type
-	* ObjectLiteralType. Throws an error if the parent handler is not set.
-	* @param node The object expression node to process.
-	* @returns An object of type ObjectLiteralType.
-	*/
-	async handle(node) {
-		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		const values = [];
-		const { properties } = node;
-		for (const property of properties) if (require_base.ASTParser.isPropertyAssignment(property)) values.push(await new require_property_assignment_handler.PropertyAssignmentHandler(this.parentHandler).handle(property));
-		return {
-			type: "object_literal",
-			values
-		};
-	}
-};
-
-//#endregion
-exports.ObjectLiteralExpressionHandler = ObjectLiteralExpressionHandler;
-//# sourceMappingURL=object_literal_expression_handler.cjs.map