@nocobase/plugin-ai 1.9.32 → 1.9.34

package/dist/node_modules/@langchain/core/dist/prompts/chat.js

@@ -9,6 +9,7 @@ import { PromptTemplate, } from "./prompt.js";
 import { ImagePromptTemplate } from "./image.js";
 import { parseFString, parseMustache, } from "./template.js";
 import { addLangChainErrorFields } from "../errors/index.js";
+import { DictPromptTemplate } from "./dict.js";
 /**
  * Abstract class that serves as a base for creating message prompt
  * templates. It defines how to format messages for different roles in a
@@ -180,6 +181,25 @@ export class ChatMessagePromptTemplate extends BaseMessageStringPromptTemplate {
         }), role);
     }
 }
+function isTextTemplateParam(param) {
+    if (param === null || typeof param !== "object" || Array.isArray(param)) {
+        return false;
+    }
+    return (Object.keys(param).length === 1 &&
+        "text" in param &&
+        typeof param.text === "string");
+}
+function isImageTemplateParam(param) {
+    if (param === null || typeof param !== "object" || Array.isArray(param)) {
+        return false;
+    }
+    return ("image_url" in param &&
+        (typeof param.image_url === "string" ||
+            (typeof param.image_url === "object" &&
+                param.image_url !== null &&
+                "url" in param.image_url &&
+                typeof param.image_url.url === "string")));
+}
 class _StringImageMessagePromptTemplate extends BaseMessagePromptTemplate {
     static _messageClass() {
         throw new Error("Can not invoke _messageClass from inside _StringImageMessagePromptTemplate");
@@ -291,24 +311,25 @@ class _StringImageMessagePromptTemplate extends BaseMessagePromptTemplate {
         }
         const prompt = [];
         for (const item of template) {
-            if (typeof item === "string" ||
-                (typeof item === "object" && "text" in item)) {
+            // handle string cases
+            if (typeof item === "string") {
+                prompt.push(PromptTemplate.fromTemplate(item, additionalOptions));
+            }
+            else if (item === null) {
+                // pass
+            }
+            else if (isTextTemplateParam(item)) {
                 let text = "";
-                if (typeof item === "string") {
-                    text = item;
-                }
-                else if (typeof item.text === "string") {
+                if (typeof item.text === "string") {
                     text = item.text ?? "";
                 }
                 const options = {
                     ...additionalOptions,
-                    ...(typeof item !== "string"
-                        ? { additionalContentFields: item }
-                        : {}),
+                    additionalContentFields: item,
                 };
                 prompt.push(PromptTemplate.fromTemplate(text, options));
             }
-            else if (typeof item === "object" && "image_url" in item) {
+            else if (isImageTemplateParam(item)) {
                 let imgTemplate = item.image_url ?? "";
                 let imgTemplateObject;
                 let inputVariables = [];
@@ -364,6 +385,12 @@ class _StringImageMessagePromptTemplate extends BaseMessagePromptTemplate {
                 }
                 prompt.push(imgTemplateObject);
             }
+            else if (typeof item === "object") {
+                prompt.push(new DictPromptTemplate({
+                    template: item,
+                    templateFormat: additionalOptions?.templateFormat,
+                }));
+            }
         }
         return new this({ prompt, additionalOptions });
     }
@@ -395,11 +422,13 @@ class _StringImageMessagePromptTemplate extends BaseMessagePromptTemplate {
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         additionalContentFields = prompt.additionalContentFields;
                     }
-                    content.push({
-                        ...additionalContentFields,
-                        type: "text",
-                        text: formatted,
-                    });
+                    if (formatted !== "") {
+                        content.push({
+                            ...additionalContentFields,
+                            type: "text",
+                            text: formatted,
+                        });
+                    }
                     /** @TODO replace this */
                     // eslint-disable-next-line no-instanceof/no-instanceof
                 }
@@ -415,6 +444,19 @@ class _StringImageMessagePromptTemplate extends BaseMessagePromptTemplate {
                         type: "image_url",
                         image_url: formatted,
                     });
+                    // eslint-disable-next-line no-instanceof/no-instanceof
+                }
+                else if (prompt instanceof DictPromptTemplate) {
+                    const formatted = await prompt.format(inputs);
+                    let additionalContentFields;
+                    if ("additionalContentFields" in prompt) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        additionalContentFields = prompt.additionalContentFields;
+                    }
+                    content.push({
+                        ...additionalContentFields,
+                        ...formatted,
+                    });
                 }
             }
             return this.createMessage(content);
@@ -670,15 +712,21 @@ export class ChatPromptTemplate extends BaseChatPromptTemplate {
                 resultMessages.push(await this._parseImagePrompts(promptMessage, allValues));
             }
             else {
-                const inputValues = promptMessage.inputVariables.reduce((acc, inputVariable) => {
-                    if (!(inputVariable in allValues) &&
-                        !(isMessagesPlaceholder(promptMessage) && promptMessage.optional)) {
-                        const error = addLangChainErrorFields(new Error(`Missing value for input variable \`${inputVariable.toString()}\``), "INVALID_PROMPT_INPUT");
-                        throw error;
-                    }
-                    acc[inputVariable] = allValues[inputVariable];
-                    return acc;
-                }, {});
+                let inputValues;
+                if (this.templateFormat === "mustache") {
+                    inputValues = { ...allValues };
+                }
+                else {
+                    inputValues = promptMessage.inputVariables.reduce((acc, inputVariable) => {
+                        if (!(inputVariable in allValues) &&
+                            !(isMessagesPlaceholder(promptMessage) && promptMessage.optional)) {
+                            const error = addLangChainErrorFields(new Error(`Missing value for input variable \`${inputVariable.toString()}\``), "INVALID_PROMPT_INPUT");
+                            throw error;
+                        }
+                        acc[inputVariable] = allValues[inputVariable];
+                        return acc;
+                    }, {});
+                }
                 const message = await promptMessage.formatMessages(inputValues);
                 resultMessages = resultMessages.concat(message);
             }

package/dist/node_modules/@langchain/core/dist/prompts/dict.cjs

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DictPromptTemplate = void 0;
+const base_js_1 = require("../runnables/base.cjs");
+const template_js_1 = require("./template.cjs");
+class DictPromptTemplate extends base_js_1.Runnable {
+    static lc_name() {
+        return "DictPromptTemplate";
+    }
+    constructor(fields) {
+        const templateFormat = fields.templateFormat ?? "f-string";
+        const inputVariables = _getInputVariables(fields.template, templateFormat);
+        super({ inputVariables, ...fields });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "prompts", "dict"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "template", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "templateFormat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inputVariables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.template = fields.template;
+        this.templateFormat = templateFormat;
+        this.inputVariables = inputVariables;
+    }
+    async format(values) {
+        return _insertInputVariables(this.template, values, this.templateFormat);
+    }
+    async invoke(values) {
+        return await this._callWithConfig(this.format.bind(this), values, {
+            runType: "prompt",
+        });
+    }
+}
+exports.DictPromptTemplate = DictPromptTemplate;
+function _getInputVariables(template, templateFormat) {
+    const inputVariables = [];
+    for (const v of Object.values(template)) {
+        if (typeof v === "string") {
+            (0, template_js_1.parseTemplate)(v, templateFormat).forEach((t) => {
+                if (t.type === "variable") {
+                    inputVariables.push(t.name);
+                }
+            });
+        }
+        else if (Array.isArray(v)) {
+            for (const x of v) {
+                if (typeof x === "string") {
+                    (0, template_js_1.parseTemplate)(x, templateFormat).forEach((t) => {
+                        if (t.type === "variable") {
+                            inputVariables.push(t.name);
+                        }
+                    });
+                }
+                else if (typeof x === "object") {
+                    inputVariables.push(..._getInputVariables(x, templateFormat));
+                }
+            }
+        }
+        else if (typeof v === "object" && v !== null) {
+            inputVariables.push(..._getInputVariables(v, templateFormat));
+        }
+    }
+    return Array.from(new Set(inputVariables));
+}
+function _insertInputVariables(template, inputs, templateFormat) {
+    const formatted = {};
+    for (const [k, v] of Object.entries(template)) {
+        if (typeof v === "string") {
+            formatted[k] = (0, template_js_1.renderTemplate)(v, templateFormat, inputs);
+        }
+        else if (Array.isArray(v)) {
+            const formattedV = [];
+            for (const x of v) {
+                if (typeof x === "string") {
+                    formattedV.push((0, template_js_1.renderTemplate)(x, templateFormat, inputs));
+                }
+                else if (typeof x === "object") {
+                    formattedV.push(_insertInputVariables(x, inputs, templateFormat));
+                }
+            }
+            formatted[k] = formattedV;
+        }
+        else if (typeof v === "object" && v !== null) {
+            formatted[k] = _insertInputVariables(v, inputs, templateFormat);
+        }
+        else {
+            formatted[k] = v;
+        }
+    }
+    return formatted;
+}

package/dist/node_modules/@langchain/core/dist/prompts/dict.d.ts

@@ -0,0 +1,18 @@
+import { Runnable } from "../runnables/base.js";
+import type { InputValues } from "../utils/types/index.js";
+import { TypedPromptInputValues } from "./base.js";
+import { TemplateFormat } from "./template.js";
+export declare class DictPromptTemplate<RunInput extends InputValues = InputValues, RunOutput extends Record<string, unknown> = Record<string, unknown>> extends Runnable<TypedPromptInputValues<RunInput>, RunOutput> {
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    template: Record<string, unknown>;
+    templateFormat: TemplateFormat;
+    inputVariables: Array<Extract<keyof RunInput, string>>;
+    static lc_name(): string;
+    constructor(fields: {
+        template: Record<string, unknown>;
+        templateFormat?: TemplateFormat;
+    });
+    format(values: TypedPromptInputValues<RunInput>): Promise<RunOutput>;
+    invoke(values: TypedPromptInputValues<InputValues>): Promise<RunOutput>;
+}

package/dist/node_modules/@langchain/core/dist/prompts/dict.js

@@ -0,0 +1,110 @@
+import { Runnable } from "../runnables/base.js";
+import { parseTemplate, renderTemplate } from "./template.js";
+export class DictPromptTemplate extends Runnable {
+    static lc_name() {
+        return "DictPromptTemplate";
+    }
+    constructor(fields) {
+        const templateFormat = fields.templateFormat ?? "f-string";
+        const inputVariables = _getInputVariables(fields.template, templateFormat);
+        super({ inputVariables, ...fields });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "prompts", "dict"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "template", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "templateFormat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inputVariables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.template = fields.template;
+        this.templateFormat = templateFormat;
+        this.inputVariables = inputVariables;
+    }
+    async format(values) {
+        return _insertInputVariables(this.template, values, this.templateFormat);
+    }
+    async invoke(values) {
+        return await this._callWithConfig(this.format.bind(this), values, {
+            runType: "prompt",
+        });
+    }
+}
+function _getInputVariables(template, templateFormat) {
+    const inputVariables = [];
+    for (const v of Object.values(template)) {
+        if (typeof v === "string") {
+            parseTemplate(v, templateFormat).forEach((t) => {
+                if (t.type === "variable") {
+                    inputVariables.push(t.name);
+                }
+            });
+        }
+        else if (Array.isArray(v)) {
+            for (const x of v) {
+                if (typeof x === "string") {
+                    parseTemplate(x, templateFormat).forEach((t) => {
+                        if (t.type === "variable") {
+                            inputVariables.push(t.name);
+                        }
+                    });
+                }
+                else if (typeof x === "object") {
+                    inputVariables.push(..._getInputVariables(x, templateFormat));
+                }
+            }
+        }
+        else if (typeof v === "object" && v !== null) {
+            inputVariables.push(..._getInputVariables(v, templateFormat));
+        }
+    }
+    return Array.from(new Set(inputVariables));
+}
+function _insertInputVariables(template, inputs, templateFormat) {
+    const formatted = {};
+    for (const [k, v] of Object.entries(template)) {
+        if (typeof v === "string") {
+            formatted[k] = renderTemplate(v, templateFormat, inputs);
+        }
+        else if (Array.isArray(v)) {
+            const formattedV = [];
+            for (const x of v) {
+                if (typeof x === "string") {
+                    formattedV.push(renderTemplate(x, templateFormat, inputs));
+                }
+                else if (typeof x === "object") {
+                    formattedV.push(_insertInputVariables(x, inputs, templateFormat));
+                }
+            }
+            formatted[k] = formattedV;
+        }
+        else if (typeof v === "object" && v !== null) {
+            formatted[k] = _insertInputVariables(v, inputs, templateFormat);
+        }
+        else {
+            formatted[k] = v;
+        }
+    }
+    return formatted;
+}

package/dist/node_modules/@langchain/core/dist/prompts/index.cjs

@@ -24,3 +24,4 @@ __exportStar(require("./string.cjs"), exports);
 __exportStar(require("./template.cjs"), exports);
 __exportStar(require("./image.cjs"), exports);
 __exportStar(require("./structured.cjs"), exports);
+__exportStar(require("./dict.cjs"), exports);

package/dist/node_modules/@langchain/core/dist/prompts/index.d.ts

@@ -8,3 +8,4 @@ export * from "./string.js";
 export * from "./template.js";
 export * from "./image.js";
 export * from "./structured.js";
+export * from "./dict.js";

package/dist/node_modules/@langchain/core/dist/prompts/index.js

@@ -8,3 +8,4 @@ export * from "./string.js";
 export * from "./template.js";
 export * from "./image.js";
 export * from "./structured.js";
+export * from "./dict.js";

package/dist/node_modules/@langchain/core/dist/prompts/structured.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StructuredPrompt = void 0;
+const base_js_1 = require("../runnables/base.cjs");
 const chat_js_1 = require("./chat.cjs");
 function isWithStructuredOutput(x
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -33,6 +34,12 @@ class StructuredPrompt extends chat_js_1.ChatPromptTemplate {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "method", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
@@ -40,6 +47,7 @@ class StructuredPrompt extends chat_js_1.ChatPromptTemplate {
             value: ["langchain_core", "prompts", "structured"]
         });
         this.schema = input.schema;
+        this.method = input.method;
     }
     pipe(coerceable) {
         if (isWithStructuredOutput(coerceable)) {
@@ -47,18 +55,20 @@ class StructuredPrompt extends chat_js_1.ChatPromptTemplate {
         }
         if (isRunnableBinding(coerceable) &&
             isWithStructuredOutput(coerceable.bound)) {
-            return super.pipe(coerceable.bound
-                .withStructuredOutput(this.schema)
-                .bind(coerceable.kwargs ?? {})
-                .withConfig(coerceable.config));
+            return super.pipe(new base_js_1.RunnableBinding({
+                bound: coerceable.bound.withStructuredOutput(this.schema, ...(this.method ? [{ method: this.method }] : [])),
+                kwargs: coerceable.kwargs ?? {},
+                config: coerceable.config,
+                configFactories: coerceable.configFactories,
+            }));
         }
         throw new Error(`Structured prompts need to be piped to a language model that supports the "withStructuredOutput()" method.`);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static fromMessagesAndSchema(promptMessages, schema
+    static fromMessagesAndSchema(promptMessages, schema, method
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
-        return StructuredPrompt.fromMessages(promptMessages, { schema });
+        return StructuredPrompt.fromMessages(promptMessages, { schema, method });
     }
 }
 exports.StructuredPrompt = StructuredPrompt;

package/dist/node_modules/@langchain/core/dist/prompts/structured.d.ts

@@ -8,12 +8,14 @@ import { BaseMessagePromptTemplateLike, ChatPromptTemplate, ChatPromptTemplateIn
  */
 export interface StructuredPromptInput<RunInput extends InputValues = any, PartialVariableName extends string = any> extends ChatPromptTemplateInput<RunInput, PartialVariableName> {
     schema: Record<string, any>;
+    method?: "jsonMode" | "jsonSchema" | "functionMode";
 }
 export declare class StructuredPrompt<RunInput extends InputValues = any, PartialVariableName extends string = any> extends ChatPromptTemplate<RunInput, PartialVariableName> implements StructuredPromptInput<RunInput, PartialVariableName> {
     schema: Record<string, any>;
+    method?: "jsonMode" | "jsonSchema" | "functionMode";
     lc_namespace: string[];
     get lc_aliases(): Record<string, string>;
     constructor(input: StructuredPromptInput<RunInput, PartialVariableName>);
     pipe<NewRunOutput>(coerceable: RunnableLike<ChatPromptValueInterface, NewRunOutput>): Runnable<RunInput, Exclude<NewRunOutput, Error>, RunnableConfig>;
-    static fromMessagesAndSchema<RunInput extends InputValues = any>(promptMessages: (ChatPromptTemplate<InputValues, string> | BaseMessagePromptTemplateLike)[], schema: StructuredPromptInput["schema"]): ChatPromptTemplate<RunInput, any>;
+    static fromMessagesAndSchema<RunInput extends InputValues = any>(promptMessages: (ChatPromptTemplate<InputValues, string> | BaseMessagePromptTemplateLike)[], schema: StructuredPromptInput["schema"], method?: "jsonMode" | "jsonSchema" | "functionMode"): ChatPromptTemplate<RunInput, any>;
 }

package/dist/node_modules/@langchain/core/dist/prompts/structured.js

@@ -1,3 +1,4 @@
+import { RunnableBinding } from "../runnables/base.js";
 import { ChatPromptTemplate, } from "./chat.js";
 function isWithStructuredOutput(x
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -30,6 +31,12 @@ export class StructuredPrompt extends ChatPromptTemplate {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "method", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
@@ -37,6 +44,7 @@ export class StructuredPrompt extends ChatPromptTemplate {
             value: ["langchain_core", "prompts", "structured"]
         });
         this.schema = input.schema;
+        this.method = input.method;
     }
     pipe(coerceable) {
         if (isWithStructuredOutput(coerceable)) {
@@ -44,17 +52,19 @@ export class StructuredPrompt extends ChatPromptTemplate {
         }
         if (isRunnableBinding(coerceable) &&
             isWithStructuredOutput(coerceable.bound)) {
-            return super.pipe(coerceable.bound
-                .withStructuredOutput(this.schema)
-                .bind(coerceable.kwargs ?? {})
-                .withConfig(coerceable.config));
+            return super.pipe(new RunnableBinding({
+                bound: coerceable.bound.withStructuredOutput(this.schema, ...(this.method ? [{ method: this.method }] : [])),
+                kwargs: coerceable.kwargs ?? {},
+                config: coerceable.config,
+                configFactories: coerceable.configFactories,
+            }));
         }
         throw new Error(`Structured prompts need to be piped to a language model that supports the "withStructuredOutput()" method.`);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static fromMessagesAndSchema(promptMessages, schema
+    static fromMessagesAndSchema(promptMessages, schema, method
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
-        return StructuredPrompt.fromMessages(promptMessages, { schema });
+        return StructuredPrompt.fromMessages(promptMessages, { schema, method });
     }
 }

package/dist/node_modules/@langchain/core/dist/prompts/template.cjs

@@ -65,22 +65,33 @@ exports.parseFString = parseFString;
  * 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.
+ * @param {string[]} context Array of section variable names for nested context
  * @returns {ParsedTemplateNode[]}
  */
-const mustacheTemplateToNodes = (template) => template.map((temp) => {
-    if (temp[0] === "name") {
-        const name = temp[1].includes(".") ? temp[1].split(".")[0] : temp[1];
-        return { type: "variable", name };
-    }
-    else if (["#", "&", "^", ">"].includes(temp[0])) {
-        // # represents a section, "&" represents an unescaped variable.
-        // These should both be considered variables.
-        return { type: "variable", name: temp[1] };
-    }
-    else {
-        return { type: "literal", text: temp[1] };
+const mustacheTemplateToNodes = (template, context = []) => {
+    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 newContext = [...context, temp[1]];
+                const nestedNodes = mustacheTemplateToNodes(temp[4], newContext);
+                nodes.push(...nestedNodes);
+            }
+        }
+        else {
+            nodes.push({ type: "literal", text: temp[1] });
+        }
     }
-});
+    return nodes;
+};
 const parseMustache = (template) => {
     configureMustache();
     const parsed = mustache_1.default.parse(template);

package/dist/node_modules/@langchain/core/dist/prompts/template.js

@@ -58,22 +58,33 @@ export const parseFString = (template) => {
  * 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.
+ * @param {string[]} context Array of section variable names for nested context
  * @returns {ParsedTemplateNode[]}
  */
-const mustacheTemplateToNodes = (template) => template.map((temp) => {
-    if (temp[0] === "name") {
-        const name = temp[1].includes(".") ? temp[1].split(".")[0] : temp[1];
-        return { type: "variable", name };
-    }
-    else if (["#", "&", "^", ">"].includes(temp[0])) {
-        // # represents a section, "&" represents an unescaped variable.
-        // These should both be considered variables.
-        return { type: "variable", name: temp[1] };
-    }
-    else {
-        return { type: "literal", text: temp[1] };
+const mustacheTemplateToNodes = (template, context = []) => {
+    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 newContext = [...context, temp[1]];
+                const nestedNodes = mustacheTemplateToNodes(temp[4], newContext);
+                nodes.push(...nestedNodes);
+            }
+        }
+        else {
+            nodes.push({ type: "literal", text: temp[1] });
+        }
     }
-});
+    return nodes;
+};
 export const parseMustache = (template) => {
     configureMustache();
     const parsed = mustache.parse(template);