@langchain/core 0.3.72 → 1.0.0-alpha.2

package/dist/prompts/template.cjs

@@ -1,178 +1,159 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkValidTemplate = exports.parseTemplate = exports.renderTemplate = exports.DEFAULT_PARSER_MAPPING = exports.DEFAULT_FORMATTER_MAPPING = exports.interpolateMustache = exports.interpolateFString = exports.parseMustache = exports.parseFString = void 0;
-const mustache_1 = __importDefault(require("mustache"));
-const index_js_1 = require("../errors/index.cjs");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_index = require('../errors/index.cjs');
+const mustache = require_rolldown_runtime.__toESM(require("mustache"));
+
+//#region src/prompts/template.ts
 function configureMustache() {
-    // Use unescaped HTML
-    // https://github.com/janl/mustache.js?tab=readme-ov-file#variables
-    mustache_1.default.escape = (text) => text;
+	mustache.default.escape = (text) => text;
 }
 const parseFString = (template) => {
-    // Core logic replicated from internals of pythons built in Formatter class.
-    // https://github.com/python/cpython/blob/135ec7cefbaffd516b77362ad2b2ad1025af462e/Objects/stringlib/unicode_format.h#L700-L706
-    const chars = template.split("");
-    const nodes = [];
-    const nextBracket = (bracket, start) => {
-        for (let i = start; i < chars.length; i += 1) {
-            if (bracket.includes(chars[i])) {
-                return i;
-            }
-        }
-        return -1;
-    };
-    let i = 0;
-    while (i < chars.length) {
-        if (chars[i] === "{" && i + 1 < chars.length && chars[i + 1] === "{") {
-            nodes.push({ type: "literal", text: "{" });
-            i += 2;
-        }
-        else if (chars[i] === "}" &&
-            i + 1 < chars.length &&
-            chars[i + 1] === "}") {
-            nodes.push({ type: "literal", text: "}" });
-            i += 2;
-        }
-        else if (chars[i] === "{") {
-            const j = nextBracket("}", i);
-            if (j < 0) {
-                throw new Error("Unclosed '{' in template.");
-            }
-            nodes.push({
-                type: "variable",
-                name: chars.slice(i + 1, j).join(""),
-            });
-            i = j + 1;
-        }
-        else if (chars[i] === "}") {
-            throw new Error("Single '}' in template.");
-        }
-        else {
-            const next = nextBracket("{}", i);
-            const text = (next < 0 ? chars.slice(i) : chars.slice(i, next)).join("");
-            nodes.push({ type: "literal", text });
-            i = next < 0 ? chars.length : next;
-        }
-    }
-    return nodes;
+	const chars = template.split("");
+	const nodes = [];
+	const nextBracket = (bracket, start) => {
+		for (let i$1 = start; i$1 < chars.length; i$1 += 1) if (bracket.includes(chars[i$1])) return i$1;
+		return -1;
+	};
+	let i = 0;
+	while (i < chars.length) if (chars[i] === "{" && i + 1 < chars.length && chars[i + 1] === "{") {
+		nodes.push({
+			type: "literal",
+			text: "{"
+		});
+		i += 2;
+	} else if (chars[i] === "}" && i + 1 < chars.length && chars[i + 1] === "}") {
+		nodes.push({
+			type: "literal",
+			text: "}"
+		});
+		i += 2;
+	} else if (chars[i] === "{") {
+		const j = nextBracket("}", i);
+		if (j < 0) throw new Error("Unclosed '{' in template.");
+		nodes.push({
+			type: "variable",
+			name: chars.slice(i + 1, j).join("")
+		});
+		i = j + 1;
+	} else if (chars[i] === "}") throw new Error("Single '}' in template.");
+	else {
+		const next = nextBracket("{}", i);
+		const text = (next < 0 ? chars.slice(i) : chars.slice(i, next)).join("");
+		nodes.push({
+			type: "literal",
+			text
+		});
+		i = next < 0 ? chars.length : next;
+	}
+	return nodes;
 };
-exports.parseFString = parseFString;
 /**
- * Convert the result of mustache.parse into an array of ParsedTemplateNode,
- * to make it compatible with other LangChain string parsing template formats.
- *
- * @param {mustache.TemplateSpans} template The result of parsing a mustache template with the mustache.js library.
- * @returns {ParsedTemplateNode[]}
- */
+* Convert the result of mustache.parse into an array of ParsedTemplateNode,
+* to make it compatible with other LangChain string parsing template formats.
+*
+* @param {mustache.TemplateSpans} template The result of parsing a mustache template with the mustache.js library.
+* @returns {ParsedTemplateNode[]}
+*/
 const mustacheTemplateToNodes = (template) => {
-    const nodes = [];
-    for (const temp of template) {
-        if (temp[0] === "name") {
-            const name = temp[1].includes(".") ? temp[1].split(".")[0] : temp[1];
-            nodes.push({ type: "variable", name });
-        }
-        else if (["#", "&", "^", ">"].includes(temp[0])) {
-            // # represents a section, "&" represents an unescaped variable.
-            // These should both be considered variables.
-            nodes.push({ type: "variable", name: temp[1] });
-            // If this is a section with nested content, recursively process it
-            if (temp[0] === "#" && temp.length > 4 && Array.isArray(temp[4])) {
-                const nestedNodes = mustacheTemplateToNodes(temp[4]);
-                nodes.push(...nestedNodes);
-            }
-        }
-        else {
-            nodes.push({ type: "literal", text: temp[1] });
-        }
-    }
-    return nodes;
+	const nodes = [];
+	for (const temp of template) if (temp[0] === "name") {
+		const name = temp[1].includes(".") ? temp[1].split(".")[0] : temp[1];
+		nodes.push({
+			type: "variable",
+			name
+		});
+	} else if ([
+		"#",
+		"&",
+		"^",
+		">"
+	].includes(temp[0])) {
+		nodes.push({
+			type: "variable",
+			name: temp[1]
+		});
+		if (temp[0] === "#" && temp.length > 4 && Array.isArray(temp[4])) {
+			const nestedNodes = mustacheTemplateToNodes(temp[4]);
+			nodes.push(...nestedNodes);
+		}
+	} else nodes.push({
+		type: "literal",
+		text: temp[1]
+	});
+	return nodes;
 };
 const parseMustache = (template) => {
-    configureMustache();
-    const parsed = mustache_1.default.parse(template);
-    return mustacheTemplateToNodes(parsed);
+	configureMustache();
+	const parsed = mustache.default.parse(template);
+	return mustacheTemplateToNodes(parsed);
 };
-exports.parseMustache = parseMustache;
 const interpolateFString = (template, values) => {
-    return (0, exports.parseFString)(template).reduce((res, node) => {
-        if (node.type === "variable") {
-            if (node.name in values) {
-                const stringValue = typeof values[node.name] === "string"
-                    ? values[node.name]
-                    : JSON.stringify(values[node.name]);
-                return res + stringValue;
-            }
-            throw new Error(`(f-string) Missing value for input ${node.name}`);
-        }
-        return res + node.text;
-    }, "");
+	return parseFString(template).reduce((res, node) => {
+		if (node.type === "variable") {
+			if (node.name in values) {
+				const stringValue = typeof values[node.name] === "string" ? values[node.name] : JSON.stringify(values[node.name]);
+				return res + stringValue;
+			}
+			throw new Error(`(f-string) Missing value for input ${node.name}`);
+		}
+		return res + node.text;
+	}, "");
 };
-exports.interpolateFString = interpolateFString;
 const interpolateMustache = (template, values) => {
-    configureMustache();
-    return mustache_1.default.render(template, values);
+	configureMustache();
+	return mustache.default.render(template, values);
 };
-exports.interpolateMustache = interpolateMustache;
-exports.DEFAULT_FORMATTER_MAPPING = {
-    "f-string": exports.interpolateFString,
-    mustache: exports.interpolateMustache,
+const DEFAULT_FORMATTER_MAPPING = {
+	"f-string": interpolateFString,
+	mustache: interpolateMustache
 };
-exports.DEFAULT_PARSER_MAPPING = {
-    "f-string": exports.parseFString,
-    mustache: exports.parseMustache,
+const DEFAULT_PARSER_MAPPING = {
+	"f-string": parseFString,
+	mustache: parseMustache
 };
 const renderTemplate = (template, templateFormat, inputValues) => {
-    try {
-        return exports.DEFAULT_FORMATTER_MAPPING[templateFormat](template, inputValues);
-    }
-    catch (e) {
-        const error = (0, index_js_1.addLangChainErrorFields)(e, "INVALID_PROMPT_INPUT");
-        throw error;
-    }
+	try {
+		return DEFAULT_FORMATTER_MAPPING[templateFormat](template, inputValues);
+	} catch (e) {
+		const error = require_index.addLangChainErrorFields(e, "INVALID_PROMPT_INPUT");
+		throw error;
+	}
 };
-exports.renderTemplate = renderTemplate;
-const parseTemplate = (template, templateFormat) => exports.DEFAULT_PARSER_MAPPING[templateFormat](template);
-exports.parseTemplate = parseTemplate;
+const parseTemplate = (template, templateFormat) => DEFAULT_PARSER_MAPPING[templateFormat](template);
 const checkValidTemplate = (template, templateFormat, inputVariables) => {
-    if (!(templateFormat in exports.DEFAULT_FORMATTER_MAPPING)) {
-        const validFormats = Object.keys(exports.DEFAULT_FORMATTER_MAPPING);
-        throw new Error(`Invalid template format. Got \`${templateFormat}\`;
+	if (!(templateFormat in DEFAULT_FORMATTER_MAPPING)) {
+		const validFormats = Object.keys(DEFAULT_FORMATTER_MAPPING);
+		throw new Error(`Invalid template format. Got \`${templateFormat}\`;
                          should be one of ${validFormats}`);
-    }
-    try {
-        const dummyInputs = inputVariables.reduce((acc, v) => {
-            acc[v] = "foo";
-            return acc;
-        }, {});
-        if (Array.isArray(template)) {
-            template.forEach((message) => {
-                if (message.type === "text") {
-                    (0, exports.renderTemplate)(message.text, templateFormat, dummyInputs);
-                }
-                else if (message.type === "image_url") {
-                    if (typeof message.image_url === "string") {
-                        (0, exports.renderTemplate)(message.image_url, templateFormat, dummyInputs);
-                    }
-                    else {
-                        const imageUrl = message.image_url.url;
-                        (0, exports.renderTemplate)(imageUrl, templateFormat, dummyInputs);
-                    }
-                }
-                else {
-                    throw new Error(`Invalid message template received. ${JSON.stringify(message, null, 2)}`);
-                }
-            });
-        }
-        else {
-            (0, exports.renderTemplate)(template, templateFormat, dummyInputs);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }
-    catch (e) {
-        throw new Error(`Invalid prompt schema: ${e.message}`);
-    }
+	}
+	try {
+		const dummyInputs = inputVariables.reduce((acc, v) => {
+			acc[v] = "foo";
+			return acc;
+		}, {});
+		if (Array.isArray(template)) template.forEach((message) => {
+			if (message.type === "text" && "text" in message && typeof message.text === "string") renderTemplate(message.text, templateFormat, dummyInputs);
+			else if (message.type === "image_url") {
+				if (typeof message.image_url === "string") renderTemplate(message.image_url, templateFormat, dummyInputs);
+				else if (typeof message.image_url === "object" && message.image_url !== null && "url" in message.image_url && typeof message.image_url.url === "string") {
+					const imageUrl = message.image_url.url;
+					renderTemplate(imageUrl, templateFormat, dummyInputs);
+				}
+			} else throw new Error(`Invalid message template received. ${JSON.stringify(message, null, 2)}`);
+		});
+		else renderTemplate(template, templateFormat, dummyInputs);
+	} catch (e) {
+		throw new Error(`Invalid prompt schema: ${e.message}`);
+	}
 };
+
+//#endregion
+exports.DEFAULT_FORMATTER_MAPPING = DEFAULT_FORMATTER_MAPPING;
+exports.DEFAULT_PARSER_MAPPING = DEFAULT_PARSER_MAPPING;
 exports.checkValidTemplate = checkValidTemplate;
+exports.interpolateFString = interpolateFString;
+exports.interpolateMustache = interpolateMustache;
+exports.parseFString = parseFString;
+exports.parseMustache = parseMustache;
+exports.parseTemplate = parseTemplate;
+exports.renderTemplate = renderTemplate;
+//# sourceMappingURL=template.cjs.map

package/dist/prompts/template.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.cjs","names":["template: string","nodes: ParsedTemplateNode[]","bracket: \"}\" | \"{\" | \"{}\"","start: number","i","template: mustache.TemplateSpans","values: InputValues","DEFAULT_FORMATTER_MAPPING: Record<TemplateFormat, Interpolator>","DEFAULT_PARSER_MAPPING: Record<TemplateFormat, Parser>","templateFormat: TemplateFormat","inputValues: InputValues","addLangChainErrorFields","template: MessageContent","inputVariables: string[]","dummyInputs: InputValues","e: any"],"sources":["../../src/prompts/template.ts"],"sourcesContent":["import mustache from \"mustache\";\nimport { MessageContent } from \"../messages/index.js\";\nimport type { InputValues } from \"../utils/types/index.js\";\nimport { addLangChainErrorFields } from \"../errors/index.js\";\n\nfunction configureMustache() {\n  // Use unescaped HTML\n  // https://github.com/janl/mustache.js?tab=readme-ov-file#variables\n  mustache.escape = (text) => text;\n}\n\n/**\n * Type that specifies the format of a template.\n */\nexport type TemplateFormat = \"f-string\" | \"mustache\";\n\n/**\n * Type that represents a node in a parsed format string. It can be either\n * a literal text or a variable name.\n */\nexport type ParsedTemplateNode =\n  | { type: \"literal\"; text: string }\n  | { type: \"variable\"; name: string };\n\n/**\n * Alias for `ParsedTemplateNode` since it is the same for\n * both f-string and mustache templates.\n */\nexport type ParsedFStringNode = ParsedTemplateNode;\n\nexport const parseFString = (template: string): ParsedTemplateNode[] => {\n  // Core logic replicated from internals of pythons built in Formatter class.\n  // https://github.com/python/cpython/blob/135ec7cefbaffd516b77362ad2b2ad1025af462e/Objects/stringlib/unicode_format.h#L700-L706\n  const chars = template.split(\"\");\n  const nodes: ParsedTemplateNode[] = [];\n\n  const nextBracket = (bracket: \"}\" | \"{\" | \"{}\", start: number) => {\n    for (let i = start; i < chars.length; i += 1) {\n      if (bracket.includes(chars[i])) {\n        return i;\n      }\n    }\n    return -1;\n  };\n\n  let i = 0;\n  while (i < chars.length) {\n    if (chars[i] === \"{\" && i + 1 < chars.length && chars[i + 1] === \"{\") {\n      nodes.push({ type: \"literal\", text: \"{\" });\n      i += 2;\n    } else if (\n      chars[i] === \"}\" &&\n      i + 1 < chars.length &&\n      chars[i + 1] === \"}\"\n    ) {\n      nodes.push({ type: \"literal\", text: \"}\" });\n      i += 2;\n    } else if (chars[i] === \"{\") {\n      const j = nextBracket(\"}\", i);\n      if (j < 0) {\n        throw new Error(\"Unclosed '{' in template.\");\n      }\n\n      nodes.push({\n        type: \"variable\",\n        name: chars.slice(i + 1, j).join(\"\"),\n      });\n      i = j + 1;\n    } else if (chars[i] === \"}\") {\n      throw new Error(\"Single '}' in template.\");\n    } else {\n      const next = nextBracket(\"{}\", i);\n      const text = (next < 0 ? chars.slice(i) : chars.slice(i, next)).join(\"\");\n      nodes.push({ type: \"literal\", text });\n      i = next < 0 ? chars.length : next;\n    }\n  }\n  return nodes;\n};\n\n/**\n * Convert the result of mustache.parse into an array of ParsedTemplateNode,\n * to make it compatible with other LangChain string parsing template formats.\n *\n * @param {mustache.TemplateSpans} template The result of parsing a mustache template with the mustache.js library.\n * @returns {ParsedTemplateNode[]}\n */\nconst mustacheTemplateToNodes = (\n  template: mustache.TemplateSpans\n): ParsedTemplateNode[] => {\n  const nodes: ParsedTemplateNode[] = [];\n\n  for (const temp of template) {\n    if (temp[0] === \"name\") {\n      const name = temp[1].includes(\".\") ? temp[1].split(\".\")[0] : temp[1];\n      nodes.push({ type: \"variable\", name });\n    } else if ([\"#\", \"&\", \"^\", \">\"].includes(temp[0])) {\n      // # represents a section, \"&\" represents an unescaped variable.\n      // These should both be considered variables.\n      nodes.push({ type: \"variable\", name: temp[1] });\n\n      // If this is a section with nested content, recursively process it\n      if (temp[0] === \"#\" && temp.length > 4 && Array.isArray(temp[4])) {\n        const nestedNodes = mustacheTemplateToNodes(temp[4]);\n        nodes.push(...nestedNodes);\n      }\n    } else {\n      nodes.push({ type: \"literal\", text: temp[1] });\n    }\n  }\n\n  return nodes;\n};\n\nexport const parseMustache = (template: string) => {\n  configureMustache();\n  const parsed = mustache.parse(template);\n  return mustacheTemplateToNodes(parsed);\n};\n\nexport const interpolateFString = (template: string, values: InputValues) => {\n  return parseFString(template).reduce((res, node) => {\n    if (node.type === \"variable\") {\n      if (node.name in values) {\n        const stringValue =\n          typeof values[node.name] === \"string\"\n            ? values[node.name]\n            : JSON.stringify(values[node.name]);\n        return res + stringValue;\n      }\n      throw new Error(`(f-string) Missing value for input ${node.name}`);\n    }\n\n    return res + node.text;\n  }, \"\");\n};\n\nexport const interpolateMustache = (template: string, values: InputValues) => {\n  configureMustache();\n  return mustache.render(template, values);\n};\n\n/**\n * Type that represents a function that takes a template string and a set\n * of input values, and returns a string where all variables in the\n * template have been replaced with their corresponding values.\n */\ntype Interpolator = (template: string, values: InputValues) => string;\n\n/**\n * Type that represents a function that takes a template string and\n * returns an array of `ParsedTemplateNode`.\n */\ntype Parser = (template: string) => ParsedTemplateNode[];\n\nexport const DEFAULT_FORMATTER_MAPPING: Record<TemplateFormat, Interpolator> = {\n  \"f-string\": interpolateFString,\n  mustache: interpolateMustache,\n};\n\nexport const DEFAULT_PARSER_MAPPING: Record<TemplateFormat, Parser> = {\n  \"f-string\": parseFString,\n  mustache: parseMustache,\n};\n\nexport const renderTemplate = (\n  template: string,\n  templateFormat: TemplateFormat,\n  inputValues: InputValues\n) => {\n  try {\n    return DEFAULT_FORMATTER_MAPPING[templateFormat](template, inputValues);\n  } catch (e) {\n    const error = addLangChainErrorFields(e, \"INVALID_PROMPT_INPUT\");\n    throw error;\n  }\n};\n\nexport const parseTemplate = (\n  template: string,\n  templateFormat: TemplateFormat\n) => DEFAULT_PARSER_MAPPING[templateFormat](template);\n\nexport const checkValidTemplate = (\n  template: MessageContent,\n  templateFormat: TemplateFormat,\n  inputVariables: string[]\n) => {\n  if (!(templateFormat in DEFAULT_FORMATTER_MAPPING)) {\n    const validFormats = Object.keys(DEFAULT_FORMATTER_MAPPING);\n    throw new Error(`Invalid template format. Got \\`${templateFormat}\\`;\n                         should be one of ${validFormats}`);\n  }\n  try {\n    const dummyInputs: InputValues = inputVariables.reduce((acc, v) => {\n      acc[v] = \"foo\";\n      return acc;\n    }, {} as Record<string, string>);\n    if (Array.isArray(template)) {\n      template.forEach((message) => {\n        if (\n          message.type === \"text\" &&\n          \"text\" in message &&\n          typeof message.text === \"string\"\n        ) {\n          renderTemplate(message.text, templateFormat, dummyInputs);\n        } else if (message.type === \"image_url\") {\n          if (typeof message.image_url === \"string\") {\n            renderTemplate(message.image_url, templateFormat, dummyInputs);\n          } else if (\n            typeof message.image_url === \"object\" &&\n            message.image_url !== null &&\n            \"url\" in message.image_url &&\n            typeof message.image_url.url === \"string\"\n          ) {\n            const imageUrl = message.image_url.url;\n            renderTemplate(imageUrl, templateFormat, dummyInputs);\n          }\n        } else {\n          throw new Error(\n            `Invalid message template received. ${JSON.stringify(\n              message,\n              null,\n              2\n            )}`\n          );\n        }\n      });\n    } else {\n      renderTemplate(template, templateFormat, dummyInputs);\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  } catch (e: any) {\n    throw new Error(`Invalid prompt schema: ${e.message}`);\n  }\n};\n"],"mappings":"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"}

package/dist/prompts/template.d.cts

@@ -0,0 +1,48 @@
+import { InputValues } from "../utils/types/index.cjs";
+import { MessageContent } from "../messages/base.cjs";
+
+//#region src/prompts/template.d.ts
+
+/**
+ * Type that specifies the format of a template.
+ */
+type TemplateFormat = "f-string" | "mustache";
+/**
+ * Type that represents a node in a parsed format string. It can be either
+ * a literal text or a variable name.
+ */
+type ParsedTemplateNode = {
+  type: "literal";
+  text: string;
+} | {
+  type: "variable";
+  name: string;
+};
+/**
+ * Alias for `ParsedTemplateNode` since it is the same for
+ * both f-string and mustache templates.
+ */
+type ParsedFStringNode = ParsedTemplateNode;
+declare const parseFString: (template: string) => ParsedTemplateNode[];
+declare const parseMustache: (template: string) => ParsedTemplateNode[];
+declare const interpolateFString: (template: string, values: InputValues) => string;
+declare const interpolateMustache: (template: string, values: InputValues) => string;
+/**
+ * Type that represents a function that takes a template string and a set
+ * of input values, and returns a string where all variables in the
+ * template have been replaced with their corresponding values.
+ */
+type Interpolator = (template: string, values: InputValues) => string;
+/**
+ * Type that represents a function that takes a template string and
+ * returns an array of `ParsedTemplateNode`.
+ */
+type Parser = (template: string) => ParsedTemplateNode[];
+declare const DEFAULT_FORMATTER_MAPPING: Record<TemplateFormat, Interpolator>;
+declare const DEFAULT_PARSER_MAPPING: Record<TemplateFormat, Parser>;
+declare const renderTemplate: (template: string, templateFormat: TemplateFormat, inputValues: InputValues) => string;
+declare const parseTemplate: (template: string, templateFormat: TemplateFormat) => ParsedTemplateNode[];
+declare const checkValidTemplate: (template: MessageContent, templateFormat: TemplateFormat, inputVariables: string[]) => void;
+//#endregion
+export { DEFAULT_FORMATTER_MAPPING, DEFAULT_PARSER_MAPPING, ParsedFStringNode, ParsedTemplateNode, TemplateFormat, checkValidTemplate, interpolateFString, interpolateMustache, parseFString, parseMustache, parseTemplate, renderTemplate };
+//# sourceMappingURL=template.d.cts.map

package/dist/prompts/template.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.cts","names":["MessageContent","InputValues","TemplateFormat","ParsedTemplateNode","ParsedFStringNode","parseFString","parseMustache","interpolateFString","interpolateMustache","Interpolator","Parser","DEFAULT_FORMATTER_MAPPING","Record","DEFAULT_PARSER_MAPPING","renderTemplate","parseTemplate","checkValidTemplate"],"sources":["../../src/prompts/template.d.ts"],"sourcesContent":["import { MessageContent } from \"../messages/index.js\";\nimport type { InputValues } from \"../utils/types/index.js\";\n/**\n * Type that specifies the format of a template.\n */\nexport type TemplateFormat = \"f-string\" | \"mustache\";\n/**\n * Type that represents a node in a parsed format string. It can be either\n * a literal text or a variable name.\n */\nexport type ParsedTemplateNode = {\n    type: \"literal\";\n    text: string;\n} | {\n    type: \"variable\";\n    name: string;\n};\n/**\n * Alias for `ParsedTemplateNode` since it is the same for\n * both f-string and mustache templates.\n */\nexport type ParsedFStringNode = ParsedTemplateNode;\nexport declare const parseFString: (template: string) => ParsedTemplateNode[];\nexport declare const parseMustache: (template: string) => ParsedTemplateNode[];\nexport declare const interpolateFString: (template: string, values: InputValues) => string;\nexport declare const interpolateMustache: (template: string, values: InputValues) => string;\n/**\n * Type that represents a function that takes a template string and a set\n * of input values, and returns a string where all variables in the\n * template have been replaced with their corresponding values.\n */\ntype Interpolator = (template: string, values: InputValues) => string;\n/**\n * Type that represents a function that takes a template string and\n * returns an array of `ParsedTemplateNode`.\n */\ntype Parser = (template: string) => ParsedTemplateNode[];\nexport declare const DEFAULT_FORMATTER_MAPPING: Record<TemplateFormat, Interpolator>;\nexport declare const DEFAULT_PARSER_MAPPING: Record<TemplateFormat, Parser>;\nexport declare const renderTemplate: (template: string, templateFormat: TemplateFormat, inputValues: InputValues) => string;\nexport declare const parseTemplate: (template: string, templateFormat: TemplateFormat) => ParsedTemplateNode[];\nexport declare const checkValidTemplate: (template: MessageContent, templateFormat: TemplateFormat, inputVariables: string[]) => void;\nexport {};\n"],"mappings":";;;;;;;AAKA;AAKYG,KALAD,cAAAA,GAKkB,UAAA,GAAA,UAAA;AAW9B;AACA;AACA;AACA;AACqBM,KAfTL,kBAAAA,GAe+E;EAMtFM,IAAAA,EAAAA,SAAY;EAKZC,IAAAA,EAAAA,MAAM;AACX,CAAA,GAAqBC;EAA+D,IAAA,EAAA,UAAA;EAAA,IAA7BT,EAAAA,MAAAA;CAAc;;AAAf;AACtD;;AAAoDA,KAjBxCE,iBAAAA,GAAoBD,kBAiBoBD;AAAgBQ,cAhB/CL,YAgB+CK,EAAAA,CAAAA,QAAAA,EAAAA,MAAAA,EAAAA,GAhBXP,kBAgBWO,EAAAA;AAAvBE,cAfxBN,aAewBM,EAAAA,CAAAA,QAAAA,EAAAA,MAAAA,EAAAA,GAfaT,kBAebS,EAAAA;AAAM,cAd9BL,kBAc8B,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAdiBN,WAcjB,EAAA,GAAA,MAAA;AAC9Ba,cAdAN,mBAcsG,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAdtDP,WAcsD,EAAA,GAAA,MAAA;;;;AAAX;AAChH;KATKQ,YAAAA,GASyG,CAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAT/DR,WAS+D,EAAA,GAAA,MAAA;;;AAAF;AAC5G;KALKS,MAAAA,GAKgI,CAAA,QAAA,EAAA,MAAA,EAAA,GALjGP,kBAKiG,EAAA;AAAjFH,cAJ/BW,yBAI+BX,EAJJY,MAIIZ,CAJGE,cAIHF,EAJmBS,YAInBT,CAAAA;AAAgCE,cAH/DW,sBAG+DX,EAHvCU,MAGuCV,CAHhCA,cAGgCA,EAHhBQ,MAGgBR,CAAAA;AAAc,cAF7EY,cAE6E,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,cAAA,EAF1BZ,cAE0B,EAAA,WAAA,EAFGD,WAEH,EAAA,GAAA,MAAA;cAD7Ec,kDAAkDb,mBAAmBC;cACrEa,+BAA+BhB,gCAAgCE"}

package/dist/prompts/template.d.ts

@@ -1,29 +1,32 @@
-import { MessageContent } from "../messages/index.js";
-import type { InputValues } from "../utils/types/index.js";
+import { InputValues } from "../utils/types/index.js";
+import { MessageContent } from "../messages/base.js";
+
+//#region src/prompts/template.d.ts
+
 /**
  * Type that specifies the format of a template.
  */
-export type TemplateFormat = "f-string" | "mustache";
+type TemplateFormat = "f-string" | "mustache";
 /**
  * Type that represents a node in a parsed format string. It can be either
  * a literal text or a variable name.
  */
-export type ParsedTemplateNode = {
-    type: "literal";
-    text: string;
+type ParsedTemplateNode = {
+  type: "literal";
+  text: string;
 } | {
-    type: "variable";
-    name: string;
+  type: "variable";
+  name: string;
 };
 /**
  * Alias for `ParsedTemplateNode` since it is the same for
  * both f-string and mustache templates.
  */
-export type ParsedFStringNode = ParsedTemplateNode;
-export declare const parseFString: (template: string) => ParsedTemplateNode[];
-export declare const parseMustache: (template: string) => ParsedTemplateNode[];
-export declare const interpolateFString: (template: string, values: InputValues) => string;
-export declare const interpolateMustache: (template: string, values: InputValues) => string;
+type ParsedFStringNode = ParsedTemplateNode;
+declare const parseFString: (template: string) => ParsedTemplateNode[];
+declare const parseMustache: (template: string) => ParsedTemplateNode[];
+declare const interpolateFString: (template: string, values: InputValues) => string;
+declare const interpolateMustache: (template: string, values: InputValues) => string;
 /**
  * Type that represents a function that takes a template string and a set
  * of input values, and returns a string where all variables in the
@@ -35,9 +38,11 @@ type Interpolator = (template: string, values: InputValues) => string;
  * returns an array of `ParsedTemplateNode`.
  */
 type Parser = (template: string) => ParsedTemplateNode[];
-export declare const DEFAULT_FORMATTER_MAPPING: Record<TemplateFormat, Interpolator>;
-export declare const DEFAULT_PARSER_MAPPING: Record<TemplateFormat, Parser>;
-export declare const renderTemplate: (template: string, templateFormat: TemplateFormat, inputValues: InputValues) => string;
-export declare const parseTemplate: (template: string, templateFormat: TemplateFormat) => ParsedTemplateNode[];
-export declare const checkValidTemplate: (template: MessageContent, templateFormat: TemplateFormat, inputVariables: string[]) => void;
-export {};
+declare const DEFAULT_FORMATTER_MAPPING: Record<TemplateFormat, Interpolator>;
+declare const DEFAULT_PARSER_MAPPING: Record<TemplateFormat, Parser>;
+declare const renderTemplate: (template: string, templateFormat: TemplateFormat, inputValues: InputValues) => string;
+declare const parseTemplate: (template: string, templateFormat: TemplateFormat) => ParsedTemplateNode[];
+declare const checkValidTemplate: (template: MessageContent, templateFormat: TemplateFormat, inputVariables: string[]) => void;
+//#endregion
+export { DEFAULT_FORMATTER_MAPPING, DEFAULT_PARSER_MAPPING, ParsedFStringNode, ParsedTemplateNode, TemplateFormat, checkValidTemplate, interpolateFString, interpolateMustache, parseFString, parseMustache, parseTemplate, renderTemplate };
+//# sourceMappingURL=template.d.ts.map

package/dist/prompts/template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","names":["MessageContent","InputValues","TemplateFormat","ParsedTemplateNode","ParsedFStringNode","parseFString","parseMustache","interpolateFString","interpolateMustache","Interpolator","Parser","DEFAULT_FORMATTER_MAPPING","Record","DEFAULT_PARSER_MAPPING","renderTemplate","parseTemplate","checkValidTemplate"],"sources":["../../src/prompts/template.d.ts"],"sourcesContent":["import { MessageContent } from \"../messages/index.js\";\nimport type { InputValues } from \"../utils/types/index.js\";\n/**\n * Type that specifies the format of a template.\n */\nexport type TemplateFormat = \"f-string\" | \"mustache\";\n/**\n * Type that represents a node in a parsed format string. It can be either\n * a literal text or a variable name.\n */\nexport type ParsedTemplateNode = {\n    type: \"literal\";\n    text: string;\n} | {\n    type: \"variable\";\n    name: string;\n};\n/**\n * Alias for `ParsedTemplateNode` since it is the same for\n * both f-string and mustache templates.\n */\nexport type ParsedFStringNode = ParsedTemplateNode;\nexport declare const parseFString: (template: string) => ParsedTemplateNode[];\nexport declare const parseMustache: (template: string) => ParsedTemplateNode[];\nexport declare const interpolateFString: (template: string, values: InputValues) => string;\nexport declare const interpolateMustache: (template: string, values: InputValues) => string;\n/**\n * Type that represents a function that takes a template string and a set\n * of input values, and returns a string where all variables in the\n * template have been replaced with their corresponding values.\n */\ntype Interpolator = (template: string, values: InputValues) => string;\n/**\n * Type that represents a function that takes a template string and\n * returns an array of `ParsedTemplateNode`.\n */\ntype Parser = (template: string) => ParsedTemplateNode[];\nexport declare const DEFAULT_FORMATTER_MAPPING: Record<TemplateFormat, Interpolator>;\nexport declare const DEFAULT_PARSER_MAPPING: Record<TemplateFormat, Parser>;\nexport declare const renderTemplate: (template: string, templateFormat: TemplateFormat, inputValues: InputValues) => string;\nexport declare const parseTemplate: (template: string, templateFormat: TemplateFormat) => ParsedTemplateNode[];\nexport declare const checkValidTemplate: (template: MessageContent, templateFormat: TemplateFormat, inputVariables: string[]) => void;\nexport {};\n"],"mappings":";;;;;;;AAKA;AAKYG,KALAD,cAAAA,GAKkB,UAAA,GAAA,UAAA;AAW9B;AACA;AACA;AACA;AACqBM,KAfTL,kBAAAA,GAe+E;EAMtFM,IAAAA,EAAAA,SAAY;EAKZC,IAAAA,EAAAA,MAAM;AACX,CAAA,GAAqBC;EAA+D,IAAA,EAAA,UAAA;EAAA,IAA7BT,EAAAA,MAAAA;CAAc;;AAAf;AACtD;;AAAoDA,KAjBxCE,iBAAAA,GAAoBD,kBAiBoBD;AAAgBQ,cAhB/CL,YAgB+CK,EAAAA,CAAAA,QAAAA,EAAAA,MAAAA,EAAAA,GAhBXP,kBAgBWO,EAAAA;AAAvBE,cAfxBN,aAewBM,EAAAA,CAAAA,QAAAA,EAAAA,MAAAA,EAAAA,GAfaT,kBAebS,EAAAA;AAAM,cAd9BL,kBAc8B,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAdiBN,WAcjB,EAAA,GAAA,MAAA;AAC9Ba,cAdAN,mBAcsG,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAdtDP,WAcsD,EAAA,GAAA,MAAA;;;;AAAX;AAChH;KATKQ,YAAAA,GASyG,CAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAT/DR,WAS+D,EAAA,GAAA,MAAA;;;AAAF;AAC5G;KALKS,MAAAA,GAKgI,CAAA,QAAA,EAAA,MAAA,EAAA,GALjGP,kBAKiG,EAAA;AAAjFH,cAJ/BW,yBAI+BX,EAJJY,MAIIZ,CAJGE,cAIHF,EAJmBS,YAInBT,CAAAA;AAAgCE,cAH/DW,sBAG+DX,EAHvCU,MAGuCV,CAHhCA,cAGgCA,EAHhBQ,MAGgBR,CAAAA;AAAc,cAF7EY,cAE6E,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,cAAA,EAF1BZ,cAE0B,EAAA,WAAA,EAFGD,WAEH,EAAA,GAAA,MAAA;cAD7Ec,kDAAkDb,mBAAmBC;cACrEa,+BAA+BhB,gCAAgCE"}