lingo.dev 0.117.6 → 0.117.8

package/build/cli.mjs

@@ -3403,8 +3403,8 @@ function serializeElement(node) {
   const attrString = Object.entries(attributes).map(([key, value]) => ` ${key}="${escapeAttributeValue(String(value))}"`).join("");
   const children = Array.isArray(node.$$) ? node.$$ : [];
   if (children.length === 0) {
-    const textContent2 = node._ ?? "";
-    return `<${name}${attrString}>${textContent2}</${name}>`;
+    const textContent3 = node._ ?? "";
+    return `<${name}${attrString}>${textContent3}</${name}>`;
   }
   const childContent = children.map(serializeElement).join("");
   return `<${name}${attrString}>${childContent}</${name}>`;
@@ -3598,7 +3598,7 @@ function createHtmlLoader() {
     // <title> should be treated as a block element for translation
   ]);
   const UNLOCALIZABLE_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
-  const LOCALIZABLE_ATTRIBUTES = {
+  const LOCALIZABLE_ATTRIBUTES2 = {
     meta: ["content"],
     img: ["alt", "title"],
     input: ["placeholder", "title"],
@@ -3644,12 +3644,12 @@ function createHtmlLoader() {
         }
         return hasTranslatableContent(element);
       }
-      function getInnerHTML(element) {
+      function getInnerHTML2(element) {
         return element.children.map((child) => DomSerializer.default(child, { encodeEntities: false })).join("");
       }
       function extractAttributes(element, path19) {
         const tagName = element.name.toLowerCase();
-        const attrs = LOCALIZABLE_ATTRIBUTES[tagName];
+        const attrs = LOCALIZABLE_ATTRIBUTES2[tagName];
         if (!attrs) return;
         for (const attr of attrs) {
           const value = element.attribs?.[attr];
@@ -3666,14 +3666,14 @@ function createHtmlLoader() {
         extractAttributes(element, path19);
         const tagName = element.name.toLowerCase();
         if (BLOCK_ELEMENTS.has(tagName) && isLeafBlock(element)) {
-          const content = getInnerHTML(element).trim();
+          const content = getInnerHTML2(element).trim();
           if (content) {
             result[path19] = content;
           }
           return;
         }
         if (PHRASING_ELEMENTS.has(tagName) && hasTranslatableContent(element)) {
-          const content = getInnerHTML(element).trim();
+          const content = getInnerHTML2(element).trim();
           if (content) {
             result[path19] = content;
           }
@@ -4004,6 +4004,264 @@ function applyTranslations(node, path19, data, pathMap) {
   }
 }
 
+// src/cli/loaders/mjml.ts
+import { parseStringPromise as parseStringPromise2 } from "xml2js";
+import * as htmlparser22 from "htmlparser2";
+import { DomHandler as DomHandler2 } from "domhandler";
+var LOCALIZABLE_COMPONENTS = [
+  "mj-text",
+  "mj-button",
+  "mj-title",
+  "mj-preview",
+  "mj-navbar-link",
+  "mj-accordion-title",
+  "mj-accordion-text",
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "li"
+];
+var LOCALIZABLE_ATTRIBUTES = {
+  "mj-image": ["alt", "title"],
+  "mj-button": ["title", "aria-label"],
+  "mj-social-element": ["title", "alt"],
+  "img": ["alt", "title"],
+  "a": ["title", "aria-label"]
+};
+function createMjmlLoader() {
+  return createLoader({
+    async pull(locale, input2) {
+      const result = {};
+      try {
+        const parsed = await parseStringPromise2(input2, {
+          explicitArray: true,
+          explicitChildren: true,
+          preserveChildrenOrder: true,
+          charsAsChildren: true,
+          includeWhiteChars: true,
+          mergeAttrs: false,
+          trim: false,
+          attrkey: "$",
+          charkey: "_",
+          childkey: "$$"
+        });
+        if (!parsed || typeof parsed !== "object") {
+          console.error("Failed to parse MJML: invalid parsed structure");
+          return result;
+        }
+        const rootKey = Object.keys(parsed).find((key) => !key.startsWith("_") && !key.startsWith("$"));
+        const rootNode = rootKey ? parsed[rootKey] : parsed;
+        const rootPath = rootNode["#name"] || rootKey || "";
+        traverse(rootNode, (node, path19, componentName) => {
+          if (typeof node !== "object") return;
+          const localizableAttrs = LOCALIZABLE_ATTRIBUTES[componentName];
+          if (localizableAttrs && node.$) {
+            localizableAttrs.forEach((attr) => {
+              const attrValue = node.$[attr];
+              if (attrValue) {
+                result[`${path19}#${attr}`] = attrValue;
+              }
+            });
+          }
+          if (LOCALIZABLE_COMPONENTS.includes(componentName)) {
+            const innerHTML = getInnerHTML(node);
+            if (innerHTML) {
+              result[path19] = innerHTML;
+              return "SKIP_CHILDREN";
+            }
+          }
+          return void 0;
+        }, rootPath);
+      } catch (error) {
+        console.error("Failed to parse MJML:", error);
+      }
+      return result;
+    },
+    async push(locale, data, originalInput) {
+      try {
+        const parsed = await parseStringPromise2(originalInput || "", {
+          explicitArray: true,
+          explicitChildren: true,
+          preserveChildrenOrder: true,
+          charsAsChildren: true,
+          includeWhiteChars: true,
+          mergeAttrs: false,
+          trim: false,
+          attrkey: "$",
+          charkey: "_",
+          childkey: "$$"
+        });
+        if (!parsed || typeof parsed !== "object") {
+          console.error("Failed to parse MJML for push: invalid parsed structure");
+          return originalInput || "";
+        }
+        const rootKey = Object.keys(parsed).find((key) => !key.startsWith("_") && !key.startsWith("$"));
+        const rootNode = rootKey ? parsed[rootKey] : parsed;
+        const rootPath = rootNode["#name"] || rootKey || "";
+        traverse(rootNode, (node, path19, componentName) => {
+          if (typeof node !== "object") return;
+          const localizableAttrs = LOCALIZABLE_ATTRIBUTES[componentName];
+          if (localizableAttrs && node.$) {
+            localizableAttrs.forEach((attr) => {
+              const attrKey = `${path19}#${attr}`;
+              if (data[attrKey] !== void 0) {
+                node.$[attr] = data[attrKey];
+              }
+            });
+          }
+          if (LOCALIZABLE_COMPONENTS.includes(componentName) && data[path19]) {
+            setInnerHTML(node, data[path19]);
+            return "SKIP_CHILDREN";
+          }
+          return void 0;
+        }, rootPath);
+        return serializeMjml(parsed);
+      } catch (error) {
+        console.error("Failed to build MJML:", error);
+        return "";
+      }
+    }
+  });
+}
+function traverse(node, visitor, path19 = "") {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  const children = node.$$;
+  if (!Array.isArray(children)) {
+    return;
+  }
+  const elementCounts = /* @__PURE__ */ new Map();
+  children.forEach((child) => {
+    const elementName = child["#name"];
+    if (!elementName || elementName.startsWith("__")) {
+      return;
+    }
+    const currentIndex = elementCounts.get(elementName) || 0;
+    elementCounts.set(elementName, currentIndex + 1);
+    const currentPath = path19 ? `${path19}/${elementName}/${currentIndex}` : `${elementName}/${currentIndex}`;
+    const result = visitor(child, currentPath, elementName);
+    if (result !== "SKIP_CHILDREN") {
+      traverse(child, visitor, currentPath);
+    }
+  });
+}
+function getInnerHTML(node) {
+  if (!node.$$ || !Array.isArray(node.$$)) {
+    return null;
+  }
+  let html = "";
+  node.$$.forEach((child) => {
+    html += serializeXmlNode(child);
+  });
+  return html.trim() || null;
+}
+function setInnerHTML(node, htmlContent) {
+  const handler = new DomHandler2();
+  const parser = new htmlparser22.Parser(handler);
+  parser.write(htmlContent);
+  parser.end();
+  const newChildren = [];
+  for (const domNode of handler.dom) {
+    const xmlNode = convertDomToXmlNode(domNode);
+    if (xmlNode) {
+      newChildren.push(xmlNode);
+    }
+  }
+  node.$$ = newChildren;
+  node._ = htmlContent;
+}
+function serializeXmlNode(node) {
+  const name = node["#name"];
+  if (name === "__text__") {
+    return node._ || "";
+  }
+  if (name === "__cdata") {
+    return `<![CDATA[${node._ || ""}]]>`;
+  }
+  if (!name || name.startsWith("__")) {
+    return "";
+  }
+  const attrs = node.$ || {};
+  const attrString = Object.entries(attrs).map(([key, value]) => ` ${key}="${escapeAttributeValue2(String(value))}"`).join("");
+  const children = node.$$ || [];
+  if (children.length === 0) {
+    const textContent3 = node._ || "";
+    if (textContent3) {
+      return `<${name}${attrString}>${textContent3}</${name}>`;
+    }
+    return `<${name}${attrString} />`;
+  }
+  const childContent = children.map(serializeXmlNode).join("");
+  return `<${name}${attrString}>${childContent}</${name}>`;
+}
+function convertDomToXmlNode(domNode) {
+  if (domNode.type === "text") {
+    return {
+      "#name": "__text__",
+      "_": domNode.data
+    };
+  }
+  if (domNode.type === "tag") {
+    const xmlNode = {
+      "#name": domNode.name,
+      "$": domNode.attribs || {},
+      "$$": []
+    };
+    if (domNode.children && domNode.children.length > 0) {
+      for (const child of domNode.children) {
+        const xmlChild = convertDomToXmlNode(child);
+        if (xmlChild) {
+          xmlNode.$$.push(xmlChild);
+        }
+      }
+    }
+    return xmlNode;
+  }
+  return null;
+}
+function serializeMjml(parsed) {
+  const xmlDec = '<?xml version="1.0" encoding="UTF-8"?>\n';
+  const rootKey = Object.keys(parsed).find((key) => !key.startsWith("_") && !key.startsWith("$"));
+  const rootNode = rootKey ? parsed[rootKey] : parsed;
+  const body = serializeElement2(rootNode);
+  return xmlDec + body;
+}
+function serializeElement2(node, indent2 = "") {
+  if (!node) {
+    return "";
+  }
+  const name = node["#name"] ?? "mjml";
+  if (name === "__text__") {
+    return node._ ?? "";
+  }
+  if (name === "__cdata") {
+    return `<![CDATA[${node._ ?? ""}]]>`;
+  }
+  if (name === "__comment__") {
+    return `<!--${node._ ?? ""}-->`;
+  }
+  const attributes = node.$ ?? {};
+  const attrString = Object.entries(attributes).map(([key, value]) => ` ${key}="${escapeAttributeValue2(String(value))}"`).join("");
+  const children = Array.isArray(node.$$) ? node.$$ : [];
+  if (children.length === 0) {
+    const textContent3 = node._ ?? "";
+    if (textContent3) {
+      return `${indent2}<${name}${attrString}>${textContent3}</${name}>`;
+    }
+    return `${indent2}<${name}${attrString} />`;
+  }
+  const childContent = children.map((child) => serializeElement2(child, indent2)).join("");
+  return `${indent2}<${name}${attrString}>${childContent}</${name}>`;
+}
+function escapeAttributeValue2(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&apos;");
+}
+
 // src/cli/loaders/properties.ts
 function createPropertiesLoader() {
   return createLoader({
@@ -4267,7 +4525,7 @@ function escapeString(str) {
 }
 
 // src/cli/loaders/xcode-strings/parser.ts
-var Parser2 = class {
+var Parser3 = class {
   tokens;
   pos;
   constructor(tokens) {
@@ -4340,7 +4598,7 @@ function createXcodeStringsLoader() {
     async pull(locale, input2) {
       const tokenizer = new Tokenizer(input2);
       const tokens = tokenizer.tokenize();
-      const parser = new Parser2(tokens);
+      const parser = new Parser3(tokens);
       const result = parser.parse();
       return result;
     },
@@ -5552,10 +5810,10 @@ function formatXml(xml) {
     if (cdataNode) {
       return `${indent2}${openTag}<![CDATA[${cdataNode.nodeValue}]]></${tagName}>`;
     }
-    const textContent2 = element.textContent?.trim() || "";
+    const textContent3 = element.textContent?.trim() || "";
     const hasOnlyText = element.childNodes.length === 1 && element.childNodes[0].nodeType === 3;
-    if (hasOnlyText && textContent2) {
-      return `${indent2}${openTag}${textContent2}</${tagName}>`;
+    if (hasOnlyText && textContent3) {
+      return `${indent2}${openTag}${textContent3}</${tagName}>`;
     }
     const children = Array.from(element.children);
     if (children.length === 0) {
@@ -5607,7 +5865,7 @@ function pushNewFile(locale, translations, originalLocale) {
 }
 
 // src/cli/loaders/xml.ts
-import { parseStringPromise as parseStringPromise2, Builder } from "xml2js";
+import { parseStringPromise as parseStringPromise3, Builder as Builder2 } from "xml2js";
 function normalizeXMLString(xmlString) {
   return xmlString.replace(/\s+/g, " ").replace(/>\s+</g, "><").replace("\n", "").trim();
 }
@@ -5616,7 +5874,7 @@ function createXmlLoader() {
     async pull(locale, input2) {
       let result = {};
       try {
-        const parsed = await parseStringPromise2(input2, {
+        const parsed = await parseStringPromise3(input2, {
           explicitArray: false,
           mergeAttrs: false,
           normalize: true,
@@ -5634,7 +5892,7 @@ function createXmlLoader() {
     },
     async push(locale, data) {
       try {
-        const builder = new Builder({ headless: true });
+        const builder = new Builder2({ headless: true });
         const xmlOutput = builder.buildObject(data);
         const expectedOutput = normalizeXMLString(xmlOutput);
         return expectedOutput;
@@ -6727,7 +6985,7 @@ function resolveCjsExport(mod, name = "module") {
 }
 
 // src/cli/loaders/typescript/index.ts
-var traverse = resolveCjsExport(babelTraverseModule, "@babel/traverse");
+var traverse2 = resolveCjsExport(babelTraverseModule, "@babel/traverse");
 var generate = resolveCjsExport(babelGenerateModule, "@babel/generator");
 function createTypescriptLoader() {
   return createLoader({
@@ -6760,7 +7018,7 @@ function parseTypeScript(input2) {
 }
 function extractStringsFromDefaultExport(ast) {
   let extracted = {};
-  traverse(ast, {
+  traverse2(ast, {
     ExportDefaultDeclaration(path19) {
       const { declaration } = path19.node;
       const decl = unwrapTSAsExpression(declaration);
@@ -6833,7 +7091,7 @@ function arrayExpressionToArray(arrayExpression) {
 }
 function updateStringsInDefaultExport(ast, data) {
   let modified = false;
-  traverse(ast, {
+  traverse2(ast, {
     ExportDefaultDeclaration(path19) {
       const { declaration } = path19.node;
       const decl = unwrapTSAsExpression(declaration);
@@ -8875,14 +9133,14 @@ function parseEjsForTranslation(input2) {
     if (part.type === "ejs") {
       template += part.content;
     } else {
-      const textContent2 = part.content;
+      const textContent3 = part.content;
       const htmlTagRegex = /<[^>]+>/g;
       const textParts = [];
       let lastTextIndex = 0;
       let htmlMatch;
-      while ((htmlMatch = htmlTagRegex.exec(textContent2)) !== null) {
+      while ((htmlMatch = htmlTagRegex.exec(textContent3)) !== null) {
         if (htmlMatch.index > lastTextIndex) {
-          const textBefore = textContent2.slice(lastTextIndex, htmlMatch.index);
+          const textBefore = textContent3.slice(lastTextIndex, htmlMatch.index);
           if (textBefore.trim()) {
             textParts.push({ type: "text", content: textBefore });
           } else {
@@ -8892,8 +9150,8 @@ function parseEjsForTranslation(input2) {
         textParts.push({ type: "html", content: htmlMatch[0] });
         lastTextIndex = htmlMatch.index + htmlMatch[0].length;
       }
-      if (lastTextIndex < textContent2.length) {
-        const remainingText = textContent2.slice(lastTextIndex);
+      if (lastTextIndex < textContent3.length) {
+        const remainingText = textContent3.slice(lastTextIndex);
         if (remainingText.trim()) {
           textParts.push({ type: "text", content: remainingText });
         } else {
@@ -8901,11 +9159,11 @@ function parseEjsForTranslation(input2) {
         }
       }
       if (textParts.length === 0) {
-        const trimmedContent = textContent2.trim();
+        const trimmedContent = textContent3.trim();
         if (trimmedContent) {
-          textParts.push({ type: "text", content: textContent2 });
+          textParts.push({ type: "text", content: textContent3 });
         } else {
-          textParts.push({ type: "html", content: textContent2 });
+          textParts.push({ type: "html", content: textContent3 });
         }
       }
       for (const textPart of textParts) {
@@ -8974,6 +9232,368 @@ function createEjsLoader() {
   });
 }
 
+// src/cli/loaders/twig.ts
+import * as htmlparser23 from "htmlparser2";
+import { DomHandler as DomHandler3 } from "domhandler";
+import * as domutils2 from "domutils";
+import * as DomSerializer2 from "dom-serializer";
+function createTwigLoader() {
+  const PHRASING_ELEMENTS = /* @__PURE__ */ new Set([
+    // Text-level semantics
+    "a",
+    "abbr",
+    "b",
+    "bdi",
+    "bdo",
+    "br",
+    "cite",
+    "code",
+    "data",
+    "dfn",
+    "em",
+    "i",
+    "kbd",
+    "mark",
+    "q",
+    "ruby",
+    "s",
+    "samp",
+    "small",
+    "span",
+    "strong",
+    "sub",
+    "sup",
+    "time",
+    "u",
+    "var",
+    "wbr",
+    // Media
+    "audio",
+    "img",
+    "video",
+    "picture",
+    // Interactive
+    "button",
+    "input",
+    "label",
+    "select",
+    "textarea",
+    // Embedded
+    "canvas",
+    "iframe",
+    "object",
+    "svg",
+    "math",
+    // Other
+    "del",
+    "ins",
+    "map",
+    "area"
+  ]);
+  const BLOCK_ELEMENTS = /* @__PURE__ */ new Set([
+    "div",
+    "p",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "ul",
+    "ol",
+    "li",
+    "dl",
+    "dt",
+    "dd",
+    "blockquote",
+    "pre",
+    "article",
+    "aside",
+    "nav",
+    "section",
+    "header",
+    "footer",
+    "main",
+    "figure",
+    "figcaption",
+    "table",
+    "thead",
+    "tbody",
+    "tfoot",
+    "tr",
+    "td",
+    "th",
+    "caption",
+    "form",
+    "fieldset",
+    "legend",
+    "details",
+    "summary",
+    "address",
+    "hr",
+    "search",
+    "dialog",
+    "noscript",
+    "title"
+  ]);
+  const UNLOCALIZABLE_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
+  const LOCALIZABLE_ATTRIBUTES2 = {
+    meta: ["content"],
+    img: ["alt", "title"],
+    input: ["placeholder", "title", "aria-label"],
+    textarea: ["placeholder", "title", "aria-label"],
+    button: ["title", "aria-label"],
+    a: ["title", "aria-label"],
+    abbr: ["title"],
+    link: ["title"]
+  };
+  function preprocessTwig(input2) {
+    const twigBlocks = [];
+    let counter = 0;
+    const processed = input2.replace(/\{%[\s\S]*?%\}/g, (match2) => {
+      twigBlocks.push(match2);
+      return `__TWIG_BLOCK_${counter++}__`;
+    });
+    return {
+      processed: processed.replace(/\{#[\s\S]*?#\}/g, (match2) => {
+        twigBlocks.push(match2);
+        return `__TWIG_BLOCK_${counter++}__`;
+      }),
+      twigBlocks
+    };
+  }
+  function postprocessTwig(text, twigBlocks) {
+    return text.replace(/__TWIG_BLOCK_(\d+)__/g, (_37, index) => {
+      return twigBlocks[parseInt(index, 10)] || "";
+    });
+  }
+  return createLoader({
+    async pull(locale, input2) {
+      const result = {};
+      const { processed, twigBlocks } = preprocessTwig(input2);
+      const handler = new DomHandler3();
+      const parser = new htmlparser23.Parser(handler, {
+        lowerCaseTags: false,
+        lowerCaseAttributeNames: false
+      });
+      parser.write(processed);
+      parser.end();
+      const dom = handler.dom;
+      function isInsideUnlocalizableTag(element) {
+        let current = element.parent;
+        while (current && current.type === "tag") {
+          if (UNLOCALIZABLE_TAGS.has(current.name.toLowerCase())) {
+            return true;
+          }
+          current = current.parent;
+        }
+        return false;
+      }
+      function hasTranslatableContent(element) {
+        const text = domutils2.textContent(element);
+        return text.trim().length > 0;
+      }
+      function isLeafBlock(element) {
+        const childElements = element.children.filter(
+          (child) => child.type === "tag"
+        );
+        for (const child of childElements) {
+          if (BLOCK_ELEMENTS.has(child.name.toLowerCase())) {
+            return false;
+          }
+        }
+        return hasTranslatableContent(element);
+      }
+      function getInnerHTML2(element) {
+        const html2 = element.children.map((child) => DomSerializer2.default(child, { encodeEntities: false })).join("");
+        return postprocessTwig(html2, twigBlocks);
+      }
+      function extractAttributes(element, path19) {
+        const tagName = element.name.toLowerCase();
+        const attrs = LOCALIZABLE_ATTRIBUTES2[tagName];
+        if (!attrs) return;
+        for (const attr of attrs) {
+          const value = element.attribs?.[attr];
+          if (value && value.trim()) {
+            const restoredValue = postprocessTwig(value.trim(), twigBlocks);
+            result[`${path19}#${attr}`] = restoredValue;
+          }
+        }
+      }
+      function extractFromElement(element, pathParts) {
+        const path19 = pathParts.join("/");
+        if (isInsideUnlocalizableTag(element)) {
+          return;
+        }
+        extractAttributes(element, path19);
+        const tagName = element.name.toLowerCase();
+        if (BLOCK_ELEMENTS.has(tagName) && isLeafBlock(element)) {
+          const content = getInnerHTML2(element).trim();
+          if (content) {
+            result[path19] = content;
+          }
+          return;
+        }
+        if (PHRASING_ELEMENTS.has(tagName) && hasTranslatableContent(element)) {
+          const content = getInnerHTML2(element).trim();
+          if (content) {
+            result[path19] = content;
+          }
+          return;
+        }
+        let childIndex = 0;
+        const childElements = element.children.filter(
+          (child) => child.type === "tag"
+        );
+        for (const child of childElements) {
+          extractFromElement(child, [...pathParts, childIndex++]);
+        }
+      }
+      const html = domutils2.findOne(
+        (elem) => elem.type === "tag" && elem.name.toLowerCase() === "html",
+        dom,
+        true
+      );
+      if (html) {
+        const head = domutils2.findOne(
+          (elem) => elem.type === "tag" && elem.name.toLowerCase() === "head",
+          html.children,
+          true
+        );
+        const body = domutils2.findOne(
+          (elem) => elem.type === "tag" && elem.name.toLowerCase() === "body",
+          html.children,
+          true
+        );
+        if (head) {
+          let headIndex = 0;
+          const headChildren = head.children.filter(
+            (child) => child.type === "tag"
+          );
+          for (const child of headChildren) {
+            extractFromElement(child, ["head", headIndex++]);
+          }
+        }
+        if (body) {
+          let bodyIndex = 0;
+          const bodyChildren = body.children.filter(
+            (child) => child.type === "tag"
+          );
+          for (const child of bodyChildren) {
+            extractFromElement(child, ["body", bodyIndex++]);
+          }
+        }
+      } else {
+        let rootIndex = 0;
+        const rootElements = dom.filter(
+          (child) => child.type === "tag"
+        );
+        for (const child of rootElements) {
+          extractFromElement(child, [rootIndex++]);
+        }
+      }
+      return result;
+    },
+    async push(locale, data, originalInput) {
+      const { processed, twigBlocks } = preprocessTwig(originalInput || "");
+      const handler = new DomHandler3();
+      const parser = new htmlparser23.Parser(handler, {
+        lowerCaseTags: false,
+        lowerCaseAttributeNames: false
+      });
+      parser.write(processed || "<!DOCTYPE html><html><head></head><body></body></html>");
+      parser.end();
+      const dom = handler.dom;
+      const html = domutils2.findOne(
+        (elem) => elem.type === "tag" && elem.name.toLowerCase() === "html",
+        dom,
+        true
+      );
+      if (html) {
+        html.attribs = html.attribs || {};
+        html.attribs.lang = locale;
+      }
+      function traverseByIndices(element, indices) {
+        let current = element;
+        for (const indexStr of indices) {
+          if (!current) return null;
+          const index = parseInt(indexStr, 10);
+          const children = current.children.filter(
+            (child) => child.type === "tag"
+          );
+          if (index >= children.length) {
+            return null;
+          }
+          current = children[index];
+        }
+        return current;
+      }
+      function resolvePathToElement(path19) {
+        const parts = path19.split("/");
+        const [rootTag, ...indices] = parts;
+        let current = null;
+        if (html) {
+          if (rootTag === "head") {
+            current = domutils2.findOne(
+              (elem) => elem.type === "tag" && elem.name.toLowerCase() === "head",
+              html.children,
+              true
+            );
+          } else if (rootTag === "body") {
+            current = domutils2.findOne(
+              (elem) => elem.type === "tag" && elem.name.toLowerCase() === "body",
+              html.children,
+              true
+            );
+          }
+          if (!current) return null;
+          return traverseByIndices(current, indices);
+        } else {
+          const rootElements = dom.filter(
+            (child) => child.type === "tag"
+          );
+          const rootIndex = parseInt(rootTag, 10);
+          if (rootIndex >= rootElements.length) {
+            return null;
+          }
+          current = rootElements[rootIndex];
+          return traverseByIndices(current, indices);
+        }
+      }
+      for (const [path19, value] of Object.entries(data)) {
+        const [nodePath, attribute] = path19.split("#");
+        const element = resolvePathToElement(nodePath);
+        if (!element) {
+          console.warn(`Path not found in original template: ${nodePath}`);
+          continue;
+        }
+        if (attribute) {
+          element.attribs = element.attribs || {};
+          element.attribs[attribute] = value;
+        } else {
+          if (value) {
+            const { processed: processedValue, twigBlocks: valueTwigBlocks } = preprocessTwig(value);
+            const valueHandler = new DomHandler3();
+            const valueParser = new htmlparser23.Parser(valueHandler);
+            valueParser.write(processedValue);
+            valueParser.end();
+            element.children = valueHandler.dom;
+            element.children.forEach((child) => {
+              if (child.type === "text" && child.data) {
+                child.data = postprocessTwig(child.data, valueTwigBlocks);
+              }
+            });
+          } else {
+            element.children = [];
+          }
+        }
+      }
+      const serialized = DomSerializer2.default(dom, { encodeEntities: false });
+      return postprocessTwig(serialized, twigBlocks);
+    }
+  });
+}
+
 // src/cli/loaders/ensure-key-order.ts
 import _25 from "lodash";
 function createEnsureKeyOrderLoader() {
@@ -9250,6 +9870,17 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
         createSyncLoader(),
         createUnlocalizableLoader(options.returnUnlocalizedKeys)
       );
+    case "mjml":
+      return composeLoaders(
+        createTextFileLoader(bucketPathPattern),
+        createFormatterLoader(options.formatter, "html", bucketPathPattern),
+        createLockedPatternsLoader(lockedPatterns),
+        createMjmlLoader(),
+        createLockedKeysLoader(lockedKeys || []),
+        createIgnoredKeysLoader(ignoredKeys || []),
+        createSyncLoader(),
+        createUnlocalizableLoader(options.returnUnlocalizedKeys)
+      );
     case "po":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
@@ -9461,6 +10092,16 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
         createIgnoredKeysLoader(ignoredKeys || []),
         createUnlocalizableLoader(options.returnUnlocalizedKeys)
       );
+    case "twig":
+      return composeLoaders(
+        createTextFileLoader(bucketPathPattern),
+        createLockedPatternsLoader(lockedPatterns),
+        createTwigLoader(),
+        createLockedKeysLoader(lockedKeys || []),
+        createIgnoredKeysLoader(ignoredKeys || []),
+        createSyncLoader(),
+        createUnlocalizableLoader(options.returnUnlocalizedKeys)
+      );
     case "txt":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
@@ -13832,7 +14473,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.117.6",
+  version: "0.117.8",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {