lingo.dev 0.74.14 → 0.74.16

package/build/cli.mjs

@@ -263,15 +263,173 @@ function _getConfigFilePath() {
 }
 
 // src/cli/cmd/init.ts
-import { defaultConfig, resolveLocaleCode, bucketTypes } from "@lingo.dev/_spec";
-import fs3 from "fs";
-import path3 from "path";
+import { defaultConfig, resolveLocaleCode as resolveLocaleCode2, bucketTypes } from "@lingo.dev/_spec";
+import fs4 from "fs";
+import path5 from "path";
 import { spawn } from "child_process";
+import _3 from "lodash";
+import { checkbox, confirm, input } from "@inquirer/prompts";
+
+// src/cli/utils/find-locale-paths.ts
+import path3 from "path";
+import { glob } from "glob";
 import _2 from "lodash";
-import { confirm } from "@inquirer/prompts";
-var openUrl = (path9) => {
+import { resolveLocaleCode } from "@lingo.dev/_spec";
+function findLocaleFiles(bucket) {
+  switch (bucket) {
+    case "json":
+      return findLocaleFilesWithExtension(".json");
+    case "yaml":
+      return findLocaleFilesWithExtension(".yml");
+    case "flutter":
+      return findLocaleFilesWithExtension(".arb");
+    case "android":
+      return findLocaleFilesWithExtension(".xml");
+    case "markdown":
+      return findLocaleFilesWithExtension(".md");
+    case "xcode-xcstrings":
+      return findLocaleFilesForFilename("Localizable.xcstrings");
+    case "xcode-strings":
+      return findLocaleFilesForFilename("Localizable.strings");
+    case "xcode-stringsdict":
+      return findLocaleFilesForFilename("Localizable.stringsdict");
+    default:
+      throw new Error(`Unsupported bucket type: ${bucket}`);
+  }
+}
+function findLocaleFilesWithExtension(ext) {
+  const files = glob.sync(`**/*${ext}`, {
+    ignore: ["node_modules/**", "package*.json", "i18n.json", "lingo.json"]
+  });
+  const localeFilePattern = new RegExp(`[/\\\\]([a-z]{2}(-[A-Z]{2})?)${ext}$`);
+  const localeDirectoryPattern = new RegExp(`[/\\\\]([a-z]{2}(-[A-Z]{2})?)[/\\\\][^/\\\\]+${ext}$`);
+  const potentialLocaleFiles = files.filter(
+    (file) => localeFilePattern.test(file) || localeDirectoryPattern.test(file)
+  );
+  const localeFilesAndPatterns = potentialLocaleFiles.map((file) => {
+    const match = file.match(new RegExp(`[/|\\\\]([a-z]{2}(-[A-Z]{2})?)(/|\\\\|${ext})`));
+    const locale = match?.[1];
+    const localeInDir = match?.[3] !== ext;
+    const filePattern = localeInDir ? file.replace(`/${locale}/`, `/[locale]/`) : path3.join(path3.dirname(file), `[locale]${ext}`);
+    return { file, locale, pattern: filePattern };
+  }).filter(({ locale }) => {
+    try {
+      resolveLocaleCode(locale);
+      return true;
+    } catch (e) {
+    }
+    return false;
+  });
+  const grouppedFilesAndPatterns = _2.groupBy(localeFilesAndPatterns, "pattern");
+  const patterns = Object.keys(grouppedFilesAndPatterns);
+  if (patterns.length > 0) {
+    return { found: true, patterns };
+  }
+  return { found: false, patterns: [`i18n/[locale]${ext}`] };
+}
+function findLocaleFilesForFilename(fileName) {
+  const pattern = fileName;
+  const localeFiles = glob.sync(`**/${fileName}`, {
+    ignore: ["node_modules/**", "package*.json", "i18n.json", "lingo.json"]
+  });
+  const localeFilesAndPatterns = localeFiles.map((file) => ({
+    file,
+    pattern: path3.join(path3.dirname(file), pattern)
+  }));
+  const grouppedFilesAndPatterns = _2.groupBy(localeFilesAndPatterns, "pattern");
+  const patterns = Object.keys(grouppedFilesAndPatterns);
+  if (patterns.length > 0) {
+    return { found: true, patterns };
+  }
+  return { found: false, patterns: [fileName] };
+}
+
+// src/cli/utils/ensure-patterns.ts
+import fs3 from "fs";
+import path4 from "path";
+function ensurePatterns(patterns, source) {
+  if (patterns.length === 0) {
+    throw new Error("No patterns found");
+  }
+  patterns.forEach((pattern) => {
+    const filePath = pattern.replace("[locale]", source);
+    if (!fs3.existsSync(filePath)) {
+      const defaultContent = getDefaultContent(path4.extname(filePath), source);
+      fs3.mkdirSync(path4.dirname(filePath), { recursive: true });
+      fs3.writeFileSync(filePath, defaultContent);
+    }
+  });
+}
+function getDefaultContent(ext, source) {
+  const defaultGreeting = "Hello from Lingo.dev";
+  switch (ext) {
+    case ".json":
+    case ".arb":
+      return `{
+	"greeting": "${defaultGreeting}"
+}`;
+    case ".yml":
+      return `${source}:
+	greeting: "${defaultGreeting}"`;
+    case ".xml":
+      return `<resources>
+	<string name="greeting">${defaultGreeting}</string>
+</resources>`;
+    case ".md":
+      return `# ${defaultGreeting}`;
+    case ".xcstrings":
+      return `{
+  "sourceLanguage" : "${source}",
+  "strings" : {
+    "${defaultGreeting}" : {
+      "extractionState" : "manual",
+      "localizations" : {
+        "${source}" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "${defaultGreeting}"
+          }
+        }
+      }
+    }
+  }
+}`;
+    case ".strings":
+      return `"greeting" = "${defaultGreeting}";`;
+    case ".stringsdict":
+      return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>key</key>
+  <dict>
+    <key>NSStringLocalizedFormatKey</key>
+    <string>%#@count@</string>
+    <key>count</key>
+    <dict>
+      <key>NSStringFormatSpecTypeKey</key>
+      <string>NSStringPluralRuleType</string>
+      <key>NSStringFormatValueTypeKey</key>
+      <string>d</string>
+      <key>zero</key>
+      <string>No items</string>
+      <key>one</key>
+      <string>One item</string>
+      <key>other</key>
+      <string>%d items</string>
+    </dict>
+  </dict>
+</dict>
+</plist>`;
+    default:
+      throw new Error(`Unsupported file extension: ${ext}`);
+  }
+}
+
+// src/cli/cmd/init.ts
+var openUrl = (path11) => {
   const settings = getSettings(void 0);
-  spawn("open", [`${settings.auth.webUrl}${path9}`]);
+  spawn("open", [`${settings.auth.webUrl}${path11}`]);
 };
 var throwHelpError = (option, value) => {
   if (value === "help") {
@@ -286,7 +444,7 @@ Do you need support for ${value} ${option}? Type "help" and we will.`
 var init_default = new InteractiveCommand().command("init").description("Initialize Lingo.dev project").helpOption("-h, --help", "Show help").addOption(new InteractiveOption("-f --force", "Overwrite existing config").prompt(void 0).default(false)).addOption(
   new InteractiveOption("-s --source <locale>", "Source locale").argParser((value) => {
     try {
-      resolveLocaleCode(value);
+      resolveLocaleCode2(value);
     } catch (e) {
       throwHelpError("locale", value);
     }
@@ -297,7 +455,7 @@ var init_default = new InteractiveCommand().command("init").description("Initial
     const values = value.includes(",") ? value.split(",") : value.split(" ");
     values.forEach((value2) => {
       try {
-        resolveLocaleCode(value2);
+        resolveLocaleCode2(value2);
       } catch (e) {
         throwHelpError("locale", value2);
       }
@@ -317,8 +475,8 @@ var init_default = new InteractiveCommand().command("init").description("Initial
     const values = value.includes(",") ? value.split(",") : value.split(" ");
     for (const p of values) {
       try {
-        const dirPath = path3.dirname(p);
-        const stats = fs3.statSync(dirPath);
+        const dirPath = path5.dirname(p);
+        const stats = fs4.statSync(dirPath);
         if (!stats.isDirectory()) {
           throw new Error(`${dirPath} is not a directory`);
         }
@@ -327,26 +485,60 @@ var init_default = new InteractiveCommand().command("init").description("Initial
       }
     }
     return values;
-  }).default([])
+  }).prompt(void 0).default([])
 ).action(async (options) => {
   const settings = getSettings(void 0);
+  const isInteractive = options.interactive;
   const spinner = Ora2().start("Initializing Lingo.dev project");
   let existingConfig = await getConfig(false);
   if (existingConfig && !options.force) {
     spinner.fail("Lingo.dev project already initialized");
     return process.exit(1);
   }
-  const newConfig = _2.cloneDeep(defaultConfig);
+  const newConfig = _3.cloneDeep(defaultConfig);
   newConfig.locale.source = options.source;
   newConfig.locale.targets = options.targets;
-  newConfig.buckets = {
-    [options.bucket]: {
-      include: options.paths || []
+  if (!isInteractive) {
+    newConfig.buckets = {
+      [options.bucket]: {
+        include: options.paths || []
+      }
+    };
+  } else {
+    let selectedPatterns = [];
+    const { found, patterns } = findLocaleFiles(options.bucket);
+    if (found) {
+      spinner.succeed("Found existing locale files:");
+      selectedPatterns = await checkbox({
+        message: "Select the paths to use",
+        choices: patterns.map((value) => ({
+          value
+        }))
+      });
+    } else {
+      spinner.succeed("No existing locale files found.");
+      const useDefault = await confirm({
+        message: `Use default path ${patterns.join(", ")}?`
+      });
+      ensurePatterns(patterns, options.source);
+      if (useDefault) {
+        selectedPatterns = patterns;
+      }
     }
-  };
+    if (selectedPatterns.length === 0) {
+      const customPaths = await input({
+        message: "Enter paths to use"
+      });
+      selectedPatterns = customPaths.includes(",") ? customPaths.split(",") : customPaths.split(" ");
+    }
+    newConfig.buckets = {
+      [options.bucket]: {
+        include: selectedPatterns || []
+      }
+    };
+  }
   await saveConfig(newConfig);
   spinner.succeed("Lingo.dev project initialized");
-  const isInteractive = !process.argv.includes("-y") && !process.argv.includes("--no-interactive");
   if (isInteractive) {
     const openDocs = await confirm({ message: "Would you like to see our docs?" });
     if (openDocs) {
@@ -394,22 +586,22 @@ import { Command as Command5 } from "interactive-commander";
 
 // src/cli/cmd/show/config.ts
 import { Command as Command2 } from "interactive-commander";
-import _3 from "lodash";
-import fs4 from "fs";
-import path4 from "path";
+import _4 from "lodash";
+import fs5 from "fs";
+import path6 from "path";
 import { defaultConfig as defaultConfig2 } from "@lingo.dev/_spec";
 var config_default = new Command2().command("config").description("Print out the current configuration").helpOption("-h, --help", "Show help").action(async (options) => {
   const fileConfig = loadReplexicaFileConfig();
-  const config = _3.merge({}, defaultConfig2, fileConfig);
+  const config = _4.merge({}, defaultConfig2, fileConfig);
   console.log(JSON.stringify(config, null, 2));
 });
 function loadReplexicaFileConfig() {
-  const replexicaConfigPath = path4.resolve(process.cwd(), "i18n.json");
-  const fileExists = fs4.existsSync(replexicaConfigPath);
+  const replexicaConfigPath = path6.resolve(process.cwd(), "i18n.json");
+  const fileExists = fs5.existsSync(replexicaConfigPath);
   if (!fileExists) {
     return void 0;
   }
-  const fileContent = fs4.readFileSync(replexicaConfigPath, "utf-8");
+  const fileContent = fs5.readFileSync(replexicaConfigPath, "utf-8");
   const replexicaFileConfig = JSON.parse(fileContent);
   return replexicaFileConfig;
 }
@@ -445,9 +637,9 @@ import { Command as Command4 } from "interactive-commander";
 import Ora4 from "ora";
 
 // src/cli/utils/buckets.ts
-import _4 from "lodash";
-import path5 from "path";
-import * as glob from "glob";
+import _5 from "lodash";
+import path7 from "path";
+import * as glob2 from "glob";
 import { resolveOverridenLocale } from "@lingo.dev/_spec";
 function getBuckets(i18nConfig) {
   const result = Object.entries(i18nConfig.buckets).map(([bucketType, bucketEntry]) => {
@@ -477,13 +669,13 @@ function extractPathPatterns(sourceLocale, include, exclude) {
       })
     )
   );
-  const result = _4.differenceBy(includedPatterns, excludedPatterns ?? [], (item) => item.pathPattern);
+  const result = _5.differenceBy(includedPatterns, excludedPatterns ?? [], (item) => item.pathPattern);
   return result;
 }
 function expandPlaceholderedGlob(_pathPattern, sourceLocale) {
-  const absolutePathPattern = path5.resolve(_pathPattern);
-  const pathPattern = path5.relative(process.cwd(), absolutePathPattern);
-  if (path5.relative(process.cwd(), pathPattern).startsWith("..")) {
+  const absolutePathPattern = path7.resolve(_pathPattern);
+  const pathPattern = path7.relative(process.cwd(), absolutePathPattern);
+  if (path7.relative(process.cwd(), pathPattern).startsWith("..")) {
     throw new CLIError({
       message: `Invalid path pattern: ${pathPattern}. Path pattern must be within the current working directory.`,
       docUrl: "invalidPathPattern"
@@ -501,19 +693,19 @@ function expandPlaceholderedGlob(_pathPattern, sourceLocale) {
       docUrl: "invalidPathPattern"
     });
   }
-  const pathPatternChunks = pathPattern.split(path5.sep);
+  const pathPatternChunks = pathPattern.split(path7.sep);
   const localeSegmentIndex = pathPatternChunks.findIndex((segment) => segment.includes("[locale]"));
   const localePlaceholderIndex = pathPatternChunks[localeSegmentIndex]?.indexOf("[locale]") ?? -1;
   const sourcePathPattern = pathPattern.replace(/\[locale\]/g, sourceLocale);
-  const sourcePaths = glob.sync(sourcePathPattern, { follow: true, withFileTypes: true }).filter((file) => file.isFile() || file.isSymbolicLink()).map((file) => file.fullpath()).map((fullpath) => path5.relative(process.cwd(), fullpath));
+  const sourcePaths = glob2.sync(sourcePathPattern, { follow: true, withFileTypes: true }).filter((file) => file.isFile() || file.isSymbolicLink()).map((file) => file.fullpath()).map((fullpath) => path7.relative(process.cwd(), fullpath));
   const placeholderedPaths = sourcePaths.map((sourcePath) => {
-    const sourcePathChunks = sourcePath.split(path5.sep);
+    const sourcePathChunks = sourcePath.split(path7.sep);
     if (localeSegmentIndex >= 0 && localePlaceholderIndex >= 0) {
       const placeholderedPathChunk = sourcePathChunks[localeSegmentIndex];
       const placeholderedSegment = placeholderedPathChunk.substring(0, localePlaceholderIndex) + "[locale]" + placeholderedPathChunk.substring(localePlaceholderIndex + sourceLocale.length);
       sourcePathChunks[localeSegmentIndex] = placeholderedSegment;
     }
-    const placeholderedPath = sourcePathChunks.join(path5.sep);
+    const placeholderedPath = sourcePathChunks.join(path7.sep);
     return placeholderedPath;
   });
   return placeholderedPaths;
@@ -555,8 +747,8 @@ var files_default = new Command4().command("files").description("Print out the l
           } else if (type.target) {
             result.push(...targetPaths);
           }
-          result.forEach((path9) => {
-            console.log(path9);
+          result.forEach((path11) => {
+            console.log(path11);
           });
         }
       }
@@ -580,7 +772,7 @@ import { bucketTypeSchema, localeCodeSchema, resolveOverridenLocale as resolveOv
 import { ReplexicaEngine } from "@lingo.dev/_sdk";
 import { Command as Command6 } from "interactive-commander";
 import Z4 from "zod";
-import _18 from "lodash";
+import _19 from "lodash";
 import Ora5 from "ora";
 
 // src/cli/loaders/_utils.ts
@@ -597,8 +789,8 @@ function composeLoaders(...loaders) {
       }
       return this;
     },
-    pull: async (locale, input) => {
-      let result = input;
+    pull: async (locale, input2) => {
+      let result = input2;
       for (let i = 0; i < loaders.length; i++) {
         result = await loaders[i].pull(locale, result);
       }
@@ -634,7 +826,7 @@ function createLoader(lDefinition) {
       state.defaultLocale = locale;
       return this;
     },
-    async pull(locale, input) {
+    async pull(locale, input2) {
       if (!state.defaultLocale) {
         throw new Error("Default locale not set");
       }
@@ -642,9 +834,9 @@ function createLoader(lDefinition) {
         throw new Error("The first pull must be for the default locale");
       }
       if (locale === state.defaultLocale) {
-        state.originalInput = input || null;
+        state.originalInput = input2 || null;
       }
-      return lDefinition.pull(locale, input, state.initCtx);
+      return lDefinition.pull(locale, input2, state.initCtx);
     },
     async push(locale, data) {
       if (!state.defaultLocale) {
@@ -663,8 +855,8 @@ function createLoader(lDefinition) {
 import { jsonrepair } from "jsonrepair";
 function createJsonLoader() {
   return createLoader({
-    pull: async (locale, input) => {
-      const jsonString = input || "{}";
+    pull: async (locale, input2) => {
+      const jsonString = input2 || "{}";
       let result;
       try {
         result = JSON.parse(jsonString);
@@ -682,33 +874,46 @@ function createJsonLoader() {
 
 // src/cli/loaders/flat.ts
 import { flatten, unflatten } from "flat";
-import _5 from "lodash";
+import _6 from "lodash";
 var OBJECT_NUMERIC_KEY_PREFIX = "__lingodotdev__obj__";
 function createFlatLoader() {
-  let denormalizedKeysMap = {};
+  return composeLoaders(createDenormalizeLoader(), createNormalizeLoader());
+}
+function createDenormalizeLoader() {
   return createLoader({
-    pull: async (locale, input) => {
-      const denormalized = denormalizeObjectKeys(input || {});
-      const flattened = flatten(denormalized, {
+    pull: async (locale, input2) => {
+      const inputDenormalized = denormalizeObjectKeys(input2 || {});
+      const denormalized = flatten(inputDenormalized, {
         delimiter: "/",
         transformKey(key) {
           return encodeURIComponent(String(key));
         }
       });
-      denormalizedKeysMap = { ...denormalizedKeysMap, ...buildDenormalizedKeysMap(flattened) };
-      const normalized = normalizeObjectKeys(flattened);
+      const keysMap = buildDenormalizedKeysMap(denormalized);
+      return { denormalized, keysMap };
+    },
+    push: async (locale, { denormalized }) => {
+      const normalized = normalizeObjectKeys(denormalized);
+      return normalized;
+    }
+  });
+}
+function createNormalizeLoader() {
+  return createLoader({
+    pull: async (locale, input2) => {
+      const normalized = normalizeObjectKeys(input2.denormalized);
       return normalized;
     },
-    push: async (locale, data) => {
-      const denormalized = mapDenormalizedKeys(data, denormalizedKeysMap);
-      const unflattened = unflatten(denormalized || {}, {
+    push: async (locale, data, originalInput) => {
+      const keysMap = originalInput?.keysMap ?? {};
+      const input2 = mapDenormalizedKeys(data, keysMap);
+      const denormalized = unflatten(input2, {
         delimiter: "/",
         transformKey(key) {
           return decodeURIComponent(String(key));
         }
       });
-      const normalized = normalizeObjectKeys(unflattened);
-      return normalized;
+      return { denormalized, keysMap: keysMap || {} };
     }
   });
 }
@@ -728,7 +933,7 @@ function buildDenormalizedKeysMap(obj) {
 function mapDenormalizedKeys(obj, denormalizedKeysMap) {
   return Object.keys(obj).reduce(
     (acc, key) => {
-      const denormalizedKey = denormalizedKeysMap[key];
+      const denormalizedKey = denormalizedKeysMap[key] ?? key;
       acc[denormalizedKey] = obj[key];
       return acc;
     },
@@ -736,12 +941,12 @@ function mapDenormalizedKeys(obj, denormalizedKeysMap) {
   );
 }
 function denormalizeObjectKeys(obj) {
-  if (_5.isObject(obj) && !_5.isArray(obj)) {
-    return _5.transform(
+  if (_6.isObject(obj) && !_6.isArray(obj)) {
+    return _6.transform(
       obj,
       (result, value, key) => {
         const newKey = !isNaN(Number(key)) ? `${OBJECT_NUMERIC_KEY_PREFIX}${key}` : key;
-        result[newKey] = _5.isObject(value) ? denormalizeObjectKeys(value) : value;
+        result[newKey] = _6.isObject(value) ? denormalizeObjectKeys(value) : value;
       },
       {}
     );
@@ -750,12 +955,12 @@ function denormalizeObjectKeys(obj) {
   }
 }
 function normalizeObjectKeys(obj) {
-  if (_5.isObject(obj) && !_5.isArray(obj)) {
-    return _5.transform(
+  if (_6.isObject(obj) && !_6.isArray(obj)) {
+    return _6.transform(
       obj,
       (result, value, key) => {
         const newKey = `${key}`.replace(OBJECT_NUMERIC_KEY_PREFIX, "");
-        result[newKey] = _5.isObject(value) ? normalizeObjectKeys(value) : value;
+        result[newKey] = _6.isObject(value) ? normalizeObjectKeys(value) : value;
       },
       {}
     );
@@ -765,8 +970,8 @@ function normalizeObjectKeys(obj) {
 }
 
 // src/cli/loaders/text-file.ts
-import fs5 from "fs/promises";
-import path6 from "path";
+import fs6 from "fs/promises";
+import path8 from "path";
 function createTextFileLoader(pathPattern) {
   return createLoader({
     async pull(locale) {
@@ -774,15 +979,15 @@ function createTextFileLoader(pathPattern) {
       const trimmedResult = result.trim();
       return trimmedResult;
     },
-    async push(locale, data, _20, originalLocale) {
+    async push(locale, data, _21, originalLocale) {
       const draftPath = pathPattern.replace("[locale]", locale);
-      const finalPath = path6.resolve(draftPath);
-      const dirPath = path6.dirname(finalPath);
-      await fs5.mkdir(dirPath, { recursive: true });
+      const finalPath = path8.resolve(draftPath);
+      const dirPath = path8.dirname(finalPath);
+      await fs6.mkdir(dirPath, { recursive: true });
       const trimmedPayload = data.trim();
       const trailingNewLine = await getTrailingNewLine(pathPattern, locale, originalLocale);
       let finalPayload = trimmedPayload + trailingNewLine;
-      await fs5.writeFile(finalPath, finalPayload, {
+      await fs6.writeFile(finalPath, finalPayload, {
         encoding: "utf-8",
         flag: "w"
       });
@@ -791,12 +996,12 @@ function createTextFileLoader(pathPattern) {
 }
 async function readFileForLocale(pathPattern, locale) {
   const draftPath = pathPattern.replace("[locale]", locale);
-  const finalPath = path6.resolve(draftPath);
-  const exists = await fs5.access(finalPath).then(() => true).catch(() => false);
+  const finalPath = path8.resolve(draftPath);
+  const exists = await fs6.access(finalPath).then(() => true).catch(() => false);
   if (!exists) {
     return "";
   }
-  return fs5.readFile(finalPath, "utf-8");
+  return fs6.readFile(finalPath, "utf-8");
 }
 async function getTrailingNewLine(pathPattern, locale, originalLocale) {
   let templateData = await readFileForLocale(pathPattern, locale);
@@ -814,8 +1019,8 @@ async function getTrailingNewLine(pathPattern, locale, originalLocale) {
 import YAML from "yaml";
 function createYamlLoader() {
   return createLoader({
-    async pull(locale, input) {
-      return YAML.parse(input) || {};
+    async pull(locale, input2) {
+      return YAML.parse(input2) || {};
     },
     async push(locale, payload) {
       return YAML.stringify(payload, {
@@ -828,8 +1033,8 @@ function createYamlLoader() {
 // src/cli/loaders/root-key.ts
 function createRootKeyLoader(replaceAll = false) {
   return createLoader({
-    async pull(locale, input) {
-      const result = input[locale];
+    async pull(locale, input2) {
+      const result = input2[locale];
       return result;
     },
     async push(locale, data, originalInput) {
@@ -843,15 +1048,15 @@ function createRootKeyLoader(replaceAll = false) {
 }
 
 // src/cli/loaders/flutter.ts
-import _6 from "lodash";
+import _7 from "lodash";
 function createFlutterLoader() {
   return createLoader({
-    async pull(locale, input) {
-      const result = _6.pickBy(input, (value, key) => !key.startsWith("@"));
+    async pull(locale, input2) {
+      const result = _7.pickBy(input2, (value, key) => !key.startsWith("@"));
       return result;
     },
     async push(locale, data, originalInput) {
-      const result = _6.merge({}, originalInput, { "@@locale": locale }, data);
+      const result = _7.merge({}, originalInput, { "@@locale": locale }, data);
       return result;
     }
   });
@@ -861,10 +1066,10 @@ function createFlutterLoader() {
 import { parseStringPromise, Builder } from "xml2js";
 function createAndroidLoader() {
   return createLoader({
-    async pull(locale, input) {
+    async pull(locale, input2) {
       try {
         const result = {};
-        const parsed = !input ? { resources: {} } : await parseStringPromise(input, { explicitArray: true });
+        const parsed = !input2 ? { resources: {} } : await parseStringPromise(input2, { explicitArray: true });
         if (!parsed || !parsed.resources) {
           console.warn("No resources found in the Android resource file");
           return result;
@@ -953,16 +1158,16 @@ function createAndroidLoader() {
 // src/cli/loaders/csv.ts
 import { parse } from "csv-parse/sync";
 import { stringify } from "csv-stringify/sync";
-import _7 from "lodash";
+import _8 from "lodash";
 function createCsvLoader() {
   return createLoader({
     async pull(locale, _input) {
-      const input = parse(_input, {
+      const input2 = parse(_input, {
         columns: true,
         skip_empty_lines: true
       });
       const result = {};
-      _7.forEach(input, (row) => {
+      _8.forEach(input2, (row) => {
         const key = row.id;
         if (key && row[locale] && row[locale].trim() !== "") {
           result[key] = row[locale];
@@ -971,16 +1176,16 @@ function createCsvLoader() {
       return result;
     },
     async push(locale, data, originalInput) {
-      const input = parse(originalInput || "", {
+      const input2 = parse(originalInput || "", {
         columns: true,
         skip_empty_lines: true
       });
-      const columns = input.length > 0 ? Object.keys(input[0]) : ["id", locale];
-      const updatedRows = input.map((row) => ({
+      const columns = input2.length > 0 ? Object.keys(input2[0]) : ["id", locale];
+      const updatedRows = input2.map((row) => ({
         ...row,
         [locale]: data[row.id] || row[locale] || ""
       }));
-      const existingKeys = new Set(input.map((row) => row.id));
+      const existingKeys = new Set(input2.map((row) => row.id));
       Object.entries(data).forEach(([key, value]) => {
         if (!existingKeys.has(key)) {
           const newRow = {
@@ -1015,9 +1220,9 @@ function createHtmlLoader() {
   };
   const UNLOCALIZABLE_TAGS = ["script", "style"];
   return createLoader({
-    async pull(locale, input) {
+    async pull(locale, input2) {
       const result = {};
-      const dom = new JSDOM(input);
+      const dom = new JSDOM(input2);
       const document = dom.window.document;
       const getPath = (node, attribute) => {
         const indices = [];
@@ -1083,9 +1288,9 @@ function createHtmlLoader() {
         const bDepth = b.split("/").length;
         return aDepth - bDepth;
       });
-      paths.forEach((path9) => {
-        const value = data[path9];
-        const [nodePath, attribute] = path9.split("#");
+      paths.forEach((path11) => {
+        const value = data[path11];
+        const [nodePath, attribute] = path11.split("#");
         const [rootTag, ...indices] = nodePath.split("/");
         let parent = rootTag === "head" ? document.head : document.body;
         let current = parent;
@@ -1137,8 +1342,8 @@ var yamlEngine = {
 };
 function createMarkdownLoader() {
   return createLoader({
-    async pull(locale, input) {
-      const { data: frontmatter, content } = matter(input, {
+    async pull(locale, input2) {
+      const { data: frontmatter, content } = matter(input2, {
         engines: {
           yaml: yamlEngine
         }
@@ -1188,7 +1393,7 @@ function createPropertiesLoader() {
       return result;
     },
     async push(locale, payload) {
-      const result = Object.entries(payload).filter(([_20, value]) => value != null).map(([key, value]) => `${key}=${value}`).join("\n");
+      const result = Object.entries(payload).filter(([_21, value]) => value != null).map(([key, value]) => `${key}=${value}`).join("\n");
       return result;
     }
   });
@@ -1207,8 +1412,8 @@ function parsePropertyLine(line) {
 // src/cli/loaders/xcode-strings.ts
 function createXcodeStringsLoader() {
   return createLoader({
-    async pull(locale, input) {
-      const lines = input.split("\n");
+    async pull(locale, input2) {
+      const lines = input2.split("\n");
       const result = {};
       for (const line of lines) {
         const trimmedLine = line.trim();
@@ -1249,9 +1454,9 @@ var emptyData = [
 ].join("\n");
 function createXcodeStringsdictLoader() {
   return createLoader({
-    async pull(locale, input) {
+    async pull(locale, input2) {
       try {
-        const parsed = plist.parse(input || emptyData);
+        const parsed = plist.parse(input2 || emptyData);
         if (typeof parsed !== "object" || parsed === null) {
           throw new CLIError({
             message: "Invalid .stringsdict format",
@@ -1274,12 +1479,12 @@ function createXcodeStringsdictLoader() {
 }
 
 // src/cli/loaders/xcode-xcstrings.ts
-import _8 from "lodash";
+import _9 from "lodash";
 function createXcodeXcstringsLoader() {
   return createLoader({
-    async pull(locale, input) {
+    async pull(locale, input2) {
       const resultData = {};
-      for (const [translationKey, _translationEntity] of Object.entries(input.strings)) {
+      for (const [translationKey, _translationEntity] of Object.entries(input2.strings)) {
         const rootTranslationEntity = _translationEntity;
         const langTranslationEntity = rootTranslationEntity?.localizations?.[locale];
         if (langTranslationEntity) {
@@ -1338,7 +1543,7 @@ function createXcodeXcstringsLoader() {
           };
         }
       }
-      const result = _8.merge({}, originalInput, langDataToMerge);
+      const result = _9.merge({}, originalInput, langDataToMerge);
       return result;
     }
   });
@@ -1380,33 +1585,33 @@ async function loadPrettierConfig() {
 }
 
 // src/cli/loaders/unlocalizable.ts
-import _9 from "lodash";
+import _10 from "lodash";
 import _isUrl from "is-url";
 import { isValid, parseISO } from "date-fns";
 function createUnlocalizableLoader() {
   const rules = {
-    isEmpty: (v) => _9.isEmpty(v),
-    isNumber: (v) => !_9.isNaN(_9.toNumber(v)),
-    isBoolean: (v) => _9.isBoolean(v),
-    isIsoDate: (v) => _9.isString(v) && _isIsoDate(v),
-    isSystemId: (v) => _9.isString(v) && _isSystemId(v),
-    isUrl: (v) => _9.isString(v) && _isUrl(v)
+    isEmpty: (v) => _10.isEmpty(v),
+    isNumber: (v) => !_10.isNaN(_10.toNumber(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)
   };
   return createLoader({
-    async pull(locale, input) {
-      const passthroughKeys = Object.entries(input).filter(([key, value]) => {
+    async pull(locale, input2) {
+      const passthroughKeys = Object.entries(input2).filter(([key, value]) => {
         for (const [ruleName, rule] of Object.entries(rules)) {
           if (rule(value)) {
             return true;
           }
         }
         return false;
-      }).map(([key, _20]) => key);
-      const result = _9.omitBy(input, (_20, key) => passthroughKeys.includes(key));
+      }).map(([key, _21]) => key);
+      const result = _10.omitBy(input2, (_21, key) => passthroughKeys.includes(key));
       return result;
     },
     async push(locale, data, originalInput) {
-      const result = _9.merge({}, originalInput, data);
+      const result = _10.merge({}, originalInput, data);
       return result;
     }
   });
@@ -1419,20 +1624,20 @@ function _isIsoDate(v) {
 }
 
 // src/cli/loaders/po/index.ts
-import _10 from "lodash";
+import _11 from "lodash";
 import gettextParser from "gettext-parser";
 function createPoLoader(params = { multiline: false }) {
   return composeLoaders(createPoDataLoader(params), createPoContentLoader());
 }
 function createPoDataLoader(params) {
   return createLoader({
-    async pull(locale, input) {
-      const parsedPo = gettextParser.po.parse(input);
+    async pull(locale, input2) {
+      const parsedPo = gettextParser.po.parse(input2);
       const result = {};
-      const sections = input.split("\n\n").filter(Boolean);
+      const sections = input2.split("\n\n").filter(Boolean);
       for (const section of sections) {
         const sectionPo = gettextParser.po.parse(section);
-        const contextKey = _10.keys(sectionPo.translations)[0];
+        const contextKey = _11.keys(sectionPo.translations)[0];
         const entries = sectionPo.translations[contextKey];
         Object.entries(entries).forEach(([msgid, entry]) => {
           if (msgid && entry.msgid) {
@@ -1450,12 +1655,12 @@ function createPoDataLoader(params) {
       const sections = originalInput?.split("\n\n").filter(Boolean) || [];
       const result = sections.map((section) => {
         const sectionPo = gettextParser.po.parse(section);
-        const contextKey = _10.keys(sectionPo.translations)[0];
+        const contextKey = _11.keys(sectionPo.translations)[0];
         const entries = sectionPo.translations[contextKey];
         const msgid = Object.keys(entries).find((key) => entries[key].msgid);
         if (!msgid) return section;
         if (data[msgid]) {
-          const updatedPo = _10.merge({}, sectionPo, {
+          const updatedPo = _11.merge({}, sectionPo, {
             translations: {
               [contextKey]: {
                 [msgid]: {
@@ -1474,8 +1679,8 @@ function createPoDataLoader(params) {
 }
 function createPoContentLoader() {
   return createLoader({
-    async pull(locale, input) {
-      const result = _10.chain(input).entries().filter(([, entry]) => !!entry.msgid).map(([, entry]) => [
+    async pull(locale, input2) {
+      const result = _11.chain(input2).entries().filter(([, entry]) => !!entry.msgid).map(([, entry]) => [
         entry.msgid,
         {
           singular: entry.msgstr[0] || entry.msgid,
@@ -1485,7 +1690,7 @@ function createPoContentLoader() {
       return result;
     },
     async push(locale, data, originalInput) {
-      const result = _10.chain(originalInput).entries().map(([, entry]) => [
+      const result = _11.chain(originalInput).entries().map(([, entry]) => [
         entry.msgid,
         {
           ...entry,
@@ -1501,8 +1706,8 @@ function createPoContentLoader() {
 import xliff from "xliff";
 function createXliffLoader() {
   return createLoader({
-    async pull(locale, input) {
-      const js = await xliff.xliff2js(input);
+    async pull(locale, input2) {
+      const js = await xliff.xliff2js(input2);
       return js || {};
     },
     async push(locale, payload) {
@@ -1519,10 +1724,10 @@ function normalizeXMLString(xmlString) {
 }
 function createXmlLoader() {
   return createLoader({
-    async pull(locale, input) {
+    async pull(locale, input2) {
       let result = {};
       try {
-        const parsed = await parseStringPromise2(input, {
+        const parsed = await parseStringPromise2(input2, {
           explicitArray: false,
           mergeAttrs: false,
           normalize: true,
@@ -1557,8 +1762,8 @@ import srtParser from "srt-parser-2";
 function createSrtLoader() {
   const parser = new srtParser();
   return createLoader({
-    async pull(locale, input) {
-      const parsed = parser.fromSrt(input) || [];
+    async pull(locale, input2) {
+      const parsed = parser.fromSrt(input2) || [];
       const result = {};
       parsed.forEach((entry) => {
         const key = `${entry.id}#${entry.startTime}-${entry.endTime}`;
@@ -1586,7 +1791,7 @@ function createSrtLoader() {
 }
 
 // src/cli/loaders/dato/index.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import JSON5 from "json5";
 
 // src/cli/loaders/dato/_base.ts
@@ -1608,34 +1813,34 @@ var datoSettingsSchema = Z2.object({
 });
 
 // src/cli/loaders/dato/filter.ts
-import _11 from "lodash";
+import _12 from "lodash";
 function createDatoFilterLoader() {
   return createLoader({
-    async pull(locale, input) {
+    async pull(locale, input2) {
       const result = {};
-      for (const [modelId, modelInfo] of _11.entries(input)) {
+      for (const [modelId, modelInfo] of _12.entries(input2)) {
         result[modelId] = {};
         for (const record of modelInfo.records) {
-          result[modelId][record.id] = _11.chain(modelInfo.fields).mapKeys((field) => field.api_key).mapValues((field) => _11.get(record, [field.api_key, locale])).value();
+          result[modelId][record.id] = _12.chain(modelInfo.fields).mapKeys((field) => field.api_key).mapValues((field) => _12.get(record, [field.api_key, locale])).value();
         }
       }
       return result;
     },
     async push(locale, data, originalInput, originalLocale) {
-      const result = _11.cloneDeep(originalInput || {});
-      for (const [modelId, modelInfo] of _11.entries(result)) {
+      const result = _12.cloneDeep(originalInput || {});
+      for (const [modelId, modelInfo] of _12.entries(result)) {
         for (const record of modelInfo.records) {
-          for (const [fieldId, fieldValue] of _11.entries(record)) {
+          for (const [fieldId, fieldValue] of _12.entries(record)) {
             const fieldInfo = modelInfo.fields.find((field) => field.api_key === fieldId);
             if (fieldInfo) {
-              const sourceFieldValue = _11.get(fieldValue, [originalLocale]);
-              const targetFieldValue = _11.get(data, [modelId, record.id, fieldId]);
+              const sourceFieldValue = _12.get(fieldValue, [originalLocale]);
+              const targetFieldValue = _12.get(data, [modelId, record.id, fieldId]);
               if (targetFieldValue) {
-                _11.set(record, [fieldId, locale], targetFieldValue);
+                _12.set(record, [fieldId, locale], targetFieldValue);
               } else {
-                _11.set(record, [fieldId, locale], sourceFieldValue);
+                _12.set(record, [fieldId, locale], sourceFieldValue);
               }
-              _11.chain(fieldValue).keys().reject((loc) => loc === locale || loc === originalLocale).filter((loc) => _11.isEmpty(_11.get(fieldValue, [loc]))).forEach((loc) => _11.set(record, [fieldId, loc], sourceFieldValue)).value();
+              _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)).value();
             }
           }
         }
@@ -1646,10 +1851,10 @@ function createDatoFilterLoader() {
 }
 
 // src/cli/loaders/dato/api.ts
-import _13 from "lodash";
+import _14 from "lodash";
 
 // src/cli/loaders/dato/_utils.ts
-import _12 from "lodash";
+import _13 from "lodash";
 import { buildClient } from "@datocms/cma-client-node";
 function createDatoClient(params) {
   if (!params.apiKey) {
@@ -1824,7 +2029,7 @@ function createDatoApiLoader(config, onConfigUpdate) {
       const result = {
         models: {}
       };
-      const updatedConfig = _13.cloneDeep(config);
+      const updatedConfig = _14.cloneDeep(config);
       console.log(`Initializing DatoCMS loader...`);
       const project = await dato.findProject();
       const modelChoices = await getModelChoices(dato, config);
@@ -1842,7 +2047,7 @@ function createDatoApiLoader(config, onConfigUpdate) {
           delete updatedConfig.models[modelId];
         }
       }
-      for (const modelId of _13.keys(updatedConfig.models)) {
+      for (const modelId of _14.keys(updatedConfig.models)) {
         const { modelName, fields } = await getModelFields(dato, modelId);
         if (fields.length > 0) {
           result.models[modelId] = { fields: [], records: [] };
@@ -1853,7 +2058,7 @@ function createDatoApiLoader(config, onConfigUpdate) {
             const isLocalized = await updateFieldLocalization(dato, fieldInfo, selectedFields.includes(fieldInfo.id));
             if (isLocalized) {
               result.models[modelId].fields.push(fieldInfo);
-              updatedConfig.models[modelId].fields = _13.uniq([
+              updatedConfig.models[modelId].fields = _14.uniq([
                 ...updatedConfig.models[modelId].fields || [],
                 fieldInfo.api_key
               ]);
@@ -1870,9 +2075,9 @@ function createDatoApiLoader(config, onConfigUpdate) {
       onConfigUpdate(updatedConfig);
       return result;
     },
-    async pull(locale, input, initCtx) {
+    async pull(locale, input2, initCtx) {
       const result = {};
-      for (const modelId of _13.keys(initCtx?.models || {})) {
+      for (const modelId of _14.keys(initCtx?.models || {})) {
         let records = initCtx?.models[modelId].records || [];
         const recordIds = records.map((record) => record.id);
         records = await dato.findRecords(recordIds);
@@ -1887,7 +2092,7 @@ function createDatoApiLoader(config, onConfigUpdate) {
       return result;
     },
     async push(locale, data, originalInput) {
-      for (const modelId of _13.keys(data)) {
+      for (const modelId of _14.keys(data)) {
         for (let i = 0; i < data[modelId].records.length; i++) {
           const record = data[modelId].records[i];
           console.log(`Updating record ${i + 1}/${data[modelId].records.length} for model ${modelId}...`);
@@ -1901,7 +2106,7 @@ async function getModelFields(dato, modelId) {
   const modelInfo = await dato.findModel(modelId);
   return {
     modelName: modelInfo.name,
-    fields: _13.filter(modelInfo.fields, (field) => field.type === "field")
+    fields: _14.filter(modelInfo.fields, (field) => field.type === "field")
   };
 }
 async function getFieldDetails(dato, fields) {
@@ -1979,17 +2184,17 @@ async function promptModelSelection(choices) {
 }
 
 // src/cli/loaders/dato/extract.ts
-import _14 from "lodash";
+import _15 from "lodash";
 function createDatoExtractLoader() {
   return createLoader({
-    async pull(locale, input) {
+    async pull(locale, input2) {
       const result = {};
-      for (const [modelId, modelInfo] of _14.entries(input)) {
-        for (const [recordId, record] of _14.entries(modelInfo)) {
-          for (const [fieldName, fieldValue] of _14.entries(record)) {
+      for (const [modelId, modelInfo] of _15.entries(input2)) {
+        for (const [recordId, record] of _15.entries(modelInfo)) {
+          for (const [fieldName, fieldValue] of _15.entries(record)) {
             const parsedValue = createParsedDatoValue(fieldValue);
             if (parsedValue) {
-              _14.set(result, [modelId, `_${recordId}`, fieldName], parsedValue);
+              _15.set(result, [modelId, `_${recordId}`, fieldName], parsedValue);
             }
           }
         }
@@ -1997,14 +2202,14 @@ function createDatoExtractLoader() {
       return result;
     },
     async push(locale, data, originalInput) {
-      const result = _14.cloneDeep(originalInput || {});
-      for (const [modelId, modelInfo] of _14.entries(data)) {
-        for (const [virtualRecordId, record] of _14.entries(modelInfo)) {
-          for (const [fieldName, fieldValue] of _14.entries(record)) {
+      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 [, recordId] = virtualRecordId.split("_");
-            const originalFieldValue = _14.get(originalInput, [modelId, recordId, fieldName]);
+            const originalFieldValue = _15.get(originalInput, [modelId, recordId, fieldName]);
             const rawValue = createRawDatoValue(fieldValue, originalFieldValue, true);
-            _14.set(result, [modelId, recordId, fieldName], rawValue || originalFieldValue);
+            _15.set(result, [modelId, recordId, fieldName], rawValue || originalFieldValue);
           }
         }
       }
@@ -2013,25 +2218,25 @@ function createDatoExtractLoader() {
   });
 }
 function detectDatoFieldType(rawDatoValue) {
-  if (_14.has(rawDatoValue, "document") && _14.get(rawDatoValue, "schema") === "dast") {
+  if (_15.has(rawDatoValue, "document") && _15.get(rawDatoValue, "schema") === "dast") {
     return "structured_text";
-  } else if (_14.has(rawDatoValue, "no_index") || _14.has(rawDatoValue, "twitter_card")) {
+  } else if (_15.has(rawDatoValue, "no_index") || _15.has(rawDatoValue, "twitter_card")) {
     return "seo";
-  } else if (_14.get(rawDatoValue, "type") === "item") {
+  } else if (_15.get(rawDatoValue, "type") === "item") {
     return "single_block";
-  } else if (_14.isArray(rawDatoValue) && _14.every(rawDatoValue, (item) => _14.get(item, "type") === "item")) {
+  } else if (_15.isArray(rawDatoValue) && _15.every(rawDatoValue, (item) => _15.get(item, "type") === "item")) {
     return "rich_text";
   } else if (_isFile(rawDatoValue)) {
     return "file";
-  } else if (_14.isArray(rawDatoValue) && _14.every(rawDatoValue, (item) => _isFile(item))) {
+  } else if (_15.isArray(rawDatoValue) && _15.every(rawDatoValue, (item) => _isFile(item))) {
     return "gallery";
   } else if (_isJson(rawDatoValue)) {
     return "json";
-  } else if (_14.isString(rawDatoValue)) {
+  } else if (_15.isString(rawDatoValue)) {
     return "string";
   } else if (_isVideo(rawDatoValue)) {
     return "video";
-  } else if (_14.isArray(rawDatoValue) && _14.every(rawDatoValue, (item) => _14.isString(item))) {
+  } else if (_15.isArray(rawDatoValue) && _15.every(rawDatoValue, (item) => _15.isString(item))) {
     return "ref_list";
   } else {
     return null;
@@ -2089,62 +2294,62 @@ function createRawDatoValue(parsedDatoValue, originalRawDatoValue, isClean = fal
 }
 function serializeStructuredText(rawStructuredText) {
   return serializeStructuredTextNode(rawStructuredText);
-  function serializeStructuredTextNode(node, path9 = [], acc = {}) {
+  function serializeStructuredTextNode(node, path11 = [], acc = {}) {
     if ("document" in node) {
-      return serializeStructuredTextNode(node.document, [...path9, "document"], acc);
+      return serializeStructuredTextNode(node.document, [...path11, "document"], acc);
     }
-    if (!_14.isNil(node.value)) {
-      acc[[...path9, "value"].join(".")] = node.value;
-    } else if (_14.get(node, "type") === "block") {
-      acc[[...path9, "item"].join(".")] = serializeBlock(node.item);
+    if (!_15.isNil(node.value)) {
+      acc[[...path11, "value"].join(".")] = node.value;
+    } else if (_15.get(node, "type") === "block") {
+      acc[[...path11, "item"].join(".")] = serializeBlock(node.item);
     }
     if (node.children) {
       for (let i = 0; i < node.children.length; i++) {
-        serializeStructuredTextNode(node.children[i], [...path9, i.toString()], acc);
+        serializeStructuredTextNode(node.children[i], [...path11, i.toString()], acc);
       }
     }
     return acc;
   }
 }
 function serializeSeo(rawSeo) {
-  return _14.chain(rawSeo).pick(["title", "description"]).value();
+  return _15.chain(rawSeo).pick(["title", "description"]).value();
 }
 function serializeBlock(rawBlock) {
-  if (_14.get(rawBlock, "type") === "item" && _14.has(rawBlock, "id")) {
+  if (_15.get(rawBlock, "type") === "item" && _15.has(rawBlock, "id")) {
     return serializeBlock(rawBlock.attributes);
   }
   const result = {};
-  for (const [attributeName, attributeValue] of _14.entries(rawBlock)) {
+  for (const [attributeName, attributeValue] of _15.entries(rawBlock)) {
     result[attributeName] = createParsedDatoValue(attributeValue);
   }
   return result;
 }
 function serializeBlockList(rawBlockList) {
-  return _14.chain(rawBlockList).map((block) => serializeBlock(block)).value();
+  return _15.chain(rawBlockList).map((block) => serializeBlock(block)).value();
 }
 function serializeVideo(rawVideo) {
-  return _14.chain(rawVideo).pick(["title"]).value();
+  return _15.chain(rawVideo).pick(["title"]).value();
 }
 function serializeFile(rawFile) {
-  return _14.chain(rawFile).pick(["alt", "title"]).value();
+  return _15.chain(rawFile).pick(["alt", "title"]).value();
 }
 function serializeGallery(rawGallery) {
-  return _14.chain(rawGallery).map((item) => serializeFile(item)).value();
+  return _15.chain(rawGallery).map((item) => serializeFile(item)).value();
 }
 function deserializeFile(parsedFile, originalRawFile) {
-  return _14.chain(parsedFile).defaults(originalRawFile).value();
+  return _15.chain(parsedFile).defaults(originalRawFile).value();
 }
 function deserializeGallery(parsedGallery, originalRawGallery) {
-  return _14.chain(parsedGallery).map((item, i) => deserializeFile(item, originalRawGallery[i])).value();
+  return _15.chain(parsedGallery).map((item, i) => deserializeFile(item, originalRawGallery[i])).value();
 }
 function deserializeVideo(parsedVideo, originalRawVideo) {
-  return _14.chain(parsedVideo).defaults(originalRawVideo).value();
+  return _15.chain(parsedVideo).defaults(originalRawVideo).value();
 }
 function deserializeBlock(payload, rawNode, isClean = false) {
-  const result = _14.cloneDeep(rawNode);
-  for (const [attributeName, attributeValue] of _14.entries(rawNode.attributes)) {
+  const result = _15.cloneDeep(rawNode);
+  for (const [attributeName, attributeValue] of _15.entries(rawNode.attributes)) {
     const rawValue = createRawDatoValue(payload[attributeName], attributeValue, isClean);
-    _14.set(result, ["attributes", attributeName], rawValue);
+    _15.set(result, ["attributes", attributeName], rawValue);
   }
   if (isClean) {
     delete result["id"];
@@ -2152,45 +2357,45 @@ function deserializeBlock(payload, rawNode, isClean = false) {
   return result;
 }
 function deserializeSeo(parsedSeo, originalRawSeo) {
-  return _14.chain(parsedSeo).pick(["title", "description"]).defaults(originalRawSeo).value();
+  return _15.chain(parsedSeo).pick(["title", "description"]).defaults(originalRawSeo).value();
 }
 function deserializeBlockList(parsedBlockList, originalRawBlockList, isClean = false) {
-  return _14.chain(parsedBlockList).map((block, i) => deserializeBlock(block, originalRawBlockList[i], isClean)).value();
+  return _15.chain(parsedBlockList).map((block, i) => deserializeBlock(block, originalRawBlockList[i], isClean)).value();
 }
 function deserializeStructuredText(parsedStructuredText, originalRawStructuredText) {
-  const result = _14.cloneDeep(originalRawStructuredText);
-  for (const [path9, value] of _14.entries(parsedStructuredText)) {
-    const realPath = _14.chain(path9.split(".")).flatMap((s) => !_14.isNaN(_14.toNumber(s)) ? ["children", s] : s).value();
-    const deserializedValue = createRawDatoValue(value, _14.get(originalRawStructuredText, realPath), true);
-    _14.set(result, realPath, deserializedValue);
+  const result = _15.cloneDeep(originalRawStructuredText);
+  for (const [path11, value] of _15.entries(parsedStructuredText)) {
+    const realPath = _15.chain(path11.split(".")).flatMap((s) => !_15.isNaN(_15.toNumber(s)) ? ["children", s] : s).value();
+    const deserializedValue = createRawDatoValue(value, _15.get(originalRawStructuredText, realPath), true);
+    _15.set(result, realPath, deserializedValue);
   }
   return result;
 }
 function _isJson(rawDatoValue) {
   try {
-    return _14.isString(rawDatoValue) && rawDatoValue.startsWith("{") && rawDatoValue.endsWith("}") && !!JSON.parse(rawDatoValue);
+    return _15.isString(rawDatoValue) && rawDatoValue.startsWith("{") && rawDatoValue.endsWith("}") && !!JSON.parse(rawDatoValue);
   } catch (e) {
     return false;
   }
 }
 function _isFile(rawDatoValue) {
-  return _14.isObject(rawDatoValue) && ["alt", "title", "custom_data", "focal_point", "upload_id"].every((key) => _14.has(rawDatoValue, key));
+  return _15.isObject(rawDatoValue) && ["alt", "title", "custom_data", "focal_point", "upload_id"].every((key) => _15.has(rawDatoValue, key));
 }
 function _isVideo(rawDatoValue) {
-  return _14.isObject(rawDatoValue) && ["url", "title", "width", "height", "provider", "provider_uid", "thumbnail_url"].every(
-    (key) => _14.has(rawDatoValue, key)
+  return _15.isObject(rawDatoValue) && ["url", "title", "width", "height", "provider", "provider_uid", "thumbnail_url"].every(
+    (key) => _15.has(rawDatoValue, key)
   );
 }
 
 // src/cli/loaders/dato/index.ts
 function createDatoLoader(configFilePath) {
   try {
-    const configContent = fs6.readFileSync(configFilePath, "utf-8");
+    const configContent = fs7.readFileSync(configFilePath, "utf-8");
     const datoConfig = datoConfigSchema.parse(JSON5.parse(configContent));
     return composeLoaders(
       createDatoApiLoader(
         datoConfig,
-        (updatedConfig) => fs6.writeFileSync(configFilePath, JSON5.stringify(updatedConfig, null, 2))
+        (updatedConfig) => fs7.writeFileSync(configFilePath, JSON5.stringify(updatedConfig, null, 2))
       ),
       createDatoFilterLoader(),
       createDatoExtractLoader()
@@ -2204,8 +2409,8 @@ function createDatoLoader(configFilePath) {
 import webvtt from "node-webvtt";
 function createVttLoader() {
   return createLoader({
-    async pull(locale, input) {
-      const vtt = webvtt.parse(input)?.cues;
+    async pull(locale, input2) {
+      const vtt = webvtt.parse(input2)?.cues;
       if (Object.keys(vtt).length === 0) {
         return {};
       } else {
@@ -2228,27 +2433,27 @@ function createVttLoader() {
           text
         };
       });
-      const input = {
+      const input2 = {
         valid: true,
         strict: true,
         cues: output
       };
-      return webvtt.compile(input);
+      return webvtt.compile(input2);
     }
   });
 }
 
 // src/cli/loaders/variable/index.ts
-import _15 from "lodash";
+import _16 from "lodash";
 function createVariableLoader(params) {
   return composeLoaders(variableExtractLoader(params), variableContentLoader());
 }
 function variableExtractLoader(params) {
   const specifierPattern = getFormatSpecifierPattern(params.type);
   return createLoader({
-    pull: async (locale, input) => {
+    pull: async (locale, input2) => {
       const result = {};
-      for (const [key, value] of Object.entries(input)) {
+      for (const [key, value] of Object.entries(input2)) {
         const matches = value.match(specifierPattern) || [];
         result[key] = result[key] || {
           value,
@@ -2281,12 +2486,12 @@ function variableExtractLoader(params) {
 }
 function variableContentLoader() {
   return createLoader({
-    pull: async (locale, input) => {
-      const result = _15.mapValues(input, (payload) => payload.value);
+    pull: async (locale, input2) => {
+      const result = _16.mapValues(input2, (payload) => payload.value);
       return result;
     },
     push: async (locale, data, originalInput) => {
-      const result = _15.cloneDeep(originalInput || {});
+      const result = _16.cloneDeep(originalInput || {});
       for (const [key, originalValueObj] of Object.entries(result)) {
         result[key] = {
           ...originalValueObj,
@@ -2309,20 +2514,20 @@ function getFormatSpecifierPattern(type) {
 }
 
 // src/cli/loaders/sync.ts
-import _16 from "lodash";
+import _17 from "lodash";
 function createSyncLoader() {
   return createLoader({
-    async pull(locale, input, originalInput) {
+    async pull(locale, input2, originalInput) {
       if (!originalInput) {
-        return input;
+        return input2;
       }
-      return _16.chain(originalInput).mapValues((value, key) => input[key]).value();
+      return _17.chain(originalInput).mapValues((value, key) => input2[key]).value();
     },
     async push(locale, data, originalInput) {
       if (!originalInput) {
         return data;
       }
-      return _16.chain(originalInput || {}).mapValues((value, key) => data[key]).value();
+      return _17.chain(originalInput || {}).mapValues((value, key) => data[key]).value();
     }
   });
 }
@@ -2544,57 +2749,57 @@ function createBucketLoader(bucketType, bucketPathPattern) {
 }
 
 // src/cli/utils/lockfile.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path9 from "path";
 import Z3 from "zod";
 import YAML3 from "yaml";
 import { MD5 } from "object-hash";
-import _17 from "lodash";
+import _18 from "lodash";
 function createLockfileHelper() {
   return {
     isLockfileExists: () => {
       const lockfilePath = _getLockfilePath();
-      return fs7.existsSync(lockfilePath);
+      return fs8.existsSync(lockfilePath);
     },
     registerSourceData: (pathPattern, sourceData) => {
       const lockfile = _loadLockfile();
       const sectionKey = MD5(pathPattern);
-      const sectionChecksums = _17.mapValues(sourceData, (value) => MD5(value));
+      const sectionChecksums = _18.mapValues(sourceData, (value) => MD5(value));
       lockfile.checksums[sectionKey] = sectionChecksums;
       _saveLockfile(lockfile);
     },
     registerPartialSourceData: (pathPattern, partialSourceData) => {
       const lockfile = _loadLockfile();
       const sectionKey = MD5(pathPattern);
-      const sectionChecksums = _17.mapValues(partialSourceData, (value) => MD5(value));
-      lockfile.checksums[sectionKey] = _17.merge({}, lockfile.checksums[sectionKey] ?? {}, sectionChecksums);
+      const sectionChecksums = _18.mapValues(partialSourceData, (value) => MD5(value));
+      lockfile.checksums[sectionKey] = _18.merge({}, lockfile.checksums[sectionKey] ?? {}, sectionChecksums);
       _saveLockfile(lockfile);
     },
     extractUpdatedData: (pathPattern, sourceData) => {
       const lockfile = _loadLockfile();
       const sectionKey = MD5(pathPattern);
-      const currentChecksums = _17.mapValues(sourceData, (value) => MD5(value));
+      const currentChecksums = _18.mapValues(sourceData, (value) => MD5(value));
       const savedChecksums = lockfile.checksums[sectionKey] || {};
-      const updatedData = _17.pickBy(sourceData, (value, key) => savedChecksums[key] !== currentChecksums[key]);
+      const updatedData = _18.pickBy(sourceData, (value, key) => savedChecksums[key] !== currentChecksums[key]);
       return updatedData;
     }
   };
   function _loadLockfile() {
     const lockfilePath = _getLockfilePath();
-    if (!fs7.existsSync(lockfilePath)) {
+    if (!fs8.existsSync(lockfilePath)) {
       return LockfileSchema.parse({});
     }
-    const content = fs7.readFileSync(lockfilePath, "utf-8");
+    const content = fs8.readFileSync(lockfilePath, "utf-8");
     const result = LockfileSchema.parse(YAML3.parse(content));
     return result;
   }
   function _saveLockfile(lockfile) {
     const lockfilePath = _getLockfilePath();
     const content = YAML3.stringify(lockfile);
-    fs7.writeFileSync(lockfilePath, content);
+    fs8.writeFileSync(lockfilePath, content);
   }
   function _getLockfilePath() {
-    return path7.join(process.cwd(), "i18n.lock");
+    return path9.join(process.cwd(), "i18n.lock");
   }
 }
 var LockfileSchema = Z3.object({
@@ -2619,8 +2824,8 @@ import inquirer2 from "inquirer";
 import externalEditor from "external-editor";
 
 // src/cli/utils/cache.ts
-import path8 from "path";
-import fs8 from "fs";
+import path10 from "path";
+import fs9 from "fs";
 var cacheChunk = (targetLocale, sourceChunk, processedChunk) => {
   const rows = Object.entries(sourceChunk).map(([key, source]) => ({
     targetLocale,
@@ -2650,26 +2855,26 @@ function getNormalizedCache() {
 function deleteCache() {
   const cacheFilePath = _getCacheFilePath();
   try {
-    fs8.unlinkSync(cacheFilePath);
+    fs9.unlinkSync(cacheFilePath);
   } catch (e) {
   }
 }
 function _loadCache() {
   const cacheFilePath = _getCacheFilePath();
-  if (!fs8.existsSync(cacheFilePath)) {
+  if (!fs9.existsSync(cacheFilePath)) {
     return [];
   }
-  const content = fs8.readFileSync(cacheFilePath, "utf-8");
+  const content = fs9.readFileSync(cacheFilePath, "utf-8");
   const result = _parseJSONLines(content);
   return result;
 }
 function _appendToCache(rows) {
   const cacheFilePath = _getCacheFilePath();
   const lines = _buildJSONLines(rows);
-  fs8.appendFileSync(cacheFilePath, lines);
+  fs9.appendFileSync(cacheFilePath, lines);
 }
 function _getCacheFilePath() {
-  return path8.join(process.cwd(), "i18n.cache");
+  return path10.join(process.cwd(), "i18n.cache");
 }
 function _buildJSONLines(rows) {
   return rows.map((row) => JSON.stringify(row)).join("\n") + "\n";
@@ -2823,7 +3028,7 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
                 targetData
               });
               if (flags.key) {
-                processableData = _18.pickBy(processableData, (_20, key) => key === flags.key);
+                processableData = _19.pickBy(processableData, (_21, key) => key === flags.key);
               }
               if (flags.verbose) {
                 bucketOra.info(JSON.stringify(processableData, null, 2));
@@ -2859,7 +3064,7 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
               if (flags.verbose) {
                 bucketOra.info(JSON.stringify(processedTargetData, null, 2));
               }
-              let finalTargetData = _18.merge({}, sourceData, targetData, processedTargetData);
+              let finalTargetData = _19.merge({}, sourceData, targetData, processedTargetData);
               if (flags.interactive) {
                 bucketOra.stop();
                 const reviewedData = await reviewChanges({
@@ -2873,7 +3078,7 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
                 finalTargetData = reviewedData;
                 bucketOra.start(`Applying changes to ${bucketConfig} (${targetLocale})`);
               }
-              const finalDiffSize = _18.chain(finalTargetData).omitBy((value, key) => value === targetData[key]).size().value();
+              const finalDiffSize = _19.chain(finalTargetData).omitBy((value, key) => value === targetData[key]).size().value();
               if (finalDiffSize > 0 || flags.force) {
                 await bucketLoader.push(targetLocale, finalTargetData);
                 bucketOra.succeed(`[${sourceLocale} -> ${targetLocale}] Localization completed`);
@@ -2918,9 +3123,9 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
   }
 });
 function calculateDataDelta(args) {
-  const newKeys = _18.difference(Object.keys(args.sourceData), Object.keys(args.targetData));
+  const newKeys = _19.difference(Object.keys(args.sourceData), Object.keys(args.targetData));
   const updatedKeys = Object.keys(args.updatedSourceData);
-  const result = _18.chain(args.sourceData).pickBy((value, key) => newKeys.includes(key) || updatedKeys.includes(key)).value();
+  const result = _19.chain(args.sourceData).pickBy((value, key) => newKeys.includes(key) || updatedKeys.includes(key)).value();
   return result;
 }
 async function retryWithExponentialBackoff(operation, maxAttempts, baseDelay = 1e3) {
@@ -3061,7 +3266,7 @@ Reviewing changes for ${chalk.blue(args.pathPattern)} (${chalk.yellow(args.targe
     return args.currentData;
   }
   const customData = { ...args.currentData };
-  const changes = _18.reduce(
+  const changes = _19.reduce(
     args.proposedData,
     (result, value, key) => {
       if (args.currentData[key] !== value) {
@@ -3142,7 +3347,7 @@ var flagsSchema = Z5.object({
 // src/cli/cmd/cleanup.ts
 import { resolveOverridenLocale as resolveOverridenLocale5 } from "@lingo.dev/_spec";
 import { Command as Command8 } from "interactive-commander";
-import _19 from "lodash";
+import _20 from "lodash";
 import Ora7 from "ora";
 var cleanup_default = new Command8().command("cleanup").description("Remove keys from target files that do not exist in the source file").helpOption("-h, --help", "Show help").option("--locale <locale>", "Specific locale to cleanup").option("--bucket <bucket>", "Specific bucket to cleanup").option("--dry-run", "Show what would be removed without making changes").option("--verbose", "Show verbose output").action(async function(options) {
   const ora = Ora7();
@@ -3172,7 +3377,7 @@ var cleanup_default = new Command8().command("cleanup").description("Remove keys
           try {
             const targetData = await bucketLoader.pull(targetLocale);
             const targetKeys = Object.keys(targetData);
-            const keysToRemove = _19.difference(targetKeys, sourceKeys);
+            const keysToRemove = _20.difference(targetKeys, sourceKeys);
             if (keysToRemove.length === 0) {
               bucketOra.succeed(`[${targetLocale}] No keys to remove`);
               continue;
@@ -3181,7 +3386,7 @@ var cleanup_default = new Command8().command("cleanup").description("Remove keys
               bucketOra.info(`[${targetLocale}] Keys to remove: ${JSON.stringify(keysToRemove, null, 2)}`);
             }
             if (!options.dryRun) {
-              const cleanedData = _19.pick(targetData, sourceKeys);
+              const cleanedData = _20.pick(targetData, sourceKeys);
               await bucketLoader.push(targetLocale, cleanedData);
               bucketOra.succeed(`[${targetLocale}] Removed ${keysToRemove.length} keys`);
             } else {
@@ -3233,7 +3438,7 @@ function displaySummary(results) {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.74.14",
+  version: "0.74.16",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {