lingo.dev 0.116.2 → 0.116.4

package/build/cli.mjs

@@ -1615,8 +1615,8 @@ function createLoader(lDefinition) {
       state.defaultLocale = locale;
       return this;
     },
-    async pullHints() {
-      return lDefinition.pullHints?.(state.originalInput);
+    async pullHints(originalInput) {
+      return lDefinition.pullHints?.(originalInput || state.originalInput);
     },
     async pull(locale, input2) {
       if (!state.defaultLocale) {
@@ -2036,7 +2036,7 @@ function createTextFileLoader(pathPattern) {
       const trimmedResult = result.trim();
       return trimmedResult;
     },
-    async push(locale, data, _36, originalLocale) {
+    async push(locale, data, _37, originalLocale) {
       const draftPath = pathPattern.replaceAll("[locale]", locale);
       const finalPath = path10.resolve(draftPath);
       const dirPath = path10.dirname(finalPath);
@@ -3666,7 +3666,7 @@ function createPropertiesLoader() {
       return result;
     },
     async push(locale, payload) {
-      const result = Object.entries(payload).filter(([_36, value]) => value != null).map(([key, value]) => `${key}=${value}`).join("\n");
+      const result = Object.entries(payload).filter(([_37, value]) => value != null).map(([key, value]) => `${key}=${value}`).join("\n");
       return result;
     }
   });
@@ -3988,7 +3988,7 @@ function createXcodeStringsLoader() {
       return result;
     },
     async push(locale, payload) {
-      const lines = Object.entries(payload).filter(([_36, value]) => value != null).map(([key, value]) => {
+      const lines = Object.entries(payload).filter(([_37, value]) => value != null).map(([key, value]) => {
         const escapedValue = escapeString(value);
         return `"${key}" = "${escapedValue}";`;
       });
@@ -4186,218 +4186,46 @@ function _removeLocale(input2, locale) {
   return { ...input2, strings: newStrings };
 }
 
-// src/cli/loaders/xcode-xcstrings-icu.ts
-var ICU_TYPE_MARKER = Symbol.for("@lingo.dev/icu-plural-object");
-var CLDR_PLURAL_CATEGORIES = /* @__PURE__ */ new Set([
-  "zero",
-  "one",
-  "two",
-  "few",
-  "many",
-  "other"
-]);
-function isICUPluralObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  if (ICU_TYPE_MARKER in value) {
-    return true;
-  }
-  if (!("icu" in value) || typeof value.icu !== "string") {
-    return false;
-  }
-  const icuPluralPattern = /^\{[\w]+,\s*plural,\s*.+\}$/;
-  if (!icuPluralPattern.test(value.icu)) {
-    return false;
-  }
-  if (value._meta !== void 0) {
-    if (typeof value._meta !== "object" || !value._meta.variables || typeof value._meta.variables !== "object") {
-      return false;
-    }
-    for (const [varName, varMeta] of Object.entries(value._meta.variables)) {
-      if (!varMeta || typeof varMeta !== "object" || typeof varMeta.format !== "string" || varMeta.role !== "plural" && varMeta.role !== "other") {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function isPluralFormsObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const keys = Object.keys(value);
-  if (keys.length === 0) {
-    return false;
-  }
-  const allKeysAreCldr = keys.every((key) => CLDR_PLURAL_CATEGORIES.has(key));
-  if (!allKeysAreCldr) {
-    return false;
-  }
-  const allValuesAreStrings = keys.every(
-    (key) => typeof value[key] === "string"
-  );
-  if (!allValuesAreStrings) {
-    return false;
-  }
-  if (!("other" in value)) {
-    return false;
-  }
-  return true;
-}
+// src/cli/loaders/xcode-xcstrings-v2.ts
+import _10 from "lodash";
 function getRequiredPluralCategories(locale) {
   try {
     const pluralRules = new Intl.PluralRules(locale);
     const categories = pluralRules.resolvedOptions().pluralCategories;
     if (!categories || categories.length === 0) {
-      throw new Error(`No plural categories found for locale: ${locale}`);
+      return ["other"];
     }
     return categories;
   } catch (error) {
-    console.warn(
-      `[xcode-xcstrings-icu] Failed to resolve plural categories for locale "${locale}". Using fallback ["one", "other"]. Error: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return ["one", "other"];
+    return ["other"];
   }
 }
-var CLDR_CATEGORY_TO_NUMBER = {
-  zero: 0,
-  one: 1,
-  two: 2
-};
-var NUMBER_TO_CLDR_CATEGORY = {
-  0: "zero",
-  1: "one",
-  2: "two"
-};
-function xcstringsToPluralWithMeta(pluralForms, sourceLocale = "en") {
-  if (!pluralForms || Object.keys(pluralForms).length === 0) {
-    throw new Error("pluralForms cannot be empty");
-  }
-  const requiredCategories = getRequiredPluralCategories(sourceLocale);
-  const variables = {};
-  const formatRegex = /(%(?:(\d+)\$)?(?:[+-])?(?:\d+)?(?:\.(\d+))?([lhqLzjt]*)([diuoxXfFeEgGaAcspn@]))/g;
-  let maxMatches = [];
-  let maxMatchText = "";
-  for (const [form, text] of Object.entries(pluralForms)) {
-    if (typeof text !== "string") {
-      console.warn(
-        `Warning: Plural form "${form}" has non-string value:`,
-        text
-      );
-      continue;
-    }
-    const matches = [...text.matchAll(formatRegex)];
-    if (matches.length > maxMatches.length) {
-      maxMatches = matches;
-      maxMatchText = text;
-    }
-  }
-  let lastNumericIndex = -1;
-  maxMatches.forEach((match2, idx) => {
-    const specifier = match2[5];
-    if (/[diuoxXfFeE]/.test(specifier)) {
-      lastNumericIndex = idx;
+function isValidPluralForm(form, locale) {
+  if (form.startsWith("=")) return true;
+  const requiredCategories = getRequiredPluralCategories(locale);
+  return requiredCategories.includes(form);
+}
+function buildIcuPluralString(forms, sourceLocale) {
+  const requiredCategories = new Set(getRequiredPluralCategories(sourceLocale));
+  const parts = Object.entries(forms).map(([form, text]) => {
+    let normalizedForm = form;
+    if (!requiredCategories.has(form)) {
+      if (form === "zero") normalizedForm = "=0";
+      else if (form === "one") normalizedForm = "=1";
+      else if (form === "two") normalizedForm = "=2";
     }
+    return `${normalizedForm} {${text}}`;
   });
-  let nonPluralCounter = 0;
-  maxMatches.forEach((match2, idx) => {
-    const fullFormat = match2[1];
-    const position = match2[2];
-    const precision = match2[3];
-    const lengthMod = match2[4];
-    const specifier = match2[5];
-    const isPluralVar = idx === lastNumericIndex;
-    const varName = isPluralVar ? "count" : `var${nonPluralCounter++}`;
-    variables[varName] = {
-      format: fullFormat,
-      role: isPluralVar ? "plural" : "other"
-    };
-  });
-  const variableKeys = Object.keys(variables);
-  const icuForms = Object.entries(pluralForms).filter(([form, text]) => {
-    if (typeof text !== "string") {
-      return false;
-    }
-    return true;
-  }).map(([form, text]) => {
-    let processed = text;
-    let vIdx = 0;
-    processed = processed.replace(formatRegex, () => {
-      if (vIdx >= variableKeys.length) {
-        vIdx++;
-        return "#";
-      }
-      const varName = variableKeys[vIdx];
-      const varMeta = variables[varName];
-      vIdx++;
-      if (varMeta.role === "plural") {
-        return "#";
-      } else {
-        return `{${varName}}`;
-      }
-    });
-    const isRequired = requiredCategories.includes(form);
-    const formKey = !isRequired && form in CLDR_CATEGORY_TO_NUMBER ? `=${CLDR_CATEGORY_TO_NUMBER[form]}` : form;
-    return `${formKey} {${processed}}`;
-  }).join(" ");
-  const pluralVarName = Object.keys(variables).find((name) => variables[name].role === "plural") || "count";
-  const icu = `{${pluralVarName}, plural, ${icuForms}}`;
-  const result = {
-    icu,
-    _meta: Object.keys(variables).length > 0 ? { variables } : void 0,
-    [ICU_TYPE_MARKER]: true
-    // Add type marker for robust detection
-  };
-  return result;
+  return `{count, plural, ${parts.join(" ")}}`;
 }
-function pluralWithMetaToXcstrings(data) {
-  if (!data.icu) {
-    throw new Error("ICU string is required");
-  }
-  const ast = parseICU(data.icu);
-  if (!ast || ast.length === 0) {
-    throw new Error("Invalid ICU format");
-  }
-  const pluralNode = ast.find((node) => node.type === "plural");
-  if (!pluralNode) {
-    throw new Error("No plural found in ICU format");
+function parseIcuPluralString(icuString, locale) {
+  const pluralMatch = icuString.match(/\{[\w]+,\s*plural,\s*(.+)\}$/);
+  if (!pluralMatch) {
+    throw new Error(`Invalid ICU plural format: ${icuString}`);
   }
+  const formsText = pluralMatch[1];
   const forms = {};
-  for (const [form, option] of Object.entries(pluralNode.options)) {
-    let text = "";
-    const optionValue = option.value;
-    for (const element of optionValue) {
-      if (element.type === "literal") {
-        text += element.value;
-      } else if (element.type === "pound") {
-        const pluralVar = Object.entries(data._meta?.variables || {}).find(
-          ([_36, meta]) => meta.role === "plural"
-        );
-        text += pluralVar?.[1].format || "%lld";
-      } else if (element.type === "argument") {
-        const varName = element.value;
-        const varMeta = data._meta?.variables?.[varName];
-        text += varMeta?.format || "%@";
-      }
-    }
-    let xcstringsFormName = form;
-    if (form.startsWith("=")) {
-      const numValue = parseInt(form.substring(1), 10);
-      xcstringsFormName = NUMBER_TO_CLDR_CATEGORY[numValue] || form;
-    }
-    forms[xcstringsFormName] = text;
-  }
-  return forms;
-}
-function parseICU(icu) {
-  const match2 = icu.match(/\{(\w+),\s*plural,\s*(.+)\}$/);
-  if (!match2) {
-    throw new Error("Invalid ICU plural format");
-  }
-  const varName = match2[1];
-  const formsText = match2[2];
-  const options = {};
+  const exactMatches = /* @__PURE__ */ new Set();
   let i = 0;
   while (i < formsText.length) {
     while (i < formsText.length && /\s/.test(formsText[i])) {
@@ -4419,6 +4247,16 @@ function parseICU(icu) {
       }
     }
     if (!formName) break;
+    if (formName === "=0") {
+      formName = "zero";
+      exactMatches.add("zero");
+    } else if (formName === "=1") {
+      formName = "one";
+      exactMatches.add("one");
+    } else if (formName === "=2") {
+      formName = "two";
+      exactMatches.add("two");
+    }
     while (i < formsText.length && /\s/.test(formsText[i])) {
       i++;
     }
@@ -4443,149 +4281,234 @@ function parseICU(icu) {
       i++;
     }
     if (braceCount !== 0) {
-      const preview = formsText.substring(
-        Math.max(0, i - 50),
-        Math.min(formsText.length, i + 50)
-      );
       throw new Error(
-        `Unclosed brace for form '${formName}' in ICU MessageFormat.
-Expected ${braceCount} more closing brace(s).
-Context: ...${preview}...
-Full ICU: {${varName}, plural, ${formsText}}`
+        `Unclosed brace for form '${formName}' in ICU: ${icuString}`
       );
     }
-    const elements = parseFormText(formText);
-    options[formName] = {
-      value: elements
-    };
+    forms[formName] = formText;
   }
-  return [
-    {
-      type: "plural",
-      value: varName,
-      options
-    }
-  ];
-}
-function parseFormText(text) {
-  const elements = [];
-  let currentText = "";
-  let i = 0;
-  while (i < text.length) {
-    if (text[i] === "#") {
-      if (currentText) {
-        elements.push({ type: "literal", value: currentText });
-        currentText = "";
-      }
-      elements.push({ type: "pound" });
-      i++;
-    } else if (text[i] === "{") {
-      if (currentText) {
-        elements.push({ type: "literal", value: currentText });
-        currentText = "";
-      }
-      let braceCount = 1;
-      let j = i + 1;
-      while (j < text.length && braceCount > 0) {
-        if (text[j] === "{") {
-          braceCount++;
-        } else if (text[j] === "}") {
-          braceCount--;
-        }
-        j++;
-      }
-      if (braceCount !== 0) {
-        throw new Error("Unclosed variable reference");
-      }
-      const varName = text.slice(i + 1, j - 1);
-      elements.push({ type: "argument", value: varName });
-      i = j;
-    } else {
-      currentText += text[i];
-      i++;
+  const filteredForms = {};
+  for (const [form, text] of Object.entries(forms)) {
+    if (exactMatches.has(form) || isValidPluralForm(form, locale)) {
+      filteredForms[form] = text;
     }
   }
-  if (currentText) {
-    elements.push({ type: "literal", value: currentText });
-  }
-  return elements;
+  return filteredForms;
 }
-
-// src/cli/loaders/xcode-xcstrings-v2-loader.ts
-function createXcodeXcstringsV2Loader(defaultLocale = "en") {
+function isIcuPluralString(value) {
+  return typeof value === "string" && /^\{[\w]+,\s*plural,\s*.+\}$/.test(value);
+}
+function createXcodeXcstringsV2Loader(defaultLocale) {
   return createLoader({
-    async pull(locale, input2) {
-      const result = {};
-      for (const [key, value] of Object.entries(input2)) {
-        if (isPluralFormsObject(value)) {
-          try {
-            result[key] = xcstringsToPluralWithMeta(value, locale);
-          } catch (error) {
-            console.error(
-              `
-[xcode-xcstrings-icu] Failed to convert plural forms for key "${key}":`,
-              `
-Error: ${error instanceof Error ? error.message : String(error)}`,
-              `
-Locale: ${locale}
-`
-            );
-            result[key] = value;
+    async pull(locale, input2, initCtx) {
+      const resultData = {};
+      const isSourceLanguage = locale === defaultLocale;
+      for (const [translationKey, _translationEntity] of Object.entries(
+        input2.strings
+      )) {
+        const rootTranslationEntity = _translationEntity;
+        if (rootTranslationEntity.shouldTranslate === false) {
+          continue;
+        }
+        const langTranslationEntity = rootTranslationEntity?.localizations?.[locale];
+        if (langTranslationEntity) {
+          if (!resultData[translationKey]) {
+            resultData[translationKey] = {};
           }
-        } else {
-          result[key] = value;
+          if ("stringUnit" in langTranslationEntity) {
+            resultData[translationKey].stringUnit = langTranslationEntity.stringUnit.value;
+            if ("substitutions" in langTranslationEntity) {
+              resultData[translationKey].substitutions = {};
+              for (const [subName, subData] of Object.entries(
+                langTranslationEntity.substitutions
+              )) {
+                const pluralForms = subData.variations?.plural;
+                if (pluralForms) {
+                  const forms = {};
+                  for (const [form, formData] of Object.entries(pluralForms)) {
+                    forms[form] = formData.stringUnit.value;
+                  }
+                  const icuString = buildIcuPluralString(forms, locale);
+                  resultData[translationKey].substitutions[subName] = {
+                    variations: {
+                      plural: icuString
+                    }
+                  };
+                }
+              }
+            }
+          } else if ("stringSet" in langTranslationEntity) {
+            const values = langTranslationEntity.stringSet.values;
+            if (Array.isArray(values) && values.length > 0) {
+              resultData[translationKey].stringSet = values;
+            }
+          } else if ("variations" in langTranslationEntity) {
+            if ("plural" in langTranslationEntity.variations) {
+              const pluralForms = langTranslationEntity.variations.plural;
+              const forms = {};
+              for (const [form, formData] of Object.entries(pluralForms)) {
+                if (formData?.stringUnit?.value) {
+                  forms[form] = formData.stringUnit.value;
+                }
+              }
+              const icuString = buildIcuPluralString(forms, locale);
+              resultData[translationKey].variations = {
+                plural: icuString
+              };
+            }
+          }
+        } else if (isSourceLanguage) {
+          if (!resultData[translationKey]) {
+            resultData[translationKey] = {};
+          }
+          resultData[translationKey].stringUnit = translationKey;
         }
       }
-      return result;
+      return resultData;
     },
-    async push(locale, payload) {
-      const result = {};
-      for (const [key, value] of Object.entries(payload)) {
-        if (isICUPluralObject(value)) {
-          try {
-            const pluralForms = pluralWithMetaToXcstrings(value);
-            result[key] = pluralForms;
-          } catch (error) {
-            throw new Error(
-              `Failed to write plural translation for key "${key}" (locale: ${locale}).
+    async push(locale, payload, originalInput) {
+      const langDataToMerge = {};
+      langDataToMerge.strings = {};
+      const input2 = _10.cloneDeep(originalInput) || {
+        sourceLanguage: locale,
+        strings: {}
+      };
+      for (const [baseKey, keyData] of Object.entries(payload)) {
+        if (!keyData || typeof keyData !== "object") {
+          continue;
+        }
+        const hasDoNotTranslateFlag = originalInput && originalInput.strings && originalInput.strings[baseKey] && originalInput.strings[baseKey].shouldTranslate === false;
+        const localizationData = {};
+        if ("stringUnit" in keyData) {
+          localizationData.stringUnit = {
+            state: "translated",
+            value: keyData.stringUnit
+          };
+        }
+        if ("substitutions" in keyData && keyData.substitutions) {
+          const subs = {};
+          for (const [subName, subData] of Object.entries(
+            keyData.substitutions
+          )) {
+            const pluralValue = subData?.variations?.plural;
+            if (pluralValue && isIcuPluralString(pluralValue)) {
+              try {
+                const pluralForms = parseIcuPluralString(pluralValue, locale);
+                const pluralOut = {};
+                for (const [form, text] of Object.entries(pluralForms)) {
+                  pluralOut[form] = {
+                    stringUnit: {
+                      state: "translated",
+                      value: text
+                    }
+                  };
+                }
+                const sourceLocale = originalInput?.sourceLanguage || "en";
+                const origFormatSpec = originalInput?.strings?.[baseKey]?.localizations?.[sourceLocale]?.substitutions?.[subName]?.formatSpecifier || subName;
+                subs[subName] = {
+                  formatSpecifier: origFormatSpec,
+                  variations: {
+                    plural: pluralOut
+                  }
+                };
+              } catch (error) {
+                throw new Error(
+                  `Failed to write substitution plural translation for key "${baseKey}/substitutions/${subName}" (locale: ${locale}).
 ${error instanceof Error ? error.message : String(error)}`
-            );
+                );
+              }
+            }
+          }
+          if (Object.keys(subs).length > 0) {
+            localizationData.substitutions = subs;
+          }
+        }
+        if ("stringSet" in keyData && Array.isArray(keyData.stringSet)) {
+          localizationData.stringSet = {
+            state: "translated",
+            values: keyData.stringSet
+          };
+        }
+        if ("variations" in keyData && keyData.variations?.plural) {
+          const pluralValue = keyData.variations.plural;
+          if (isIcuPluralString(pluralValue)) {
+            try {
+              const pluralForms = parseIcuPluralString(pluralValue, locale);
+              const pluralOut = {};
+              for (const [form, text] of Object.entries(pluralForms)) {
+                pluralOut[form] = {
+                  stringUnit: {
+                    state: "translated",
+                    value: text
+                  }
+                };
+              }
+              localizationData.variations = {
+                plural: pluralOut
+              };
+            } catch (error) {
+              throw new Error(
+                `Failed to write plural translation for key "${baseKey}" (locale: ${locale}).
+${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+          }
+        }
+        if (Object.keys(localizationData).length > 0) {
+          langDataToMerge.strings[baseKey] = {
+            extractionState: originalInput?.strings?.[baseKey]?.extractionState,
+            localizations: {
+              [locale]: localizationData
+            }
+          };
+          if (hasDoNotTranslateFlag) {
+            langDataToMerge.strings[baseKey].shouldTranslate = false;
           }
-        } else {
-          result[key] = value;
         }
       }
-      return result;
+      return _10.merge(input2, langDataToMerge);
+    },
+    async pullHints(input2) {
+      const hints = {};
+      for (const [translationKey, _translationEntity] of Object.entries(
+        input2.strings || {}
+      )) {
+        const rootTranslationEntity = _translationEntity;
+        if (rootTranslationEntity.comment && typeof rootTranslationEntity.comment === "string") {
+          hints[translationKey] = { hint: rootTranslationEntity.comment };
+        }
+      }
+      return hints;
     }
   });
 }
 
 // src/cli/loaders/unlocalizable.ts
-import _10 from "lodash";
+import _11 from "lodash";
 import _isUrl from "is-url";
 import { isValid, parseISO } from "date-fns";
 function createUnlocalizableLoader(returnUnlocalizedKeys = false) {
   return createLoader({
     async pull(locale, input2) {
       const unlocalizableKeys = _getUnlocalizableKeys(input2);
-      const result = _10.omitBy(
+      const result = _11.omitBy(
         input2,
-        (_36, key) => unlocalizableKeys.includes(key)
+        (_37, key) => unlocalizableKeys.includes(key)
       );
       if (returnUnlocalizedKeys) {
-        result.unlocalizable = _10.omitBy(
+        result.unlocalizable = _11.omitBy(
           input2,
-          (_36, key) => !unlocalizableKeys.includes(key)
+          (_37, key) => !unlocalizableKeys.includes(key)
         );
       }
       return result;
     },
     async push(locale, data, originalInput) {
       const unlocalizableKeys = _getUnlocalizableKeys(originalInput);
-      const result = _10.merge(
+      const result = _11.merge(
         {},
         data,
-        _10.omitBy(originalInput, (_36, key) => !unlocalizableKeys.includes(key))
+        _11.omitBy(originalInput, (_37, key) => !unlocalizableKeys.includes(key))
       );
       return result;
     }
@@ -4599,12 +4522,12 @@ function _isIsoDate(v) {
 }
 function _getUnlocalizableKeys(input2) {
   const rules = {
-    isEmpty: (v) => _10.isEmpty(v),
+    isEmpty: (v) => _11.isEmpty(v),
     isNumber: (v) => typeof v === "number" || /^[0-9]+$/.test(v),
-    isBoolean: (v) => _10.isBoolean(v),
-    isIsoDate: (v) => _10.isString(v) && _isIsoDate(v),
-    isSystemId: (v) => _10.isString(v) && _isSystemId(v),
-    isUrl: (v) => _10.isString(v) && _isUrl(v)
+    isBoolean: (v) => _11.isBoolean(v),
+    isIsoDate: (v) => _11.isString(v) && _isIsoDate(v),
+    isSystemId: (v) => _11.isString(v) && _isSystemId(v),
+    isUrl: (v) => _11.isString(v) && _isUrl(v)
   };
   if (!input2) {
     return [];
@@ -4616,7 +4539,7 @@ function _getUnlocalizableKeys(input2) {
       }
     }
     return false;
-  }).map(([key, _36]) => key);
+  }).map(([key, _37]) => key);
 }
 
 // src/cli/loaders/formatters/prettier.ts
@@ -4783,7 +4706,7 @@ function createFormatterLoader(formatterType, parser, bucketPathPattern) {
 }
 
 // src/cli/loaders/po/index.ts
-import _11 from "lodash";
+import _12 from "lodash";
 import gettextParser from "gettext-parser";
 function createPoLoader(params = { multiline: false }) {
   return composeLoaders(createPoDataLoader(params), createPoContentLoader());
@@ -4799,7 +4722,7 @@ function createPoDataLoader(params) {
         if (Object.keys(sectionPo.translations).length === 0) {
           continue;
         }
-        const contextKey = _11.keys(sectionPo.translations)[0];
+        const contextKey = _12.keys(sectionPo.translations)[0];
         const entries = sectionPo.translations[contextKey];
         Object.entries(entries).forEach(([msgid, entry]) => {
           if (msgid && entry.msgid) {
@@ -4821,13 +4744,13 @@ function createPoDataLoader(params) {
         if (Object.keys(sectionPo.translations).length === 0) {
           return null;
         }
-        const contextKey = _11.keys(sectionPo.translations)[0];
+        const contextKey = _12.keys(sectionPo.translations)[0];
         const entries = sectionPo.translations[contextKey];
         const msgid = Object.keys(entries).find((key) => entries[key].msgid);
         if (!msgid) {
           const currentSection = currentSections.find((cs) => {
             const csPo = gettextParser.po.parse(cs);
-            const csContextKey = _11.keys(csPo.translations)[0];
+            const csContextKey = _12.keys(csPo.translations)[0];
             const csEntries = csPo.translations[csContextKey];
             const csMsgid = Object.keys(csEntries).find(
               (key) => csEntries[key].msgid
@@ -4840,7 +4763,7 @@ function createPoDataLoader(params) {
           return section;
         }
         if (data[msgid]) {
-          const updatedPo = _11.merge({}, sectionPo, {
+          const updatedPo = _12.merge({}, sectionPo, {
             translations: {
               [contextKey]: {
                 [msgid]: {
@@ -4864,7 +4787,7 @@ function createPoDataLoader(params) {
 function createPoContentLoader() {
   return createLoader({
     async pull(locale, input2, initCtx, originalLocale) {
-      const result = _11.chain(input2).entries().filter(([, entry]) => !!entry.msgid).map(([, entry]) => {
+      const result = _12.chain(input2).entries().filter(([, entry]) => !!entry.msgid).map(([, entry]) => {
         const singularFallback = locale === originalLocale ? entry.msgid : null;
         const pluralFallback = locale === originalLocale ? entry.msgid_plural || entry.msgid : null;
         const hasPlural = entry.msgstr.length > 1;
@@ -4879,7 +4802,7 @@ function createPoContentLoader() {
       return result;
     },
     async push(locale, data, originalInput) {
-      const result = _11.chain(originalInput).entries().map(([, entry]) => [
+      const result = _12.chain(originalInput).entries().map(([, entry]) => [
         entry.msgid,
         {
           ...entry,
@@ -5422,41 +5345,41 @@ var datoSettingsSchema = Z2.object({
 });
 
 // src/cli/loaders/dato/filter.ts
-import _12 from "lodash";
+import _13 from "lodash";
 function createDatoFilterLoader() {
   return createLoader({
     async pull(locale, input2) {
       const result = {};
-      for (const [modelId, modelInfo] of _12.entries(input2)) {
+      for (const [modelId, modelInfo] of _13.entries(input2)) {
         result[modelId] = {};
         for (const record of modelInfo.records) {
-          result[modelId][record.id] = _12.chain(modelInfo.fields).mapKeys((field) => field.api_key).mapValues((field) => _12.get(record, [field.api_key, locale])).value();
+          result[modelId][record.id] = _13.chain(modelInfo.fields).mapKeys((field) => field.api_key).mapValues((field) => _13.get(record, [field.api_key, locale])).value();
         }
       }
       return result;
     },
     async push(locale, data, originalInput, originalLocale) {
-      const result = _12.cloneDeep(originalInput || {});
-      for (const [modelId, modelInfo] of _12.entries(result)) {
+      const result = _13.cloneDeep(originalInput || {});
+      for (const [modelId, modelInfo] of _13.entries(result)) {
         for (const record of modelInfo.records) {
-          for (const [fieldId, fieldValue] of _12.entries(record)) {
+          for (const [fieldId, fieldValue] of _13.entries(record)) {
             const fieldInfo = modelInfo.fields.find(
               (field) => field.api_key === fieldId
             );
             if (fieldInfo) {
-              const sourceFieldValue = _12.get(fieldValue, [originalLocale]);
-              const targetFieldValue = _12.get(data, [
+              const sourceFieldValue = _13.get(fieldValue, [originalLocale]);
+              const targetFieldValue = _13.get(data, [
                 modelId,
                 record.id,
                 fieldId
               ]);
               if (targetFieldValue) {
-                _12.set(record, [fieldId, locale], targetFieldValue);
+                _13.set(record, [fieldId, locale], targetFieldValue);
               } else {
-                _12.set(record, [fieldId, locale], sourceFieldValue);
+                _13.set(record, [fieldId, locale], sourceFieldValue);
               }
-              _12.chain(fieldValue).keys().reject((loc) => loc === locale || loc === originalLocale).filter((loc) => _12.isEmpty(_12.get(fieldValue, [loc]))).forEach(
-                (loc) => _12.set(record, [fieldId, loc], sourceFieldValue)
+              _13.chain(fieldValue).keys().reject((loc) => loc === locale || loc === originalLocale).filter((loc) => _13.isEmpty(_13.get(fieldValue, [loc]))).forEach(
+                (loc) => _13.set(record, [fieldId, loc], sourceFieldValue)
               ).value();
             }
           }
@@ -5468,10 +5391,10 @@ function createDatoFilterLoader() {
 }
 
 // src/cli/loaders/dato/api.ts
-import _14 from "lodash";
+import _15 from "lodash";
 
 // src/cli/loaders/dato/_utils.ts
-import _13 from "lodash";
+import _14 from "lodash";
 import { buildClient } from "@datocms/cma-client-node";
 function createDatoClient(params) {
   if (!params.apiKey) {
@@ -5664,7 +5587,7 @@ function createDatoApiLoader(config, onConfigUpdate) {
       const result = {
         models: {}
       };
-      const updatedConfig = _14.cloneDeep(config);
+      const updatedConfig = _15.cloneDeep(config);
       console.log(`Initializing DatoCMS loader...`);
       const project = await dato.findProject();
       const modelChoices = await getModelChoices(dato, config);
@@ -5682,7 +5605,7 @@ function createDatoApiLoader(config, onConfigUpdate) {
           delete updatedConfig.models[modelId];
         }
       }
-      for (const modelId of _14.keys(updatedConfig.models)) {
+      for (const modelId of _15.keys(updatedConfig.models)) {
         const { modelName, fields } = await getModelFields(dato, modelId);
         if (fields.length > 0) {
           result.models[modelId] = { fields: [], records: [] };
@@ -5700,7 +5623,7 @@ function createDatoApiLoader(config, onConfigUpdate) {
             );
             if (isLocalized) {
               result.models[modelId].fields.push(fieldInfo);
-              updatedConfig.models[modelId].fields = _14.uniq([
+              updatedConfig.models[modelId].fields = _15.uniq([
                 ...updatedConfig.models[modelId].fields || [],
                 fieldInfo.api_key
               ]);
@@ -5728,7 +5651,7 @@ function createDatoApiLoader(config, onConfigUpdate) {
     },
     async pull(locale, input2, initCtx) {
       const result = {};
-      for (const modelId of _14.keys(initCtx?.models || {})) {
+      for (const modelId of _15.keys(initCtx?.models || {})) {
         let records = initCtx?.models[modelId].records || [];
         const recordIds = records.map((record) => record.id);
         records = await dato.findRecords(recordIds);
@@ -5743,7 +5666,7 @@ function createDatoApiLoader(config, onConfigUpdate) {
       return result;
     },
     async push(locale, data, originalInput) {
-      for (const modelId of _14.keys(data)) {
+      for (const modelId of _15.keys(data)) {
         for (let i = 0; i < data[modelId].records.length; i++) {
           const record = data[modelId].records[i];
           console.log(
@@ -5759,7 +5682,7 @@ async function getModelFields(dato, modelId) {
   const modelInfo = await dato.findModel(modelId);
   return {
     modelName: modelInfo.name,
-    fields: _14.filter(modelInfo.fields, (field) => field.type === "field")
+    fields: _15.filter(modelInfo.fields, (field) => field.type === "field")
   };
 }
 async function getFieldDetails(dato, fields) {
@@ -5839,17 +5762,17 @@ async function promptModelSelection(choices) {
 }
 
 // src/cli/loaders/dato/extract.ts
-import _15 from "lodash";
+import _16 from "lodash";
 function createDatoExtractLoader() {
   return createLoader({
     async pull(locale, input2) {
       const result = {};
-      for (const [modelId, modelInfo] of _15.entries(input2)) {
-        for (const [recordId, record] of _15.entries(modelInfo)) {
-          for (const [fieldName, fieldValue] of _15.entries(record)) {
+      for (const [modelId, modelInfo] of _16.entries(input2)) {
+        for (const [recordId, record] of _16.entries(modelInfo)) {
+          for (const [fieldName, fieldValue] of _16.entries(record)) {
             const parsedValue = createParsedDatoValue(fieldValue);
             if (parsedValue) {
-              _15.set(result, [modelId, `_${recordId}`, fieldName], parsedValue);
+              _16.set(result, [modelId, `_${recordId}`, fieldName], parsedValue);
             }
           }
         }
@@ -5857,12 +5780,12 @@ function createDatoExtractLoader() {
       return result;
     },
     async push(locale, data, originalInput) {
-      const result = _15.cloneDeep(originalInput || {});
-      for (const [modelId, modelInfo] of _15.entries(data)) {
-        for (const [virtualRecordId, record] of _15.entries(modelInfo)) {
-          for (const [fieldName, fieldValue] of _15.entries(record)) {
+      const result = _16.cloneDeep(originalInput || {});
+      for (const [modelId, modelInfo] of _16.entries(data)) {
+        for (const [virtualRecordId, record] of _16.entries(modelInfo)) {
+          for (const [fieldName, fieldValue] of _16.entries(record)) {
             const [, recordId] = virtualRecordId.split("_");
-            const originalFieldValue = _15.get(originalInput, [
+            const originalFieldValue = _16.get(originalInput, [
               modelId,
               recordId,
               fieldName
@@ -5872,7 +5795,7 @@ function createDatoExtractLoader() {
               originalFieldValue,
               true
             );
-            _15.set(
+            _16.set(
               result,
               [modelId, recordId, fieldName],
               rawValue || originalFieldValue
@@ -5885,25 +5808,25 @@ function createDatoExtractLoader() {
   });
 }
 function detectDatoFieldType(rawDatoValue) {
-  if (_15.has(rawDatoValue, "document") && _15.get(rawDatoValue, "schema") === "dast") {
+  if (_16.has(rawDatoValue, "document") && _16.get(rawDatoValue, "schema") === "dast") {
     return "structured_text";
-  } else if (_15.has(rawDatoValue, "no_index") || _15.has(rawDatoValue, "twitter_card")) {
+  } else if (_16.has(rawDatoValue, "no_index") || _16.has(rawDatoValue, "twitter_card")) {
     return "seo";
-  } else if (_15.get(rawDatoValue, "type") === "item") {
+  } else if (_16.get(rawDatoValue, "type") === "item") {
     return "single_block";
-  } else if (_15.isArray(rawDatoValue) && _15.every(rawDatoValue, (item) => _15.get(item, "type") === "item")) {
+  } else if (_16.isArray(rawDatoValue) && _16.every(rawDatoValue, (item) => _16.get(item, "type") === "item")) {
     return "rich_text";
   } else if (_isFile(rawDatoValue)) {
     return "file";
-  } else if (_15.isArray(rawDatoValue) && _15.every(rawDatoValue, (item) => _isFile(item))) {
+  } else if (_16.isArray(rawDatoValue) && _16.every(rawDatoValue, (item) => _isFile(item))) {
     return "gallery";
   } else if (_isJson(rawDatoValue)) {
     return "json";
-  } else if (_15.isString(rawDatoValue)) {
+  } else if (_16.isString(rawDatoValue)) {
     return "string";
   } else if (_isVideo(rawDatoValue)) {
     return "video";
-  } else if (_15.isArray(rawDatoValue) && _15.every(rawDatoValue, (item) => _15.isString(item))) {
+  } else if (_16.isArray(rawDatoValue) && _16.every(rawDatoValue, (item) => _16.isString(item))) {
     return "ref_list";
   } else {
     return null;
@@ -5973,9 +5896,9 @@ function serializeStructuredText(rawStructuredText) {
         acc
       );
     }
-    if (!_15.isNil(node.value)) {
+    if (!_16.isNil(node.value)) {
       acc[[...path19, "value"].join(".")] = node.value;
-    } else if (_15.get(node, "type") === "block") {
+    } else if (_16.get(node, "type") === "block") {
       acc[[...path19, "item"].join(".")] = serializeBlock(node.item);
     }
     if (node.children) {
@@ -5991,48 +5914,48 @@ function serializeStructuredText(rawStructuredText) {
   }
 }
 function serializeSeo(rawSeo) {
-  return _15.chain(rawSeo).pick(["title", "description"]).value();
+  return _16.chain(rawSeo).pick(["title", "description"]).value();
 }
 function serializeBlock(rawBlock) {
-  if (_15.get(rawBlock, "type") === "item" && _15.has(rawBlock, "id")) {
+  if (_16.get(rawBlock, "type") === "item" && _16.has(rawBlock, "id")) {
     return serializeBlock(rawBlock.attributes);
   }
   const result = {};
-  for (const [attributeName, attributeValue] of _15.entries(rawBlock)) {
+  for (const [attributeName, attributeValue] of _16.entries(rawBlock)) {
     result[attributeName] = createParsedDatoValue(attributeValue);
   }
   return result;
 }
 function serializeBlockList(rawBlockList) {
-  return _15.chain(rawBlockList).map((block) => serializeBlock(block)).value();
+  return _16.chain(rawBlockList).map((block) => serializeBlock(block)).value();
 }
 function serializeVideo(rawVideo) {
-  return _15.chain(rawVideo).pick(["title"]).value();
+  return _16.chain(rawVideo).pick(["title"]).value();
 }
 function serializeFile(rawFile) {
-  return _15.chain(rawFile).pick(["alt", "title"]).value();
+  return _16.chain(rawFile).pick(["alt", "title"]).value();
 }
 function serializeGallery(rawGallery) {
-  return _15.chain(rawGallery).map((item) => serializeFile(item)).value();
+  return _16.chain(rawGallery).map((item) => serializeFile(item)).value();
 }
 function deserializeFile(parsedFile, originalRawFile) {
-  return _15.chain(parsedFile).defaults(originalRawFile).value();
+  return _16.chain(parsedFile).defaults(originalRawFile).value();
 }
 function deserializeGallery(parsedGallery, originalRawGallery) {
-  return _15.chain(parsedGallery).map((item, i) => deserializeFile(item, originalRawGallery[i])).value();
+  return _16.chain(parsedGallery).map((item, i) => deserializeFile(item, originalRawGallery[i])).value();
 }
 function deserializeVideo(parsedVideo, originalRawVideo) {
-  return _15.chain(parsedVideo).defaults(originalRawVideo).value();
+  return _16.chain(parsedVideo).defaults(originalRawVideo).value();
 }
 function deserializeBlock(payload, rawNode, isClean = false) {
-  const result = _15.cloneDeep(rawNode);
-  for (const [attributeName, attributeValue] of _15.entries(rawNode.attributes)) {
+  const result = _16.cloneDeep(rawNode);
+  for (const [attributeName, attributeValue] of _16.entries(rawNode.attributes)) {
     const rawValue = createRawDatoValue(
       payload[attributeName],
       attributeValue,
       isClean
     );
-    _15.set(result, ["attributes", attributeName], rawValue);
+    _16.set(result, ["attributes", attributeName], rawValue);
   }
   if (isClean) {
     delete result["id"];
@@ -6040,40 +5963,40 @@ function deserializeBlock(payload, rawNode, isClean = false) {
   return result;
 }
 function deserializeSeo(parsedSeo, originalRawSeo) {
-  return _15.chain(parsedSeo).pick(["title", "description"]).defaults(originalRawSeo).value();
+  return _16.chain(parsedSeo).pick(["title", "description"]).defaults(originalRawSeo).value();
 }
 function deserializeBlockList(parsedBlockList, originalRawBlockList, isClean = false) {
-  return _15.chain(parsedBlockList).map(
+  return _16.chain(parsedBlockList).map(
     (block, i) => deserializeBlock(block, originalRawBlockList[i], isClean)
   ).value();
 }
 function deserializeStructuredText(parsedStructuredText, originalRawStructuredText) {
-  const result = _15.cloneDeep(originalRawStructuredText);
-  for (const [path19, value] of _15.entries(parsedStructuredText)) {
-    const realPath = _15.chain(path19.split(".")).flatMap((s) => !_15.isNaN(_15.toNumber(s)) ? ["children", s] : s).value();
+  const result = _16.cloneDeep(originalRawStructuredText);
+  for (const [path19, value] of _16.entries(parsedStructuredText)) {
+    const realPath = _16.chain(path19.split(".")).flatMap((s) => !_16.isNaN(_16.toNumber(s)) ? ["children", s] : s).value();
     const deserializedValue = createRawDatoValue(
       value,
-      _15.get(originalRawStructuredText, realPath),
+      _16.get(originalRawStructuredText, realPath),
       true
     );
-    _15.set(result, realPath, deserializedValue);
+    _16.set(result, realPath, deserializedValue);
   }
   return result;
 }
 function _isJson(rawDatoValue) {
   try {
-    return _15.isString(rawDatoValue) && rawDatoValue.startsWith("{") && rawDatoValue.endsWith("}") && !!JSON.parse(rawDatoValue);
+    return _16.isString(rawDatoValue) && rawDatoValue.startsWith("{") && rawDatoValue.endsWith("}") && !!JSON.parse(rawDatoValue);
   } catch (e) {
     return false;
   }
 }
 function _isFile(rawDatoValue) {
-  return _15.isObject(rawDatoValue) && ["alt", "title", "custom_data", "focal_point", "upload_id"].every(
-    (key) => _15.has(rawDatoValue, key)
+  return _16.isObject(rawDatoValue) && ["alt", "title", "custom_data", "focal_point", "upload_id"].every(
+    (key) => _16.has(rawDatoValue, key)
   );
 }
 function _isVideo(rawDatoValue) {
-  return _15.isObject(rawDatoValue) && [
+  return _16.isObject(rawDatoValue) && [
     "url",
     "title",
     "width",
@@ -6081,7 +6004,7 @@ function _isVideo(rawDatoValue) {
     "provider",
     "provider_uid",
     "thumbnail_url"
-  ].every((key) => _15.has(rawDatoValue, key));
+  ].every((key) => _16.has(rawDatoValue, key));
 }
 
 // src/cli/loaders/dato/index.ts
@@ -6151,7 +6074,7 @@ function createVttLoader() {
 }
 
 // src/cli/loaders/variable/index.ts
-import _16 from "lodash";
+import _17 from "lodash";
 function createVariableLoader(params) {
   return composeLoaders(variableExtractLoader(params), variableContentLoader());
 }
@@ -6160,18 +6083,9 @@ function variableExtractLoader(params) {
   return createLoader({
     pull: async (locale, input2, initXtx, originalLocale, originalInput) => {
       const result = {};
-      const inputValues = _16.omitBy(input2, _16.isEmpty);
+      const inputValues = _17.omitBy(input2, _17.isEmpty);
       for (const [key, value] of Object.entries(inputValues)) {
         const originalValue = originalInput[key];
-        if (isICUPluralObject(originalValue)) {
-          const icuValue = isICUPluralObject(value) ? { icu: value.icu } : value;
-          result[key] = {
-            value: icuValue,
-            variables: []
-            // Metadata stored separately, not in variables
-          };
-          continue;
-        }
         const matches = originalValue.match(specifierPattern) || [];
         result[key] = result[key] || {
           value,
@@ -6191,19 +6105,14 @@ function variableExtractLoader(params) {
       const result = {};
       for (const [key, valueObj] of Object.entries(data)) {
         result[key] = valueObj.value;
-        const resultValue = result[key];
-        if (isICUPluralObject(resultValue)) {
-          const originalValue = originalInput?.[key];
-          if (isICUPluralObject(originalValue) && originalValue._meta) {
-            resultValue._meta = originalValue._meta;
-            resultValue[Symbol.for("@lingo.dev/icu-plural-object")] = true;
-          }
-        }
         for (let i = 0; i < valueObj.variables.length; i++) {
           const variable = valueObj.variables[i];
           const currentValue = result[key];
           if (typeof currentValue === "string") {
-            const newValue = currentValue?.replace(`{variable:${i}}`, variable);
+            const newValue = currentValue?.replaceAll(
+              `{variable:${i}}`,
+              variable
+            );
             result[key] = newValue;
           }
         }
@@ -6215,11 +6124,11 @@ function variableExtractLoader(params) {
 function variableContentLoader() {
   return createLoader({
     pull: async (locale, input2) => {
-      const result = _16.mapValues(input2, (payload) => payload.value);
+      const result = _17.mapValues(input2, (payload) => payload.value);
       return result;
     },
     push: async (locale, data, originalInput, defaultLocale, pullInput) => {
-      const result = _16.cloneDeep(
+      const result = _17.cloneDeep(
         originalInput || {}
       );
       for (const [key, originalValueObj] of Object.entries(result)) {
@@ -6244,20 +6153,20 @@ function getFormatSpecifierPattern(type) {
 }
 
 // src/cli/loaders/sync.ts
-import _17 from "lodash";
+import _18 from "lodash";
 function createSyncLoader() {
   return createLoader({
     async pull(locale, input2, initCtx, originalLocale, originalInput) {
       if (!originalInput) {
         return input2;
       }
-      return _17.chain(originalInput).mapValues((value, key) => input2[key]).value();
+      return _18.chain(originalInput).mapValues((value, key) => input2[key]).value();
     },
     async push(locale, data, originalInput) {
       if (!originalInput) {
         return data;
       }
-      return _17.chain(originalInput || {}).mapValues((value, key) => data[key]).value();
+      return _18.chain(originalInput || {}).mapValues((value, key) => data[key]).value();
     }
   });
 }
@@ -6439,7 +6348,7 @@ function parseVueFile(input2) {
 
 // src/cli/loaders/typescript/index.ts
 import { parse as parse3 } from "@babel/parser";
-import _18 from "lodash";
+import _19 from "lodash";
 import babelTraverseModule from "@babel/traverse";
 import * as t from "@babel/types";
 import babelGenerateModule from "@babel/generator";
@@ -6475,7 +6384,7 @@ function createTypescriptLoader() {
     },
     push: async (locale, data, originalInput, defaultLocale, pullInput, pullOutput) => {
       const ast = parseTypeScript(originalInput || "");
-      const finalData = _18.merge({}, pullOutput, data);
+      const finalData = _19.merge({}, pullOutput, data);
       updateStringsInDefaultExport(ast, finalData);
       const { code } = generate(ast, {
         jsescOption: {
@@ -6676,7 +6585,7 @@ function getPropertyKey(prop) {
 }
 
 // src/cli/loaders/inject-locale.ts
-import _19 from "lodash";
+import _20 from "lodash";
 
 // ../../node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a, b, str) => {
@@ -7367,7 +7276,7 @@ var AST = class _AST {
     if (!this.type) {
       const noEmpty = this.isStart() && this.isEnd();
       const src = this.#parts.map((p) => {
-        const [re, _36, hasMagic, uflag] = typeof p === "string" ? _AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+        const [re, _37, hasMagic, uflag] = typeof p === "string" ? _AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
         this.#hasMagic = this.#hasMagic || hasMagic;
         this.#uflag = this.#uflag || uflag;
         return re;
@@ -7440,7 +7349,7 @@ var AST = class _AST {
       if (typeof p === "string") {
         throw new Error("string type in extglob ast??");
       }
-      const [re, _36, _hasMagic, uflag] = p.toRegExpSource(dot);
+      const [re, _37, _hasMagic, uflag] = p.toRegExpSource(dot);
       this.#uflag = this.#uflag || uflag;
       return re;
     }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
@@ -7685,7 +7594,7 @@ var Minimatch = class {
     }
     return false;
   }
-  debug(..._36) {
+  debug(..._37) {
   }
   make() {
     const pattern = this.pattern;
@@ -7707,7 +7616,7 @@ var Minimatch = class {
     const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
     this.globParts = this.preprocess(rawGlobParts);
     this.debug(this.pattern, this.globParts);
-    let set = this.globParts.map((s, _36, __) => {
+    let set = this.globParts.map((s, _37, __) => {
       if (this.isWindows && this.windowsNoMagicRoot) {
         const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
         const isDrive = /^[a-z]:/i.test(s[0]);
@@ -8224,7 +8133,7 @@ function createInjectLocaleLoader(injectLocaleKeys) {
         return data;
       }
       const omitKeys = _getKeysWithLocales(data, injectLocaleKeys, locale);
-      const result = _19.omit(data, omitKeys);
+      const result = _20.omit(data, omitKeys);
       return result;
     },
     async push(locale, data, originalInput, originalLocale) {
@@ -8237,7 +8146,7 @@ function createInjectLocaleLoader(injectLocaleKeys) {
         originalLocale
       );
       localeKeys.forEach((key) => {
-        _19.set(data, key, locale);
+        _20.set(data, key, locale);
       });
       return data;
     }
@@ -8246,7 +8155,7 @@ function createInjectLocaleLoader(injectLocaleKeys) {
 function _getKeysWithLocales(data, injectLocaleKeys, locale) {
   const allKeys = _getAllKeys(data);
   return allKeys.filter((key) => {
-    return injectLocaleKeys.some((pattern) => minimatch(key, pattern)) && _19.get(data, key) === locale;
+    return injectLocaleKeys.some((pattern) => minimatch(key, pattern)) && _20.get(data, key) === locale;
   });
 }
 function _getAllKeys(obj, prefix = "") {
@@ -8264,7 +8173,7 @@ function _getAllKeys(obj, prefix = "") {
 }
 
 // src/cli/loaders/locked-keys.ts
-import _20 from "lodash";
+import _21 from "lodash";
 
 // src/cli/utils/key-matching.ts
 function matchesKeyPattern(key, patterns) {
@@ -8283,14 +8192,14 @@ function formatDisplayValue(value, maxLength = 50) {
 function createLockedKeysLoader(lockedKeys) {
   return createLoader({
     pull: async (locale, data) => {
-      return _20.pickBy(
+      return _21.pickBy(
         data,
         (value, key) => !matchesKeyPattern(key, lockedKeys)
       );
     },
     push: async (locale, data, originalInput) => {
-      const lockedSubObject = _20.chain(originalInput).pickBy((value, key) => matchesKeyPattern(key, lockedKeys)).value();
-      return _20.merge({}, data, lockedSubObject);
+      const lockedSubObject = _21.chain(originalInput).pickBy((value, key) => matchesKeyPattern(key, lockedKeys)).value();
+      return _21.merge({}, data, lockedSubObject);
     }
   });
 }
@@ -8342,7 +8251,7 @@ function md5(input2) {
 }
 
 // src/cli/loaders/mdx2/code-placeholder.ts
-import _21 from "lodash";
+import _22 from "lodash";
 var fenceRegex = /([ \t]*)(^>\s*)?```([\s\S]*?)```/gm;
 var inlineCodeRegex = /(?<!`)`([^`\r\n]+?)`(?!`)/g;
 var imageRegex = /([ \t]*)(^>\s*)?!\[[^\]]*?\]\(([^()]*(\([^()]*\)[^()]*)*)\)/gm;
@@ -8365,7 +8274,7 @@ ${match2}
       found = true;
     }
   } while (found);
-  content = _21.chain(content).split("\n\n").map((section) => _21.trim(section, "\n")).filter(Boolean).join("\n\n").value();
+  content = _22.chain(content).split("\n\n").map((section) => _22.trim(section, "\n")).filter(Boolean).join("\n\n").value();
   return content;
 }
 function ensureTrailingFenceNewline(_content) {
@@ -8387,7 +8296,7 @@ ${match2}
       found = true;
     }
   } while (found);
-  content = _21.chain(content).split("\n\n").map((section) => _21.trim(section, "\n")).filter(Boolean).join("\n\n").value();
+  content = _22.chain(content).split("\n\n").map((section) => _22.trim(section, "\n")).filter(Boolean).join("\n\n").value();
   return content;
 }
 function extractCodePlaceholders(content) {
@@ -8429,7 +8338,7 @@ function createMdxCodePlaceholderLoader() {
     async push(locale, data, originalInput, originalLocale, pullInput) {
       const sourceInfo = extractCodePlaceholders(originalInput ?? "");
       const currentInfo = extractCodePlaceholders(pullInput ?? "");
-      const codePlaceholders = _21.merge(
+      const codePlaceholders = _22.merge(
         sourceInfo.codePlaceholders,
         currentInfo.codePlaceholders,
         globalPlaceholderRegistry
@@ -8437,7 +8346,7 @@ function createMdxCodePlaceholderLoader() {
       );
       let result = data;
       for (const [placeholder, original] of Object.entries(codePlaceholders)) {
-        const replacement = original.startsWith(">") ? _21.trimStart(original, "> ") : original;
+        const replacement = original.startsWith(">") ? _22.trimStart(original, "> ") : original;
         result = result.replaceAll(placeholder, () => replacement);
       }
       return result;
@@ -8465,11 +8374,11 @@ function createLocalizableMdxDocumentLoader() {
 }
 
 // src/cli/loaders/mdx2/sections-split-2.ts
-import _22 from "lodash";
+import _23 from "lodash";
 function createMdxSectionsSplit2Loader() {
   return createLoader({
     async pull(locale, input2) {
-      const sections = _22.chain(input2.content).split("\n\n").filter(Boolean).map((section, index) => [index, section]).fromPairs().value();
+      const sections = _23.chain(input2.content).split("\n\n").filter(Boolean).map((section, index) => [index, section]).fromPairs().value();
       const result = {
         frontmatter: input2.frontmatter,
         sections
@@ -8477,7 +8386,7 @@ function createMdxSectionsSplit2Loader() {
       return result;
     },
     async push(locale, data, originalInput, _originalLocale, pullInput) {
-      const content = _22.chain(data.sections).values().join("\n\n").value();
+      const content = _23.chain(data.sections).values().join("\n\n").value();
       const result = {
         frontmatter: data.frontmatter,
         codePlaceholders: pullInput?.codePlaceholders || {},
@@ -8543,18 +8452,18 @@ function createLockedPatternsLoader(defaultPatterns) {
 }
 
 // src/cli/loaders/ignored-keys.ts
-import _23 from "lodash";
+import _24 from "lodash";
 function createIgnoredKeysLoader(ignoredKeys) {
   return createLoader({
     pull: async (locale, data) => {
-      const result = _23.omitBy(
+      const result = _24.omitBy(
         data,
         (value, key) => matchesKeyPattern(key, ignoredKeys)
       );
       return result;
     },
     push: async (locale, data, originalInput, originalLocale, pullInput) => {
-      const result = _23.omitBy(
+      const result = _24.omitBy(
         data,
         (value, key) => matchesKeyPattern(key, ignoredKeys)
       );
@@ -8695,7 +8604,7 @@ function createEjsLoader() {
 }
 
 // src/cli/loaders/ensure-key-order.ts
-import _24 from "lodash";
+import _25 from "lodash";
 function createEnsureKeyOrderLoader() {
   return createLoader({
     pull: async (_locale, input2) => {
@@ -8710,10 +8619,10 @@ function createEnsureKeyOrderLoader() {
   });
 }
 function reorderKeys(data, originalInput) {
-  if (_24.isArray(originalInput) && _24.isArray(data)) {
+  if (_25.isArray(originalInput) && _25.isArray(data)) {
     return data.map((item, idx) => reorderKeys(item, originalInput[idx] ?? {}));
   }
-  if (!_24.isObject(data) || _24.isArray(data) || _24.isDate(data)) {
+  if (!_25.isObject(data) || _25.isArray(data) || _25.isDate(data)) {
     return data;
   }
   const orderedData = {};
@@ -8745,13 +8654,13 @@ function createTxtLoader() {
       const sortedEntries = Object.entries(payload).sort(
         ([a], [b]) => parseInt(a) - parseInt(b)
       );
-      return sortedEntries.map(([_36, value]) => value).join("\n");
+      return sortedEntries.map(([_37, value]) => value).join("\n");
     }
   });
 }
 
 // src/cli/loaders/json-dictionary.ts
-import _25 from "lodash";
+import _26 from "lodash";
 var TOP_LEVEL_KEY = "--content--";
 function createJsonDictionaryLoader() {
   return createLoader({
@@ -8766,7 +8675,7 @@ function createJsonDictionaryLoader() {
       if (!originalInput) {
         throw new Error("Error while parsing json-dictionary bucket");
       }
-      const input2 = _25.cloneDeep(originalInput);
+      const input2 = _26.cloneDeep(originalInput);
       if (Object.keys(data).length === 1 && Object.keys(data)[0] === TOP_LEVEL_KEY) {
         setNestedLocale(
           { [TOP_LEVEL_KEY]: input2 },
@@ -9036,9 +8945,8 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
         createPlutilJsonTextLoader(),
         createLockedPatternsLoader(lockedPatterns),
         createJsonLoader(),
-        createXcodeXcstringsLoader(options.defaultLocale),
         createXcodeXcstringsV2Loader(options.defaultLocale),
-        createFlatLoader({ shouldPreserveObject: isICUPluralObject }),
+        createFlatLoader(),
         createEnsureKeyOrderLoader(),
         createLockedKeysLoader(lockedKeys || []),
         createIgnoredKeysLoader(ignoredKeys || []),
@@ -9347,7 +9255,7 @@ import { Command as Command13 } from "interactive-commander";
 import { Command as Command10 } from "interactive-commander";
 import chalk2 from "chalk";
 import dedent from "dedent";
-import _26 from "lodash";
+import _27 from "lodash";
 var set_default = new Command10().name("set").description("Set or update a CLI setting in ~/.lingodotdevrc").addHelpText("afterAll", `
 Available keys:
   ${SETTINGS_KEYS.join("\n  ")}`).argument(
@@ -9365,8 +9273,8 @@ Available keys:
     return;
   }
   const current = loadSystemSettings();
-  const updated = _26.cloneDeep(current);
-  _26.set(updated, key, value);
+  const updated = _27.cloneDeep(current);
+  _27.set(updated, key, value);
   try {
     saveSettings(updated);
     console.log(`${chalk2.green("\u2714")} Set ${chalk2.bold(key)}`);
@@ -9386,7 +9294,7 @@ Available keys:
 import { Command as Command11 } from "interactive-commander";
 import chalk3 from "chalk";
 import dedent2 from "dedent";
-import _27 from "lodash";
+import _28 from "lodash";
 var unset_default = new Command11().name("unset").description("Remove a CLI setting from ~/.lingodotdevrc").addHelpText("afterAll", `
 Available keys:
   ${SETTINGS_KEYS.join("\n  ")}`).argument(
@@ -9406,13 +9314,13 @@ Available keys:
     return;
   }
   const settings = loadSystemSettings();
-  const currentValue = _27.get(settings, key);
-  if (!_27.trim(String(currentValue || ""))) {
+  const currentValue = _28.get(settings, key);
+  if (!_28.trim(String(currentValue || ""))) {
     console.log(`${chalk3.cyan("\u2139")} ${chalk3.bold(key)} is not set.`);
     return;
   } else {
-    const updated = _27.cloneDeep(settings);
-    _27.unset(updated, key);
+    const updated = _28.cloneDeep(settings);
+    _28.unset(updated, key);
     try {
       saveSettings(updated);
       console.log(
@@ -9434,7 +9342,7 @@ Available keys:
 // src/cli/cmd/config/get.ts
 import { Command as Command12 } from "interactive-commander";
 import chalk4 from "chalk";
-import _28 from "lodash";
+import _29 from "lodash";
 import dedent3 from "dedent";
 var get_default = new Command12().name("get").description("Display the value of a CLI setting from ~/.lingodotdevrc").addHelpText("afterAll", `
 Available keys:
@@ -9453,7 +9361,7 @@ Available keys:
     return;
   }
   const settings = loadSystemSettings();
-  const value = _28.get(settings, key);
+  const value = _29.get(settings, key);
   if (!value) {
     console.log(`${chalk4.cyan("\u2139")} ${chalk4.bold(key)} is not set.`);
     return;
@@ -9478,7 +9386,7 @@ import {
 } from "@lingo.dev/_spec";
 import { Command as Command14 } from "interactive-commander";
 import Z3 from "zod";
-import _31 from "lodash";
+import _32 from "lodash";
 import Ora9 from "ora";
 import chalk6 from "chalk";
 import { createTwoFilesPatch } from "diff";
@@ -9518,7 +9426,7 @@ function createLingoLocalizer(params) {
 
 // src/cli/processor/basic.ts
 import { generateText } from "ai";
-import _29 from "lodash";
+import _30 from "lodash";
 function createBasicTranslator(model, systemPrompt, settings = {}) {
   return async (input2, onProgress) => {
     const chunks = extractPayloadChunks(input2.processableData);
@@ -9532,7 +9440,7 @@ function createBasicTranslator(model, systemPrompt, settings = {}) {
       subResults.push(result2);
       onProgress(i / chunks.length * 100, chunk, result2);
     }
-    const result = _29.merge({}, ...subResults);
+    const result = _30.merge({}, ...subResults);
     return result;
   };
   async function doJob(input2) {
@@ -9809,7 +9717,7 @@ function trackEvent(distinctId, event, properties) {
 }
 
 // src/cli/utils/delta.ts
-import _30 from "lodash";
+import _31 from "lodash";
 import z from "zod";
 
 // src/cli/utils/fs.ts
@@ -9858,11 +9766,11 @@ function createDeltaProcessor(fileKey) {
       return checkIfFileExists(lockfilePath);
     },
     async calculateDelta(params) {
-      let added = _30.difference(
+      let added = _31.difference(
         Object.keys(params.sourceData),
         Object.keys(params.targetData)
       );
-      let removed = _30.difference(
+      let removed = _31.difference(
         Object.keys(params.targetData),
         Object.keys(params.sourceData)
       );
@@ -9924,7 +9832,7 @@ function createDeltaProcessor(fileKey) {
       await this.saveLock(lockfileData);
     },
     async createChecksums(sourceData) {
-      const checksums = _30.mapValues(sourceData, (value) => md5(value));
+      const checksums = _31.mapValues(sourceData, (value) => md5(value));
       return checksums;
     }
   };
@@ -10117,7 +10025,7 @@ var i18n_default = new Command14().command("i18n").description(
           const deltaProcessor = createDeltaProcessor(bucketPath.pathPattern);
           const sourceChecksums = await deltaProcessor.createChecksums(sourceData);
           const savedChecksums = await deltaProcessor.loadChecksums();
-          const updatedSourceData = _31.pickBy(
+          const updatedSourceData = _32.pickBy(
             sourceData,
             (value, key) => sourceChecksums[key] !== savedChecksums[key]
           );
@@ -10131,15 +10039,15 @@ var i18n_default = new Command14().command("i18n").description(
               bucketPath.delimiter
             );
             const { unlocalizable: targetUnlocalizable, ...targetData } = await bucketLoader.pull(targetLocale);
-            const missingKeys = _31.difference(
+            const missingKeys = _32.difference(
               Object.keys(sourceData),
               Object.keys(targetData)
             );
-            const extraKeys = _31.difference(
+            const extraKeys = _32.difference(
               Object.keys(targetData),
               Object.keys(sourceData)
             );
-            const unlocalizableDataDiff = !_31.isEqual(
+            const unlocalizableDataDiff = !_32.isEqual(
               sourceUnlocalizable,
               targetUnlocalizable
             );
@@ -10223,13 +10131,13 @@ var i18n_default = new Command14().command("i18n").description(
                 targetData,
                 checksums: checksums2
               });
-              let processableData = _31.chain(sourceData).entries().filter(
+              let processableData = _32.chain(sourceData).entries().filter(
                 ([key, value]) => delta.added.includes(key) || delta.updated.includes(key) || !!flags.force
               ).fromPairs().value();
               if (flags.key) {
-                processableData = _31.pickBy(
+                processableData = _32.pickBy(
                   processableData,
-                  (_36, key) => key === flags.key
+                  (_37, key) => key === flags.key
                 );
               }
               if (flags.verbose) {
@@ -10262,13 +10170,13 @@ var i18n_default = new Command14().command("i18n").description(
               if (flags.verbose) {
                 bucketOra.info(JSON.stringify(processedTargetData, null, 2));
               }
-              let finalTargetData = _31.merge(
+              let finalTargetData = _32.merge(
                 {},
                 sourceData,
                 targetData,
                 processedTargetData
               );
-              finalTargetData = _31.chain(finalTargetData).entries().map(([key, value]) => {
+              finalTargetData = _32.chain(finalTargetData).entries().map(([key, value]) => {
                 const renaming = delta.renamed.find(
                   ([oldKey, newKey]) => oldKey === key
                 );
@@ -10292,13 +10200,10 @@ var i18n_default = new Command14().command("i18n").description(
                   `Applying changes to ${bucketPath} (${targetLocale})`
                 );
               }
-              const finalDiffSize = _31.chain(finalTargetData).omitBy((value, key) => {
+              const finalDiffSize = _32.chain(finalTargetData).omitBy((value, key) => {
                 const targetValue = targetData[key];
-                if (isICUPluralObject(value) && isICUPluralObject(targetValue)) {
-                  return _31.isEqual(
-                    { icu: value.icu, _meta: value._meta },
-                    { icu: targetValue.icu, _meta: targetValue._meta }
-                  );
+                if (typeof value === "object" && value !== null) {
+                  return _32.isEqual(value, targetValue);
                 }
                 return value === targetValue;
               }).size().value();
@@ -10532,7 +10437,7 @@ Reviewing changes for ${chalk6.blue(args.pathPattern)} (${chalk6.yellow(
     return args.currentData;
   }
   const customData = { ...args.currentData };
-  const changes = _31.reduce(
+  const changes = _32.reduce(
     args.proposedData,
     (result, value, key) => {
       if (args.currentData[key] !== value) {
@@ -10605,7 +10510,7 @@ import path16 from "path";
 import Z4 from "zod";
 import YAML6 from "yaml";
 import { MD5 as MD52 } from "object-hash";
-import _32 from "lodash";
+import _33 from "lodash";
 function createLockfileHelper() {
   return {
     isLockfileExists: () => {
@@ -10615,18 +10520,18 @@ function createLockfileHelper() {
     registerSourceData: (pathPattern, sourceData) => {
       const lockfile = _loadLockfile();
       const sectionKey = MD52(pathPattern);
-      const sectionChecksums = _32.mapValues(sourceData, (value) => MD52(value));
+      const sectionChecksums = _33.mapValues(sourceData, (value) => MD52(value));
       lockfile.checksums[sectionKey] = sectionChecksums;
       _saveLockfile(lockfile);
     },
     registerPartialSourceData: (pathPattern, partialSourceData) => {
       const lockfile = _loadLockfile();
       const sectionKey = MD52(pathPattern);
-      const sectionChecksums = _32.mapValues(
+      const sectionChecksums = _33.mapValues(
         partialSourceData,
         (value) => MD52(value)
       );
-      lockfile.checksums[sectionKey] = _32.merge(
+      lockfile.checksums[sectionKey] = _33.merge(
         {},
         lockfile.checksums[sectionKey] ?? {},
         sectionChecksums
@@ -10636,9 +10541,9 @@ function createLockfileHelper() {
     extractUpdatedData: (pathPattern, sourceData) => {
       const lockfile = _loadLockfile();
       const sectionKey = MD52(pathPattern);
-      const currentChecksums = _32.mapValues(sourceData, (value) => MD52(value));
+      const currentChecksums = _33.mapValues(sourceData, (value) => MD52(value));
       const savedChecksums = lockfile.checksums[sectionKey] || {};
-      const updatedData = _32.pickBy(
+      const updatedData = _33.pickBy(
         sourceData,
         (value, key) => savedChecksums[key] !== currentChecksums[key]
       );
@@ -10731,7 +10636,7 @@ var flagsSchema = Z5.object({
 // src/cli/cmd/cleanup.ts
 import { resolveOverriddenLocale as resolveOverriddenLocale6 } from "@lingo.dev/_spec";
 import { Command as Command16 } from "interactive-commander";
-import _33 from "lodash";
+import _34 from "lodash";
 import Ora11 from "ora";
 var cleanup_default = new Command16().command("cleanup").description(
   "Remove translation keys from target locales that no longer exist in the source locale"
@@ -10795,7 +10700,7 @@ var cleanup_default = new Command16().command("cleanup").description(
           try {
             const targetData = await bucketLoader.pull(targetLocale);
             const targetKeys = Object.keys(targetData);
-            const keysToRemove = _33.difference(targetKeys, sourceKeys);
+            const keysToRemove = _34.difference(targetKeys, sourceKeys);
             if (keysToRemove.length === 0) {
               bucketOra.succeed(`[${targetLocale}] No keys to remove`);
               continue;
@@ -10810,7 +10715,7 @@ var cleanup_default = new Command16().command("cleanup").description(
               );
             }
             if (!options.dryRun) {
-              const cleanedData = _33.pick(targetData, sourceKeys);
+              const cleanedData = _34.pick(targetData, sourceKeys);
               await bucketLoader.push(targetLocale, cleanedData);
               bucketOra.succeed(
                 `[${targetLocale}] Removed ${keysToRemove.length} keys`
@@ -10873,7 +10778,7 @@ import Z6 from "zod";
 import { ReplexicaEngine } from "@lingo.dev/_sdk";
 var mcp_default = new Command17().command("mcp").description(
   "Start a Model Context Protocol (MCP) server for AI assistant integration"
-).helpOption("-h, --help", "Show help").action(async (_36, program) => {
+).helpOption("-h, --help", "Show help").action(async (_37, program) => {
   const apiKey = program.args[0];
   const settings = getSettings(apiKey);
   if (!settings.auth.apiKey) {
@@ -11459,7 +11364,7 @@ async function plan(input2) {
 import chalk12 from "chalk";
 import { Listr as Listr3 } from "listr2";
 import pLimit from "p-limit";
-import _34 from "lodash";
+import _35 from "lodash";
 var MAX_WORKER_COUNT = 10;
 async function execute(input2) {
   const effectiveConcurrency = Math.min(
@@ -11489,7 +11394,7 @@ async function execute(input2) {
             return;
           }
           const initialChecksumsMap = /* @__PURE__ */ new Map();
-          const uniqueBucketPatterns = _34.uniq(
+          const uniqueBucketPatterns = _35.uniq(
             ctx.tasks.map((t2) => t2.bucketPathPattern)
           );
           for (const bucketPathPattern of uniqueBucketPatterns) {
@@ -11511,7 +11416,7 @@ async function execute(input2) {
           const workerTasks = [];
           for (let i = 0; i < workersCount; i++) {
             const assignedTasks = ctx.tasks.filter(
-              (_36, idx) => idx % workersCount === i
+              (_37, idx) => idx % workersCount === i
             );
             workerTasks.push(
               createWorkerTask({
@@ -11621,7 +11526,7 @@ function createWorkerTask(args) {
               targetData,
               checksums: initialChecksums
             });
-            const processableData = _34.chain(sourceData).entries().filter(
+            const processableData = _35.chain(sourceData).entries().filter(
               ([key, value]) => delta.added.includes(key) || delta.updated.includes(key) || !!args.ctx.flags.force
             ).filter(
               ([key]) => !assignedTask.onlyKeys.length || assignedTask.onlyKeys?.some(
@@ -11639,7 +11544,7 @@ function createWorkerTask(args) {
                 targetLocale: assignedTask.targetLocale
               };
             }
-            const relevantHints = _34.pick(hints, Object.keys(processableData));
+            const relevantHints = _35.pick(hints, Object.keys(processableData));
             const processedTargetData = await args.ctx.localizer.localize(
               {
                 sourceLocale: assignedTask.sourceLocale,
@@ -11655,7 +11560,7 @@ function createWorkerTask(args) {
                   const latestTargetData = await bucketLoader.pull(
                     assignedTask.targetLocale
                   );
-                  const _partialData = _34.merge(
+                  const _partialData = _35.merge(
                     {},
                     latestTargetData,
                     processedChunk
@@ -11675,7 +11580,7 @@ function createWorkerTask(args) {
                 });
               }
             );
-            const finalTargetData = _34.merge(
+            const finalTargetData = _35.merge(
               {},
               sourceData,
               targetData,
@@ -11724,7 +11629,7 @@ function countTasks(ctx, predicate) {
   ).length;
 }
 function processRenamedKeys(delta, targetData) {
-  return _34.chain(targetData).entries().map(([key, value]) => {
+  return _35.chain(targetData).entries().map(([key, value]) => {
     const renaming = delta.renamed.find(([oldKey]) => oldKey === key);
     if (!renaming) {
       return [key, value];
@@ -11892,7 +11797,7 @@ var flagsSchema2 = z2.object({
 // src/cli/cmd/run/frozen.ts
 import chalk14 from "chalk";
 import { Listr as Listr4 } from "listr2";
-import _35 from "lodash";
+import _36 from "lodash";
 import { resolveOverriddenLocale as resolveOverriddenLocale8 } from "@lingo.dev/_spec";
 async function frozen(input2) {
   console.log(chalk14.hex(colors.orange)("[Frozen]"));
@@ -11980,7 +11885,7 @@ async function frozen(input2) {
               const delta = createDeltaProcessor(bucketPath.pathPattern);
               const sourceChecksums = await delta.createChecksums(src);
               const savedChecksums = await delta.loadChecksums();
-              const updatedSourceData = _35.pickBy(
+              const updatedSourceData = _36.pickBy(
                 src,
                 (value, key) => sourceChecksums[key] !== savedChecksums[key]
               );
@@ -11995,7 +11900,7 @@ async function frozen(input2) {
                   bucketPath.delimiter
                 );
                 const { unlocalizable: tgtUnlocalizable, ...tgt } = await loader.pull(resolvedTargetLocale);
-                const missingKeys = _35.difference(
+                const missingKeys = _36.difference(
                   Object.keys(src),
                   Object.keys(tgt)
                 );
@@ -12004,7 +11909,7 @@ async function frozen(input2) {
                     `Localization data has changed; please update i18n.lock or run without --frozen. Details: Target file is missing translations.`
                   );
                 }
-                const extraKeys = _35.difference(
+                const extraKeys = _36.difference(
                   Object.keys(tgt),
                   Object.keys(src)
                 );
@@ -12013,7 +11918,7 @@ async function frozen(input2) {
                     `Localization data has changed; please update i18n.lock or run without --frozen. Details: Target file has extra translations not present in the source file.`
                   );
                 }
-                const unlocalizableDataDiff = !_35.isEqual(
+                const unlocalizableDataDiff = !_36.isEqual(
                   srcUnlocalizable,
                   tgtUnlocalizable
                 );
@@ -13556,7 +13461,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.116.2",
+  version: "0.116.4",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {