langchain 1.0.0-alpha.7 → 1.0.0-alpha.9

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"object_literal_expression_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: ObjectExpression","values: PropertyAssignmentType[]","PropertyAssignmentHandler"],"sources":["../../../src/output_parsers/expression_type_handlers/object_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { ObjectLiteralType, PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ObjectExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles object literal expressions in the LangChain Expression\n * Language. Extends the NodeHandler class.\n */\nexport class ObjectLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an object expression. Returns the node if it\n   * is, otherwise returns false.\n   * @param node The node to check.\n   * @returns The node if it is an object expression, otherwise false.\n   */\n  async accepts(node: ExpressionNode): Promise<ObjectExpression | boolean> {\n    if (ASTParser.isObjectExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the object expression node and returns an object of type\n   * ObjectLiteralType. Throws an error if the parent handler is not set.\n   * @param node The object expression node to process.\n   * @returns An object of type ObjectLiteralType.\n   */\n  async handle(node: ObjectExpression): Promise<ObjectLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const values: PropertyAssignmentType[] = [];\n    const { properties } = node;\n    for (const property of properties) {\n      if (ASTParser.isPropertyAssignment(property)) {\n        values.push(\n          await new PropertyAssignmentHandler(this.parentHandler).handle(\n            property\n          )\n        );\n      }\n    }\n    return { type: \"object_literal\", values };\n  }\n}\n"],"mappings":";;;;;;;;AAYA,IAAa,iCAAb,cAAoDA,yBAAY;;;;;;;CAO9D,MAAM,QAAQC,MAA2D;AACvE,MAAIC,uBAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;CAEV;;;;;;;CAQD,MAAM,OAAOC,MAAoD;AAC/D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAMC,SAAmC,CAAE;EAC3C,MAAM,EAAE,YAAY,GAAG;AACvB,OAAK,MAAM,YAAY,WACrB,KAAIF,uBAAU,qBAAqB,SAAS,EAC1C,OAAO,KACL,MAAM,IAAIG,8DAA0B,KAAK,eAAe,OACtD,SACD,CACF;AAGL,SAAO;GAAE,MAAM;GAAkB;EAAQ;CAC1C;AACF"}

package/dist/output_parsers/expression_type_handlers/object_literal_expression_handler.js

@@ -1,40 +0,0 @@
-import { ASTParser, NodeHandler } from "./base.js";
-import { PropertyAssignmentHandler } from "./property_assignment_handler.js";
-
-//#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 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 (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 (ASTParser.isPropertyAssignment(property)) values.push(await new PropertyAssignmentHandler(this.parentHandler).handle(property));
-		return {
-			type: "object_literal",
-			values
-		};
-	}
-};
-
-//#endregion
-export { ObjectLiteralExpressionHandler };
-//# sourceMappingURL=object_literal_expression_handler.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"object_literal_expression_handler.js","names":["node: ExpressionNode","node: ObjectExpression","values: PropertyAssignmentType[]"],"sources":["../../../src/output_parsers/expression_type_handlers/object_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { ObjectLiteralType, PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ObjectExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles object literal expressions in the LangChain Expression\n * Language. Extends the NodeHandler class.\n */\nexport class ObjectLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an object expression. Returns the node if it\n   * is, otherwise returns false.\n   * @param node The node to check.\n   * @returns The node if it is an object expression, otherwise false.\n   */\n  async accepts(node: ExpressionNode): Promise<ObjectExpression | boolean> {\n    if (ASTParser.isObjectExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the object expression node and returns an object of type\n   * ObjectLiteralType. Throws an error if the parent handler is not set.\n   * @param node The object expression node to process.\n   * @returns An object of type ObjectLiteralType.\n   */\n  async handle(node: ObjectExpression): Promise<ObjectLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const values: PropertyAssignmentType[] = [];\n    const { properties } = node;\n    for (const property of properties) {\n      if (ASTParser.isPropertyAssignment(property)) {\n        values.push(\n          await new PropertyAssignmentHandler(this.parentHandler).handle(\n            property\n          )\n        );\n      }\n    }\n    return { type: \"object_literal\", values };\n  }\n}\n"],"mappings":";;;;;;;;AAYA,IAAa,iCAAb,cAAoD,YAAY;;;;;;;CAO9D,MAAM,QAAQA,MAA2D;AACvE,MAAI,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;CAEV;;;;;;;CAQD,MAAM,OAAOC,MAAoD;AAC/D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAMC,SAAmC,CAAE;EAC3C,MAAM,EAAE,YAAY,GAAG;AACvB,OAAK,MAAM,YAAY,WACrB,KAAI,UAAU,qBAAqB,SAAS,EAC1C,OAAO,KACL,MAAM,IAAI,0BAA0B,KAAK,eAAe,OACtD,SACD,CACF;AAGL,SAAO;GAAE,MAAM;GAAkB;EAAQ;CAC1C;AACF"}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.cjs

@@ -1,45 +0,0 @@
-const require_base = require('./base.cjs');
-
-//#region src/output_parsers/expression_type_handlers/property_assignment_handler.ts
-/**
-* Handler for `PropertyAssignment` nodes in an AST. Extends the
-* `NodeHandler` base class.
-*/
-var PropertyAssignmentHandler = class extends require_base.NodeHandler {
-	/**
-	* Checks if a given node is a `PropertyAssignment` and returns the node
-	* if true, or false otherwise.
-	* @param node The node to check.
-	* @returns The node if it is a `PropertyAssignment`, or false otherwise.
-	*/
-	async accepts(node) {
-		if (require_base.ASTParser.isPropertyAssignment(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes a `PropertyAssignment` node. Extracts the key and value of
-	* the property assignment and returns an object of type
-	* `PropertyAssignmentType` with the extracted identifier and value.
-	* @param node The `PropertyAssignment` node to process.
-	* @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.
-	*/
-	async handle(node) {
-		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		let name;
-		if (require_base.ASTParser.isIdentifier(node.key)) name = node.key.name;
-		else if (require_base.ASTParser.isStringLiteral(node.key)) name = node.key.value;
-		else throw new Error("Invalid property key type");
-		if (!name) throw new Error("Invalid property key");
-		const identifier = `${name}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
-		const value = await this.parentHandler.handle(node.value);
-		return {
-			type: "property_assignment",
-			identifier,
-			value
-		};
-	}
-};
-
-//#endregion
-exports.PropertyAssignmentHandler = PropertyAssignmentHandler;
-//# sourceMappingURL=property_assignment_handler.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"property_assignment_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: PropertyAssignment"],"sources":["../../../src/output_parsers/expression_type_handlers/property_assignment_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  PropertyAssignment,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for `PropertyAssignment` nodes in an AST. Extends the\n * `NodeHandler` base class.\n */\nexport class PropertyAssignmentHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a `PropertyAssignment` and returns the node\n   * if true, or false otherwise.\n   * @param node The node to check.\n   * @returns The node if it is a `PropertyAssignment`, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<PropertyAssignment | boolean> {\n    if (ASTParser.isPropertyAssignment(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a `PropertyAssignment` node. Extracts the key and value of\n   * the property assignment and returns an object of type\n   * `PropertyAssignmentType` with the extracted identifier and value.\n   * @param node The `PropertyAssignment` node to process.\n   * @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.\n   */\n  async handle(node: PropertyAssignment): Promise<PropertyAssignmentType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    let name;\n    if (ASTParser.isIdentifier(node.key)) {\n      name = node.key.name;\n    } else if (ASTParser.isStringLiteral(node.key)) {\n      name = node.key.value;\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    if (!name) {\n      throw new Error(\"Invalid property key\");\n    }\n    const identifier = (`${name}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    const value = await this.parentHandler.handle(node.value);\n    return { type: \"property_assignment\", identifier, value };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,4BAAb,cAA+CA,yBAAY;;;;;;;CAOzD,MAAM,QAAQC,MAA6D;AACzE,MAAIC,uBAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;CAEV;;;;;;;;CASD,MAAM,OAAOC,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,IAAI;AACJ,MAAID,uBAAU,aAAa,KAAK,IAAI,EAClC,OAAO,KAAK,IAAI;WACPA,uBAAU,gBAAgB,KAAK,IAAI,EAC5C,OAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM;AAElB,MAAI,CAAC,KACH,OAAM,IAAI,MAAM;EAElB,MAAM,aAAc,GAAG,MAAM,CAAY,QACvC,2BACA,KACD;EACD,MAAM,QAAQ,MAAM,KAAK,cAAc,OAAO,KAAK,MAAM;AACzD,SAAO;GAAE,MAAM;GAAuB;GAAY;EAAO;CAC1D;AACF"}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.js

@@ -1,45 +0,0 @@
-import { ASTParser, NodeHandler } from "./base.js";
-
-//#region src/output_parsers/expression_type_handlers/property_assignment_handler.ts
-/**
-* Handler for `PropertyAssignment` nodes in an AST. Extends the
-* `NodeHandler` base class.
-*/
-var PropertyAssignmentHandler = class extends NodeHandler {
-	/**
-	* Checks if a given node is a `PropertyAssignment` and returns the node
-	* if true, or false otherwise.
-	* @param node The node to check.
-	* @returns The node if it is a `PropertyAssignment`, or false otherwise.
-	*/
-	async accepts(node) {
-		if (ASTParser.isPropertyAssignment(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes a `PropertyAssignment` node. Extracts the key and value of
-	* the property assignment and returns an object of type
-	* `PropertyAssignmentType` with the extracted identifier and value.
-	* @param node The `PropertyAssignment` node to process.
-	* @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.
-	*/
-	async handle(node) {
-		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		let name;
-		if (ASTParser.isIdentifier(node.key)) name = node.key.name;
-		else if (ASTParser.isStringLiteral(node.key)) name = node.key.value;
-		else throw new Error("Invalid property key type");
-		if (!name) throw new Error("Invalid property key");
-		const identifier = `${name}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
-		const value = await this.parentHandler.handle(node.value);
-		return {
-			type: "property_assignment",
-			identifier,
-			value
-		};
-	}
-};
-
-//#endregion
-export { PropertyAssignmentHandler };
-//# sourceMappingURL=property_assignment_handler.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"property_assignment_handler.js","names":["node: ExpressionNode","node: PropertyAssignment"],"sources":["../../../src/output_parsers/expression_type_handlers/property_assignment_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  PropertyAssignment,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for `PropertyAssignment` nodes in an AST. Extends the\n * `NodeHandler` base class.\n */\nexport class PropertyAssignmentHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a `PropertyAssignment` and returns the node\n   * if true, or false otherwise.\n   * @param node The node to check.\n   * @returns The node if it is a `PropertyAssignment`, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<PropertyAssignment | boolean> {\n    if (ASTParser.isPropertyAssignment(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a `PropertyAssignment` node. Extracts the key and value of\n   * the property assignment and returns an object of type\n   * `PropertyAssignmentType` with the extracted identifier and value.\n   * @param node The `PropertyAssignment` node to process.\n   * @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.\n   */\n  async handle(node: PropertyAssignment): Promise<PropertyAssignmentType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    let name;\n    if (ASTParser.isIdentifier(node.key)) {\n      name = node.key.name;\n    } else if (ASTParser.isStringLiteral(node.key)) {\n      name = node.key.value;\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    if (!name) {\n      throw new Error(\"Invalid property key\");\n    }\n    const identifier = (`${name}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    const value = await this.parentHandler.handle(node.value);\n    return { type: \"property_assignment\", identifier, value };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,4BAAb,cAA+C,YAAY;;;;;;;CAOzD,MAAM,QAAQA,MAA6D;AACzE,MAAI,UAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;CAEV;;;;;;;;CASD,MAAM,OAAOC,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,IAAI;AACJ,MAAI,UAAU,aAAa,KAAK,IAAI,EAClC,OAAO,KAAK,IAAI;WACP,UAAU,gBAAgB,KAAK,IAAI,EAC5C,OAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM;AAElB,MAAI,CAAC,KACH,OAAM,IAAI,MAAM;EAElB,MAAM,aAAc,GAAG,MAAM,CAAY,QACvC,2BACA,KACD;EACD,MAAM,QAAQ,MAAM,KAAK,cAAc,OAAO,KAAK,MAAM;AACzD,SAAO;GAAE,MAAM;GAAuB;GAAY;EAAO;CAC1D;AACF"}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.cjs

@@ -1,37 +0,0 @@
-const require_base = require('./base.cjs');
-
-//#region src/output_parsers/expression_type_handlers/string_literal_handler.ts
-/**
-* Handler for string literal nodes in the LangChain Expression Language.
-* Extends the NodeHandler base class.
-*/
-var StringLiteralHandler = class extends require_base.NodeHandler {
-	/**
-	* Checks if a given node is a string literal. If it is, the method
-	* returns the node; otherwise, it returns false.
-	* @param node The ExpressionNode to check.
-	* @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.
-	*/
-	async accepts(node) {
-		if (require_base.ASTParser.isStringLiteral(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes a string literal node to extract its value. Throws an error
-	* if the handler does not have a parent handler.
-	* @param node The StringLiteral node to process.
-	* @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.
-	*/
-	async handle(node) {
-		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		const text = `${node.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
-		return {
-			type: "string_literal",
-			value: text
-		};
-	}
-};
-
-//#endregion
-exports.StringLiteralHandler = StringLiteralHandler;
-//# sourceMappingURL=string_literal_handler.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"string_literal_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: StringLiteral"],"sources":["../../../src/output_parsers/expression_type_handlers/string_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { StringLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  StringLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for string literal nodes in the LangChain Expression Language.\n * Extends the NodeHandler base class.\n */\nexport class StringLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a string literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<StringLiteral | boolean> {\n    if (ASTParser.isStringLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a string literal node to extract its value. Throws an error\n   * if the handler does not have a parent handler.\n   * @param node The StringLiteral node to process.\n   * @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.\n   */\n  async handle(node: StringLiteral): Promise<StringLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = (`${node.value}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    return { type: \"string_literal\", value: text };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,uBAAb,cAA0CA,yBAAY;;;;;;;CAOpD,MAAM,QAAQC,MAAwD;AACpE,MAAIC,uBAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;CAEV;;;;;;;CAQD,MAAM,OAAOC,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAM,OAAQ,GAAG,KAAK,OAAO,CAAY,QACvC,2BACA,KACD;AACD,SAAO;GAAE,MAAM;GAAkB,OAAO;EAAM;CAC/C;AACF"}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.js

@@ -1,37 +0,0 @@
-import { ASTParser, NodeHandler } from "./base.js";
-
-//#region src/output_parsers/expression_type_handlers/string_literal_handler.ts
-/**
-* Handler for string literal nodes in the LangChain Expression Language.
-* Extends the NodeHandler base class.
-*/
-var StringLiteralHandler = class extends NodeHandler {
-	/**
-	* Checks if a given node is a string literal. If it is, the method
-	* returns the node; otherwise, it returns false.
-	* @param node The ExpressionNode to check.
-	* @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.
-	*/
-	async accepts(node) {
-		if (ASTParser.isStringLiteral(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes a string literal node to extract its value. Throws an error
-	* if the handler does not have a parent handler.
-	* @param node The StringLiteral node to process.
-	* @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.
-	*/
-	async handle(node) {
-		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		const text = `${node.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
-		return {
-			type: "string_literal",
-			value: text
-		};
-	}
-};
-
-//#endregion
-export { StringLiteralHandler };
-//# sourceMappingURL=string_literal_handler.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"string_literal_handler.js","names":["node: ExpressionNode","node: StringLiteral"],"sources":["../../../src/output_parsers/expression_type_handlers/string_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { StringLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  StringLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for string literal nodes in the LangChain Expression Language.\n * Extends the NodeHandler base class.\n */\nexport class StringLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a string literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<StringLiteral | boolean> {\n    if (ASTParser.isStringLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a string literal node to extract its value. Throws an error\n   * if the handler does not have a parent handler.\n   * @param node The StringLiteral node to process.\n   * @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.\n   */\n  async handle(node: StringLiteral): Promise<StringLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = (`${node.value}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    return { type: \"string_literal\", value: text };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,uBAAb,cAA0C,YAAY;;;;;;;CAOpD,MAAM,QAAQA,MAAwD;AACpE,MAAI,UAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;CAEV;;;;;;;CAQD,MAAM,OAAOC,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAM,OAAQ,GAAG,KAAK,OAAO,CAAY,QACvC,2BACA,KACD;AACD,SAAO;GAAE,MAAM;GAAkB,OAAO;EAAM;CAC/C;AACF"}