@wads.dev/i18n-editor 0.0.1-alpha.0

package/dist/public/editor.js

@@ -0,0 +1,1461 @@
+// node_modules/@wads.dev/i18n-ts/dist/bundle/index.js
+var BUNDLE_FORMAT = "wads-i18n-bundle";
+var BUNDLE_VERSION = 2;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function assertBundle(value) {
+  if (!isRecord(value))
+    throw new Error("The bundle must be a JSON object.");
+  if (value.format !== BUNDLE_FORMAT) {
+    throw new Error(`Invalid bundle format. Expected: ${BUNDLE_FORMAT}.`);
+  }
+  if (value.version !== BUNDLE_VERSION) {
+    throw new Error(`Unsupported bundle version: ${String(value.version)}.`);
+  }
+  if (!Number.isSafeInteger(value.updatedAt) || Number(value.updatedAt) < 0) {
+    throw new Error("The bundle must contain a valid numeric updatedAt value.");
+  }
+  if (!isRecord(value.languages)) {
+    throw new Error("The bundle must contain a languages object.");
+  }
+  for (const [key, language] of Object.entries(value.languages)) {
+    if (!isRecord(language) || !isRecord(language.translations)) {
+      throw new Error(`Language "${key}" must contain a translations object.`);
+    }
+  }
+  return value;
+}
+function withUpdatedAt(bundle, updatedAt = Date.now()) {
+  const validBundle = assertBundle(bundle);
+  return {
+    ...validBundle,
+    updatedAt: Math.max(updatedAt, validBundle.updatedAt + 1)
+  };
+}
+
+// src/web/bundle-storage.ts
+var DATABASE_NAME = "wads-i18n-editor";
+var DATABASE_VERSION = 1;
+var STORE_NAME = "bundles";
+var CURRENT_BUNDLE_KEY = "current";
+var PROJECT_CONFIG_KEY = "project-config";
+var LEGACY_VISUALIZATION_CONFIG_KEY = "visualization-config";
+function requestResult(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function transactionComplete(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onerror = () => reject(transaction.error);
+    transaction.onabort = () => reject(transaction.error);
+  });
+}
+function openDatabase() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DATABASE_NAME, DATABASE_VERSION);
+    request.onupgradeneeded = () => {
+      if (!request.result.objectStoreNames.contains(STORE_NAME)) {
+        request.result.createObjectStore(STORE_NAME, { keyPath: "id" });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+async function loadStoredBundle() {
+  const database = await openDatabase();
+  try {
+    const transaction = database.transaction(STORE_NAME, "readonly");
+    const record = await requestResult(
+      transaction.objectStore(STORE_NAME).get(CURRENT_BUNDLE_KEY)
+    );
+    await transactionComplete(transaction);
+    return record ? assertBundle(record.bundle) : null;
+  } finally {
+    database.close();
+  }
+}
+async function saveStoredBundle(bundle) {
+  const database = await openDatabase();
+  try {
+    const transaction = database.transaction(STORE_NAME, "readwrite");
+    await requestResult(transaction.objectStore(STORE_NAME).put({ id: CURRENT_BUNDLE_KEY, bundle }));
+    await transactionComplete(transaction);
+  } finally {
+    database.close();
+  }
+}
+async function loadStoredProjectConfig() {
+  const database = await openDatabase();
+  try {
+    const transaction = database.transaction(STORE_NAME, "readonly");
+    const store = transaction.objectStore(STORE_NAME);
+    const record = await requestResult(store.get(PROJECT_CONFIG_KEY));
+    const legacyRecord = record ? void 0 : await requestResult(store.get(LEGACY_VISUALIZATION_CONFIG_KEY));
+    await transactionComplete(transaction);
+    return record?.config ?? legacyRecord?.config ?? null;
+  } finally {
+    database.close();
+  }
+}
+async function saveStoredProjectConfig(config) {
+  const database = await openDatabase();
+  try {
+    const transaction = database.transaction(STORE_NAME, "readwrite");
+    await requestResult(transaction.objectStore(STORE_NAME).put({ id: PROJECT_CONFIG_KEY, config }));
+    await transactionComplete(transaction);
+  } finally {
+    database.close();
+  }
+}
+
+// src/core/keyPath.ts
+function isContainer(value) {
+  return value !== null && typeof value === "object";
+}
+function asRecord(value) {
+  return value;
+}
+function parseKeyPath(key, parameterName) {
+  if (key.trim() === "") {
+    throw new Error(`${parameterName} must be a non-empty key.`);
+  }
+  const segments = [];
+  const matcher = /(?:^|\.)([^.[\]]+)|\[(\d+)\]/g;
+  let match;
+  let matchedCharacters = "";
+  while ((match = matcher.exec(key)) !== null) {
+    segments.push(match[2] === void 0 ? match[1] : Number(match[2]));
+    matchedCharacters += match[0];
+  }
+  if (segments.length === 0 || matchedCharacters !== key) {
+    throw new Error(`${parameterName} contains an invalid path: ${key}`);
+  }
+  return segments;
+}
+function getKeyPathValue(root, segments) {
+  let current = root;
+  for (const segment of segments) {
+    if (!isContainer(current) || !Object.hasOwn(current, segment)) return { found: false };
+    current = asRecord(current)[segment];
+  }
+  return { found: true, value: current };
+}
+function deleteKeyPathValue(root, segments) {
+  const parentPath = segments.slice(0, -1);
+  const property = segments.at(-1);
+  let parent = root;
+  for (const segment of parentPath) {
+    const nested = asRecord(parent)[segment];
+    if (!isContainer(nested)) throw new Error(`The key path is invalid at ${String(segment)}.`);
+    parent = nested;
+  }
+  delete asRecord(parent)[property];
+}
+function setKeyPathValue(root, segments, value) {
+  const property = segments.at(-1);
+  let current = root;
+  segments.slice(0, -1).forEach((segment, index) => {
+    if (!Object.hasOwn(current, segment)) {
+      asRecord(current)[segment] = typeof segments[index + 1] === "number" ? [] : {};
+    }
+    const nested = asRecord(current)[segment];
+    if (!isContainer(nested)) {
+      throw new Error(`The destination key cannot be created inside ${String(segment)}.`);
+    }
+    current = nested;
+  });
+  asRecord(current)[property] = value;
+}
+
+// src/core/moveKey.ts
+function cloneBundle(bundle) {
+  return structuredClone(bundle);
+}
+function moveKey(bundle, { sourceKey, targetKey }) {
+  const validBundle = assertBundle(bundle);
+  const sourceSegments = parseKeyPath(sourceKey, "sourceKey");
+  const targetSegments = parseKeyPath(targetKey, "targetKey");
+  if (sourceKey === targetKey) return cloneBundle(validBundle);
+  if (targetKey.startsWith(`${sourceKey}.`) || targetKey.startsWith(`${sourceKey}[`)) {
+    throw new Error("The destination key cannot be nested inside the source key.");
+  }
+  const valuesByLanguage = Object.entries(validBundle.languages).map(([languageKey, language]) => {
+    const source = getKeyPathValue(language.translations, sourceSegments);
+    if (!source.found) {
+      throw new Error(`The source key does not exist in language "${languageKey}".`);
+    }
+    if (getKeyPathValue(language.translations, targetSegments).found) {
+      throw new Error(`The destination key already exists in language "${languageKey}".`);
+    }
+    return [languageKey, source.value];
+  });
+  const nextBundle = cloneBundle(validBundle);
+  valuesByLanguage.forEach(([languageKey, value]) => {
+    const translations = nextBundle.languages[languageKey].translations;
+    deleteKeyPathValue(translations, sourceSegments);
+    setKeyPathValue(translations, targetSegments, value);
+  });
+  return nextBundle;
+}
+
+// node_modules/@wads.dev/i18n-ts/dist/config/index.js
+var PROJECT_CONFIG_FORMAT = "wads-i18n-project-config";
+var PROJECT_CONFIG_VERSION = 1;
+function getDefaultLevelImport(levelIndex) {
+  if (levelIndex === 0)
+    return { path: "@/shared" };
+  if (levelIndex === 1)
+    return { path: "@/modules/{value}" };
+  if (levelIndex === 2)
+    return { path: "features/{value}" };
+  return { path: `level-${levelIndex}/{value}` };
+}
+function createDefaultProjectConfig() {
+  return {
+    format: PROJECT_CONFIG_FORMAT,
+    version: PROJECT_CONFIG_VERSION,
+    catalogFile: "src/shared/i18n/index.ts",
+    levelCount: 2,
+    levelNames: "Module, Feature",
+    levelImports: [
+      getDefaultLevelImport(0),
+      getDefaultLevelImport(1),
+      getDefaultLevelImport(2)
+    ],
+    exportConfig: {
+      importAliases: { "@/": "src/" },
+      codeFormat: {
+        useDoubleQuotes: false,
+        useSemicolons: true,
+        useShorthandProperties: true,
+        useTrailingCommas: true,
+        printWidth: 120,
+        maxObjectInlineItems: 4,
+        maxArrayInlineItems: 8,
+        objectLayout: "fit",
+        arrayLayout: "fit",
+        indentation: {
+          character: "space",
+          size: 2
+        }
+      }
+    },
+    translationsDirectory: "i18n",
+    languageFileTemplate: "{language}.ts",
+    languageReplacer: {},
+    deletion: {
+      ignoredExtensions: [],
+      autoDelete: false
+    }
+  };
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeReplacer(value) {
+  if (!isRecord2(value))
+    return {};
+  const result = {};
+  Object.entries(value).forEach(([key, replacement]) => {
+    if (replacement === null || typeof replacement === "string")
+      result[key] = replacement;
+    else if (isRecord2(replacement))
+      result[key] = normalizeReplacer(replacement);
+  });
+  return result;
+}
+function normalizeStringRecord(value) {
+  if (!isRecord2(value))
+    return {};
+  return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string").map(([key, item]) => [key, item.trim()]));
+}
+function normalizeDeletionConfig(value) {
+  if (value === false)
+    return false;
+  const input = isRecord2(value) ? value : {};
+  const ignoredExtensions = Array.isArray(input.ignoredExtensions) ? [...new Set(input.ignoredExtensions.filter((extension) => typeof extension === "string").map((extension) => extension.trim().toLowerCase()).filter(Boolean).map((extension) => extension.startsWith(".") ? extension : `.${extension}`))] : [];
+  return {
+    ignoredExtensions,
+    autoDelete: input.autoDelete === true
+  };
+}
+function normalizeCodeFormat(value, legacyExportConfig) {
+  const defaults = createDefaultProjectConfig().exportConfig.codeFormat;
+  const input = isRecord2(value) ? value : {};
+  const indentation = isRecord2(input.indentation) ? input.indentation : {};
+  const rawIndentationSize = Number.parseInt(String(indentation.size ?? defaults.indentation.size), 10);
+  const rawPrintWidth = Number.parseInt(String(input.printWidth ?? defaults.printWidth), 10);
+  const rawMaxObjectInlineItems = Number.parseInt(String(input.maxObjectInlineItems ?? defaults.maxObjectInlineItems), 10);
+  const rawMaxArrayInlineItems = Number.parseInt(String(input.maxArrayInlineItems ?? defaults.maxArrayInlineItems), 10);
+  return {
+    useDoubleQuotes: (input.useDoubleQuotes ?? legacyExportConfig.useDoubleQuotes) === true,
+    useSemicolons: input.useSemicolons !== false,
+    useShorthandProperties: input.useShorthandProperties !== false,
+    useTrailingCommas: input.useTrailingCommas !== false,
+    printWidth: Number.isFinite(rawPrintWidth) ? Math.min(400, Math.max(40, rawPrintWidth)) : defaults.printWidth,
+    maxObjectInlineItems: Number.isFinite(rawMaxObjectInlineItems) ? Math.min(100, Math.max(0, rawMaxObjectInlineItems)) : defaults.maxObjectInlineItems,
+    maxArrayInlineItems: Number.isFinite(rawMaxArrayInlineItems) ? Math.min(100, Math.max(0, rawMaxArrayInlineItems)) : defaults.maxArrayInlineItems,
+    objectLayout: input.objectLayout === "multiline" ? "multiline" : "fit",
+    arrayLayout: input.arrayLayout === "multiline" ? "multiline" : "fit",
+    indentation: {
+      character: indentation.character === "tab" ? "tab" : "space",
+      size: Number.isFinite(rawIndentationSize) ? Math.min(8, Math.max(1, rawIndentationSize)) : defaults.indentation.size
+    }
+  };
+}
+function normalizeProjectConfig(value = {}) {
+  const defaults = createDefaultProjectConfig();
+  const levelCount = Math.max(0, Number.parseInt(String(value.levelCount ?? defaults.levelCount), 10) || 0);
+  const inputImports = Array.isArray(value.levelImports) ? value.levelImports : [];
+  const inputRecord = value;
+  const exportConfig = isRecord2(value.exportConfig) ? value.exportConfig : {};
+  return {
+    format: PROJECT_CONFIG_FORMAT,
+    version: PROJECT_CONFIG_VERSION,
+    catalogFile: typeof value.catalogFile === "string" && value.catalogFile.trim() ? value.catalogFile.trim() : defaults.catalogFile,
+    levelCount,
+    levelNames: typeof value.levelNames === "string" ? value.levelNames : defaults.levelNames,
+    levelImports: Array.from({ length: levelCount + 1 }, (_, index) => {
+      const input = isRecord2(inputImports[index]) ? inputImports[index] : {};
+      const fallback = getDefaultLevelImport(index);
+      return {
+        path: typeof input.path === "string" && input.path.trim() ? input.path.trim() : fallback.path,
+        valueReplacer: normalizeReplacer(input.valueReplacer),
+        fullReplacer: normalizeReplacer(input.fullReplacer)
+      };
+    }),
+    exportConfig: {
+      importAliases: {
+        ...defaults.exportConfig.importAliases,
+        ...normalizeStringRecord(exportConfig.importAliases ?? inputRecord.importAliases)
+      },
+      codeFormat: normalizeCodeFormat(exportConfig.codeFormat, exportConfig)
+    },
+    translationsDirectory: typeof value.translationsDirectory === "string" && value.translationsDirectory.trim() ? value.translationsDirectory.trim() : defaults.translationsDirectory,
+    languageFileTemplate: typeof value.languageFileTemplate === "string" && value.languageFileTemplate.trim() ? value.languageFileTemplate.trim() : defaults.languageFileTemplate,
+    languageReplacer: normalizeStringRecord(value.languageReplacer),
+    deletion: normalizeDeletionConfig(value.deletion)
+  };
+}
+function flattenPathReplacer(replacer, parentPath = "") {
+  const flattened = {};
+  Object.entries(replacer || {}).forEach(([key, value]) => {
+    const fullKey = parentPath ? `${parentPath}.${key}` : key;
+    if (value === null || typeof value === "string")
+      flattened[fullKey] = value;
+    else
+      Object.assign(flattened, flattenPathReplacer(value, fullKey));
+  });
+  return flattened;
+}
+function resolveImportAlias(path, aliases) {
+  const alias = Object.keys(aliases).filter((candidate) => path.startsWith(candidate)).sort((left, right) => right.length - left.length)[0];
+  if (!alias)
+    return path;
+  return `${aliases[alias]}${path.slice(alias.length)}`;
+}
+
+// src/core/projectConfig.ts
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeStringRecord2(value) {
+  if (!isRecord3(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value).filter((entry) => typeof entry[1] === "string")
+  );
+}
+function normalizeCodeFormat2(value, legacyExportConfig) {
+  const input = isRecord3(value) ? value : {};
+  const indentation = isRecord3(input.indentation) ? input.indentation : {};
+  const indentationSize = Number.parseInt(String(indentation.size ?? 2), 10);
+  const printWidth = Number.parseInt(String(input.printWidth ?? 120), 10);
+  const maxObjectInlineItems = Number.parseInt(String(input.maxObjectInlineItems ?? 4), 10);
+  const maxArrayInlineItems = Number.parseInt(String(input.maxArrayInlineItems ?? 8), 10);
+  return {
+    useDoubleQuotes: (input.useDoubleQuotes ?? legacyExportConfig.useDoubleQuotes) === true,
+    useSemicolons: input.useSemicolons !== false,
+    useShorthandProperties: input.useShorthandProperties !== false,
+    useTrailingCommas: input.useTrailingCommas !== false,
+    printWidth: Number.isFinite(printWidth) ? Math.min(400, Math.max(40, printWidth)) : 120,
+    maxObjectInlineItems: Number.isFinite(maxObjectInlineItems) ? Math.min(100, Math.max(0, maxObjectInlineItems)) : 4,
+    maxArrayInlineItems: Number.isFinite(maxArrayInlineItems) ? Math.min(100, Math.max(0, maxArrayInlineItems)) : 8,
+    objectLayout: input.objectLayout === "multiline" ? "multiline" : "fit",
+    arrayLayout: input.arrayLayout === "multiline" ? "multiline" : "fit",
+    indentation: {
+      character: indentation.character === "tab" ? "tab" : "space",
+      size: Number.isFinite(indentationSize) ? Math.min(8, Math.max(1, indentationSize)) : 2
+    }
+  };
+}
+function normalizeDeletionConfig2(value) {
+  if (value === false) return false;
+  const input = isRecord3(value) ? value : {};
+  const ignoredExtensions = Array.isArray(input.ignoredExtensions) ? [...new Set(input.ignoredExtensions.filter((extension) => typeof extension === "string").map((extension) => extension.trim().toLowerCase()).filter(Boolean).map((extension) => extension.startsWith(".") ? extension : `.${extension}`))] : [];
+  return {
+    ignoredExtensions,
+    autoDelete: input.autoDelete === true
+  };
+}
+function normalizeEditorProjectConfig(value) {
+  const input = isRecord3(value) ? value : {};
+  const exportInput = isRecord3(input.exportConfig) ? input.exportConfig : {};
+  const importAliases = normalizeStringRecord2(exportInput.importAliases ?? input.importAliases);
+  const normalized = normalizeProjectConfig({
+    ...input,
+    importAliases
+  });
+  const normalizedRecord = normalized;
+  const normalizedExport = isRecord3(normalizedRecord.exportConfig) ? normalizedRecord.exportConfig : {};
+  const normalizedAliases = normalizeStringRecord2(normalizedExport.importAliases ?? normalizedRecord.importAliases);
+  const { importAliases: _legacyAliases, exportConfig: _normalizedExport, ...config } = normalizedRecord;
+  return {
+    ...config,
+    catalogFile: typeof input.catalogFile === "string" && input.catalogFile.trim() ? input.catalogFile.trim() : "src/shared/i18n/index.ts",
+    deletion: normalizeDeletionConfig2(input.deletion),
+    exportConfig: {
+      importAliases: normalizedAliases,
+      codeFormat: normalizeCodeFormat2(exportInput.codeFormat, exportInput)
+    }
+  };
+}
+function createDefaultEditorProjectConfig() {
+  const defaults = createDefaultProjectConfig();
+  const defaultsExport = isRecord3(defaults.exportConfig) ? defaults.exportConfig : {};
+  const importAliases = normalizeStringRecord2(defaultsExport.importAliases ?? defaults.importAliases);
+  const { importAliases: _legacyAliases, exportConfig: _defaultsExport, ...config } = defaults;
+  return {
+    ...config,
+    catalogFile: "src/shared/i18n/index.ts",
+    deletion: normalizeDeletionConfig2(void 0),
+    exportConfig: {
+      importAliases,
+      codeFormat: normalizeCodeFormat2(void 0, {})
+    }
+  };
+}
+function getEditorLevelName(config, level) {
+  if (level === 0) return "Root";
+  const names = config.levelNames.split(",").map((name) => name.trim()).filter(Boolean);
+  return names[level - 1] || `Level ${level}`;
+}
+
+// src/core/setStringValue.ts
+function cloneBundle2(bundle) {
+  return structuredClone(bundle);
+}
+function setStringValue(bundle, { languageKey, key, value }) {
+  const validBundle = assertBundle(bundle);
+  const language = validBundle.languages[languageKey];
+  if (!language) {
+    throw new Error(`Language "${languageKey}" does not exist in the bundle.`);
+  }
+  const segments = parseKeyPath(key, "key");
+  const currentValue = getKeyPathValue(language.translations, segments);
+  if (!currentValue.found) {
+    throw new Error(`Key "${key}" does not exist in language "${languageKey}".`);
+  }
+  if (typeof currentValue.value !== "string") {
+    throw new Error("Editing functions and non-string values is not supported yet.");
+  }
+  const nextBundle = cloneBundle2(validBundle);
+  setKeyPathValue(nextBundle.languages[languageKey].translations, segments, value);
+  return nextBundle;
+}
+
+// src/core/exportPlan.ts
+function getConfiguredLevelImport(config, level) {
+  return config.levelImports[level] || getDefaultLevelImport(level);
+}
+function appendPath(basePath, nextPath) {
+  return [basePath, nextPath].filter(Boolean).join("/").replaceAll(/\/+/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+}
+function expandTemplate(template, value) {
+  return template.replaceAll("{value}", value);
+}
+function hasAlias(path, aliases) {
+  return Object.keys(aliases).some((alias) => path.startsWith(alias));
+}
+function getReplacement(replacer, fullKey, segment) {
+  const flattened = flattenPathReplacer(replacer);
+  if (Object.hasOwn(flattened, fullKey)) return { found: true, value: flattened[fullKey] };
+  if (Object.hasOwn(flattened, segment)) return { found: true, value: flattened[segment] };
+  return { found: false, value: void 0 };
+}
+function getTranslationOwnerChain(fullKey, config) {
+  const segments = fullKey.split(".");
+  const groupCount = Math.min(config.levelCount, Math.max(segments.length - 1, 0));
+  const rootImport = getConfiguredLevelImport(config, 0);
+  let directory = resolveImportAlias(expandTemplate(rootImport.path, ""), config.exportConfig.importAliases);
+  let consumedSegments = 0;
+  const owners = [{ directory, keyPath: "", importPathStyle: "relative" }];
+  for (let level = 1; level <= groupCount; level += 1) {
+    const segment = segments[level - 1];
+    const objectPath = segments.slice(0, level).join(".");
+    const levelImport = getConfiguredLevelImport(config, level);
+    const fullReplacement = getReplacement(levelImport.fullReplacer, objectPath, segment);
+    if (fullReplacement.found) {
+      if (fullReplacement.value !== null) {
+        directory = resolveImportAlias(fullReplacement.value, config.exportConfig.importAliases);
+        consumedSegments = level;
+        owners.push({
+          directory,
+          keyPath: objectPath,
+          importPathStyle: hasAlias(fullReplacement.value, config.exportConfig.importAliases) ? "alias" : "relative"
+        });
+      }
+      break;
+    }
+    const valueReplacement = getReplacement(levelImport.valueReplacer, objectPath, segment);
+    const value = typeof valueReplacement.value === "string" ? valueReplacement.value : segment;
+    const template = expandTemplate(levelImport.path, value);
+    const resolved = resolveImportAlias(template, config.exportConfig.importAliases);
+    directory = hasAlias(template, config.exportConfig.importAliases) || template.startsWith("/") ? resolved : appendPath(directory, resolved);
+    consumedSegments = level;
+    owners.push({
+      directory,
+      keyPath: objectPath,
+      importPathStyle: hasAlias(template, config.exportConfig.importAliases) ? "alias" : "relative"
+    });
+  }
+  void consumedSegments;
+  return owners;
+}
+function isFunctionDescriptor(value) {
+  return value !== null && typeof value === "object" && "$type" in value && value.$type === "function";
+}
+function collectTranslationKeys(value, path = "", keys = []) {
+  if (isFunctionDescriptor(value)) {
+    keys.push(path);
+    return keys;
+  }
+  if (Array.isArray(value)) {
+    keys.push(path);
+    return keys;
+  }
+  if (value && typeof value === "object") {
+    Object.entries(value).forEach(([key, nestedValue]) => {
+      collectTranslationKeys(nestedValue, path ? `${path}.${key}` : key, keys);
+    });
+    return keys;
+  }
+  keys.push(path);
+  return keys;
+}
+function buildTranslationOwners(bundle, config) {
+  const validBundle = assertBundle(bundle);
+  const validConfig = normalizeEditorProjectConfig(config);
+  const owners = /* @__PURE__ */ new Map();
+  const referenceLanguage = Object.values(validBundle.languages)[0];
+  if (referenceLanguage) {
+    collectTranslationKeys(referenceLanguage.translations).forEach((key) => {
+      getTranslationOwnerChain(key, validConfig).forEach((owner) => {
+        const existing = owners.get(owner.directory);
+        if (existing && existing.keyPath !== owner.keyPath) {
+          throw new Error(`The export path "${owner.directory}" resolves multiple translation owners.`);
+        }
+        owners.set(owner.directory, owner);
+      });
+    });
+  }
+  return [...owners.values()].sort((left, right) => left.keyPath.localeCompare(right.keyPath));
+}
+function buildExportPlan(bundle, config) {
+  const validBundle = assertBundle(bundle);
+  const validConfig = normalizeEditorProjectConfig(config);
+  const owners = buildTranslationOwners(validBundle, validConfig);
+  return owners.flatMap(({ directory, keyPath }) => {
+    const translationsDirectory = appendPath(directory, validConfig.translationsDirectory);
+    const structuralFiles = [
+      { kind: "base", path: appendPath(translationsDirectory, "base.ts") }
+    ];
+    if (keyPath === "") {
+      structuralFiles.push({
+        kind: "index",
+        path: validConfig.catalogFile || appendPath(translationsDirectory, "index.ts")
+      });
+    }
+    const languageFiles = Object.keys(validBundle.languages).map((languageKey) => {
+      const language = validConfig.languageReplacer[languageKey] || languageKey;
+      return {
+        kind: "language",
+        languageKey,
+        path: appendPath(
+          translationsDirectory,
+          validConfig.languageFileTemplate.replaceAll("{language}", language)
+        )
+      };
+    });
+    return [...structuralFiles, ...languageFiles];
+  }).sort((left, right) => left.path.localeCompare(right.path));
+}
+
+// src/web/export-preview.ts
+var statusLabels = {
+  create: "new",
+  modify: "modified",
+  unchanged: "unchanged",
+  delete: "delete"
+};
+function createDiff(document2, diff) {
+  const pre = document2.createElement("pre");
+  pre.className = "export-file-diff";
+  diff.trimEnd().split("\n").forEach((line) => {
+    const row = document2.createElement("span");
+    row.className = line.startsWith("+++") || line.startsWith("---") ? "diff-file-header" : line.startsWith("@@") ? "diff-range" : line.startsWith("+") ? "diff-addition" : line.startsWith("-") ? "diff-removal" : "diff-context";
+    row.textContent = line;
+    pre.append(row);
+  });
+  return pre;
+}
+function renderExportPreview(container, bundle, config, checkedChanges = null) {
+  const document2 = container.ownerDocument;
+  if (!bundle) {
+    container.textContent = "Carregue um bundle para visualizar os arquivos de sa\xEDda.";
+    return;
+  }
+  const plan = checkedChanges ?? buildExportPlan(bundle, config);
+  if (plan.length === 0) {
+    container.textContent = "N\xE3o h\xE1 tradu\xE7\xF5es para exportar.";
+    return;
+  }
+  const list = document2.createElement("ul");
+  list.className = "export-preview-list";
+  plan.forEach(({ path, status, diff }) => {
+    const item = document2.createElement("li");
+    item.className = status ? `export-preview-item export-preview-${status}` : "export-preview-item";
+    const line = document2.createElement("div");
+    line.className = "export-preview-path";
+    if (status) {
+      const badge = document2.createElement("span");
+      badge.className = "export-preview-status";
+      badge.textContent = statusLabels[status];
+      line.append(badge);
+    }
+    const code = document2.createElement("code");
+    code.textContent = path;
+    line.append(code);
+    item.append(line);
+    if (diff && status !== "delete") {
+      const details = document2.createElement("details");
+      details.className = "export-diff-details";
+      const summary = document2.createElement("summary");
+      summary.textContent = "Mostrar diff";
+      details.append(summary, createDiff(document2, diff));
+      item.append(details);
+    }
+    list.append(item);
+  });
+  container.replaceChildren(list);
+}
+
+// src/web/project-settings.ts
+function createJsonField(document2, { labelText, value, placeholder, onInput }) {
+  const label = document2.createElement("label");
+  label.className = "level-field level-json-field";
+  const title = document2.createElement("span");
+  title.textContent = labelText;
+  const textarea = document2.createElement("textarea");
+  textarea.spellcheck = false;
+  textarea.value = JSON.stringify(value || {}, null, 2);
+  textarea.placeholder = placeholder;
+  textarea.addEventListener("input", () => onInput(textarea.value));
+  label.append(title, textarea);
+  return label;
+}
+function renderLevelImportFields(container, config, onChange) {
+  const document2 = container.ownerDocument;
+  const fragment = document2.createDocumentFragment();
+  for (let index = 0; index <= config.levelCount; index += 1) {
+    const levelImport = config.levelImports[index] || getDefaultLevelImport(index);
+    const card = document2.createElement("section");
+    card.className = "level-import-card";
+    const heading = document2.createElement("h4");
+    heading.textContent = index === 0 ? "Root (n\xEDvel 0)" : `${getEditorLevelName(config, index)} (n\xEDvel ${index})`;
+    const pathLabel = document2.createElement("label");
+    pathLabel.className = "level-field level-path-field";
+    const pathTitle = document2.createElement("span");
+    pathTitle.textContent = "Template do caminho";
+    const pathInput = document2.createElement("input");
+    pathInput.type = "text";
+    pathInput.value = levelImport.path;
+    pathInput.placeholder = getDefaultLevelImport(index).path;
+    pathInput.addEventListener("input", () => onChange(index, "path", pathInput.value));
+    pathLabel.append(pathTitle, pathInput);
+    card.append(heading, pathLabel);
+    if (index > 0) {
+      const replacers = document2.createElement("div");
+      replacers.className = "level-replacers";
+      replacers.append(
+        createJsonField(document2, {
+          labelText: "Value replacer (JSON)",
+          value: levelImport.valueReplacer,
+          placeholder: '{ "module.feature": "folder-name" }',
+          onInput: (value) => onChange(index, "valueReplacer", value)
+        }),
+        createJsonField(document2, {
+          labelText: "Full replacer (JSON)",
+          value: levelImport.fullReplacer,
+          placeholder: '{ "module.feature": "@/custom/path" }',
+          onInput: (value) => onChange(index, "fullReplacer", value)
+        })
+      );
+      card.append(replacers);
+    }
+    fragment.append(card);
+  }
+  container.replaceChildren(fragment);
+}
+
+// src/web/project-api.ts
+async function readResponse(response) {
+  const value = await response.json();
+  if (!response.ok) {
+    throw new Error("error" in value ? value.error : `Request failed with status ${response.status}.`);
+  }
+  return value;
+}
+async function getProjectInfo() {
+  const info = await readResponse(await fetch("/api/project", { cache: "no-store" }));
+  return {
+    ...info,
+    config: info.config ? normalizeEditorProjectConfig(info.config) : null,
+    bundle: info.bundle ? assertBundle(info.bundle) : null
+  };
+}
+async function generateProjectBundle() {
+  const result = await readResponse(await fetch("/api/bundle", { method: "POST" }));
+  return { ...result, bundle: assertBundle(result.bundle) };
+}
+async function checkProjectExport(bundle, config) {
+  return readResponse(await fetch("/api/export-preview", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ bundle, config })
+  }));
+}
+
+// src/web/state.ts
+function createEditorState() {
+  let bundle = null;
+  const listeners = /* @__PURE__ */ new Set();
+  function notify(reason) {
+    listeners.forEach((listener) => listener(bundle, { reason }));
+  }
+  return {
+    getBundle: () => bundle,
+    replaceBundle(nextBundle) {
+      bundle = nextBundle;
+      notify("replace");
+    },
+    update(updater) {
+      if (!bundle) throw new Error("N\xE3o existe um bundle carregado para editar.");
+      bundle = withUpdatedAt(updater(bundle));
+      notify("edit");
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+// src/web/table.ts
+function isFunctionDescriptor2(value) {
+  return value && typeof value === "object" && value.$type === "function";
+}
+function splitFunctionSource(source) {
+  const arrowIndex = source.indexOf("=>");
+  if (arrowIndex === -1) return { signature: "\u0192 function (\u2026) => \u2026", body: source };
+  return {
+    signature: `\u0192 ${source.slice(0, arrowIndex).trim()} => \u2026`,
+    body: source.slice(arrowIndex + 2).trim()
+  };
+}
+function describeBase(entries) {
+  const presentEntries = entries.filter(Boolean);
+  if (presentEntries.length === 0) return { label: "ausente", type: "missing" };
+  if (presentEntries.every((entry) => entry.type === "string")) return { label: "string", type: "string" };
+  if (presentEntries.every((entry) => entry.type === "function")) {
+    return { label: presentEntries[0].signature, type: "function" };
+  }
+  return { label: "inconsistente", type: "inconsistent" };
+}
+function appendSegment(path, segment) {
+  return segment.startsWith("[") ? `${path}${segment}` : path ? `${path}.${segment}` : segment;
+}
+function flatten(value, path = "", entries = /* @__PURE__ */ new Map()) {
+  if (isFunctionDescriptor2(value)) {
+    const { signature, body } = splitFunctionSource(value.source);
+    entries.set(path, { text: body, type: "function", signature });
+    return entries;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => flatten(item, appendSegment(path, `[${index}]`), entries));
+    return entries;
+  }
+  if (value && typeof value === "object") {
+    Object.entries(value).forEach(([key, nestedValue]) => flatten(nestedValue, appendSegment(path, key), entries));
+    return entries;
+  }
+  entries.set(path, { text: value == null ? "" : String(value), type: "string" });
+  return entries;
+}
+function createCell(document2, value, className) {
+  const cell = document2.createElement("td");
+  if (className) cell.className = className;
+  cell.textContent = value;
+  return cell;
+}
+function beginTextEdit(cell, originalValue, onCommit) {
+  let completed = false;
+  const input = cell.ownerDocument.createElement("input");
+  input.className = "inline-value-input";
+  input.type = "text";
+  input.value = originalValue;
+  input.setAttribute("aria-label", "Editar tradu\xE7\xE3o");
+  function finish(save) {
+    if (completed) return;
+    completed = true;
+    if (!save || input.value === originalValue) {
+      cell.textContent = originalValue;
+      return;
+    }
+    if (onCommit(input.value) === false) cell.textContent = originalValue;
+  }
+  input.addEventListener("keydown", (event) => {
+    if (event.key === "Enter") {
+      event.preventDefault();
+      finish(true);
+    }
+    if (event.key === "Escape") {
+      event.preventDefault();
+      finish(false);
+    }
+  });
+  input.addEventListener("blur", () => finish(true));
+  cell.replaceChildren(input);
+  input.focus();
+  input.select();
+}
+function createRows(bundle) {
+  const languages = Object.entries(bundle.languages);
+  const flattenedTranslations = Object.fromEntries(
+    languages.map(([key, language]) => [key, flatten(language.translations)])
+  );
+  const keys = [...new Set(Object.values(flattenedTranslations).flatMap((entries) => [...entries.keys()]))].sort((left, right) => left.localeCompare(right));
+  return {
+    languages,
+    rows: keys.map((fullKey) => ({
+      fullKey,
+      languageEntries: languages.map(([languageKey]) => flattenedTranslations[languageKey].get(fullKey))
+    }))
+  };
+}
+function createGroupTree(rows, levelCount) {
+  const root = { depth: 0, name: "Raiz", rows: [], children: /* @__PURE__ */ new Map() };
+  rows.forEach((row) => {
+    const segments = row.fullKey.split(".");
+    const groupCount = Math.min(levelCount, Math.max(segments.length - 1, 0));
+    let node = root;
+    for (let index = 0; index < groupCount; index += 1) {
+      const name = segments[index];
+      if (!node.children.has(name)) {
+        node.children.set(name, { depth: index + 1, name, rows: [], children: /* @__PURE__ */ new Map() });
+      }
+      node = node.children.get(name);
+    }
+    node.rows.push(row);
+  });
+  return root;
+}
+function getNodeRowCount(node) {
+  return node.rows.length + [...node.children.values()].reduce(
+    (count, child) => count + getNodeRowCount(child),
+    0
+  );
+}
+function getRelativeKey(fullKey, depth) {
+  return fullKey.split(".").slice(depth).join(".");
+}
+function createTranslationTable(document2, languages, rows, depth, { onMoveKey, onEditValue }) {
+  const table = document2.createElement("table");
+  const header = table.createTHead().insertRow();
+  const keyHeader = document2.createElement("th");
+  keyHeader.textContent = "Chave";
+  header.append(keyHeader);
+  languages.forEach(([key, language]) => {
+    const cell = document2.createElement("th");
+    cell.className = "language-header";
+    cell.textContent = `${key} \xB7 ${language.short}`;
+    header.append(cell);
+  });
+  const baseHeader = document2.createElement("th");
+  baseHeader.textContent = "Base";
+  header.append(baseHeader);
+  const body = table.createTBody();
+  rows.forEach((rowData) => {
+    const row = body.insertRow();
+    const { fullKey, languageEntries } = rowData;
+    row.dataset.search = [
+      fullKey,
+      ...languageEntries.map((entry) => entry?.text ?? "")
+    ].join(" ").toLocaleLowerCase();
+    const keyCell = createCell(document2, getRelativeKey(fullKey, depth), "key");
+    if (onMoveKey) {
+      keyCell.title = "Clique duas vezes para mover esta chave";
+      keyCell.addEventListener("dblclick", () => onMoveKey(fullKey));
+    }
+    row.append(keyCell);
+    languages.forEach(([languageKey], index) => {
+      const entry = languageEntries[index];
+      const className = ["language-value", entry?.type === "function" ? "function-value" : ""].filter(Boolean).join(" ");
+      const valueCell = createCell(document2, entry?.text ?? "Ausente", className);
+      if (entry?.type === "string" && onEditValue) {
+        valueCell.title = "Clique duas vezes para editar esta tradu\xE7\xE3o";
+        valueCell.addEventListener("dblclick", () => {
+          beginTextEdit(valueCell, entry.text, (value) => onEditValue({
+            languageKey,
+            key: fullKey,
+            value
+          }));
+        });
+      }
+      row.append(valueCell);
+    });
+    const base = describeBase(languageEntries);
+    row.append(createCell(document2, base.label, `base-value base-${base.type}`));
+  });
+  return table;
+}
+function appendTableGroup(document2, container, node, languages, callbacks, isRoot = false) {
+  if (isRoot) {
+    if (node.rows.length > 0) {
+      const rootGroup = document2.createElement("section");
+      rootGroup.className = "table-group";
+      const title = document2.createElement("h3");
+      title.className = "table-group-title";
+      title.textContent = "Raiz";
+      rootGroup.append(title, createTranslationTable(document2, languages, node.rows, node.depth, callbacks));
+      container.append(rootGroup);
+    }
+  } else {
+    const details = document2.createElement("details");
+    details.className = "translation-group";
+    const summary = document2.createElement("summary");
+    const label = document2.createElement("span");
+    label.textContent = `${getEditorLevelName(callbacks.projectConfig, node.depth)} \xB7 ${node.name}`;
+    const count = document2.createElement("span");
+    count.className = "group-count";
+    count.textContent = `${getNodeRowCount(node)} chaves`;
+    summary.append(label, count);
+    details.append(summary);
+    const content = document2.createElement("div");
+    content.className = "translation-group-content";
+    if (node.rows.length > 0) {
+      const tableGroup = document2.createElement("section");
+      tableGroup.className = "table-group";
+      if (node.children.size > 0) {
+        const title = document2.createElement("h3");
+        title.className = "table-group-title";
+        title.textContent = "Raiz";
+        tableGroup.append(title);
+      }
+      tableGroup.append(createTranslationTable(document2, languages, node.rows, node.depth, callbacks));
+      content.append(tableGroup);
+    }
+    details.append(content);
+    container.append(details);
+    container = content;
+  }
+  [...node.children.values()].sort((left, right) => left.name.localeCompare(right.name)).forEach((child) => appendTableGroup(document2, container, child, languages, callbacks));
+}
+function renderTranslationTables(container, bundle, { projectConfig: projectConfig2, onMoveKey, onEditValue }) {
+  const document2 = container.ownerDocument;
+  const { languages, rows } = createRows(bundle);
+  const normalizedLevelCount = Math.max(0, Number.isInteger(projectConfig2?.levelCount) ? projectConfig2.levelCount : 0);
+  const tree = createGroupTree(rows, normalizedLevelCount);
+  const fragment = document2.createDocumentFragment();
+  appendTableGroup(document2, fragment, tree, languages, { projectConfig: projectConfig2, onMoveKey, onEditValue }, true);
+  container.replaceChildren(fragment);
+  return rows.length;
+}
+
+// src/web/view.ts
+function createEditorView({ emptyState, tableWrap, tableContainer, summary, search, onMoveKey, onEditValue }) {
+  let currentRows = [];
+  let currentBundle = null;
+  let projectConfig2 = createDefaultEditorProjectConfig();
+  search.addEventListener("input", () => {
+    const query = search.value.trim().toLocaleLowerCase();
+    currentRows.forEach((row) => {
+      row.hidden = query !== "" && !row.dataset.search.includes(query);
+    });
+  });
+  return {
+    render(bundle) {
+      currentBundle = bundle;
+      if (!bundle) {
+        emptyState.hidden = false;
+        tableWrap.hidden = true;
+        summary.textContent = "Carregue um bundle para visualizar as tradu\xE7\xF5es.";
+        search.value = "";
+        currentRows = [];
+        return;
+      }
+      const keyCount = renderTranslationTables(tableContainer, bundle, {
+        projectConfig: projectConfig2,
+        onMoveKey,
+        onEditValue
+      });
+      currentRows = [...tableContainer.querySelectorAll("tbody tr")];
+      emptyState.hidden = true;
+      tableWrap.hidden = false;
+      search.value = "";
+      summary.textContent = `${keyCount} chaves em ${Object.keys(bundle.languages).length} idiomas.`;
+    },
+    setProjectConfig(nextProjectConfig) {
+      projectConfig2 = nextProjectConfig;
+      if (currentBundle) this.render(currentBundle);
+    }
+  };
+}
+
+// src/web/main.ts
+var state = createEditorState();
+function getElement(selector) {
+  const element = document.querySelector(selector);
+  if (!element) throw new Error(`Required editor element not found: ${selector}`);
+  return element;
+}
+var elements = {
+  emptyState: getElement("#empty-state"),
+  feedback: getElement("#editor-feedback"),
+  levelCount: getElement("#level-count"),
+  levelNames: getElement("#level-names"),
+  levelImports: getElement("#level-imports"),
+  importAliases: getElement("#import-aliases"),
+  translationsDirectory: getElement("#translations-directory"),
+  languageFileTemplate: getElement("#language-file-template"),
+  languageReplacer: getElement("#language-replacer"),
+  useDoubleQuotes: getElement("#use-double-quotes"),
+  useSemicolons: getElement("#use-semicolons"),
+  useShorthandProperties: getElement("#use-shorthand-properties"),
+  useTrailingCommas: getElement("#use-trailing-commas"),
+  indentationCharacter: getElement("#indentation-character"),
+  indentationSize: getElement("#indentation-size"),
+  printWidth: getElement("#print-width"),
+  maxObjectInlineItems: getElement("#max-object-inline-items"),
+  maxArrayInlineItems: getElement("#max-array-inline-items"),
+  objectLayout: getElement("#object-layout"),
+  arrayLayout: getElement("#array-layout"),
+  deletionEnabled: getElement("#deletion-enabled"),
+  ignoredDeletionExtensions: getElement("#ignored-deletion-extensions"),
+  autoDelete: getElement("#auto-delete"),
+  exportPreview: getElement("#export-preview"),
+  exportPreviewFeedback: getElement("#export-preview-feedback"),
+  checkExportDiffs: getElement("#check-export-diffs"),
+  search: getElement("#translation-search"),
+  summary: getElement("#bundle-summary"),
+  settingsPanel: getElement("#settings-panel"),
+  tableWrap: getElement("#table-wrap"),
+  toggleSettingsPanel: getElement("#toggle-settings-panel"),
+  projectStatus: getElement("#project-status"),
+  projectStatusText: getElement("#project-status-text"),
+  retryProjectLoad: getElement("#retry-project-load")
+};
+var settingsPanelVisible = false;
+var projectConfig = createDefaultEditorProjectConfig();
+var checkedExportChanges = null;
+var exportPreviewRequestVersion = 0;
+function renderCurrentExportPreview() {
+  renderExportPreview(elements.exportPreview, state.getBundle(), projectConfig, checkedExportChanges);
+}
+function invalidateExportPreview() {
+  exportPreviewRequestVersion += 1;
+  checkedExportChanges = null;
+  elements.exportPreviewFeedback.textContent = "";
+  elements.exportPreviewFeedback.classList.remove("error", "warning");
+  elements.checkExportDiffs.disabled = !state.getBundle();
+  elements.checkExportDiffs.textContent = "Verificar diffs";
+  renderCurrentExportPreview();
+}
+var view = createEditorView({
+  emptyState: elements.emptyState,
+  tableWrap: elements.tableWrap,
+  tableContainer: elements.tableWrap,
+  summary: elements.summary,
+  search: elements.search,
+  onMoveKey(sourceKey) {
+    const targetKey = window.prompt("Mover chave para:", sourceKey);
+    if (targetKey === null || targetKey.trim() === "" || targetKey === sourceKey) return;
+    try {
+      state.update((bundle) => moveKey(bundle, { sourceKey, targetKey: targetKey.trim() }));
+      setFeedback(`Chave movida de ${sourceKey} para ${targetKey.trim()}.`);
+    } catch (error) {
+      setFeedback(error instanceof Error ? error.message : String(error), true);
+    }
+  },
+  onEditValue({ languageKey, key, value }) {
+    try {
+      state.update((bundle) => setStringValue(bundle, { languageKey, key, value }));
+      setFeedback(`Tradu\xE7\xE3o ${languageKey}.${key} atualizada.`);
+      return true;
+    } catch (error) {
+      setFeedback(error instanceof Error ? error.message : String(error), true);
+      return false;
+    }
+  }
+});
+function setFeedback(message, isError = false) {
+  elements.feedback.textContent = message;
+  elements.feedback.classList.toggle("error", isError);
+}
+function setSettingsPanelVisibility(visible) {
+  settingsPanelVisible = visible;
+  elements.settingsPanel.hidden = !visible;
+  elements.toggleSettingsPanel.setAttribute("aria-expanded", String(visible));
+  elements.toggleSettingsPanel.setAttribute(
+    "aria-label",
+    visible ? "Ocultar configura\xE7\xF5es" : "Mostrar configura\xE7\xF5es"
+  );
+  elements.toggleSettingsPanel.title = elements.toggleSettingsPanel.getAttribute("aria-label");
+}
+var projectConfigQueue = Promise.resolve();
+function parseJsonObject(value, fieldName) {
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${fieldName} deve ser um objeto JSON.`);
+  }
+  return parsed;
+}
+function applyProjectConfig(nextConfig, persist = true, renderLevelImports = true, syncJsonFields = true) {
+  projectConfig = normalizeEditorProjectConfig(nextConfig);
+  elements.levelCount.value = String(projectConfig.levelCount);
+  elements.levelNames.value = projectConfig.levelNames;
+  elements.translationsDirectory.value = projectConfig.translationsDirectory;
+  elements.languageFileTemplate.value = projectConfig.languageFileTemplate;
+  elements.deletionEnabled.checked = projectConfig.deletion !== false;
+  elements.ignoredDeletionExtensions.value = projectConfig.deletion === false ? "" : projectConfig.deletion.ignoredExtensions.join(", ");
+  elements.ignoredDeletionExtensions.disabled = projectConfig.deletion === false;
+  elements.autoDelete.checked = projectConfig.deletion !== false && projectConfig.deletion.autoDelete;
+  elements.autoDelete.disabled = projectConfig.deletion === false;
+  const codeFormat = projectConfig.exportConfig.codeFormat;
+  elements.useDoubleQuotes.checked = codeFormat.useDoubleQuotes;
+  elements.useSemicolons.checked = codeFormat.useSemicolons;
+  elements.useShorthandProperties.checked = codeFormat.useShorthandProperties;
+  elements.useTrailingCommas.checked = codeFormat.useTrailingCommas;
+  elements.indentationCharacter.value = codeFormat.indentation.character;
+  elements.indentationSize.value = String(codeFormat.indentation.size);
+  elements.printWidth.value = String(codeFormat.printWidth);
+  elements.maxObjectInlineItems.value = String(codeFormat.maxObjectInlineItems);
+  elements.maxArrayInlineItems.value = String(codeFormat.maxArrayInlineItems);
+  elements.objectLayout.value = codeFormat.objectLayout;
+  elements.arrayLayout.value = codeFormat.arrayLayout;
+  if (syncJsonFields) {
+    elements.importAliases.value = JSON.stringify(projectConfig.exportConfig.importAliases, null, 2);
+    elements.languageReplacer.value = JSON.stringify(projectConfig.languageReplacer, null, 2);
+  }
+  if (renderLevelImports) {
+    renderLevelImportFields(elements.levelImports, projectConfig, (index, field, value) => {
+      try {
+        const levelImports = projectConfig.levelImports.map((item) => ({ ...item }));
+        levelImports[index][field] = field === "path" ? value : parseJsonObject(value, field === "valueReplacer" ? "Value replacer" : "Full replacer");
+        applyProjectConfig({ ...projectConfig, levelImports }, true, false);
+        setFeedback("Configura\xE7\xE3o atualizada.");
+      } catch (error) {
+        setFeedback(error instanceof Error ? error.message : String(error), true);
+      }
+    });
+  }
+  view.setProjectConfig(projectConfig);
+  invalidateExportPreview();
+  if (!persist) return;
+  projectConfigQueue = projectConfigQueue.catch(() => void 0).then(() => saveStoredProjectConfig(projectConfig)).catch((error) => {
+    setFeedback(`N\xE3o foi poss\xEDvel salvar as configura\xE7\xF5es: ${error instanceof Error ? error.message : String(error)}`, true);
+  });
+}
+var persistenceQueue = Promise.resolve();
+function persistBundle(bundle) {
+  persistenceQueue = persistenceQueue.catch(() => void 0).then(() => saveStoredBundle(bundle)).catch((error) => {
+    setFeedback(`N\xE3o foi poss\xEDvel salvar a c\xF3pia local: ${error instanceof Error ? error.message : String(error)}`, true);
+  });
+}
+state.subscribe((bundle) => {
+  view.render(bundle);
+  invalidateExportPreview();
+  if (bundle) persistBundle(bundle);
+});
+view.render(state.getBundle());
+elements.toggleSettingsPanel.addEventListener("click", () => {
+  setSettingsPanelVisibility(!settingsPanelVisible);
+});
+elements.checkExportDiffs.addEventListener("click", async () => {
+  const bundle = state.getBundle();
+  if (!bundle) return;
+  const requestVersion = ++exportPreviewRequestVersion;
+  elements.checkExportDiffs.disabled = true;
+  elements.checkExportDiffs.textContent = "Verificando\u2026";
+  elements.exportPreviewFeedback.textContent = "Comparando com os arquivos atuais do projeto\u2026";
+  elements.exportPreviewFeedback.classList.remove("error", "warning");
+  try {
+    const result = await checkProjectExport(bundle, projectConfig);
+    if (requestVersion !== exportPreviewRequestVersion) return;
+    checkedExportChanges = result.changes;
+    renderCurrentExportPreview();
+    const changed = result.changes.filter(({ status }) => status !== "unchanged").length;
+    const deletionCount = result.changes.filter(({ status }) => status === "delete").length;
+    if (deletionCount > 0) {
+      const deletionMessage = projectConfig.deletion !== false && projectConfig.deletion.autoDelete ? `${deletionCount} arquivo${deletionCount === 1 ? "" : "s"} divergente${deletionCount === 1 ? "" : "s"} ${deletionCount === 1 ? "ser\xE1 exclu\xEDdo" : "ser\xE3o exclu\xEDdos"} durante o export porque autoDelete est\xE1 ativo.` : `${deletionCount} candidato${deletionCount === 1 ? "" : "s"} \xE0 exclus\xE3o ${deletionCount === 1 ? "ser\xE1 preservado" : "ser\xE3o preservados"} sem i18n-edit export --delete.`;
+      elements.exportPreviewFeedback.textContent = `${changed} arquivo${changed === 1 ? "" : "s"} com altera\xE7\xF5es planejadas. Aten\xE7\xE3o: ${deletionMessage}`;
+      elements.exportPreviewFeedback.classList.add("warning");
+    } else {
+      elements.exportPreviewFeedback.textContent = changed === 0 ? "Os arquivos do projeto j\xE1 correspondem \xE0 pr\xE9via." : `${changed} arquivo${changed === 1 ? "" : "s"} com altera\xE7\xF5es planejadas.`;
+    }
+  } catch (error) {
+    if (requestVersion !== exportPreviewRequestVersion) return;
+    elements.exportPreviewFeedback.textContent = `N\xE3o foi poss\xEDvel verificar os diffs: ${error instanceof Error ? error.message : String(error)}`;
+    elements.exportPreviewFeedback.classList.add("error");
+  } finally {
+    if (requestVersion === exportPreviewRequestVersion) {
+      elements.checkExportDiffs.disabled = false;
+      elements.checkExportDiffs.textContent = "Verificar novamente";
+    }
+  }
+});
+elements.levelCount.addEventListener("input", () => {
+  applyProjectConfig({
+    ...projectConfig,
+    levelCount: elements.levelCount.value
+  });
+});
+elements.levelNames.addEventListener("input", () => {
+  applyProjectConfig({
+    ...projectConfig,
+    levelNames: elements.levelNames.value
+  });
+});
+elements.translationsDirectory.addEventListener("input", () => {
+  applyProjectConfig({ ...projectConfig, translationsDirectory: elements.translationsDirectory.value });
+});
+elements.languageFileTemplate.addEventListener("input", () => {
+  applyProjectConfig({ ...projectConfig, languageFileTemplate: elements.languageFileTemplate.value });
+});
+elements.importAliases.addEventListener("input", () => {
+  try {
+    const importAliases = parseJsonObject(elements.importAliases.value, "Aliases de import");
+    applyProjectConfig({
+      ...projectConfig,
+      exportConfig: { ...projectConfig.exportConfig, importAliases }
+    }, true, false, false);
+    setFeedback("Aliases atualizados.");
+  } catch (error) {
+    setFeedback(error instanceof Error ? error.message : String(error), true);
+  }
+});
+elements.useDoubleQuotes.addEventListener("change", () => {
+  applyProjectConfig({
+    ...projectConfig,
+    exportConfig: {
+      ...projectConfig.exportConfig,
+      codeFormat: {
+        ...projectConfig.exportConfig.codeFormat,
+        useDoubleQuotes: elements.useDoubleQuotes.checked
+      }
+    }
+  });
+  setFeedback(elements.useDoubleQuotes.checked ? "A exporta\xE7\xE3o usar\xE1 aspas duplas." : "A exporta\xE7\xE3o usar\xE1 aspas simples.");
+});
+elements.useSemicolons.addEventListener("change", () => {
+  applyProjectConfig({
+    ...projectConfig,
+    exportConfig: {
+      ...projectConfig.exportConfig,
+      codeFormat: {
+        ...projectConfig.exportConfig.codeFormat,
+        useSemicolons: elements.useSemicolons.checked
+      }
+    }
+  });
+  setFeedback(elements.useSemicolons.checked ? "A exporta\xE7\xE3o usar\xE1 ponto e v\xEDrgula." : "A exporta\xE7\xE3o n\xE3o usar\xE1 ponto e v\xEDrgula.");
+});
+elements.useShorthandProperties.addEventListener("change", () => {
+  applyProjectConfig({
+    ...projectConfig,
+    exportConfig: {
+      ...projectConfig.exportConfig,
+      codeFormat: {
+        ...projectConfig.exportConfig.codeFormat,
+        useShorthandProperties: elements.useShorthandProperties.checked
+      }
+    }
+  });
+  setFeedback("Prefer\xEAncia de propriedades shorthand atualizada.");
+});
+elements.useTrailingCommas.addEventListener("change", () => {
+  applyProjectConfig({
+    ...projectConfig,
+    exportConfig: {
+      ...projectConfig.exportConfig,
+      codeFormat: {
+        ...projectConfig.exportConfig.codeFormat,
+        useTrailingCommas: elements.useTrailingCommas.checked
+      }
+    }
+  });
+  setFeedback("Prefer\xEAncia de v\xEDrgula final atualizada.");
+});
+function updateIndentation() {
+  applyProjectConfig({
+    ...projectConfig,
+    exportConfig: {
+      ...projectConfig.exportConfig,
+      codeFormat: {
+        ...projectConfig.exportConfig.codeFormat,
+        indentation: {
+          character: elements.indentationCharacter.value,
+          size: elements.indentationSize.value
+        }
+      }
+    }
+  });
+  setFeedback("Indenta\xE7\xE3o da exporta\xE7\xE3o atualizada.");
+}
+elements.indentationCharacter.addEventListener("change", updateIndentation);
+elements.indentationSize.addEventListener("input", updateIndentation);
+elements.printWidth.addEventListener("input", () => {
+  applyProjectConfig({
+    ...projectConfig,
+    exportConfig: {
+      ...projectConfig.exportConfig,
+      codeFormat: {
+        ...projectConfig.exportConfig.codeFormat,
+        printWidth: elements.printWidth.value
+      }
+    }
+  });
+  setFeedback("Largura m\xE1xima da exporta\xE7\xE3o atualizada.");
+});
+function updateInlineItemLimits() {
+  applyProjectConfig({
+    ...projectConfig,
+    exportConfig: {
+      ...projectConfig.exportConfig,
+      codeFormat: {
+        ...projectConfig.exportConfig.codeFormat,
+        maxObjectInlineItems: elements.maxObjectInlineItems.value,
+        maxArrayInlineItems: elements.maxArrayInlineItems.value
+      }
+    }
+  });
+  setFeedback("Limites de cole\xE7\xF5es inline atualizados.");
+}
+elements.maxObjectInlineItems.addEventListener("input", updateInlineItemLimits);
+elements.maxArrayInlineItems.addEventListener("input", updateInlineItemLimits);
+function updateCollectionLayouts() {
+  applyProjectConfig({
+    ...projectConfig,
+    exportConfig: {
+      ...projectConfig.exportConfig,
+      codeFormat: {
+        ...projectConfig.exportConfig.codeFormat,
+        objectLayout: elements.objectLayout.value,
+        arrayLayout: elements.arrayLayout.value
+      }
+    }
+  });
+  setFeedback("Layout de objetos e arrays atualizado.");
+}
+elements.objectLayout.addEventListener("change", updateCollectionLayouts);
+elements.arrayLayout.addEventListener("change", updateCollectionLayouts);
+elements.languageReplacer.addEventListener("input", () => {
+  try {
+    const languageReplacer = parseJsonObject(elements.languageReplacer.value, "Replacer dos idiomas");
+    applyProjectConfig({ ...projectConfig, languageReplacer }, true, false, false);
+    setFeedback("Replacer dos idiomas atualizado.");
+  } catch (error) {
+    setFeedback(error instanceof Error ? error.message : String(error), true);
+  }
+});
+elements.deletionEnabled.addEventListener("change", () => {
+  applyProjectConfig({
+    ...projectConfig,
+    deletion: elements.deletionEnabled.checked ? { ignoredExtensions: [], autoDelete: false } : false
+  });
+  setFeedback(elements.deletionEnabled.checked ? "Detec\xE7\xE3o de arquivos divergentes ativada." : "Detec\xE7\xE3o e avisos de exclus\xE3o desativados.");
+});
+elements.ignoredDeletionExtensions.addEventListener("input", () => {
+  if (projectConfig.deletion === false) return;
+  applyProjectConfig({
+    ...projectConfig,
+    deletion: {
+      ...projectConfig.deletion,
+      ignoredExtensions: elements.ignoredDeletionExtensions.value.split(",")
+    }
+  });
+  setFeedback("Extens\xF5es ignoradas atualizadas.");
+});
+elements.autoDelete.addEventListener("change", () => {
+  if (projectConfig.deletion === false) return;
+  applyProjectConfig({
+    ...projectConfig,
+    deletion: { ...projectConfig.deletion, autoDelete: elements.autoDelete.checked }
+  });
+  setFeedback(elements.autoDelete.checked ? "Exclus\xE3o autom\xE1tica ativada para o projeto." : "Exclus\xF5es voltar\xE3o a exigir a op\xE7\xE3o --delete.");
+});
+function setProjectStatus(message, isError = false) {
+  elements.projectStatus.hidden = false;
+  elements.projectStatus.classList.toggle("error", isError);
+  elements.projectStatus.classList.toggle("loading", !isError);
+  elements.projectStatusText.textContent = message;
+  elements.retryProjectLoad.hidden = !isError;
+}
+function hideProjectStatus() {
+  elements.projectStatus.hidden = true;
+}
+async function loadProject() {
+  setProjectStatus("Conectando ao projeto\u2026");
+  try {
+    const [info, storedBundle, storedConfig] = await Promise.all([
+      getProjectInfo(),
+      loadStoredBundle(),
+      loadStoredProjectConfig()
+    ]);
+    if (info.config) {
+      applyProjectConfig(info.config, false);
+    } else if (storedConfig && Array.isArray(storedConfig.levelImports)) {
+      applyProjectConfig(storedConfig, false);
+    }
+    let projectBundle = info.bundle;
+    let generated = false;
+    if (!projectBundle) {
+      if (!info.canGenerateBundle) {
+        throw new Error("O projeto n\xE3o possui uma bundle e o cat\xE1logo TypeScript n\xE3o foi encontrado.");
+      }
+      setProjectStatus("Gerando a bundle do projeto\u2026");
+      projectBundle = (await generateProjectBundle()).bundle;
+      generated = true;
+    }
+    const projectIsNewer = storedBundle && projectBundle.updatedAt > storedBundle.updatedAt;
+    const selectedBundle = !storedBundle || projectIsNewer ? projectBundle : storedBundle;
+    if (projectIsNewer && !generated) {
+      window.alert("Existe uma bundle mais recente no projeto. Ela foi carregada e substituir\xE1 a c\xF3pia local do navegador.");
+    }
+    state.replaceBundle(selectedBundle);
+    setFeedback(generated ? "Bundle gerada automaticamente a partir do cat\xE1logo do projeto." : selectedBundle === storedBundle ? "Vers\xE3o mais recente restaurada do navegador." : "Bundle do projeto carregada automaticamente.");
+    hideProjectStatus();
+  } catch (error) {
+    setProjectStatus(
+      `N\xE3o foi poss\xEDvel carregar o projeto: ${error instanceof Error ? error.message : String(error)}`,
+      true
+    );
+  }
+}
+applyProjectConfig(projectConfig, false);
+elements.retryProjectLoad.addEventListener("click", () => void loadProject());
+void loadProject();