lingo.dev 0.113.5 → 0.113.7

package/build/cli.mjs

@@ -2151,7 +2151,13 @@ function _isMetadataKey(key) {
 }
 
 // src/cli/loaders/android.ts
-import { parseStringPromise, Builder } from "xml2js";
+import { createRequire } from "node:module";
+import { parseStringPromise } from "xml2js";
+var require2 = createRequire(import.meta.url);
+var sax = require2("sax");
+var defaultAndroidResourcesXml = `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+</resources>`;
 function createAndroidLoader() {
   return createLoader({
     async pull(locale, input2) {
@@ -2159,173 +2165,1053 @@ function createAndroidLoader() {
         if (!input2) {
           return {};
         }
-        const result = {};
-        const stringRegex = /<string\s+name="([^"]+)"(?:\s+translatable="([^"]+)")?[^>]*>([\s\S]*?)<\/string>/gi;
-        let stringMatch;
-        while ((stringMatch = stringRegex.exec(input2)) !== null) {
-          const name = stringMatch[1];
-          const translatable = stringMatch[2];
-          let value = stringMatch[3];
-          if (translatable === "false") {
+        const document = await parseAndroidDocument(input2);
+        return buildPullResult(document);
+      } catch (error) {
+        console.error("Error parsing Android resource file:", error);
+        throw new CLIError({
+          message: "Failed to parse Android resource file",
+          docUrl: "androidResouceError"
+        });
+      }
+    },
+    async push(locale, payload, originalInput, originalLocale, pullInput, pullOutput) {
+      try {
+        const selectedBase = selectBaseXml(
+          locale,
+          originalLocale,
+          pullInput,
+          originalInput
+        );
+        const existingDocument = await parseAndroidDocument(selectedBase);
+        const sourceDocument = await parseAndroidDocument(originalInput);
+        const translatedDocument = buildTranslatedDocument(
+          payload,
+          existingDocument,
+          sourceDocument
+        );
+        const referenceXml = selectedBase || originalInput || defaultAndroidResourcesXml;
+        const declaration = resolveXmlDeclaration(referenceXml);
+        return buildAndroidXml(translatedDocument, declaration);
+      } catch (error) {
+        console.error("Error generating Android resource file:", error);
+        throw new CLIError({
+          message: "Failed to generate Android resource file",
+          docUrl: "androidResouceError"
+        });
+      }
+    }
+  });
+}
+function resolveXmlDeclaration(xml) {
+  if (!xml) {
+    const xmldec = {
+      version: "1.0",
+      encoding: "utf-8"
+    };
+    return {
+      xmldec,
+      headless: false
+    };
+  }
+  const match2 = xml.match(
+    /<\?xml\s+version="([^"]+)"(?:\s+encoding="([^"]+)")?\s*\?>/
+  );
+  if (match2) {
+    const version = match2[1] && match2[1].trim().length > 0 ? match2[1] : "1.0";
+    const encoding = match2[2] && match2[2].trim().length > 0 ? match2[2] : void 0;
+    const xmldec = encoding ? { version, encoding } : { version };
+    return {
+      xmldec,
+      headless: false
+    };
+  }
+  return { headless: true };
+}
+async function parseAndroidDocument(input2) {
+  const xmlToParse = input2 && input2.trim().length > 0 ? input2 : defaultAndroidResourcesXml;
+  const parsed = await parseStringPromise(xmlToParse, {
+    explicitArray: true,
+    explicitChildren: true,
+    preserveChildrenOrder: true,
+    charsAsChildren: true,
+    includeWhiteChars: true,
+    mergeAttrs: false,
+    normalize: false,
+    normalizeTags: false,
+    trim: false,
+    attrkey: "$",
+    charkey: "_",
+    childkey: "$$"
+  });
+  if (!parsed || !parsed.resources) {
+    return {
+      resources: { $$: [] },
+      resourceNodes: []
+    };
+  }
+  const resourcesNode = parsed.resources;
+  resourcesNode["#name"] = resourcesNode["#name"] ?? "resources";
+  resourcesNode.$$ = resourcesNode.$$ ?? [];
+  const metadata = extractResourceMetadata(xmlToParse);
+  const resourceNodes = [];
+  let metaIndex = 0;
+  for (const child of resourcesNode.$$) {
+    const elementName = child?.["#name"];
+    if (!isResourceElementName(elementName)) {
+      continue;
+    }
+    const meta = metadata[metaIndex++];
+    if (!meta || meta.type !== elementName) {
+      continue;
+    }
+    const name = child?.$?.name ?? meta.name;
+    if (!name) {
+      continue;
+    }
+    const translatable = (child?.$?.translatable ?? "").toLowerCase() !== "false";
+    switch (meta.type) {
+      case "string": {
+        resourceNodes.push({
+          type: "string",
+          name,
+          translatable,
+          node: child,
+          meta: cloneTextMeta(meta.meta)
+        });
+        break;
+      }
+      case "string-array": {
+        const itemNodes = child?.item ?? [];
+        const items = [];
+        const templateItems = meta.items;
+        for (let i = 0; i < Math.max(itemNodes.length, templateItems.length); i++) {
+          const nodeItem = itemNodes[i];
+          const templateItem = templateItems[i] ?? templateItems[templateItems.length - 1];
+          if (!nodeItem) {
             continue;
           }
-          const cdataRegex = /<!\[CDATA\[([\s\S]*?)\]\]>/g;
-          value = value.replace(cdataRegex, (match2, content) => content);
-          value = value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/\\'/g, "'");
-          result[name] = value;
+          items.push({
+            node: nodeItem,
+            meta: cloneTextMeta(templateItem.meta)
+          });
         }
-        const parsed = await parseStringPromise(input2, {
-          explicitArray: true,
-          mergeAttrs: false,
-          normalize: true,
-          normalizeTags: false,
-          trim: true,
-          attrkey: "$",
-          charkey: "_"
+        resourceNodes.push({
+          type: "string-array",
+          name,
+          translatable,
+          node: child,
+          items
         });
-        if (!parsed || !parsed.resources) {
-          return result;
-        }
-        if (parsed.resources["string-array"]) {
-          parsed.resources["string-array"].forEach((arrayItem) => {
-            if (arrayItem.$ && arrayItem.$.translatable === "false") {
-              return;
-            }
-            const name = arrayItem.$.name;
-            const items = [];
-            if (arrayItem.item) {
-              arrayItem.item.forEach((item) => {
-                let itemValue = "";
-                if (typeof item === "string") {
-                  itemValue = item;
-                } else if (item._) {
-                  itemValue = item._;
-                } else if (item._ === "") {
-                  itemValue = "";
-                }
-                items.push(
-                  itemValue === "" || /^\s+$/.test(itemValue) ? itemValue : itemValue.trim()
-                );
-              });
-            }
-            result[name] = items;
+        break;
+      }
+      case "plurals": {
+        const itemNodes = child?.item ?? [];
+        const templateItems = meta.items;
+        const items = [];
+        for (const templateItem of templateItems) {
+          const quantity = templateItem.quantity;
+          if (!quantity) {
+            continue;
+          }
+          const nodeItem = itemNodes.find(
+            (item) => item?.$?.quantity === quantity
+          );
+          if (!nodeItem) {
+            continue;
+          }
+          items.push({
+            node: nodeItem,
+            quantity,
+            meta: cloneTextMeta(templateItem.meta)
           });
         }
-        if (parsed.resources.plurals) {
-          parsed.resources.plurals.forEach((pluralItem) => {
-            if (pluralItem.$ && pluralItem.$.translatable === "false") {
-              return;
-            }
-            const name = pluralItem.$.name;
-            const pluralObj = {};
-            if (pluralItem.item) {
-              pluralItem.item.forEach((item) => {
-                if (item.$ && item.$.quantity) {
-                  let value = "";
-                  if (item._) {
-                    value = item._;
-                  } else if (item._ === "") {
-                    value = "";
-                  }
-                  pluralObj[item.$.quantity] = value === "" || /^\s+$/.test(value) ? value : value.trim();
-                }
-              });
-            }
-            result[name] = pluralObj;
-          });
+        resourceNodes.push({
+          type: "plurals",
+          name,
+          translatable,
+          node: child,
+          items
+        });
+        break;
+      }
+      case "bool": {
+        resourceNodes.push({
+          type: "bool",
+          name,
+          translatable,
+          node: child,
+          meta: cloneTextMeta(meta.meta)
+        });
+        break;
+      }
+      case "integer": {
+        resourceNodes.push({
+          type: "integer",
+          name,
+          translatable,
+          node: child,
+          meta: cloneTextMeta(meta.meta)
+        });
+        break;
+      }
+    }
+  }
+  return { resources: resourcesNode, resourceNodes };
+}
+function buildPullResult(document) {
+  const result = {};
+  for (const resource of document.resourceNodes) {
+    if (!resource.translatable) {
+      continue;
+    }
+    switch (resource.type) {
+      case "string": {
+        result[resource.name] = decodeAndroidText(
+          segmentsToString(resource.meta.segments)
+        );
+        break;
+      }
+      case "string-array": {
+        result[resource.name] = resource.items.map(
+          (item) => decodeAndroidText(segmentsToString(item.meta.segments))
+        );
+        break;
+      }
+      case "plurals": {
+        const pluralMap = {};
+        for (const item of resource.items) {
+          pluralMap[item.quantity] = decodeAndroidText(
+            segmentsToString(item.meta.segments)
+          );
         }
-        if (parsed.resources.bool) {
-          parsed.resources.bool.forEach((boolItem) => {
-            if (boolItem.$ && boolItem.$.translatable === "false") {
-              return;
-            }
-            const name = boolItem.$.name;
-            result[name] = boolItem._ === "true";
-          });
+        result[resource.name] = pluralMap;
+        break;
+      }
+      case "bool": {
+        const value = segmentsToString(resource.meta.segments).trim();
+        result[resource.name] = value === "true";
+        break;
+      }
+      case "integer": {
+        const value = parseInt(
+          segmentsToString(resource.meta.segments).trim(),
+          10
+        );
+        result[resource.name] = Number.isNaN(value) ? 0 : value;
+        break;
+      }
+    }
+  }
+  return result;
+}
+function buildTranslatedDocument(payload, existingDocument, sourceDocument) {
+  const templateDocument = sourceDocument;
+  const finalDocument = cloneDocumentStructure(templateDocument);
+  const templateMap = createResourceMap(templateDocument);
+  const existingMap = createResourceMap(existingDocument);
+  const payloadEntries = payload ?? {};
+  const finalMap = createResourceMap(finalDocument);
+  for (const resource of finalDocument.resourceNodes) {
+    if (!resource.translatable) {
+      continue;
+    }
+    const templateResource = templateMap.get(resource.name);
+    let translationValue;
+    if (Object.prototype.hasOwnProperty.call(payloadEntries, resource.name) && payloadEntries[resource.name] !== void 0 && payloadEntries[resource.name] !== null) {
+      translationValue = payloadEntries[resource.name];
+    } else if (existingMap.has(resource.name)) {
+      translationValue = extractValueFromResource(
+        existingMap.get(resource.name)
+      );
+    } else {
+      translationValue = extractValueFromResource(templateResource ?? resource);
+    }
+    updateResourceNode(resource, translationValue, templateResource);
+  }
+  for (const resource of existingDocument.resourceNodes) {
+    if (finalMap.has(resource.name)) {
+      continue;
+    }
+    const cloned = cloneResourceNode(resource);
+    appendResourceNode(finalDocument, cloned);
+    finalMap.set(cloned.name, cloned);
+  }
+  for (const [name, value] of Object.entries(payloadEntries)) {
+    if (finalMap.has(name)) {
+      continue;
+    }
+    try {
+      const inferred = createResourceNodeFromValue(name, value);
+      appendResourceNode(finalDocument, inferred);
+      finalMap.set(name, inferred);
+    } catch (error) {
+      if (error instanceof CLIError) {
+        throw error;
+      }
+    }
+  }
+  return finalDocument;
+}
+function buildAndroidXml(document, declaration) {
+  const xmlBody = serializeElement(document.resources);
+  if (declaration.headless) {
+    return xmlBody;
+  }
+  if (declaration.xmldec) {
+    const { version, encoding } = declaration.xmldec;
+    const encodingPart = encoding ? ` encoding="${encoding}"` : "";
+    return `<?xml version="${version}"${encodingPart}?>
+${xmlBody}`;
+  }
+  return `<?xml version="1.0" encoding="utf-8"?>
+${xmlBody}`;
+}
+function selectBaseXml(locale, originalLocale, pullInput, originalInput) {
+  if (locale === originalLocale) {
+    return pullInput ?? originalInput;
+  }
+  return pullInput ?? originalInput;
+}
+function updateResourceNode(target, rawValue, template) {
+  switch (target.type) {
+    case "string": {
+      const value = asString(rawValue, target.name);
+      const templateMeta = template && template.type === "string" ? template.meta : target.meta;
+      const useCdata = templateMeta.hasCdata;
+      setTextualNodeContent(target.node, value, useCdata);
+      target.meta = makeTextMeta([
+        { kind: useCdata ? "cdata" : "text", value }
+      ]);
+      break;
+    }
+    case "string-array": {
+      const values = asStringArray(rawValue, target.name);
+      const templateItems = template && template.type === "string-array" ? template.items : target.items;
+      const maxLength = Math.max(target.items.length, templateItems.length);
+      for (let index = 0; index < maxLength; index++) {
+        const targetItem = target.items[index];
+        const templateItem = templateItems[index] ?? templateItems[templateItems.length - 1] ?? target.items[index];
+        if (!targetItem || !templateItem) {
+          continue;
         }
-        if (parsed.resources.integer) {
-          parsed.resources.integer.forEach((intItem) => {
-            if (intItem.$ && intItem.$.translatable === "false") {
-              return;
-            }
-            const name = intItem.$.name;
-            result[name] = parseInt(intItem._ || "0", 10);
-          });
+        const translation = index < values.length ? values[index] : segmentsToString(templateItem.meta.segments);
+        const useCdata = templateItem.meta.hasCdata;
+        setTextualNodeContent(targetItem.node, translation, useCdata);
+        targetItem.meta = makeTextMeta([
+          { kind: useCdata ? "cdata" : "text", value: translation }
+        ]);
+      }
+      break;
+    }
+    case "plurals": {
+      const pluralValues = asPluralMap(rawValue, target.name);
+      const templateItems = template && template.type === "plurals" ? template.items : target.items;
+      const templateMap = new Map(
+        templateItems.map((item) => [item.quantity, item])
+      );
+      for (const item of target.items) {
+        const templateItem = templateMap.get(item.quantity) ?? templateMap.values().next().value;
+        const fallback = templateItem ? segmentsToString(templateItem.meta.segments) : segmentsToString(item.meta.segments);
+        const translation = typeof pluralValues[item.quantity] === "string" ? pluralValues[item.quantity] : fallback;
+        const useCdata = templateItem ? templateItem.meta.hasCdata : item.meta.hasCdata;
+        setTextualNodeContent(item.node, translation, useCdata);
+        item.meta = makeTextMeta([
+          { kind: useCdata ? "cdata" : "text", value: translation }
+        ]);
+      }
+      break;
+    }
+    case "bool": {
+      const boolValue = asBoolean(rawValue, target.name);
+      const strValue = boolValue ? "true" : "false";
+      setTextualNodeContent(target.node, strValue, false);
+      target.meta = makeTextMeta([{ kind: "text", value: strValue }]);
+      break;
+    }
+    case "integer": {
+      const intValue = asInteger(rawValue, target.name);
+      const strValue = intValue.toString();
+      setTextualNodeContent(target.node, strValue, false);
+      target.meta = makeTextMeta([{ kind: "text", value: strValue }]);
+      break;
+    }
+  }
+}
+function appendResourceNode(document, resourceNode) {
+  document.resources.$$ = document.resources.$$ ?? [];
+  const children = document.resources.$$;
+  if (children.length === 0 || children[children.length - 1]["#name"] !== "__text__" && children[children.length - 1]["#name"] !== "__comment__") {
+    children.push({ "#name": "__text__", _: "\n    " });
+  }
+  children.push(resourceNode.node);
+  children.push({ "#name": "__text__", _: "\n" });
+  document.resourceNodes.push(resourceNode);
+}
+function setTextualNodeContent(node, value, useCdata) {
+  const escapedValue = useCdata ? value : escapeAndroidString(value);
+  node._ = escapedValue;
+  node.$$ = node.$$ ?? [];
+  let textNode = node.$$.find(
+    (child) => child["#name"] === "__text__" || child["#name"] === "__cdata"
+  );
+  if (!textNode) {
+    textNode = {};
+    node.$$.push(textNode);
+  }
+  textNode["#name"] = useCdata ? "__cdata" : "__text__";
+  textNode._ = useCdata ? value : escapedValue;
+}
+function buildResourceNameMap(document) {
+  const map = /* @__PURE__ */ new Map();
+  for (const node of document.resourceNodes) {
+    if (!map.has(node.name)) {
+      map.set(node.name, node);
+    }
+  }
+  return map;
+}
+function createResourceMap(document) {
+  return buildResourceNameMap(document);
+}
+function cloneResourceNode(resource) {
+  switch (resource.type) {
+    case "string": {
+      const nodeClone = deepClone(resource.node);
+      return {
+        type: "string",
+        name: resource.name,
+        translatable: resource.translatable,
+        node: nodeClone,
+        meta: cloneTextMeta(resource.meta)
+      };
+    }
+    case "string-array": {
+      const nodeClone = deepClone(resource.node);
+      const itemNodes = nodeClone.item ?? [];
+      const items = itemNodes.map((itemNode, index) => {
+        const templateMeta = resource.items[index]?.meta ?? resource.items[resource.items.length - 1]?.meta ?? makeTextMeta([]);
+        return {
+          node: itemNode,
+          meta: cloneTextMeta(templateMeta)
+        };
+      });
+      return {
+        type: "string-array",
+        name: resource.name,
+        translatable: resource.translatable,
+        node: nodeClone,
+        items
+      };
+    }
+    case "plurals": {
+      const nodeClone = deepClone(resource.node);
+      const itemNodes = nodeClone.item ?? [];
+      const items = [];
+      for (const templateItem of resource.items) {
+        const cloneNode = itemNodes.find(
+          (item) => item?.$?.quantity === templateItem.quantity
+        );
+        if (!cloneNode) {
+          continue;
         }
-        return result;
-      } catch (error) {
-        console.error("Error parsing Android resource file:", error);
+        items.push({
+          node: cloneNode,
+          quantity: templateItem.quantity,
+          meta: cloneTextMeta(templateItem.meta)
+        });
+      }
+      return {
+        type: "plurals",
+        name: resource.name,
+        translatable: resource.translatable,
+        node: nodeClone,
+        items
+      };
+    }
+    case "bool": {
+      const nodeClone = deepClone(resource.node);
+      return {
+        type: "bool",
+        name: resource.name,
+        translatable: resource.translatable,
+        node: nodeClone,
+        meta: cloneTextMeta(resource.meta)
+      };
+    }
+    case "integer": {
+      const nodeClone = deepClone(resource.node);
+      return {
+        type: "integer",
+        name: resource.name,
+        translatable: resource.translatable,
+        node: nodeClone,
+        meta: cloneTextMeta(resource.meta)
+      };
+    }
+  }
+}
+function cloneTextMeta(meta) {
+  return {
+    hasCdata: meta.hasCdata,
+    segments: meta.segments.map((segment) => ({ ...segment }))
+  };
+}
+function asString(value, name) {
+  if (typeof value === "string") {
+    return value;
+  }
+  throw new CLIError({
+    message: `Expected string value for resource "${name}"`,
+    docUrl: "androidResouceError"
+  });
+}
+function asStringArray(value, name) {
+  if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+    return value;
+  }
+  throw new CLIError({
+    message: `Expected array of strings for resource "${name}"`,
+    docUrl: "androidResouceError"
+  });
+}
+function asPluralMap(value, name) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const result = {};
+    for (const [quantity, pluralValue] of Object.entries(value)) {
+      if (typeof pluralValue !== "string") {
         throw new CLIError({
-          message: "Failed to parse Android resource file",
+          message: `Expected plural item "${quantity}" of "${name}" to be a string`,
           docUrl: "androidResouceError"
         });
       }
-    },
-    async push(locale, payload) {
-      try {
-        const xmlObj = {
-          resources: {
-            string: [],
-            "string-array": [],
-            plurals: [],
-            bool: [],
-            integer: []
-          }
+      result[quantity] = pluralValue;
+    }
+    return result;
+  }
+  throw new CLIError({
+    message: `Expected object value for plurals resource "${name}"`,
+    docUrl: "androidResouceError"
+  });
+}
+function asBoolean(value, name) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    if (value === "true" || value === "false") {
+      return value === "true";
+    }
+  }
+  throw new CLIError({
+    message: `Expected boolean value for resource "${name}"`,
+    docUrl: "androidResouceError"
+  });
+}
+function asInteger(value, name) {
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return value;
+  }
+  throw new CLIError({
+    message: `Expected number value for resource "${name}"`,
+    docUrl: "androidResouceError"
+  });
+}
+function escapeAndroidString(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/(?<!\\)'/g, "\\'");
+}
+function segmentsToString(segments) {
+  return segments.map((segment) => segment.value).join("");
+}
+function makeTextMeta(segments) {
+  return {
+    segments,
+    hasCdata: segments.some((segment) => segment.kind === "cdata")
+  };
+}
+function createResourceNodeFromValue(name, value) {
+  const inferredType = inferTypeFromValue(value);
+  switch (inferredType) {
+    case "string": {
+      const stringValue = asString(value, name);
+      const escaped = escapeAndroidString(stringValue);
+      const node = {
+        "#name": "string",
+        $: { name },
+        _: escaped,
+        $$: [{ "#name": "__text__", _: escaped }]
+      };
+      return {
+        type: "string",
+        name,
+        translatable: true,
+        node,
+        meta: makeTextMeta([{ kind: "text", value: stringValue }])
+      };
+    }
+    case "string-array": {
+      const items = asStringArray(value, name);
+      const node = {
+        "#name": "string-array",
+        $: { name },
+        $$: [],
+        item: []
+      };
+      const itemNodes = [];
+      for (const itemValue of items) {
+        const escaped = escapeAndroidString(itemValue);
+        const itemNode = {
+          "#name": "item",
+          _: escaped,
+          $$: [{ "#name": "__text__", _: escaped }]
         };
-        const processHtmlContent = (str) => {
-          if (typeof str !== "string") return { _: String(str) };
-          const processedStr = str.replace(/(?<!\\)'/g, "\\'");
-          return { _: processedStr };
+        node.$$.push(itemNode);
+        node.item.push(itemNode);
+        itemNodes.push({
+          node: itemNode,
+          meta: makeTextMeta([{ kind: "text", value: itemValue }])
+        });
+      }
+      return {
+        type: "string-array",
+        name,
+        translatable: true,
+        node,
+        items: itemNodes
+      };
+    }
+    case "plurals": {
+      const pluralMap = asPluralMap(value, name);
+      const node = {
+        "#name": "plurals",
+        $: { name },
+        $$: [],
+        item: []
+      };
+      const items = [];
+      for (const [quantity, pluralValue] of Object.entries(pluralMap)) {
+        const escaped = escapeAndroidString(pluralValue);
+        const itemNode = {
+          "#name": "item",
+          $: { quantity },
+          _: escaped,
+          $$: [{ "#name": "__text__", _: escaped }]
         };
-        for (const [key, value] of Object.entries(payload)) {
-          if (typeof value === "string") {
-            xmlObj.resources.string.push({
-              $: { name: key },
-              ...processHtmlContent(value)
-            });
-          } else if (Array.isArray(value)) {
-            xmlObj.resources["string-array"].push({
-              $: { name: key },
-              item: value.map((item) => processHtmlContent(item))
-            });
-          } else if (typeof value === "object") {
-            xmlObj.resources.plurals.push({
-              $: { name: key },
-              item: Object.entries(value).map(([quantity, text]) => ({
-                $: { quantity },
-                ...processHtmlContent(text)
-              }))
-            });
-          } else if (typeof value === "boolean") {
-            xmlObj.resources.bool.push({
-              $: { name: key },
-              _: value.toString()
-            });
-          } else if (typeof value === "number") {
-            xmlObj.resources.integer.push({
-              $: { name: key },
-              _: value.toString()
-            });
-          }
+        node.$$.push(itemNode);
+        node.item.push(itemNode);
+        items.push({
+          node: itemNode,
+          quantity,
+          meta: makeTextMeta([{ kind: "text", value: pluralValue }])
+        });
+      }
+      return {
+        type: "plurals",
+        name,
+        translatable: true,
+        node,
+        items
+      };
+    }
+    case "bool": {
+      const boolValue = asBoolean(value, name);
+      const textValue = boolValue ? "true" : "false";
+      const node = {
+        "#name": "bool",
+        $: { name },
+        _: textValue,
+        $$: [{ "#name": "__text__", _: textValue }]
+      };
+      return {
+        type: "bool",
+        name,
+        translatable: true,
+        node,
+        meta: makeTextMeta([{ kind: "text", value: textValue }])
+      };
+    }
+    case "integer": {
+      const intValue = asInteger(value, name);
+      const textValue = intValue.toString();
+      const node = {
+        "#name": "integer",
+        $: { name },
+        _: textValue,
+        $$: [{ "#name": "__text__", _: textValue }]
+      };
+      return {
+        type: "integer",
+        name,
+        translatable: true,
+        node,
+        meta: makeTextMeta([{ kind: "text", value: textValue }])
+      };
+    }
+  }
+}
+function cloneDocumentStructure(document) {
+  const resourcesClone = deepClone(document.resources);
+  const lookup = buildResourceLookup(resourcesClone);
+  const resourceNodes = [];
+  for (const resource of document.resourceNodes) {
+    const cloned = cloneResourceNodeFromLookup(resource, lookup);
+    resourceNodes.push(cloned);
+  }
+  return {
+    resources: resourcesClone,
+    resourceNodes
+  };
+}
+function buildResourceLookup(resources) {
+  const lookup = /* @__PURE__ */ new Map();
+  const children = Array.isArray(resources.$$) ? resources.$$ : [];
+  for (const child of children) {
+    const type = child?.["#name"];
+    const name = child?.$?.name;
+    if (!type || !name || !isResourceElementName(type)) {
+      continue;
+    }
+    const key = resourceLookupKey(type, name);
+    if (!lookup.has(key)) {
+      lookup.set(key, []);
+    }
+    lookup.get(key).push(child);
+  }
+  return lookup;
+}
+function cloneResourceNodeFromLookup(resource, lookup) {
+  const node = takeResourceNode(lookup, resource.type, resource.name);
+  if (!node) {
+    return cloneResourceNode(resource);
+  }
+  switch (resource.type) {
+    case "string": {
+      return {
+        type: "string",
+        name: resource.name,
+        translatable: resource.translatable,
+        node,
+        meta: cloneTextMeta(resource.meta)
+      };
+    }
+    case "string-array": {
+      const childItems = (Array.isArray(node.$$) ? node.$$ : []).filter(
+        (child) => child?.["#name"] === "item"
+      );
+      node.item = childItems;
+      if (childItems.length < resource.items.length) {
+        return cloneResourceNode(resource);
+      }
+      const items = resource.items.map((item, index) => {
+        const nodeItem = childItems[index];
+        if (!nodeItem) {
+          return {
+            node: deepClone(item.node),
+            meta: cloneTextMeta(item.meta)
+          };
         }
-        const builder = new Builder({
-          headless: true,
-          renderOpts: {
-            pretty: true,
-            indent: "  ",
-            newline: "\n"
+        return {
+          node: nodeItem,
+          meta: cloneTextMeta(item.meta)
+        };
+      });
+      return {
+        type: "string-array",
+        name: resource.name,
+        translatable: resource.translatable,
+        node,
+        items
+      };
+    }
+    case "plurals": {
+      const childItems = (Array.isArray(node.$$) ? node.$$ : []).filter(
+        (child) => child?.["#name"] === "item"
+      );
+      node.item = childItems;
+      const itemMap = /* @__PURE__ */ new Map();
+      for (const item of childItems) {
+        if (item?.$?.quantity) {
+          itemMap.set(item.$.quantity, item);
+        }
+      }
+      const items = [];
+      for (const templateItem of resource.items) {
+        const nodeItem = itemMap.get(templateItem.quantity);
+        if (!nodeItem) {
+          return cloneResourceNode(resource);
+        }
+        items.push({
+          node: nodeItem,
+          quantity: templateItem.quantity,
+          meta: cloneTextMeta(templateItem.meta)
+        });
+      }
+      return {
+        type: "plurals",
+        name: resource.name,
+        translatable: resource.translatable,
+        node,
+        items
+      };
+    }
+    case "bool": {
+      return {
+        type: "bool",
+        name: resource.name,
+        translatable: resource.translatable,
+        node,
+        meta: cloneTextMeta(resource.meta)
+      };
+    }
+    case "integer": {
+      return {
+        type: "integer",
+        name: resource.name,
+        translatable: resource.translatable,
+        node,
+        meta: cloneTextMeta(resource.meta)
+      };
+    }
+  }
+}
+function takeResourceNode(lookup, type, name) {
+  const key = resourceLookupKey(type, name);
+  const list = lookup.get(key);
+  if (!list || list.length === 0) {
+    return void 0;
+  }
+  return list.shift();
+}
+function resourceLookupKey(type, name) {
+  return `${type}:${name}`;
+}
+function extractValueFromResource(resource) {
+  switch (resource.type) {
+    case "string":
+      return decodeAndroidText(segmentsToString(resource.meta.segments));
+    case "string-array":
+      return resource.items.map(
+        (item) => decodeAndroidText(segmentsToString(item.meta.segments))
+      );
+    case "plurals": {
+      const result = {};
+      for (const item of resource.items) {
+        result[item.quantity] = decodeAndroidText(
+          segmentsToString(item.meta.segments)
+        );
+      }
+      return result;
+    }
+    case "bool": {
+      const value = segmentsToString(resource.meta.segments).trim();
+      return value === "true";
+    }
+    case "integer": {
+      const value = parseInt(
+        segmentsToString(resource.meta.segments).trim(),
+        10
+      );
+      return Number.isNaN(value) ? 0 : value;
+    }
+  }
+}
+function inferTypeFromValue(value) {
+  if (typeof value === "string") {
+    return "string";
+  }
+  if (Array.isArray(value)) {
+    return "string-array";
+  }
+  if (value && typeof value === "object") {
+    return "plurals";
+  }
+  if (typeof value === "boolean") {
+    return "bool";
+  }
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return "integer";
+  }
+  throw new CLIError({
+    message: "Unable to infer Android resource type from payload",
+    docUrl: "androidResouceError"
+  });
+}
+function extractResourceMetadata(xml) {
+  const parser = sax.parser(true, {
+    trim: false,
+    normalize: false,
+    lowercase: false
+  });
+  const stack = [];
+  const result = [];
+  parser.onopentag = (node) => {
+    const lowerName = node.name.toLowerCase();
+    const attributes = {};
+    for (const [key, value] of Object.entries(node.attributes ?? {})) {
+      attributes[key.toLowerCase()] = String(value);
+    }
+    stack.push({
+      name: lowerName,
+      rawName: node.name,
+      attributes,
+      segments: [],
+      items: []
+    });
+    if (lowerName !== "resources" && lowerName !== "item" && !isResourceElementName(lowerName)) {
+      const attrString = Object.entries(node.attributes ?? {}).map(
+        ([key, value]) => ` ${key}="${escapeAttributeValue(String(value))}"`
+      ).join("");
+      appendSegmentToNearestResource(stack, {
+        kind: "text",
+        value: `<${node.name}${attrString}>`
+      });
+    }
+  };
+  parser.ontext = (text) => {
+    if (!text) {
+      return;
+    }
+    appendSegmentToNearestResource(stack, { kind: "text", value: text });
+  };
+  parser.oncdata = (cdata) => {
+    appendSegmentToNearestResource(stack, { kind: "cdata", value: cdata });
+  };
+  parser.onclosetag = () => {
+    const entry = stack.pop();
+    if (!entry) {
+      return;
+    }
+    const parent = stack[stack.length - 1];
+    if (entry.name === "item" && parent) {
+      const meta = makeTextMeta(entry.segments);
+      parent.items.push({
+        quantity: entry.attributes.quantity,
+        meta
+      });
+      return;
+    }
+    if (entry.name !== "resources" && entry.name !== "item" && !isResourceElementName(entry.name)) {
+      appendSegmentToNearestResource(stack, {
+        kind: "text",
+        value: `</${entry.rawName}>`
+      });
+      return;
+    }
+    if (!isResourceElementName(entry.name)) {
+      return;
+    }
+    const name = entry.attributes.name;
+    if (!name) {
+      return;
+    }
+    const translatable = (entry.attributes.translatable ?? "").toLowerCase() !== "false";
+    switch (entry.name) {
+      case "string": {
+        result.push({
+          type: "string",
+          name,
+          translatable,
+          meta: makeTextMeta(entry.segments)
+        });
+        break;
+      }
+      case "string-array": {
+        result.push({
+          type: "string-array",
+          name,
+          translatable,
+          items: entry.items.map((item) => ({
+            meta: cloneTextMeta(item.meta)
+          }))
+        });
+        break;
+      }
+      case "plurals": {
+        const items = [];
+        for (const item of entry.items) {
+          if (!item.quantity) {
+            continue;
           }
+          items.push({
+            quantity: item.quantity,
+            meta: cloneTextMeta(item.meta)
+          });
+        }
+        result.push({
+          type: "plurals",
+          name,
+          translatable,
+          items
         });
-        return builder.buildObject(xmlObj);
-      } catch (error) {
-        console.error("Error generating Android resource file:", error);
-        throw new CLIError({
-          message: "Failed to generate Android resource file",
-          docUrl: "androidResouceError"
+        break;
+      }
+      case "bool": {
+        result.push({
+          type: "bool",
+          name,
+          translatable,
+          meta: makeTextMeta(entry.segments)
+        });
+        break;
+      }
+      case "integer": {
+        result.push({
+          type: "integer",
+          name,
+          translatable,
+          meta: makeTextMeta(entry.segments)
         });
+        break;
       }
     }
-  });
+  };
+  parser.write(xml).close();
+  return result;
+}
+function appendSegmentToNearestResource(stack, segment) {
+  for (let index = stack.length - 1; index >= 0; index--) {
+    const entry = stack[index];
+    if (entry.name === "string" || entry.name === "item" || entry.name === "bool" || entry.name === "integer") {
+      entry.segments.push(segment);
+      return;
+    }
+  }
+}
+function isResourceElementName(value) {
+  return value === "string" || value === "string-array" || value === "plurals" || value === "bool" || value === "integer";
+}
+function deepClone(value) {
+  return value === void 0 ? value : JSON.parse(JSON.stringify(value));
+}
+function serializeElement(node) {
+  if (!node) {
+    return "";
+  }
+  const name = node["#name"] ?? "resources";
+  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}="${escapeAttributeValue(String(value))}"`).join("");
+  const children = Array.isArray(node.$$) ? node.$$ : [];
+  if (children.length === 0) {
+    const textContent = node._ ?? "";
+    return `<${name}${attrString}>${textContent}</${name}>`;
+  }
+  const childContent = children.map(serializeElement).join("");
+  return `<${name}${attrString}>${childContent}</${name}>`;
+}
+function escapeAttributeValue(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&apos;");
+}
+function decodeAndroidText(value) {
+  return value.replace(/\\'/g, "'");
 }
 
 // src/cli/loaders/csv.ts
@@ -2751,39 +3637,320 @@ function parsePropertyLine(line) {
   };
 }
 
+// src/cli/loaders/xcode-strings/tokenizer.ts
+var Tokenizer = class {
+  input;
+  pos;
+  line;
+  column;
+  constructor(input2) {
+    this.input = input2;
+    this.pos = 0;
+    this.line = 1;
+    this.column = 1;
+  }
+  tokenize() {
+    const tokens = [];
+    while (this.pos < this.input.length) {
+      const char = this.current();
+      if (this.isWhitespace(char)) {
+        this.advance();
+        continue;
+      }
+      if (char === "/" && this.peek() === "/") {
+        tokens.push(this.scanSingleLineComment());
+        continue;
+      }
+      if (char === "/" && this.peek() === "*") {
+        tokens.push(this.scanMultiLineComment());
+        continue;
+      }
+      if (char === '"') {
+        tokens.push(this.scanString());
+        continue;
+      }
+      if (char === "=") {
+        tokens.push(this.makeToken("EQUALS" /* EQUALS */, "="));
+        this.advance();
+        continue;
+      }
+      if (char === ";") {
+        tokens.push(this.makeToken("SEMICOLON" /* SEMICOLON */, ";"));
+        this.advance();
+        continue;
+      }
+      this.advance();
+    }
+    tokens.push(this.makeToken("EOF" /* EOF */, ""));
+    return tokens;
+  }
+  scanString() {
+    const start = this.getPosition();
+    let value = "";
+    this.advance();
+    while (this.pos < this.input.length) {
+      const char = this.current();
+      if (char === "\\") {
+        this.advance();
+        if (this.pos < this.input.length) {
+          const nextChar = this.current();
+          value += "\\" + nextChar;
+          this.advance();
+        }
+        continue;
+      }
+      if (char === '"') {
+        this.advance();
+        return {
+          type: "STRING" /* STRING */,
+          value,
+          ...start
+        };
+      }
+      value += char;
+      this.advance();
+    }
+    return {
+      type: "STRING" /* STRING */,
+      value,
+      ...start
+    };
+  }
+  scanSingleLineComment() {
+    const start = this.getPosition();
+    let value = "";
+    this.advance();
+    this.advance();
+    while (this.pos < this.input.length && this.current() !== "\n") {
+      value += this.current();
+      this.advance();
+    }
+    return {
+      type: "COMMENT_SINGLE" /* COMMENT_SINGLE */,
+      value,
+      ...start
+    };
+  }
+  scanMultiLineComment() {
+    const start = this.getPosition();
+    let value = "";
+    this.advance();
+    this.advance();
+    while (this.pos < this.input.length) {
+      if (this.current() === "*" && this.peek() === "/") {
+        this.advance();
+        this.advance();
+        return {
+          type: "COMMENT_MULTI" /* COMMENT_MULTI */,
+          value,
+          ...start
+        };
+      }
+      value += this.current();
+      this.advance();
+    }
+    return {
+      type: "COMMENT_MULTI" /* COMMENT_MULTI */,
+      value,
+      ...start
+    };
+  }
+  current() {
+    return this.input[this.pos];
+  }
+  peek() {
+    if (this.pos + 1 < this.input.length) {
+      return this.input[this.pos + 1];
+    }
+    return null;
+  }
+  advance() {
+    if (this.pos < this.input.length) {
+      if (this.current() === "\n") {
+        this.line++;
+        this.column = 1;
+      } else {
+        this.column++;
+      }
+      this.pos++;
+    }
+  }
+  isWhitespace(char) {
+    return char === " " || char === "	" || char === "\n" || char === "\r";
+  }
+  getPosition() {
+    return {
+      line: this.line,
+      column: this.column
+    };
+  }
+  makeToken(type, value) {
+    return {
+      type,
+      value,
+      ...this.getPosition()
+    };
+  }
+};
+
+// src/cli/loaders/xcode-strings/escape.ts
+function unescapeString(raw) {
+  let result = "";
+  let i = 0;
+  while (i < raw.length) {
+    if (raw[i] === "\\" && i + 1 < raw.length) {
+      const nextChar = raw[i + 1];
+      switch (nextChar) {
+        case '"':
+          result += '"';
+          i += 2;
+          break;
+        case "\\":
+          result += "\\";
+          i += 2;
+          break;
+        case "n":
+          result += "\n";
+          i += 2;
+          break;
+        case "t":
+          result += "	";
+          i += 2;
+          break;
+        case "r":
+          result += "\r";
+          i += 2;
+          break;
+        default:
+          result += raw[i];
+          i++;
+          break;
+      }
+    } else {
+      result += raw[i];
+      i++;
+    }
+  }
+  return result;
+}
+function escapeString(str) {
+  if (str == null) {
+    return "";
+  }
+  let result = "";
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    switch (char) {
+      case "\\":
+        result += "\\\\";
+        break;
+      case '"':
+        result += '\\"';
+        break;
+      case "\n":
+        result += "\\n";
+        break;
+      case "\r":
+        result += "\\r";
+        break;
+      case "	":
+        result += "\\t";
+        break;
+      default:
+        result += char;
+        break;
+    }
+  }
+  return result;
+}
+
+// src/cli/loaders/xcode-strings/parser.ts
+var Parser = class {
+  tokens;
+  pos;
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.pos = 0;
+  }
+  parse() {
+    const result = {};
+    while (this.pos < this.tokens.length) {
+      const token = this.current();
+      if (token.type === "COMMENT_SINGLE" /* COMMENT_SINGLE */ || token.type === "COMMENT_MULTI" /* COMMENT_MULTI */) {
+        this.advance();
+        continue;
+      }
+      if (token.type === "EOF" /* EOF */) {
+        break;
+      }
+      if (token.type === "STRING" /* STRING */) {
+        const entry = this.parseEntry();
+        if (entry) {
+          result[entry.key] = entry.value;
+        }
+        continue;
+      }
+      this.advance();
+    }
+    return result;
+  }
+  parseEntry() {
+    const keyToken = this.current();
+    if (keyToken.type !== "STRING" /* STRING */) {
+      return null;
+    }
+    const key = keyToken.value;
+    this.advance();
+    if (!this.expect("EQUALS" /* EQUALS */)) {
+      return null;
+    }
+    const valueToken = this.current();
+    if (valueToken.type !== "STRING" /* STRING */) {
+      return null;
+    }
+    const rawValue = valueToken.value;
+    this.advance();
+    if (!this.expect("SEMICOLON" /* SEMICOLON */)) {
+    }
+    const value = unescapeString(rawValue);
+    return { key, value };
+  }
+  current() {
+    return this.tokens[this.pos];
+  }
+  advance() {
+    if (this.pos < this.tokens.length) {
+      this.pos++;
+    }
+  }
+  expect(type) {
+    if (this.current()?.type === type) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+};
+
 // src/cli/loaders/xcode-strings.ts
 function createXcodeStringsLoader() {
   return createLoader({
     async pull(locale, input2) {
-      const lines = input2.split("\n");
-      const result = {};
-      for (const line of lines) {
-        const trimmedLine = line.trim();
-        if (trimmedLine && !trimmedLine.startsWith("//")) {
-          const match2 = trimmedLine.match(/^"(.+)"\s*=\s*"(.+)";$/);
-          if (match2) {
-            const [, key, value] = match2;
-            result[key] = unescapeXcodeString(value);
-          }
-        }
-      }
+      const tokenizer = new Tokenizer(input2);
+      const tokens = tokenizer.tokenize();
+      const parser = new Parser(tokens);
+      const result = parser.parse();
       return result;
     },
     async push(locale, payload) {
-      const lines = Object.entries(payload).map(([key, value]) => {
-        const escapedValue = escapeXcodeString(value);
+      const lines = Object.entries(payload).filter(([_36, value]) => value != null).map(([key, value]) => {
+        const escapedValue = escapeString(value);
         return `"${key}" = "${escapedValue}";`;
       });
       return lines.join("\n");
     }
   });
 }
-function unescapeXcodeString(str) {
-  return str.replace(/\\"/g, '"').replace(/\\n/g, "\n").replace(/\\\\/g, "\\");
-}
-function escapeXcodeString(str) {
-  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
-}
 
 // src/cli/loaders/xcode-stringsdict.ts
 import plist from "plist";
@@ -4095,7 +5262,7 @@ function pushNewFile(locale, translations, originalLocale) {
 }
 
 // src/cli/loaders/xml.ts
-import { parseStringPromise as parseStringPromise2, Builder as Builder2 } from "xml2js";
+import { parseStringPromise as parseStringPromise2, Builder } from "xml2js";
 function normalizeXMLString(xmlString) {
   return xmlString.replace(/\s+/g, " ").replace(/>\s+</g, "><").replace("\n", "").trim();
 }
@@ -4122,7 +5289,7 @@ function createXmlLoader() {
     },
     async push(locale, data) {
       try {
-        const builder = new Builder2({ headless: true });
+        const builder = new Builder({ headless: true });
         const xmlOutput = builder.buildObject(data);
         const expectedOutput = normalizeXMLString(xmlOutput);
         return expectedOutput;
@@ -12212,7 +13379,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.113.5",
+  version: "0.113.7",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {
@@ -12419,6 +13586,7 @@ var package_default = {
     "remark-parse": "^11.0.0",
     "remark-rehype": "^11.1.2",
     "remark-stringify": "^11.0.0",
+    sax: "^1.4.1",
     "srt-parser-2": "^1.2.3",
     unified: "^11.0.5",
     "unist-util-visit": "^5.0.0",