@langchain/classic 1.0.23 → 1.0.24-dev-1773698445534

package/dist/output_parsers/expression_type_handlers/identifier_handler.cjs

@@ -1,5 +1,4 @@
-const require_base = 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
@@ -33,7 +32,7 @@ var IdentifierHandler = class extends require_base.NodeHandler {
 		};
 	}
 };
-
 //#endregion
 exports.IdentifierHandler = IdentifierHandler;
+
 //# sourceMappingURL=identifier_handler.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"identifier_handler.cjs","names":["NodeHandler","ASTParser"],"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,QAAQ,MAAqD;AACjE,MAAIC,uBAAU,aAAa,KAAK,CAC9B,QAAO;MAEP,QAAO;;;;;;;;;;;CAaX,MAAM,OAAO,MAA2C;AACtD,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAGH,SAAO;GAAE,MAAM;GAAc,OADhB,KAAK,KAAK,QAAQ,2BAA2B,KAAK;GACrB"}
+{"version":3,"file":"identifier_handler.cjs","names":["NodeHandler","ASTParser"],"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,aAAAA,YAAY;;;;;;;CAOjD,MAAM,QAAQ,MAAqD;AACjE,MAAIC,aAAAA,UAAU,aAAa,KAAK,CAC9B,QAAO;MAEP,QAAO;;;;;;;;;;;CAaX,MAAM,OAAO,MAA2C;AACtD,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAGH,SAAO;GAAE,MAAM;GAAc,OADhB,KAAK,KAAK,QAAQ,2BAA2B,KAAK;GACrB"}

package/dist/output_parsers/expression_type_handlers/identifier_handler.js

@@ -1,5 +1,4 @@
 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
@@ -33,7 +32,7 @@ var IdentifierHandler = class extends NodeHandler {
 		};
 	}
 };
-
 //#endregion
 export { IdentifierHandler };
+
 //# sourceMappingURL=identifier_handler.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"identifier_handler.js","names":[],"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,QAAQ,MAAqD;AACjE,MAAI,UAAU,aAAa,KAAK,CAC9B,QAAO;MAEP,QAAO;;;;;;;;;;;CAaX,MAAM,OAAO,MAA2C;AACtD,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAGH,SAAO;GAAE,MAAM;GAAc,OADhB,KAAK,KAAK,QAAQ,2BAA2B,KAAK;GACrB"}
+{"version":3,"file":"identifier_handler.js","names":[],"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,QAAQ,MAAqD;AACjE,MAAI,UAAU,aAAa,KAAK,CAC9B,QAAO;MAEP,QAAO;;;;;;;;;;;CAaX,MAAM,OAAO,MAA2C;AACtD,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAGH,SAAO;GAAE,MAAM;GAAc,OADhB,KAAK,KAAK,QAAQ,2BAA2B,KAAK;GACrB"}

package/dist/output_parsers/expression_type_handlers/member_expression_handler.cjs

@@ -1,5 +1,4 @@
-const require_base = 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).
@@ -42,7 +41,7 @@ var MemberExpressionHandler = class extends require_base.NodeHandler {
 		};
 	}
 };
-
 //#endregion
 exports.MemberExpressionHandler = MemberExpressionHandler;
+
 //# sourceMappingURL=member_expression_handler.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"member_expression_handler.cjs","names":["NodeHandler","ASTParser"],"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,QAAQ,MAA2D;AACvE,MAAIC,uBAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAAuD;AAClE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,EAAE,QAAQ,aAAa;EAC7B,IAAI;AACJ,MAAIA,uBAAU,aAAa,SAAS,CAClC,QAAO,SAAS,KAAK,QAAQ,2BAA2B,KAAK;WACpDA,uBAAU,gBAAgB,SAAS,CAC5C,QAAQ,GAAG,SAAS,QAAmB,QACrC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,4BAA4B;EAE9C,IAAI;AACJ,MAAIA,uBAAU,aAAa,OAAO,CAChC,cAAa,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACxDA,uBAAU,gBAAgB,OAAO,CAC1C,cAAc,GAAG,OAAO,QAAmB,QACzC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,sBAAsB;AAExC,MAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,gBAClD,OAAM,IAAI,MAAM,mCAAmC;AAGrD,SAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;GAAM"}
+{"version":3,"file":"member_expression_handler.cjs","names":["NodeHandler","ASTParser"],"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,aAAAA,YAAY;;;;;;;CAOvD,MAAM,QAAQ,MAA2D;AACvE,MAAIC,aAAAA,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAAuD;AAClE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,EAAE,QAAQ,aAAa;EAC7B,IAAI;AACJ,MAAIA,aAAAA,UAAU,aAAa,SAAS,CAClC,QAAO,SAAS,KAAK,QAAQ,2BAA2B,KAAK;WACpDA,aAAAA,UAAU,gBAAgB,SAAS,CAC5C,QAAQ,GAAG,SAAS,QAAmB,QACrC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,4BAA4B;EAE9C,IAAI;AACJ,MAAIA,aAAAA,UAAU,aAAa,OAAO,CAChC,cAAa,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACxDA,aAAAA,UAAU,gBAAgB,OAAO,CAC1C,cAAc,GAAG,OAAO,QAAmB,QACzC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,sBAAsB;AAExC,MAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,gBAClD,OAAM,IAAI,MAAM,mCAAmC;AAGrD,SAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;GAAM"}

package/dist/output_parsers/expression_type_handlers/member_expression_handler.js

@@ -1,5 +1,4 @@
 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).
@@ -42,7 +41,7 @@ var MemberExpressionHandler = class extends NodeHandler {
 		};
 	}
 };
-
 //#endregion
 export { MemberExpressionHandler };
+
 //# sourceMappingURL=member_expression_handler.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"member_expression_handler.js","names":[],"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,QAAQ,MAA2D;AACvE,MAAI,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAAuD;AAClE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,EAAE,QAAQ,aAAa;EAC7B,IAAI;AACJ,MAAI,UAAU,aAAa,SAAS,CAClC,QAAO,SAAS,KAAK,QAAQ,2BAA2B,KAAK;WACpD,UAAU,gBAAgB,SAAS,CAC5C,QAAQ,GAAG,SAAS,QAAmB,QACrC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,4BAA4B;EAE9C,IAAI;AACJ,MAAI,UAAU,aAAa,OAAO,CAChC,cAAa,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACxD,UAAU,gBAAgB,OAAO,CAC1C,cAAc,GAAG,OAAO,QAAmB,QACzC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,sBAAsB;AAExC,MAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,gBAClD,OAAM,IAAI,MAAM,mCAAmC;AAGrD,SAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;GAAM"}
+{"version":3,"file":"member_expression_handler.js","names":[],"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,QAAQ,MAA2D;AACvE,MAAI,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAAuD;AAClE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,EAAE,QAAQ,aAAa;EAC7B,IAAI;AACJ,MAAI,UAAU,aAAa,SAAS,CAClC,QAAO,SAAS,KAAK,QAAQ,2BAA2B,KAAK;WACpD,UAAU,gBAAgB,SAAS,CAC5C,QAAQ,GAAG,SAAS,QAAmB,QACrC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,4BAA4B;EAE9C,IAAI;AACJ,MAAI,UAAU,aAAa,OAAO,CAChC,cAAa,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACxD,UAAU,gBAAgB,OAAO,CAC1C,cAAc,GAAG,OAAO,QAAmB,QACzC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,sBAAsB;AAExC,MAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,gBAClD,OAAM,IAAI,MAAM,mCAAmC;AAGrD,SAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;GAAM"}

package/dist/output_parsers/expression_type_handlers/numeric_literal_handler.cjs

@@ -1,5 +1,4 @@
-const require_base = require('./base.cjs');
-
+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).
@@ -30,7 +29,7 @@ var NumericLiteralHandler = class extends require_base.NodeHandler {
 		};
 	}
 };
-
 //#endregion
 exports.NumericLiteralHandler = NumericLiteralHandler;
+
 //# sourceMappingURL=numeric_literal_handler.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"numeric_literal_handler.cjs","names":["NodeHandler","ASTParser"],"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,QAAQ,MAAyD;AACrE,MAAIC,uBAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,MAAM;GAC1B"}
+{"version":3,"file":"numeric_literal_handler.cjs","names":["NodeHandler","ASTParser"],"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,aAAAA,YAAY;;;;;;;CAOrD,MAAM,QAAQ,MAAyD;AACrE,MAAIC,aAAAA,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,MAAM;GAC1B"}

package/dist/output_parsers/expression_type_handlers/numeric_literal_handler.js

@@ -1,5 +1,4 @@
 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).
@@ -30,7 +29,7 @@ var NumericLiteralHandler = class extends NodeHandler {
 		};
 	}
 };
-
 //#endregion
 export { NumericLiteralHandler };
+
 //# sourceMappingURL=numeric_literal_handler.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"numeric_literal_handler.js","names":[],"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,QAAQ,MAAyD;AACrE,MAAI,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,MAAM;GAC1B"}
+{"version":3,"file":"numeric_literal_handler.js","names":[],"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,QAAQ,MAAyD;AACrE,MAAI,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,MAAM;GAC1B"}

package/dist/output_parsers/expression_type_handlers/object_literal_expression_handler.cjs

@@ -1,6 +1,5 @@
-const require_base = require('./base.cjs');
-const require_property_assignment_handler = require('./property_assignment_handler.cjs');
-
+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
@@ -34,7 +33,7 @@ var ObjectLiteralExpressionHandler = class extends require_base.NodeHandler {
 		};
 	}
 };
-
 //#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 +1 @@
-{"version":3,"file":"object_literal_expression_handler.cjs","names":["NodeHandler","ASTParser","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,QAAQ,MAA2D;AACvE,MAAIC,uBAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAoD;AAC/D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,SAAmC,EAAE;EAC3C,MAAM,EAAE,eAAe;AACvB,OAAK,MAAM,YAAY,WACrB,KAAIA,uBAAU,qBAAqB,SAAS,CAC1C,QAAO,KACL,MAAM,IAAIC,8DAA0B,KAAK,cAAc,CAAC,OACtD,SACD,CACF;AAGL,SAAO;GAAE,MAAM;GAAkB;GAAQ"}
+{"version":3,"file":"object_literal_expression_handler.cjs","names":["NodeHandler","ASTParser","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,aAAAA,YAAY;;;;;;;CAO9D,MAAM,QAAQ,MAA2D;AACvE,MAAIC,aAAAA,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAoD;AAC/D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,SAAmC,EAAE;EAC3C,MAAM,EAAE,eAAe;AACvB,OAAK,MAAM,YAAY,WACrB,KAAIA,aAAAA,UAAU,qBAAqB,SAAS,CAC1C,QAAO,KACL,MAAM,IAAIC,oCAAAA,0BAA0B,KAAK,cAAc,CAAC,OACtD,SACD,CACF;AAGL,SAAO;GAAE,MAAM;GAAkB;GAAQ"}

package/dist/output_parsers/expression_type_handlers/object_literal_expression_handler.js

@@ -1,6 +1,5 @@
 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
@@ -34,7 +33,7 @@ var ObjectLiteralExpressionHandler = class extends NodeHandler {
 		};
 	}
 };
-
 //#endregion
 export { ObjectLiteralExpressionHandler };
+
 //# sourceMappingURL=object_literal_expression_handler.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"object_literal_expression_handler.js","names":[],"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,QAAQ,MAA2D;AACvE,MAAI,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAoD;AAC/D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,SAAmC,EAAE;EAC3C,MAAM,EAAE,eAAe;AACvB,OAAK,MAAM,YAAY,WACrB,KAAI,UAAU,qBAAqB,SAAS,CAC1C,QAAO,KACL,MAAM,IAAI,0BAA0B,KAAK,cAAc,CAAC,OACtD,SACD,CACF;AAGL,SAAO;GAAE,MAAM;GAAkB;GAAQ"}
+{"version":3,"file":"object_literal_expression_handler.js","names":[],"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,QAAQ,MAA2D;AACvE,MAAI,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAoD;AAC/D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,SAAmC,EAAE;EAC3C,MAAM,EAAE,eAAe;AACvB,OAAK,MAAM,YAAY,WACrB,KAAI,UAAU,qBAAqB,SAAS,CAC1C,QAAO,KACL,MAAM,IAAI,0BAA0B,KAAK,cAAc,CAAC,OACtD,SACD,CACF;AAGL,SAAO;GAAE,MAAM;GAAkB;GAAQ"}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.cjs

@@ -1,5 +1,4 @@
-const require_base = require('./base.cjs');
-
+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
@@ -37,7 +36,7 @@ var PropertyAssignmentHandler = class extends require_base.NodeHandler {
 		};
 	}
 };
-
 //#endregion
 exports.PropertyAssignmentHandler = PropertyAssignmentHandler;
+
 //# sourceMappingURL=property_assignment_handler.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"property_assignment_handler.cjs","names":["NodeHandler","ASTParser"],"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,QAAQ,MAA6D;AACzE,MAAIC,uBAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,IAAI;AACJ,MAAIA,uBAAU,aAAa,KAAK,IAAI,CAClC,QAAO,KAAK,IAAI;WACPA,uBAAU,gBAAgB,KAAK,IAAI,CAC5C,QAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM,4BAA4B;AAE9C,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,uBAAuB;AAOzC,SAAO;GAAE,MAAM;GAAuB,YALlB,GAAG,OAAkB,QACvC,2BACA,KACD;GAEiD,OADpC,MAAM,KAAK,cAAc,OAAO,KAAK,MAAM;GACA"}
+{"version":3,"file":"property_assignment_handler.cjs","names":["NodeHandler","ASTParser"],"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,aAAAA,YAAY;;;;;;;CAOzD,MAAM,QAAQ,MAA6D;AACzE,MAAIC,aAAAA,UAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,IAAI;AACJ,MAAIA,aAAAA,UAAU,aAAa,KAAK,IAAI,CAClC,QAAO,KAAK,IAAI;WACPA,aAAAA,UAAU,gBAAgB,KAAK,IAAI,CAC5C,QAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM,4BAA4B;AAE9C,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,uBAAuB;AAOzC,SAAO;GAAE,MAAM;GAAuB,YALlB,GAAG,OAAkB,QACvC,2BACA,KACD;GAEiD,OADpC,MAAM,KAAK,cAAc,OAAO,KAAK,MAAM;GACA"}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.js

@@ -1,5 +1,4 @@
 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
@@ -37,7 +36,7 @@ var PropertyAssignmentHandler = class extends NodeHandler {
 		};
 	}
 };
-
 //#endregion
 export { PropertyAssignmentHandler };
+
 //# sourceMappingURL=property_assignment_handler.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"property_assignment_handler.js","names":[],"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,QAAQ,MAA6D;AACzE,MAAI,UAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,IAAI;AACJ,MAAI,UAAU,aAAa,KAAK,IAAI,CAClC,QAAO,KAAK,IAAI;WACP,UAAU,gBAAgB,KAAK,IAAI,CAC5C,QAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM,4BAA4B;AAE9C,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,uBAAuB;AAOzC,SAAO;GAAE,MAAM;GAAuB,YALlB,GAAG,OAAkB,QACvC,2BACA,KACD;GAEiD,OADpC,MAAM,KAAK,cAAc,OAAO,KAAK,MAAM;GACA"}
+{"version":3,"file":"property_assignment_handler.js","names":[],"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,QAAQ,MAA6D;AACzE,MAAI,UAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,IAAI;AACJ,MAAI,UAAU,aAAa,KAAK,IAAI,CAClC,QAAO,KAAK,IAAI;WACP,UAAU,gBAAgB,KAAK,IAAI,CAC5C,QAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM,4BAA4B;AAE9C,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,uBAAuB;AAOzC,SAAO;GAAE,MAAM;GAAuB,YALlB,GAAG,OAAkB,QACvC,2BACA,KACD;GAEiD,OADpC,MAAM,KAAK,cAAc,OAAO,KAAK,MAAM;GACA"}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.cjs

@@ -1,5 +1,4 @@
-const require_base = require('./base.cjs');
-
+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.
@@ -30,7 +29,7 @@ var StringLiteralHandler = class extends require_base.NodeHandler {
 		};
 	}
 };
-
 //#endregion
 exports.StringLiteralHandler = StringLiteralHandler;
+
 //# sourceMappingURL=string_literal_handler.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"string_literal_handler.cjs","names":["NodeHandler","ASTParser"],"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,QAAQ,MAAwD;AACpE,MAAIC,uBAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAMH,SAAO;GAAE,MAAM;GAAkB,OAJnB,GAAG,KAAK,QAAmB,QACvC,2BACA,KACD;GAC6C"}
+{"version":3,"file":"string_literal_handler.cjs","names":["NodeHandler","ASTParser"],"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,aAAAA,YAAY;;;;;;;CAOpD,MAAM,QAAQ,MAAwD;AACpE,MAAIC,aAAAA,UAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAMH,SAAO;GAAE,MAAM;GAAkB,OAJnB,GAAG,KAAK,QAAmB,QACvC,2BACA,KACD;GAC6C"}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.js

@@ -1,5 +1,4 @@
 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.
@@ -30,7 +29,7 @@ var StringLiteralHandler = class extends NodeHandler {
 		};
 	}
 };
-
 //#endregion
 export { StringLiteralHandler };
+
 //# sourceMappingURL=string_literal_handler.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"string_literal_handler.js","names":[],"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,QAAQ,MAAwD;AACpE,MAAI,UAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAMH,SAAO;GAAE,MAAM;GAAkB,OAJnB,GAAG,KAAK,QAAmB,QACvC,2BACA,KACD;GAC6C"}
+{"version":3,"file":"string_literal_handler.js","names":[],"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,QAAQ,MAAwD;AACpE,MAAI,UAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAMH,SAAO;GAAE,MAAM;GAAkB,OAJnB,GAAG,KAAK,QAAmB,QACvC,2BACA,KACD;GAC6C"}

package/dist/output_parsers/fix.cjs

@@ -1,8 +1,7 @@
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_llm_chain = require('../chains/llm_chain.cjs');
-const require_prompts = require('./prompts.cjs');
+require("../_virtual/_rolldown/runtime.cjs");
+const require_llm_chain = require("../chains/llm_chain.cjs");
+const require_prompts = require("./prompts.cjs");
 let _langchain_core_output_parsers = require("@langchain/core/output_parsers");
-
 //#region src/output_parsers/fix.ts
 function isLLMChain(x) {
 	return x.prompt !== void 0 && x.llm !== void 0;
@@ -80,7 +79,7 @@ var OutputFixingParser = class OutputFixingParser extends _langchain_core_output
 		return this.parser.getFormatInstructions();
 	}
 };
-
 //#endregion
 exports.OutputFixingParser = OutputFixingParser;
+
 //# sourceMappingURL=fix.cjs.map

package/dist/output_parsers/fix.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"fix.cjs","names":["BaseOutputParser","LLMChain","NAIVE_FIX_PROMPT","OutputParserException"],"sources":["../../src/output_parsers/fix.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { NAIVE_FIX_PROMPT } from \"./prompts.js\";\n\ninterface OutputFixingParserRetryInput {\n  instructions: string;\n  completion: string;\n  error: OutputParserException;\n}\n\nfunction isLLMChain<T>(\n  x: LLMChain | Runnable<OutputFixingParserRetryInput, T>\n): x is LLMChain {\n  return (\n    (x as LLMChain).prompt !== undefined && (x as LLMChain).llm !== undefined\n  );\n}\n\n/**\n * Class that extends the BaseOutputParser to handle situations where the\n * initial parsing attempt fails. It contains a retryChain for retrying\n * the parsing process in case of a failure.\n */\nexport class OutputFixingParser<T> extends BaseOutputParser<T> {\n  static lc_name() {\n    return \"OutputFixingParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"fix\"];\n\n  lc_serializable = true;\n\n  parser: BaseOutputParser<T>;\n\n  retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n\n  /**\n   * Static method to create a new instance of OutputFixingParser using a\n   * given language model, parser, and optional fields.\n   * @param llm The language model to be used.\n   * @param parser The parser to be used.\n   * @param fields Optional fields which may contain a prompt.\n   * @returns A new instance of OutputFixingParser.\n   */\n  static fromLLM<T>(\n    llm: BaseLanguageModelInterface,\n    parser: BaseOutputParser<T>,\n    fields?: {\n      prompt?: BasePromptTemplate;\n    }\n  ) {\n    const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;\n    const chain = new LLMChain({ llm, prompt });\n    return new OutputFixingParser<T>({ parser, retryChain: chain });\n  }\n\n  constructor({\n    parser,\n    retryChain,\n  }: {\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n  }) {\n    super(...arguments);\n    this.parser = parser;\n    this.retryChain = retryChain;\n  }\n\n  /**\n   * Method to parse the completion using the parser. If the initial parsing\n   * fails, it uses the retryChain to attempt to fix the output and retry\n   * the parsing process.\n   * @param completion The completion to be parsed.\n   * @param callbacks Optional callbacks to be used during parsing.\n   * @returns The parsed output.\n   */\n  async parse(completion: string, callbacks?: Callbacks) {\n    try {\n      return await this.parser.parse(completion, callbacks);\n    } catch (e) {\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      if (e instanceof OutputParserException) {\n        const retryInput = {\n          instructions: this.parser.getFormatInstructions(),\n          completion,\n          error: e,\n        };\n\n        if (isLLMChain(this.retryChain)) {\n          const result = await this.retryChain.call(retryInput, callbacks);\n          const newCompletion: string = result[this.retryChain.outputKey];\n          return this.parser.parse(newCompletion, callbacks);\n        } else {\n          const result = await this.retryChain.invoke(retryInput, {\n            callbacks,\n          });\n          return result;\n        }\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Method to get the format instructions for the parser.\n   * @returns The format instructions for the parser.\n   */\n  getFormatInstructions() {\n    return this.parser.getFormatInstructions();\n  }\n}\n"],"mappings":";;;;;;AAiBA,SAAS,WACP,GACe;AACf,QACG,EAAe,WAAW,UAAc,EAAe,QAAQ;;;;;;;AASpE,IAAa,qBAAb,MAAa,2BAA8BA,gDAAoB;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAM;CAErD,kBAAkB;CAElB;CAEA;;;;;;;;;CAUA,OAAO,QACL,KACA,QACA,QAGA;AAGA,SAAO,IAAI,mBAAsB;GAAE;GAAQ,YAD7B,IAAIC,2BAAS;IAAE;IAAK,QADnB,QAAQ,UAAUC;IACS,CAAC;GACmB,CAAC;;CAGjE,YAAY,EACV,QACA,cAIC;AACD,QAAM,GAAG,UAAU;AACnB,OAAK,SAAS;AACd,OAAK,aAAa;;;;;;;;;;CAWpB,MAAM,MAAM,YAAoB,WAAuB;AACrD,MAAI;AACF,UAAO,MAAM,KAAK,OAAO,MAAM,YAAY,UAAU;WAC9C,GAAG;AAEV,OAAI,aAAaC,sDAAuB;IACtC,MAAM,aAAa;KACjB,cAAc,KAAK,OAAO,uBAAuB;KACjD;KACA,OAAO;KACR;AAED,QAAI,WAAW,KAAK,WAAW,EAAE;KAE/B,MAAM,iBADS,MAAM,KAAK,WAAW,KAAK,YAAY,UAAU,EAC3B,KAAK,WAAW;AACrD,YAAO,KAAK,OAAO,MAAM,eAAe,UAAU;UAKlD,QAHe,MAAM,KAAK,WAAW,OAAO,YAAY,EACtD,WACD,CAAC;;AAIN,SAAM;;;;;;;CAQV,wBAAwB;AACtB,SAAO,KAAK,OAAO,uBAAuB"}
+{"version":3,"file":"fix.cjs","names":["BaseOutputParser","LLMChain","NAIVE_FIX_PROMPT","OutputParserException"],"sources":["../../src/output_parsers/fix.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { NAIVE_FIX_PROMPT } from \"./prompts.js\";\n\ninterface OutputFixingParserRetryInput {\n  instructions: string;\n  completion: string;\n  error: OutputParserException;\n}\n\nfunction isLLMChain<T>(\n  x: LLMChain | Runnable<OutputFixingParserRetryInput, T>\n): x is LLMChain {\n  return (\n    (x as LLMChain).prompt !== undefined && (x as LLMChain).llm !== undefined\n  );\n}\n\n/**\n * Class that extends the BaseOutputParser to handle situations where the\n * initial parsing attempt fails. It contains a retryChain for retrying\n * the parsing process in case of a failure.\n */\nexport class OutputFixingParser<T> extends BaseOutputParser<T> {\n  static lc_name() {\n    return \"OutputFixingParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"fix\"];\n\n  lc_serializable = true;\n\n  parser: BaseOutputParser<T>;\n\n  retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n\n  /**\n   * Static method to create a new instance of OutputFixingParser using a\n   * given language model, parser, and optional fields.\n   * @param llm The language model to be used.\n   * @param parser The parser to be used.\n   * @param fields Optional fields which may contain a prompt.\n   * @returns A new instance of OutputFixingParser.\n   */\n  static fromLLM<T>(\n    llm: BaseLanguageModelInterface,\n    parser: BaseOutputParser<T>,\n    fields?: {\n      prompt?: BasePromptTemplate;\n    }\n  ) {\n    const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;\n    const chain = new LLMChain({ llm, prompt });\n    return new OutputFixingParser<T>({ parser, retryChain: chain });\n  }\n\n  constructor({\n    parser,\n    retryChain,\n  }: {\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n  }) {\n    super(...arguments);\n    this.parser = parser;\n    this.retryChain = retryChain;\n  }\n\n  /**\n   * Method to parse the completion using the parser. If the initial parsing\n   * fails, it uses the retryChain to attempt to fix the output and retry\n   * the parsing process.\n   * @param completion The completion to be parsed.\n   * @param callbacks Optional callbacks to be used during parsing.\n   * @returns The parsed output.\n   */\n  async parse(completion: string, callbacks?: Callbacks) {\n    try {\n      return await this.parser.parse(completion, callbacks);\n    } catch (e) {\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      if (e instanceof OutputParserException) {\n        const retryInput = {\n          instructions: this.parser.getFormatInstructions(),\n          completion,\n          error: e,\n        };\n\n        if (isLLMChain(this.retryChain)) {\n          const result = await this.retryChain.call(retryInput, callbacks);\n          const newCompletion: string = result[this.retryChain.outputKey];\n          return this.parser.parse(newCompletion, callbacks);\n        } else {\n          const result = await this.retryChain.invoke(retryInput, {\n            callbacks,\n          });\n          return result;\n        }\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Method to get the format instructions for the parser.\n   * @returns The format instructions for the parser.\n   */\n  getFormatInstructions() {\n    return this.parser.getFormatInstructions();\n  }\n}\n"],"mappings":";;;;;AAiBA,SAAS,WACP,GACe;AACf,QACG,EAAe,WAAW,KAAA,KAAc,EAAe,QAAQ,KAAA;;;;;;;AASpE,IAAa,qBAAb,MAAa,2BAA8BA,+BAAAA,iBAAoB;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAM;CAErD,kBAAkB;CAElB;CAEA;;;;;;;;;CAUA,OAAO,QACL,KACA,QACA,QAGA;AAGA,SAAO,IAAI,mBAAsB;GAAE;GAAQ,YAD7B,IAAIC,kBAAAA,SAAS;IAAE;IAAK,QADnB,QAAQ,UAAUC,gBAAAA;IACS,CAAC;GACmB,CAAC;;CAGjE,YAAY,EACV,QACA,cAIC;AACD,QAAM,GAAG,UAAU;AACnB,OAAK,SAAS;AACd,OAAK,aAAa;;;;;;;;;;CAWpB,MAAM,MAAM,YAAoB,WAAuB;AACrD,MAAI;AACF,UAAO,MAAM,KAAK,OAAO,MAAM,YAAY,UAAU;WAC9C,GAAG;AAEV,OAAI,aAAaC,+BAAAA,uBAAuB;IACtC,MAAM,aAAa;KACjB,cAAc,KAAK,OAAO,uBAAuB;KACjD;KACA,OAAO;KACR;AAED,QAAI,WAAW,KAAK,WAAW,EAAE;KAE/B,MAAM,iBADS,MAAM,KAAK,WAAW,KAAK,YAAY,UAAU,EAC3B,KAAK,WAAW;AACrD,YAAO,KAAK,OAAO,MAAM,eAAe,UAAU;UAKlD,QAHe,MAAM,KAAK,WAAW,OAAO,YAAY,EACtD,WACD,CAAC;;AAIN,SAAM;;;;;;;CAQV,wBAAwB;AACtB,SAAO,KAAK,OAAO,uBAAuB"}

package/dist/output_parsers/fix.js

@@ -1,7 +1,6 @@
 import { LLMChain } from "../chains/llm_chain.js";
 import { NAIVE_FIX_PROMPT } from "./prompts.js";
 import { BaseOutputParser, OutputParserException } from "@langchain/core/output_parsers";
-
 //#region src/output_parsers/fix.ts
 function isLLMChain(x) {
 	return x.prompt !== void 0 && x.llm !== void 0;
@@ -79,7 +78,7 @@ var OutputFixingParser = class OutputFixingParser extends BaseOutputParser {
 		return this.parser.getFormatInstructions();
 	}
 };
-
 //#endregion
 export { OutputFixingParser };
+
 //# sourceMappingURL=fix.js.map

package/dist/output_parsers/fix.js.map

@@ -1 +1 @@
-{"version":3,"file":"fix.js","names":[],"sources":["../../src/output_parsers/fix.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { NAIVE_FIX_PROMPT } from \"./prompts.js\";\n\ninterface OutputFixingParserRetryInput {\n  instructions: string;\n  completion: string;\n  error: OutputParserException;\n}\n\nfunction isLLMChain<T>(\n  x: LLMChain | Runnable<OutputFixingParserRetryInput, T>\n): x is LLMChain {\n  return (\n    (x as LLMChain).prompt !== undefined && (x as LLMChain).llm !== undefined\n  );\n}\n\n/**\n * Class that extends the BaseOutputParser to handle situations where the\n * initial parsing attempt fails. It contains a retryChain for retrying\n * the parsing process in case of a failure.\n */\nexport class OutputFixingParser<T> extends BaseOutputParser<T> {\n  static lc_name() {\n    return \"OutputFixingParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"fix\"];\n\n  lc_serializable = true;\n\n  parser: BaseOutputParser<T>;\n\n  retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n\n  /**\n   * Static method to create a new instance of OutputFixingParser using a\n   * given language model, parser, and optional fields.\n   * @param llm The language model to be used.\n   * @param parser The parser to be used.\n   * @param fields Optional fields which may contain a prompt.\n   * @returns A new instance of OutputFixingParser.\n   */\n  static fromLLM<T>(\n    llm: BaseLanguageModelInterface,\n    parser: BaseOutputParser<T>,\n    fields?: {\n      prompt?: BasePromptTemplate;\n    }\n  ) {\n    const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;\n    const chain = new LLMChain({ llm, prompt });\n    return new OutputFixingParser<T>({ parser, retryChain: chain });\n  }\n\n  constructor({\n    parser,\n    retryChain,\n  }: {\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n  }) {\n    super(...arguments);\n    this.parser = parser;\n    this.retryChain = retryChain;\n  }\n\n  /**\n   * Method to parse the completion using the parser. If the initial parsing\n   * fails, it uses the retryChain to attempt to fix the output and retry\n   * the parsing process.\n   * @param completion The completion to be parsed.\n   * @param callbacks Optional callbacks to be used during parsing.\n   * @returns The parsed output.\n   */\n  async parse(completion: string, callbacks?: Callbacks) {\n    try {\n      return await this.parser.parse(completion, callbacks);\n    } catch (e) {\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      if (e instanceof OutputParserException) {\n        const retryInput = {\n          instructions: this.parser.getFormatInstructions(),\n          completion,\n          error: e,\n        };\n\n        if (isLLMChain(this.retryChain)) {\n          const result = await this.retryChain.call(retryInput, callbacks);\n          const newCompletion: string = result[this.retryChain.outputKey];\n          return this.parser.parse(newCompletion, callbacks);\n        } else {\n          const result = await this.retryChain.invoke(retryInput, {\n            callbacks,\n          });\n          return result;\n        }\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Method to get the format instructions for the parser.\n   * @returns The format instructions for the parser.\n   */\n  getFormatInstructions() {\n    return this.parser.getFormatInstructions();\n  }\n}\n"],"mappings":";;;;;AAiBA,SAAS,WACP,GACe;AACf,QACG,EAAe,WAAW,UAAc,EAAe,QAAQ;;;;;;;AASpE,IAAa,qBAAb,MAAa,2BAA8B,iBAAoB;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAM;CAErD,kBAAkB;CAElB;CAEA;;;;;;;;;CAUA,OAAO,QACL,KACA,QACA,QAGA;AAGA,SAAO,IAAI,mBAAsB;GAAE;GAAQ,YAD7B,IAAI,SAAS;IAAE;IAAK,QADnB,QAAQ,UAAU;IACS,CAAC;GACmB,CAAC;;CAGjE,YAAY,EACV,QACA,cAIC;AACD,QAAM,GAAG,UAAU;AACnB,OAAK,SAAS;AACd,OAAK,aAAa;;;;;;;;;;CAWpB,MAAM,MAAM,YAAoB,WAAuB;AACrD,MAAI;AACF,UAAO,MAAM,KAAK,OAAO,MAAM,YAAY,UAAU;WAC9C,GAAG;AAEV,OAAI,aAAa,uBAAuB;IACtC,MAAM,aAAa;KACjB,cAAc,KAAK,OAAO,uBAAuB;KACjD;KACA,OAAO;KACR;AAED,QAAI,WAAW,KAAK,WAAW,EAAE;KAE/B,MAAM,iBADS,MAAM,KAAK,WAAW,KAAK,YAAY,UAAU,EAC3B,KAAK,WAAW;AACrD,YAAO,KAAK,OAAO,MAAM,eAAe,UAAU;UAKlD,QAHe,MAAM,KAAK,WAAW,OAAO,YAAY,EACtD,WACD,CAAC;;AAIN,SAAM;;;;;;;CAQV,wBAAwB;AACtB,SAAO,KAAK,OAAO,uBAAuB"}
+{"version":3,"file":"fix.js","names":[],"sources":["../../src/output_parsers/fix.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { NAIVE_FIX_PROMPT } from \"./prompts.js\";\n\ninterface OutputFixingParserRetryInput {\n  instructions: string;\n  completion: string;\n  error: OutputParserException;\n}\n\nfunction isLLMChain<T>(\n  x: LLMChain | Runnable<OutputFixingParserRetryInput, T>\n): x is LLMChain {\n  return (\n    (x as LLMChain).prompt !== undefined && (x as LLMChain).llm !== undefined\n  );\n}\n\n/**\n * Class that extends the BaseOutputParser to handle situations where the\n * initial parsing attempt fails. It contains a retryChain for retrying\n * the parsing process in case of a failure.\n */\nexport class OutputFixingParser<T> extends BaseOutputParser<T> {\n  static lc_name() {\n    return \"OutputFixingParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"fix\"];\n\n  lc_serializable = true;\n\n  parser: BaseOutputParser<T>;\n\n  retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n\n  /**\n   * Static method to create a new instance of OutputFixingParser using a\n   * given language model, parser, and optional fields.\n   * @param llm The language model to be used.\n   * @param parser The parser to be used.\n   * @param fields Optional fields which may contain a prompt.\n   * @returns A new instance of OutputFixingParser.\n   */\n  static fromLLM<T>(\n    llm: BaseLanguageModelInterface,\n    parser: BaseOutputParser<T>,\n    fields?: {\n      prompt?: BasePromptTemplate;\n    }\n  ) {\n    const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;\n    const chain = new LLMChain({ llm, prompt });\n    return new OutputFixingParser<T>({ parser, retryChain: chain });\n  }\n\n  constructor({\n    parser,\n    retryChain,\n  }: {\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n  }) {\n    super(...arguments);\n    this.parser = parser;\n    this.retryChain = retryChain;\n  }\n\n  /**\n   * Method to parse the completion using the parser. If the initial parsing\n   * fails, it uses the retryChain to attempt to fix the output and retry\n   * the parsing process.\n   * @param completion The completion to be parsed.\n   * @param callbacks Optional callbacks to be used during parsing.\n   * @returns The parsed output.\n   */\n  async parse(completion: string, callbacks?: Callbacks) {\n    try {\n      return await this.parser.parse(completion, callbacks);\n    } catch (e) {\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      if (e instanceof OutputParserException) {\n        const retryInput = {\n          instructions: this.parser.getFormatInstructions(),\n          completion,\n          error: e,\n        };\n\n        if (isLLMChain(this.retryChain)) {\n          const result = await this.retryChain.call(retryInput, callbacks);\n          const newCompletion: string = result[this.retryChain.outputKey];\n          return this.parser.parse(newCompletion, callbacks);\n        } else {\n          const result = await this.retryChain.invoke(retryInput, {\n            callbacks,\n          });\n          return result;\n        }\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Method to get the format instructions for the parser.\n   * @returns The format instructions for the parser.\n   */\n  getFormatInstructions() {\n    return this.parser.getFormatInstructions();\n  }\n}\n"],"mappings":";;;;AAiBA,SAAS,WACP,GACe;AACf,QACG,EAAe,WAAW,KAAA,KAAc,EAAe,QAAQ,KAAA;;;;;;;AASpE,IAAa,qBAAb,MAAa,2BAA8B,iBAAoB;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAM;CAErD,kBAAkB;CAElB;CAEA;;;;;;;;;CAUA,OAAO,QACL,KACA,QACA,QAGA;AAGA,SAAO,IAAI,mBAAsB;GAAE;GAAQ,YAD7B,IAAI,SAAS;IAAE;IAAK,QADnB,QAAQ,UAAU;IACS,CAAC;GACmB,CAAC;;CAGjE,YAAY,EACV,QACA,cAIC;AACD,QAAM,GAAG,UAAU;AACnB,OAAK,SAAS;AACd,OAAK,aAAa;;;;;;;;;;CAWpB,MAAM,MAAM,YAAoB,WAAuB;AACrD,MAAI;AACF,UAAO,MAAM,KAAK,OAAO,MAAM,YAAY,UAAU;WAC9C,GAAG;AAEV,OAAI,aAAa,uBAAuB;IACtC,MAAM,aAAa;KACjB,cAAc,KAAK,OAAO,uBAAuB;KACjD;KACA,OAAO;KACR;AAED,QAAI,WAAW,KAAK,WAAW,EAAE;KAE/B,MAAM,iBADS,MAAM,KAAK,WAAW,KAAK,YAAY,UAAU,EAC3B,KAAK,WAAW;AACrD,YAAO,KAAK,OAAO,MAAM,eAAe,UAAU;UAKlD,QAHe,MAAM,KAAK,WAAW,OAAO,YAAY,EACtD,WACD,CAAC;;AAIN,SAAM;;;;;;;CAQV,wBAAwB;AACtB,SAAO,KAAK,OAAO,uBAAuB"}

package/dist/output_parsers/http_response.cjs

@@ -1,6 +1,5 @@
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+require("../_virtual/_rolldown/runtime.cjs");
 let _langchain_core_output_parsers = require("@langchain/core/output_parsers");
-
 //#region src/output_parsers/http_response.ts
 /**
 * OutputParser that formats chunks emitted from an LLM for different HTTP content types.
@@ -44,7 +43,7 @@ var HttpResponseOutputParser = class extends _langchain_core_output_parsers.Base
 		return "";
 	}
 };
-
 //#endregion
 exports.HttpResponseOutputParser = HttpResponseOutputParser;
+
 //# sourceMappingURL=http_response.cjs.map

package/dist/output_parsers/http_response.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"http_response.cjs","names":["BaseTransformOutputParser","StringOutputParser"],"sources":["../../src/output_parsers/http_response.ts"],"sourcesContent":["import { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  BaseTransformOutputParser,\n  StringOutputParser,\n} from \"@langchain/core/output_parsers\";\n\nexport type HttpResponseOutputParserInput = {\n  outputParser?: BaseTransformOutputParser;\n  contentType?: \"text/plain\" | \"text/event-stream\";\n};\n\n/**\n * OutputParser that formats chunks emitted from an LLM for different HTTP content types.\n */\nexport class HttpResponseOutputParser extends BaseTransformOutputParser<Uint8Array> {\n  static lc_name() {\n    return \"HttpResponseOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parser\"];\n\n  lc_serializable = true;\n\n  outputParser: BaseTransformOutputParser = new StringOutputParser();\n\n  contentType: \"text/plain\" | \"text/event-stream\" = \"text/plain\";\n\n  constructor(fields?: HttpResponseOutputParserInput) {\n    super(fields);\n    this.outputParser = fields?.outputParser ?? this.outputParser;\n    this.contentType = fields?.contentType ?? this.contentType;\n  }\n\n  async *_transform(\n    inputGenerator: AsyncGenerator<string | BaseMessage>\n  ): AsyncGenerator<Uint8Array> {\n    for await (const chunk of this.outputParser._transform(inputGenerator)) {\n      if (typeof chunk === \"string\") {\n        yield this.parse(chunk);\n      } else {\n        yield this.parse(JSON.stringify(chunk));\n      }\n    }\n    if (this.contentType === \"text/event-stream\") {\n      const encoder = new TextEncoder();\n      yield encoder.encode(`event: end\\n\\n`);\n    }\n  }\n\n  /**\n   * Parses a string output from an LLM call. This method is meant to be\n   * implemented by subclasses to define how a string output from an LLM\n   * should be parsed.\n   * @param text The string output from an LLM call.\n   * @param callbacks Optional callbacks.\n   * @returns A promise of the parsed output.\n   */\n  async parse(text: string): Promise<Uint8Array> {\n    const chunk = await this.outputParser.parse(text);\n    const encoder = new TextEncoder();\n    if (this.contentType === \"text/event-stream\") {\n      return encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`);\n    }\n    let parsedChunk;\n    if (typeof chunk === \"string\") {\n      parsedChunk = chunk;\n    } else {\n      parsedChunk = JSON.stringify(chunk);\n    }\n    return encoder.encode(parsedChunk);\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;;;AAcA,IAAa,2BAAb,cAA8CA,yDAAsC;CAClF,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,aAAa,gBAAgB;CAE7C,kBAAkB;CAElB,eAA0C,IAAIC,mDAAoB;CAElE,cAAkD;CAElD,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,eAAe,QAAQ,gBAAgB,KAAK;AACjD,OAAK,cAAc,QAAQ,eAAe,KAAK;;CAGjD,OAAO,WACL,gBAC4B;AAC5B,aAAW,MAAM,SAAS,KAAK,aAAa,WAAW,eAAe,CACpE,KAAI,OAAO,UAAU,SACnB,OAAM,KAAK,MAAM,MAAM;MAEvB,OAAM,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC;AAG3C,MAAI,KAAK,gBAAgB,oBAEvB,OADgB,IAAI,aAAa,CACnB,OAAO,iBAAiB;;;;;;;;;;CAY1C,MAAM,MAAM,MAAmC;EAC7C,MAAM,QAAQ,MAAM,KAAK,aAAa,MAAM,KAAK;EACjD,MAAM,UAAU,IAAI,aAAa;AACjC,MAAI,KAAK,gBAAgB,oBACvB,QAAO,QAAQ,OAAO,sBAAsB,KAAK,UAAU,MAAM,CAAC,MAAM;EAE1E,IAAI;AACJ,MAAI,OAAO,UAAU,SACnB,eAAc;MAEd,eAAc,KAAK,UAAU,MAAM;AAErC,SAAO,QAAQ,OAAO,YAAY;;CAGpC,wBAAgC;AAC9B,SAAO"}
+{"version":3,"file":"http_response.cjs","names":["BaseTransformOutputParser","StringOutputParser"],"sources":["../../src/output_parsers/http_response.ts"],"sourcesContent":["import { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  BaseTransformOutputParser,\n  StringOutputParser,\n} from \"@langchain/core/output_parsers\";\n\nexport type HttpResponseOutputParserInput = {\n  outputParser?: BaseTransformOutputParser;\n  contentType?: \"text/plain\" | \"text/event-stream\";\n};\n\n/**\n * OutputParser that formats chunks emitted from an LLM for different HTTP content types.\n */\nexport class HttpResponseOutputParser extends BaseTransformOutputParser<Uint8Array> {\n  static lc_name() {\n    return \"HttpResponseOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parser\"];\n\n  lc_serializable = true;\n\n  outputParser: BaseTransformOutputParser = new StringOutputParser();\n\n  contentType: \"text/plain\" | \"text/event-stream\" = \"text/plain\";\n\n  constructor(fields?: HttpResponseOutputParserInput) {\n    super(fields);\n    this.outputParser = fields?.outputParser ?? this.outputParser;\n    this.contentType = fields?.contentType ?? this.contentType;\n  }\n\n  async *_transform(\n    inputGenerator: AsyncGenerator<string | BaseMessage>\n  ): AsyncGenerator<Uint8Array> {\n    for await (const chunk of this.outputParser._transform(inputGenerator)) {\n      if (typeof chunk === \"string\") {\n        yield this.parse(chunk);\n      } else {\n        yield this.parse(JSON.stringify(chunk));\n      }\n    }\n    if (this.contentType === \"text/event-stream\") {\n      const encoder = new TextEncoder();\n      yield encoder.encode(`event: end\\n\\n`);\n    }\n  }\n\n  /**\n   * Parses a string output from an LLM call. This method is meant to be\n   * implemented by subclasses to define how a string output from an LLM\n   * should be parsed.\n   * @param text The string output from an LLM call.\n   * @param callbacks Optional callbacks.\n   * @returns A promise of the parsed output.\n   */\n  async parse(text: string): Promise<Uint8Array> {\n    const chunk = await this.outputParser.parse(text);\n    const encoder = new TextEncoder();\n    if (this.contentType === \"text/event-stream\") {\n      return encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`);\n    }\n    let parsedChunk;\n    if (typeof chunk === \"string\") {\n      parsedChunk = chunk;\n    } else {\n      parsedChunk = JSON.stringify(chunk);\n    }\n    return encoder.encode(parsedChunk);\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;;AAcA,IAAa,2BAAb,cAA8CA,+BAAAA,0BAAsC;CAClF,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,aAAa,gBAAgB;CAE7C,kBAAkB;CAElB,eAA0C,IAAIC,+BAAAA,oBAAoB;CAElE,cAAkD;CAElD,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,eAAe,QAAQ,gBAAgB,KAAK;AACjD,OAAK,cAAc,QAAQ,eAAe,KAAK;;CAGjD,OAAO,WACL,gBAC4B;AAC5B,aAAW,MAAM,SAAS,KAAK,aAAa,WAAW,eAAe,CACpE,KAAI,OAAO,UAAU,SACnB,OAAM,KAAK,MAAM,MAAM;MAEvB,OAAM,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC;AAG3C,MAAI,KAAK,gBAAgB,oBAEvB,OADgB,IAAI,aAAa,CACnB,OAAO,iBAAiB;;;;;;;;;;CAY1C,MAAM,MAAM,MAAmC;EAC7C,MAAM,QAAQ,MAAM,KAAK,aAAa,MAAM,KAAK;EACjD,MAAM,UAAU,IAAI,aAAa;AACjC,MAAI,KAAK,gBAAgB,oBACvB,QAAO,QAAQ,OAAO,sBAAsB,KAAK,UAAU,MAAM,CAAC,MAAM;EAE1E,IAAI;AACJ,MAAI,OAAO,UAAU,SACnB,eAAc;MAEd,eAAc,KAAK,UAAU,MAAM;AAErC,SAAO,QAAQ,OAAO,YAAY;;CAGpC,wBAAgC;AAC9B,SAAO"}

package/dist/output_parsers/http_response.js

@@ -1,5 +1,4 @@
 import { BaseTransformOutputParser, StringOutputParser } from "@langchain/core/output_parsers";
-
 //#region src/output_parsers/http_response.ts
 /**
 * OutputParser that formats chunks emitted from an LLM for different HTTP content types.
@@ -43,7 +42,7 @@ var HttpResponseOutputParser = class extends BaseTransformOutputParser {
 		return "";
 	}
 };
-
 //#endregion
 export { HttpResponseOutputParser };
+
 //# sourceMappingURL=http_response.js.map

package/dist/output_parsers/http_response.js.map

@@ -1 +1 @@
-{"version":3,"file":"http_response.js","names":[],"sources":["../../src/output_parsers/http_response.ts"],"sourcesContent":["import { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  BaseTransformOutputParser,\n  StringOutputParser,\n} from \"@langchain/core/output_parsers\";\n\nexport type HttpResponseOutputParserInput = {\n  outputParser?: BaseTransformOutputParser;\n  contentType?: \"text/plain\" | \"text/event-stream\";\n};\n\n/**\n * OutputParser that formats chunks emitted from an LLM for different HTTP content types.\n */\nexport class HttpResponseOutputParser extends BaseTransformOutputParser<Uint8Array> {\n  static lc_name() {\n    return \"HttpResponseOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parser\"];\n\n  lc_serializable = true;\n\n  outputParser: BaseTransformOutputParser = new StringOutputParser();\n\n  contentType: \"text/plain\" | \"text/event-stream\" = \"text/plain\";\n\n  constructor(fields?: HttpResponseOutputParserInput) {\n    super(fields);\n    this.outputParser = fields?.outputParser ?? this.outputParser;\n    this.contentType = fields?.contentType ?? this.contentType;\n  }\n\n  async *_transform(\n    inputGenerator: AsyncGenerator<string | BaseMessage>\n  ): AsyncGenerator<Uint8Array> {\n    for await (const chunk of this.outputParser._transform(inputGenerator)) {\n      if (typeof chunk === \"string\") {\n        yield this.parse(chunk);\n      } else {\n        yield this.parse(JSON.stringify(chunk));\n      }\n    }\n    if (this.contentType === \"text/event-stream\") {\n      const encoder = new TextEncoder();\n      yield encoder.encode(`event: end\\n\\n`);\n    }\n  }\n\n  /**\n   * Parses a string output from an LLM call. This method is meant to be\n   * implemented by subclasses to define how a string output from an LLM\n   * should be parsed.\n   * @param text The string output from an LLM call.\n   * @param callbacks Optional callbacks.\n   * @returns A promise of the parsed output.\n   */\n  async parse(text: string): Promise<Uint8Array> {\n    const chunk = await this.outputParser.parse(text);\n    const encoder = new TextEncoder();\n    if (this.contentType === \"text/event-stream\") {\n      return encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`);\n    }\n    let parsedChunk;\n    if (typeof chunk === \"string\") {\n      parsedChunk = chunk;\n    } else {\n      parsedChunk = JSON.stringify(chunk);\n    }\n    return encoder.encode(parsedChunk);\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;;AAcA,IAAa,2BAAb,cAA8C,0BAAsC;CAClF,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,aAAa,gBAAgB;CAE7C,kBAAkB;CAElB,eAA0C,IAAI,oBAAoB;CAElE,cAAkD;CAElD,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,eAAe,QAAQ,gBAAgB,KAAK;AACjD,OAAK,cAAc,QAAQ,eAAe,KAAK;;CAGjD,OAAO,WACL,gBAC4B;AAC5B,aAAW,MAAM,SAAS,KAAK,aAAa,WAAW,eAAe,CACpE,KAAI,OAAO,UAAU,SACnB,OAAM,KAAK,MAAM,MAAM;MAEvB,OAAM,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC;AAG3C,MAAI,KAAK,gBAAgB,oBAEvB,OADgB,IAAI,aAAa,CACnB,OAAO,iBAAiB;;;;;;;;;;CAY1C,MAAM,MAAM,MAAmC;EAC7C,MAAM,QAAQ,MAAM,KAAK,aAAa,MAAM,KAAK;EACjD,MAAM,UAAU,IAAI,aAAa;AACjC,MAAI,KAAK,gBAAgB,oBACvB,QAAO,QAAQ,OAAO,sBAAsB,KAAK,UAAU,MAAM,CAAC,MAAM;EAE1E,IAAI;AACJ,MAAI,OAAO,UAAU,SACnB,eAAc;MAEd,eAAc,KAAK,UAAU,MAAM;AAErC,SAAO,QAAQ,OAAO,YAAY;;CAGpC,wBAAgC;AAC9B,SAAO"}
+{"version":3,"file":"http_response.js","names":[],"sources":["../../src/output_parsers/http_response.ts"],"sourcesContent":["import { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  BaseTransformOutputParser,\n  StringOutputParser,\n} from \"@langchain/core/output_parsers\";\n\nexport type HttpResponseOutputParserInput = {\n  outputParser?: BaseTransformOutputParser;\n  contentType?: \"text/plain\" | \"text/event-stream\";\n};\n\n/**\n * OutputParser that formats chunks emitted from an LLM for different HTTP content types.\n */\nexport class HttpResponseOutputParser extends BaseTransformOutputParser<Uint8Array> {\n  static lc_name() {\n    return \"HttpResponseOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parser\"];\n\n  lc_serializable = true;\n\n  outputParser: BaseTransformOutputParser = new StringOutputParser();\n\n  contentType: \"text/plain\" | \"text/event-stream\" = \"text/plain\";\n\n  constructor(fields?: HttpResponseOutputParserInput) {\n    super(fields);\n    this.outputParser = fields?.outputParser ?? this.outputParser;\n    this.contentType = fields?.contentType ?? this.contentType;\n  }\n\n  async *_transform(\n    inputGenerator: AsyncGenerator<string | BaseMessage>\n  ): AsyncGenerator<Uint8Array> {\n    for await (const chunk of this.outputParser._transform(inputGenerator)) {\n      if (typeof chunk === \"string\") {\n        yield this.parse(chunk);\n      } else {\n        yield this.parse(JSON.stringify(chunk));\n      }\n    }\n    if (this.contentType === \"text/event-stream\") {\n      const encoder = new TextEncoder();\n      yield encoder.encode(`event: end\\n\\n`);\n    }\n  }\n\n  /**\n   * Parses a string output from an LLM call. This method is meant to be\n   * implemented by subclasses to define how a string output from an LLM\n   * should be parsed.\n   * @param text The string output from an LLM call.\n   * @param callbacks Optional callbacks.\n   * @returns A promise of the parsed output.\n   */\n  async parse(text: string): Promise<Uint8Array> {\n    const chunk = await this.outputParser.parse(text);\n    const encoder = new TextEncoder();\n    if (this.contentType === \"text/event-stream\") {\n      return encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`);\n    }\n    let parsedChunk;\n    if (typeof chunk === \"string\") {\n      parsedChunk = chunk;\n    } else {\n      parsedChunk = JSON.stringify(chunk);\n    }\n    return encoder.encode(parsedChunk);\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;AAcA,IAAa,2BAAb,cAA8C,0BAAsC;CAClF,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,aAAa,gBAAgB;CAE7C,kBAAkB;CAElB,eAA0C,IAAI,oBAAoB;CAElE,cAAkD;CAElD,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,eAAe,QAAQ,gBAAgB,KAAK;AACjD,OAAK,cAAc,QAAQ,eAAe,KAAK;;CAGjD,OAAO,WACL,gBAC4B;AAC5B,aAAW,MAAM,SAAS,KAAK,aAAa,WAAW,eAAe,CACpE,KAAI,OAAO,UAAU,SACnB,OAAM,KAAK,MAAM,MAAM;MAEvB,OAAM,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC;AAG3C,MAAI,KAAK,gBAAgB,oBAEvB,OADgB,IAAI,aAAa,CACnB,OAAO,iBAAiB;;;;;;;;;;CAY1C,MAAM,MAAM,MAAmC;EAC7C,MAAM,QAAQ,MAAM,KAAK,aAAa,MAAM,KAAK;EACjD,MAAM,UAAU,IAAI,aAAa;AACjC,MAAI,KAAK,gBAAgB,oBACvB,QAAO,QAAQ,OAAO,sBAAsB,KAAK,UAAU,MAAM,CAAC,MAAM;EAE1E,IAAI;AACJ,MAAI,OAAO,UAAU,SACnB,eAAc;MAEd,eAAc,KAAK,UAAU,MAAM;AAErC,SAAO,QAAQ,OAAO,YAAY;;CAGpC,wBAAgC;AAC9B,SAAO"}