trello-cli-unofficial 0.7.3 → 0.7.5

package/dist/main.js

@@ -23178,6 +23178,2653 @@ var init_esm16 = __esm(() => {
   esm_default12 = inquirer;
 });
 
+// node_modules/i18next/dist/esm/i18next.js
+class RegExpCache {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.regExpMap = new Map;
+    this.regExpQueue = [];
+  }
+  getRegExp(pattern) {
+    const regExpFromCache = this.regExpMap.get(pattern);
+    if (regExpFromCache !== undefined) {
+      return regExpFromCache;
+    }
+    const regExpNew = new RegExp(pattern);
+    if (this.regExpQueue.length === this.capacity) {
+      this.regExpMap.delete(this.regExpQueue.shift());
+    }
+    this.regExpMap.set(pattern, regExpNew);
+    this.regExpQueue.push(pattern);
+    return regExpNew;
+  }
+}
+
+class Logger {
+  constructor(concreteLogger, options = {}) {
+    this.init(concreteLogger, options);
+  }
+  init(concreteLogger, options = {}) {
+    this.prefix = options.prefix || "i18next:";
+    this.logger = concreteLogger || consoleLogger;
+    this.options = options;
+    this.debug = options.debug;
+  }
+  log(...args) {
+    return this.forward(args, "log", "", true);
+  }
+  warn(...args) {
+    return this.forward(args, "warn", "", true);
+  }
+  error(...args) {
+    return this.forward(args, "error", "");
+  }
+  deprecate(...args) {
+    return this.forward(args, "warn", "WARNING DEPRECATED: ", true);
+  }
+  forward(args, lvl, prefix, debugOnly) {
+    if (debugOnly && !this.debug)
+      return null;
+    if (isString(args[0]))
+      args[0] = `${prefix}${this.prefix} ${args[0]}`;
+    return this.logger[lvl](args);
+  }
+  create(moduleName) {
+    return new Logger(this.logger, {
+      ...{
+        prefix: `${this.prefix}:${moduleName}:`
+      },
+      ...this.options
+    });
+  }
+  clone(options) {
+    options = options || this.options;
+    options.prefix = options.prefix || this.prefix;
+    return new Logger(this.logger, options);
+  }
+}
+
+class EventEmitter {
+  constructor() {
+    this.observers = {};
+  }
+  on(events, listener) {
+    events.split(" ").forEach((event) => {
+      if (!this.observers[event])
+        this.observers[event] = new Map;
+      const numListeners = this.observers[event].get(listener) || 0;
+      this.observers[event].set(listener, numListeners + 1);
+    });
+    return this;
+  }
+  off(event, listener) {
+    if (!this.observers[event])
+      return;
+    if (!listener) {
+      delete this.observers[event];
+      return;
+    }
+    this.observers[event].delete(listener);
+  }
+  emit(event, ...args) {
+    if (this.observers[event]) {
+      const cloned = Array.from(this.observers[event].entries());
+      cloned.forEach(([observer, numTimesAdded]) => {
+        for (let i = 0;i < numTimesAdded; i++) {
+          observer(...args);
+        }
+      });
+    }
+    if (this.observers["*"]) {
+      const cloned = Array.from(this.observers["*"].entries());
+      cloned.forEach(([observer, numTimesAdded]) => {
+        for (let i = 0;i < numTimesAdded; i++) {
+          observer.apply(observer, [event, ...args]);
+        }
+      });
+    }
+  }
+}
+function createProxy() {
+  const state = [];
+  const handler = Object.create(null);
+  let proxy;
+  handler.get = (target, key) => {
+    proxy?.revoke?.();
+    if (key === PATH_KEY)
+      return state;
+    state.push(key);
+    proxy = Proxy.revocable(target, handler);
+    return proxy.proxy;
+  };
+  return Proxy.revocable(Object.create(null), handler).proxy;
+}
+function keysFromSelector(selector, opts) {
+  const {
+    [PATH_KEY]: path2
+  } = selector(createProxy());
+  return path2.join(opts?.keySeparator ?? ".");
+}
+
+class LanguageUtil {
+  constructor(options) {
+    this.options = options;
+    this.supportedLngs = this.options.supportedLngs || false;
+    this.logger = baseLogger.create("languageUtils");
+  }
+  getScriptPartFromCode(code) {
+    code = getCleanedCode(code);
+    if (!code || code.indexOf("-") < 0)
+      return null;
+    const p = code.split("-");
+    if (p.length === 2)
+      return null;
+    p.pop();
+    if (p[p.length - 1].toLowerCase() === "x")
+      return null;
+    return this.formatLanguageCode(p.join("-"));
+  }
+  getLanguagePartFromCode(code) {
+    code = getCleanedCode(code);
+    if (!code || code.indexOf("-") < 0)
+      return code;
+    const p = code.split("-");
+    return this.formatLanguageCode(p[0]);
+  }
+  formatLanguageCode(code) {
+    if (isString(code) && code.indexOf("-") > -1) {
+      let formattedCode;
+      try {
+        formattedCode = Intl.getCanonicalLocales(code)[0];
+      } catch (e) {}
+      if (formattedCode && this.options.lowerCaseLng) {
+        formattedCode = formattedCode.toLowerCase();
+      }
+      if (formattedCode)
+        return formattedCode;
+      if (this.options.lowerCaseLng) {
+        return code.toLowerCase();
+      }
+      return code;
+    }
+    return this.options.cleanCode || this.options.lowerCaseLng ? code.toLowerCase() : code;
+  }
+  isSupportedCode(code) {
+    if (this.options.load === "languageOnly" || this.options.nonExplicitSupportedLngs) {
+      code = this.getLanguagePartFromCode(code);
+    }
+    return !this.supportedLngs || !this.supportedLngs.length || this.supportedLngs.indexOf(code) > -1;
+  }
+  getBestMatchFromCodes(codes) {
+    if (!codes)
+      return null;
+    let found;
+    codes.forEach((code) => {
+      if (found)
+        return;
+      const cleanedLng = this.formatLanguageCode(code);
+      if (!this.options.supportedLngs || this.isSupportedCode(cleanedLng))
+        found = cleanedLng;
+    });
+    if (!found && this.options.supportedLngs) {
+      codes.forEach((code) => {
+        if (found)
+          return;
+        const lngScOnly = this.getScriptPartFromCode(code);
+        if (this.isSupportedCode(lngScOnly))
+          return found = lngScOnly;
+        const lngOnly = this.getLanguagePartFromCode(code);
+        if (this.isSupportedCode(lngOnly))
+          return found = lngOnly;
+        found = this.options.supportedLngs.find((supportedLng) => {
+          if (supportedLng === lngOnly)
+            return supportedLng;
+          if (supportedLng.indexOf("-") < 0 && lngOnly.indexOf("-") < 0)
+            return;
+          if (supportedLng.indexOf("-") > 0 && lngOnly.indexOf("-") < 0 && supportedLng.substring(0, supportedLng.indexOf("-")) === lngOnly)
+            return supportedLng;
+          if (supportedLng.indexOf(lngOnly) === 0 && lngOnly.length > 1)
+            return supportedLng;
+        });
+      });
+    }
+    if (!found)
+      found = this.getFallbackCodes(this.options.fallbackLng)[0];
+    return found;
+  }
+  getFallbackCodes(fallbacks, code) {
+    if (!fallbacks)
+      return [];
+    if (typeof fallbacks === "function")
+      fallbacks = fallbacks(code);
+    if (isString(fallbacks))
+      fallbacks = [fallbacks];
+    if (Array.isArray(fallbacks))
+      return fallbacks;
+    if (!code)
+      return fallbacks.default || [];
+    let found = fallbacks[code];
+    if (!found)
+      found = fallbacks[this.getScriptPartFromCode(code)];
+    if (!found)
+      found = fallbacks[this.formatLanguageCode(code)];
+    if (!found)
+      found = fallbacks[this.getLanguagePartFromCode(code)];
+    if (!found)
+      found = fallbacks.default;
+    return found || [];
+  }
+  toResolveHierarchy(code, fallbackCode) {
+    const fallbackCodes = this.getFallbackCodes((fallbackCode === false ? [] : fallbackCode) || this.options.fallbackLng || [], code);
+    const codes = [];
+    const addCode = (c) => {
+      if (!c)
+        return;
+      if (this.isSupportedCode(c)) {
+        codes.push(c);
+      } else {
+        this.logger.warn(`rejecting language code not found in supportedLngs: ${c}`);
+      }
+    };
+    if (isString(code) && (code.indexOf("-") > -1 || code.indexOf("_") > -1)) {
+      if (this.options.load !== "languageOnly")
+        addCode(this.formatLanguageCode(code));
+      if (this.options.load !== "languageOnly" && this.options.load !== "currentOnly")
+        addCode(this.getScriptPartFromCode(code));
+      if (this.options.load !== "currentOnly")
+        addCode(this.getLanguagePartFromCode(code));
+    } else if (isString(code)) {
+      addCode(this.formatLanguageCode(code));
+    }
+    fallbackCodes.forEach((fc) => {
+      if (codes.indexOf(fc) < 0)
+        addCode(this.formatLanguageCode(fc));
+    });
+    return codes;
+  }
+}
+
+class PluralResolver {
+  constructor(languageUtils, options = {}) {
+    this.languageUtils = languageUtils;
+    this.options = options;
+    this.logger = baseLogger.create("pluralResolver");
+    this.pluralRulesCache = {};
+  }
+  addRule(lng, obj) {
+    this.rules[lng] = obj;
+  }
+  clearCache() {
+    this.pluralRulesCache = {};
+  }
+  getRule(code, options = {}) {
+    const cleanedCode = getCleanedCode(code === "dev" ? "en" : code);
+    const type = options.ordinal ? "ordinal" : "cardinal";
+    const cacheKey = JSON.stringify({
+      cleanedCode,
+      type
+    });
+    if (cacheKey in this.pluralRulesCache) {
+      return this.pluralRulesCache[cacheKey];
+    }
+    let rule;
+    try {
+      rule = new Intl.PluralRules(cleanedCode, {
+        type
+      });
+    } catch (err) {
+      if (!Intl) {
+        this.logger.error("No Intl support, please use an Intl polyfill!");
+        return dummyRule;
+      }
+      if (!code.match(/-|_/))
+        return dummyRule;
+      const lngPart = this.languageUtils.getLanguagePartFromCode(code);
+      rule = this.getRule(lngPart, options);
+    }
+    this.pluralRulesCache[cacheKey] = rule;
+    return rule;
+  }
+  needsPlural(code, options = {}) {
+    let rule = this.getRule(code, options);
+    if (!rule)
+      rule = this.getRule("dev", options);
+    return rule?.resolvedOptions().pluralCategories.length > 1;
+  }
+  getPluralFormsOfKey(code, key, options = {}) {
+    return this.getSuffixes(code, options).map((suffix) => `${key}${suffix}`);
+  }
+  getSuffixes(code, options = {}) {
+    let rule = this.getRule(code, options);
+    if (!rule)
+      rule = this.getRule("dev", options);
+    if (!rule)
+      return [];
+    return rule.resolvedOptions().pluralCategories.sort((pluralCategory1, pluralCategory2) => suffixesOrder[pluralCategory1] - suffixesOrder[pluralCategory2]).map((pluralCategory) => `${this.options.prepend}${options.ordinal ? `ordinal${this.options.prepend}` : ""}${pluralCategory}`);
+  }
+  getSuffix(code, count, options = {}) {
+    const rule = this.getRule(code, options);
+    if (rule) {
+      return `${this.options.prepend}${options.ordinal ? `ordinal${this.options.prepend}` : ""}${rule.select(count)}`;
+    }
+    this.logger.warn(`no plural rule found for: ${code}`);
+    return this.getSuffix("dev", count, options);
+  }
+}
+
+class Interpolator {
+  constructor(options = {}) {
+    this.logger = baseLogger.create("interpolator");
+    this.options = options;
+    this.format = options?.interpolation?.format || ((value) => value);
+    this.init(options);
+  }
+  init(options = {}) {
+    if (!options.interpolation)
+      options.interpolation = {
+        escapeValue: true
+      };
+    const {
+      escape: escape$1,
+      escapeValue,
+      useRawValueToEscape,
+      prefix,
+      prefixEscaped,
+      suffix,
+      suffixEscaped,
+      formatSeparator,
+      unescapeSuffix,
+      unescapePrefix,
+      nestingPrefix,
+      nestingPrefixEscaped,
+      nestingSuffix,
+      nestingSuffixEscaped,
+      nestingOptionsSeparator,
+      maxReplaces,
+      alwaysFormat
+    } = options.interpolation;
+    this.escape = escape$1 !== undefined ? escape$1 : escape;
+    this.escapeValue = escapeValue !== undefined ? escapeValue : true;
+    this.useRawValueToEscape = useRawValueToEscape !== undefined ? useRawValueToEscape : false;
+    this.prefix = prefix ? regexEscape(prefix) : prefixEscaped || "{{";
+    this.suffix = suffix ? regexEscape(suffix) : suffixEscaped || "}}";
+    this.formatSeparator = formatSeparator || ",";
+    this.unescapePrefix = unescapeSuffix ? "" : unescapePrefix || "-";
+    this.unescapeSuffix = this.unescapePrefix ? "" : unescapeSuffix || "";
+    this.nestingPrefix = nestingPrefix ? regexEscape(nestingPrefix) : nestingPrefixEscaped || regexEscape("$t(");
+    this.nestingSuffix = nestingSuffix ? regexEscape(nestingSuffix) : nestingSuffixEscaped || regexEscape(")");
+    this.nestingOptionsSeparator = nestingOptionsSeparator || ",";
+    this.maxReplaces = maxReplaces || 1000;
+    this.alwaysFormat = alwaysFormat !== undefined ? alwaysFormat : false;
+    this.resetRegExp();
+  }
+  reset() {
+    if (this.options)
+      this.init(this.options);
+  }
+  resetRegExp() {
+    const getOrResetRegExp = (existingRegExp, pattern) => {
+      if (existingRegExp?.source === pattern) {
+        existingRegExp.lastIndex = 0;
+        return existingRegExp;
+      }
+      return new RegExp(pattern, "g");
+    };
+    this.regexp = getOrResetRegExp(this.regexp, `${this.prefix}(.+?)${this.suffix}`);
+    this.regexpUnescape = getOrResetRegExp(this.regexpUnescape, `${this.prefix}${this.unescapePrefix}(.+?)${this.unescapeSuffix}${this.suffix}`);
+    this.nestingRegexp = getOrResetRegExp(this.nestingRegexp, `${this.nestingPrefix}((?:[^()"']+|"[^"]*"|'[^']*'|\\((?:[^()]|"[^"]*"|'[^']*')*\\))*?)${this.nestingSuffix}`);
+  }
+  interpolate(str, data, lng, options) {
+    let match;
+    let value;
+    let replaces;
+    const defaultData = this.options && this.options.interpolation && this.options.interpolation.defaultVariables || {};
+    const handleFormat = (key) => {
+      if (key.indexOf(this.formatSeparator) < 0) {
+        const path2 = deepFindWithDefaults(data, defaultData, key, this.options.keySeparator, this.options.ignoreJSONStructure);
+        return this.alwaysFormat ? this.format(path2, undefined, lng, {
+          ...options,
+          ...data,
+          interpolationkey: key
+        }) : path2;
+      }
+      const p = key.split(this.formatSeparator);
+      const k = p.shift().trim();
+      const f = p.join(this.formatSeparator).trim();
+      return this.format(deepFindWithDefaults(data, defaultData, k, this.options.keySeparator, this.options.ignoreJSONStructure), f, lng, {
+        ...options,
+        ...data,
+        interpolationkey: k
+      });
+    };
+    this.resetRegExp();
+    const missingInterpolationHandler = options?.missingInterpolationHandler || this.options.missingInterpolationHandler;
+    const skipOnVariables = options?.interpolation?.skipOnVariables !== undefined ? options.interpolation.skipOnVariables : this.options.interpolation.skipOnVariables;
+    const todos = [{
+      regex: this.regexpUnescape,
+      safeValue: (val) => regexSafe(val)
+    }, {
+      regex: this.regexp,
+      safeValue: (val) => this.escapeValue ? regexSafe(this.escape(val)) : regexSafe(val)
+    }];
+    todos.forEach((todo) => {
+      replaces = 0;
+      while (match = todo.regex.exec(str)) {
+        const matchedVar = match[1].trim();
+        value = handleFormat(matchedVar);
+        if (value === undefined) {
+          if (typeof missingInterpolationHandler === "function") {
+            const temp = missingInterpolationHandler(str, match, options);
+            value = isString(temp) ? temp : "";
+          } else if (options && Object.prototype.hasOwnProperty.call(options, matchedVar)) {
+            value = "";
+          } else if (skipOnVariables) {
+            value = match[0];
+            continue;
+          } else {
+            this.logger.warn(`missed to pass in variable ${matchedVar} for interpolating ${str}`);
+            value = "";
+          }
+        } else if (!isString(value) && !this.useRawValueToEscape) {
+          value = makeString(value);
+        }
+        const safeValue = todo.safeValue(value);
+        str = str.replace(match[0], safeValue);
+        if (skipOnVariables) {
+          todo.regex.lastIndex += value.length;
+          todo.regex.lastIndex -= match[0].length;
+        } else {
+          todo.regex.lastIndex = 0;
+        }
+        replaces++;
+        if (replaces >= this.maxReplaces) {
+          break;
+        }
+      }
+    });
+    return str;
+  }
+  nest(str, fc, options = {}) {
+    let match;
+    let value;
+    let clonedOptions;
+    const handleHasOptions = (key, inheritedOptions) => {
+      const sep = this.nestingOptionsSeparator;
+      if (key.indexOf(sep) < 0)
+        return key;
+      const c = key.split(new RegExp(`${sep}[ ]*{`));
+      let optionsString = `{${c[1]}`;
+      key = c[0];
+      optionsString = this.interpolate(optionsString, clonedOptions);
+      const matchedSingleQuotes = optionsString.match(/'/g);
+      const matchedDoubleQuotes = optionsString.match(/"/g);
+      if ((matchedSingleQuotes?.length ?? 0) % 2 === 0 && !matchedDoubleQuotes || matchedDoubleQuotes.length % 2 !== 0) {
+        optionsString = optionsString.replace(/'/g, '"');
+      }
+      try {
+        clonedOptions = JSON.parse(optionsString);
+        if (inheritedOptions)
+          clonedOptions = {
+            ...inheritedOptions,
+            ...clonedOptions
+          };
+      } catch (e) {
+        this.logger.warn(`failed parsing options string in nesting for key ${key}`, e);
+        return `${key}${sep}${optionsString}`;
+      }
+      if (clonedOptions.defaultValue && clonedOptions.defaultValue.indexOf(this.prefix) > -1)
+        delete clonedOptions.defaultValue;
+      return key;
+    };
+    while (match = this.nestingRegexp.exec(str)) {
+      let formatters = [];
+      clonedOptions = {
+        ...options
+      };
+      clonedOptions = clonedOptions.replace && !isString(clonedOptions.replace) ? clonedOptions.replace : clonedOptions;
+      clonedOptions.applyPostProcessor = false;
+      delete clonedOptions.defaultValue;
+      const keyEndIndex = /{.*}/.test(match[1]) ? match[1].lastIndexOf("}") + 1 : match[1].indexOf(this.formatSeparator);
+      if (keyEndIndex !== -1) {
+        formatters = match[1].slice(keyEndIndex).split(this.formatSeparator).map((elem) => elem.trim()).filter(Boolean);
+        match[1] = match[1].slice(0, keyEndIndex);
+      }
+      value = fc(handleHasOptions.call(this, match[1].trim(), clonedOptions), clonedOptions);
+      if (value && match[0] === str && !isString(value))
+        return value;
+      if (!isString(value))
+        value = makeString(value);
+      if (!value) {
+        this.logger.warn(`missed to resolve ${match[1]} for nesting ${str}`);
+        value = "";
+      }
+      if (formatters.length) {
+        value = formatters.reduce((v, f) => this.format(v, f, options.lng, {
+          ...options,
+          interpolationkey: match[1].trim()
+        }), value.trim());
+      }
+      str = str.replace(match[0], value);
+      this.regexp.lastIndex = 0;
+    }
+    return str;
+  }
+}
+
+class Formatter {
+  constructor(options = {}) {
+    this.logger = baseLogger.create("formatter");
+    this.options = options;
+    this.init(options);
+  }
+  init(services, options = {
+    interpolation: {}
+  }) {
+    this.formatSeparator = options.interpolation.formatSeparator || ",";
+    const cf = options.cacheInBuiltFormats ? createCachedFormatter : createNonCachedFormatter;
+    this.formats = {
+      number: cf((lng, opt) => {
+        const formatter = new Intl.NumberFormat(lng, {
+          ...opt
+        });
+        return (val) => formatter.format(val);
+      }),
+      currency: cf((lng, opt) => {
+        const formatter = new Intl.NumberFormat(lng, {
+          ...opt,
+          style: "currency"
+        });
+        return (val) => formatter.format(val);
+      }),
+      datetime: cf((lng, opt) => {
+        const formatter = new Intl.DateTimeFormat(lng, {
+          ...opt
+        });
+        return (val) => formatter.format(val);
+      }),
+      relativetime: cf((lng, opt) => {
+        const formatter = new Intl.RelativeTimeFormat(lng, {
+          ...opt
+        });
+        return (val) => formatter.format(val, opt.range || "day");
+      }),
+      list: cf((lng, opt) => {
+        const formatter = new Intl.ListFormat(lng, {
+          ...opt
+        });
+        return (val) => formatter.format(val);
+      })
+    };
+  }
+  add(name, fc) {
+    this.formats[name.toLowerCase().trim()] = fc;
+  }
+  addCached(name, fc) {
+    this.formats[name.toLowerCase().trim()] = createCachedFormatter(fc);
+  }
+  format(value, format, lng, options = {}) {
+    const formats = format.split(this.formatSeparator);
+    if (formats.length > 1 && formats[0].indexOf("(") > 1 && formats[0].indexOf(")") < 0 && formats.find((f) => f.indexOf(")") > -1)) {
+      const lastIndex = formats.findIndex((f) => f.indexOf(")") > -1);
+      formats[0] = [formats[0], ...formats.splice(1, lastIndex)].join(this.formatSeparator);
+    }
+    const result = formats.reduce((mem, f) => {
+      const {
+        formatName,
+        formatOptions
+      } = parseFormatStr(f);
+      if (this.formats[formatName]) {
+        let formatted = mem;
+        try {
+          const valOptions = options?.formatParams?.[options.interpolationkey] || {};
+          const l = valOptions.locale || valOptions.lng || options.locale || options.lng || lng;
+          formatted = this.formats[formatName](mem, l, {
+            ...formatOptions,
+            ...options,
+            ...valOptions
+          });
+        } catch (error) {
+          this.logger.warn(error);
+        }
+        return formatted;
+      } else {
+        this.logger.warn(`there was no format function for ${formatName}`);
+      }
+      return mem;
+    }, value);
+    return result;
+  }
+}
+var isString = (obj) => typeof obj === "string", defer2 = () => {
+  let res;
+  let rej;
+  const promise = new Promise((resolve, reject) => {
+    res = resolve;
+    rej = reject;
+  });
+  promise.resolve = res;
+  promise.reject = rej;
+  return promise;
+}, makeString = (object) => {
+  if (object == null)
+    return "";
+  return "" + object;
+}, copy = (a, s, t) => {
+  a.forEach((m) => {
+    if (s[m])
+      t[m] = s[m];
+  });
+}, lastOfPathSeparatorRegExp, cleanKey = (key) => key && key.indexOf("###") > -1 ? key.replace(lastOfPathSeparatorRegExp, ".") : key, canNotTraverseDeeper = (object) => !object || isString(object), getLastOfPath = (object, path2, Empty) => {
+  const stack = !isString(path2) ? path2 : path2.split(".");
+  let stackIndex = 0;
+  while (stackIndex < stack.length - 1) {
+    if (canNotTraverseDeeper(object))
+      return {};
+    const key = cleanKey(stack[stackIndex]);
+    if (!object[key] && Empty)
+      object[key] = new Empty;
+    if (Object.prototype.hasOwnProperty.call(object, key)) {
+      object = object[key];
+    } else {
+      object = {};
+    }
+    ++stackIndex;
+  }
+  if (canNotTraverseDeeper(object))
+    return {};
+  return {
+    obj: object,
+    k: cleanKey(stack[stackIndex])
+  };
+}, setPath = (object, path2, newValue) => {
+  const {
+    obj,
+    k
+  } = getLastOfPath(object, path2, Object);
+  if (obj !== undefined || path2.length === 1) {
+    obj[k] = newValue;
+    return;
+  }
+  let e = path2[path2.length - 1];
+  let p = path2.slice(0, path2.length - 1);
+  let last = getLastOfPath(object, p, Object);
+  while (last.obj === undefined && p.length) {
+    e = `${p[p.length - 1]}.${e}`;
+    p = p.slice(0, p.length - 1);
+    last = getLastOfPath(object, p, Object);
+    if (last?.obj && typeof last.obj[`${last.k}.${e}`] !== "undefined") {
+      last.obj = undefined;
+    }
+  }
+  last.obj[`${last.k}.${e}`] = newValue;
+}, pushPath = (object, path2, newValue, concat) => {
+  const {
+    obj,
+    k
+  } = getLastOfPath(object, path2, Object);
+  obj[k] = obj[k] || [];
+  obj[k].push(newValue);
+}, getPath = (object, path2) => {
+  const {
+    obj,
+    k
+  } = getLastOfPath(object, path2);
+  if (!obj)
+    return;
+  if (!Object.prototype.hasOwnProperty.call(obj, k))
+    return;
+  return obj[k];
+}, getPathWithDefaults = (data, defaultData, key) => {
+  const value = getPath(data, key);
+  if (value !== undefined) {
+    return value;
+  }
+  return getPath(defaultData, key);
+}, deepExtend = (target, source, overwrite) => {
+  for (const prop in source) {
+    if (prop !== "__proto__" && prop !== "constructor") {
+      if (prop in target) {
+        if (isString(target[prop]) || target[prop] instanceof String || isString(source[prop]) || source[prop] instanceof String) {
+          if (overwrite)
+            target[prop] = source[prop];
+        } else {
+          deepExtend(target[prop], source[prop], overwrite);
+        }
+      } else {
+        target[prop] = source[prop];
+      }
+    }
+  }
+  return target;
+}, regexEscape = (str) => str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"), _entityMap, escape = (data) => {
+  if (isString(data)) {
+    return data.replace(/[&<>"'\/]/g, (s) => _entityMap[s]);
+  }
+  return data;
+}, chars, looksLikeObjectPathRegExpCache, looksLikeObjectPath = (key, nsSeparator, keySeparator) => {
+  nsSeparator = nsSeparator || "";
+  keySeparator = keySeparator || "";
+  const possibleChars = chars.filter((c) => nsSeparator.indexOf(c) < 0 && keySeparator.indexOf(c) < 0);
+  if (possibleChars.length === 0)
+    return true;
+  const r = looksLikeObjectPathRegExpCache.getRegExp(`(${possibleChars.map((c) => c === "?" ? "\\?" : c).join("|")})`);
+  let matched = !r.test(key);
+  if (!matched) {
+    const ki = key.indexOf(keySeparator);
+    if (ki > 0 && !r.test(key.substring(0, ki))) {
+      matched = true;
+    }
+  }
+  return matched;
+}, deepFind = (obj, path2, keySeparator = ".") => {
+  if (!obj)
+    return;
+  if (obj[path2]) {
+    if (!Object.prototype.hasOwnProperty.call(obj, path2))
+      return;
+    return obj[path2];
+  }
+  const tokens = path2.split(keySeparator);
+  let current = obj;
+  for (let i = 0;i < tokens.length; ) {
+    if (!current || typeof current !== "object") {
+      return;
+    }
+    let next;
+    let nextPath = "";
+    for (let j = i;j < tokens.length; ++j) {
+      if (j !== i) {
+        nextPath += keySeparator;
+      }
+      nextPath += tokens[j];
+      next = current[nextPath];
+      if (next !== undefined) {
+        if (["string", "number", "boolean"].indexOf(typeof next) > -1 && j < tokens.length - 1) {
+          continue;
+        }
+        i += j - i + 1;
+        break;
+      }
+    }
+    current = next;
+  }
+  return current;
+}, getCleanedCode = (code) => code?.replace("_", "-"), consoleLogger, baseLogger, ResourceStore, postProcessor, PATH_KEY, checkedLoadedFor, shouldHandleAsObject = (res) => !isString(res) && typeof res !== "boolean" && typeof res !== "number", Translator, suffixesOrder, dummyRule, deepFindWithDefaults = (data, defaultData, key, keySeparator = ".", ignoreJSONStructure = true) => {
+  let path2 = getPathWithDefaults(data, defaultData, key);
+  if (!path2 && ignoreJSONStructure && isString(key)) {
+    path2 = deepFind(data, key, keySeparator);
+    if (path2 === undefined)
+      path2 = deepFind(defaultData, key, keySeparator);
+  }
+  return path2;
+}, regexSafe = (val) => val.replace(/\$/g, "$$$$"), parseFormatStr = (formatStr) => {
+  let formatName = formatStr.toLowerCase().trim();
+  const formatOptions = {};
+  if (formatStr.indexOf("(") > -1) {
+    const p = formatStr.split("(");
+    formatName = p[0].toLowerCase().trim();
+    const optStr = p[1].substring(0, p[1].length - 1);
+    if (formatName === "currency" && optStr.indexOf(":") < 0) {
+      if (!formatOptions.currency)
+        formatOptions.currency = optStr.trim();
+    } else if (formatName === "relativetime" && optStr.indexOf(":") < 0) {
+      if (!formatOptions.range)
+        formatOptions.range = optStr.trim();
+    } else {
+      const opts = optStr.split(";");
+      opts.forEach((opt) => {
+        if (opt) {
+          const [key, ...rest] = opt.split(":");
+          const val = rest.join(":").trim().replace(/^'+|'+$/g, "");
+          const trimmedKey = key.trim();
+          if (!formatOptions[trimmedKey])
+            formatOptions[trimmedKey] = val;
+          if (val === "false")
+            formatOptions[trimmedKey] = false;
+          if (val === "true")
+            formatOptions[trimmedKey] = true;
+          if (!isNaN(val))
+            formatOptions[trimmedKey] = parseInt(val, 10);
+        }
+      });
+    }
+  }
+  return {
+    formatName,
+    formatOptions
+  };
+}, createCachedFormatter = (fn) => {
+  const cache = {};
+  return (v, l, o) => {
+    let optForCache = o;
+    if (o && o.interpolationkey && o.formatParams && o.formatParams[o.interpolationkey] && o[o.interpolationkey]) {
+      optForCache = {
+        ...optForCache,
+        [o.interpolationkey]: undefined
+      };
+    }
+    const key = l + JSON.stringify(optForCache);
+    let frm = cache[key];
+    if (!frm) {
+      frm = fn(getCleanedCode(l), o);
+      cache[key] = frm;
+    }
+    return frm(v);
+  };
+}, createNonCachedFormatter = (fn) => (v, l, o) => fn(getCleanedCode(l), o)(v), removePending = (q, name) => {
+  if (q.pending[name] !== undefined) {
+    delete q.pending[name];
+    q.pendingCount--;
+  }
+}, Connector, get = () => ({
+  debug: false,
+  initAsync: true,
+  ns: ["translation"],
+  defaultNS: ["translation"],
+  fallbackLng: ["dev"],
+  fallbackNS: false,
+  supportedLngs: false,
+  nonExplicitSupportedLngs: false,
+  load: "all",
+  preload: false,
+  simplifyPluralSuffix: true,
+  keySeparator: ".",
+  nsSeparator: ":",
+  pluralSeparator: "_",
+  contextSeparator: "_",
+  partialBundledLanguages: false,
+  saveMissing: false,
+  updateMissing: false,
+  saveMissingTo: "fallback",
+  saveMissingPlurals: true,
+  missingKeyHandler: false,
+  missingInterpolationHandler: false,
+  postProcess: false,
+  postProcessPassResolved: false,
+  returnNull: false,
+  returnEmptyString: true,
+  returnObjects: false,
+  joinArrays: false,
+  returnedObjectHandler: false,
+  parseMissingKeyHandler: false,
+  appendNamespaceToMissingKey: false,
+  appendNamespaceToCIMode: false,
+  overloadTranslationOptionHandler: (args) => {
+    let ret = {};
+    if (typeof args[1] === "object")
+      ret = args[1];
+    if (isString(args[1]))
+      ret.defaultValue = args[1];
+    if (isString(args[2]))
+      ret.tDescription = args[2];
+    if (typeof args[2] === "object" || typeof args[3] === "object") {
+      const options = args[3] || args[2];
+      Object.keys(options).forEach((key) => {
+        ret[key] = options[key];
+      });
+    }
+    return ret;
+  },
+  interpolation: {
+    escapeValue: true,
+    format: (value) => value,
+    prefix: "{{",
+    suffix: "}}",
+    formatSeparator: ",",
+    unescapePrefix: "-",
+    nestingPrefix: "$t(",
+    nestingSuffix: ")",
+    nestingOptionsSeparator: ",",
+    maxReplaces: 1000,
+    skipOnVariables: true
+  },
+  cacheInBuiltFormats: true
+}), transformOptions = (options) => {
+  if (isString(options.ns))
+    options.ns = [options.ns];
+  if (isString(options.fallbackLng))
+    options.fallbackLng = [options.fallbackLng];
+  if (isString(options.fallbackNS))
+    options.fallbackNS = [options.fallbackNS];
+  if (options.supportedLngs?.indexOf?.("cimode") < 0) {
+    options.supportedLngs = options.supportedLngs.concat(["cimode"]);
+  }
+  if (typeof options.initImmediate === "boolean")
+    options.initAsync = options.initImmediate;
+  return options;
+}, noop = () => {}, bindMemberFunctions = (inst) => {
+  const mems = Object.getOwnPropertyNames(Object.getPrototypeOf(inst));
+  mems.forEach((mem) => {
+    if (typeof inst[mem] === "function") {
+      inst[mem] = inst[mem].bind(inst);
+    }
+  });
+}, I18n, instance, createInstance, dir, init, loadResources, reloadResources, use, changeLanguage, getFixedT, t, exists, setDefaultNamespace, hasLoadedNamespace, loadNamespaces, loadLanguages;
+var init_i18next = __esm(() => {
+  lastOfPathSeparatorRegExp = /###/g;
+  _entityMap = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+    "/": "&#x2F;"
+  };
+  chars = [" ", ",", "?", "!", ";"];
+  looksLikeObjectPathRegExpCache = new RegExpCache(20);
+  consoleLogger = {
+    type: "logger",
+    log(args) {
+      this.output("log", args);
+    },
+    warn(args) {
+      this.output("warn", args);
+    },
+    error(args) {
+      this.output("error", args);
+    },
+    output(type, args) {
+      console?.[type]?.apply?.(console, args);
+    }
+  };
+  baseLogger = new Logger;
+  ResourceStore = class ResourceStore extends EventEmitter {
+    constructor(data, options = {
+      ns: ["translation"],
+      defaultNS: "translation"
+    }) {
+      super();
+      this.data = data || {};
+      this.options = options;
+      if (this.options.keySeparator === undefined) {
+        this.options.keySeparator = ".";
+      }
+      if (this.options.ignoreJSONStructure === undefined) {
+        this.options.ignoreJSONStructure = true;
+      }
+    }
+    addNamespaces(ns) {
+      if (this.options.ns.indexOf(ns) < 0) {
+        this.options.ns.push(ns);
+      }
+    }
+    removeNamespaces(ns) {
+      const index = this.options.ns.indexOf(ns);
+      if (index > -1) {
+        this.options.ns.splice(index, 1);
+      }
+    }
+    getResource(lng, ns, key, options = {}) {
+      const keySeparator = options.keySeparator !== undefined ? options.keySeparator : this.options.keySeparator;
+      const ignoreJSONStructure = options.ignoreJSONStructure !== undefined ? options.ignoreJSONStructure : this.options.ignoreJSONStructure;
+      let path2;
+      if (lng.indexOf(".") > -1) {
+        path2 = lng.split(".");
+      } else {
+        path2 = [lng, ns];
+        if (key) {
+          if (Array.isArray(key)) {
+            path2.push(...key);
+          } else if (isString(key) && keySeparator) {
+            path2.push(...key.split(keySeparator));
+          } else {
+            path2.push(key);
+          }
+        }
+      }
+      const result = getPath(this.data, path2);
+      if (!result && !ns && !key && lng.indexOf(".") > -1) {
+        lng = path2[0];
+        ns = path2[1];
+        key = path2.slice(2).join(".");
+      }
+      if (result || !ignoreJSONStructure || !isString(key))
+        return result;
+      return deepFind(this.data?.[lng]?.[ns], key, keySeparator);
+    }
+    addResource(lng, ns, key, value, options = {
+      silent: false
+    }) {
+      const keySeparator = options.keySeparator !== undefined ? options.keySeparator : this.options.keySeparator;
+      let path2 = [lng, ns];
+      if (key)
+        path2 = path2.concat(keySeparator ? key.split(keySeparator) : key);
+      if (lng.indexOf(".") > -1) {
+        path2 = lng.split(".");
+        value = ns;
+        ns = path2[1];
+      }
+      this.addNamespaces(ns);
+      setPath(this.data, path2, value);
+      if (!options.silent)
+        this.emit("added", lng, ns, key, value);
+    }
+    addResources(lng, ns, resources, options = {
+      silent: false
+    }) {
+      for (const m in resources) {
+        if (isString(resources[m]) || Array.isArray(resources[m]))
+          this.addResource(lng, ns, m, resources[m], {
+            silent: true
+          });
+      }
+      if (!options.silent)
+        this.emit("added", lng, ns, resources);
+    }
+    addResourceBundle(lng, ns, resources, deep, overwrite, options = {
+      silent: false,
+      skipCopy: false
+    }) {
+      let path2 = [lng, ns];
+      if (lng.indexOf(".") > -1) {
+        path2 = lng.split(".");
+        deep = resources;
+        resources = ns;
+        ns = path2[1];
+      }
+      this.addNamespaces(ns);
+      let pack = getPath(this.data, path2) || {};
+      if (!options.skipCopy)
+        resources = JSON.parse(JSON.stringify(resources));
+      if (deep) {
+        deepExtend(pack, resources, overwrite);
+      } else {
+        pack = {
+          ...pack,
+          ...resources
+        };
+      }
+      setPath(this.data, path2, pack);
+      if (!options.silent)
+        this.emit("added", lng, ns, resources);
+    }
+    removeResourceBundle(lng, ns) {
+      if (this.hasResourceBundle(lng, ns)) {
+        delete this.data[lng][ns];
+      }
+      this.removeNamespaces(ns);
+      this.emit("removed", lng, ns);
+    }
+    hasResourceBundle(lng, ns) {
+      return this.getResource(lng, ns) !== undefined;
+    }
+    getResourceBundle(lng, ns) {
+      if (!ns)
+        ns = this.options.defaultNS;
+      return this.getResource(lng, ns);
+    }
+    getDataByLanguage(lng) {
+      return this.data[lng];
+    }
+    hasLanguageSomeTranslations(lng) {
+      const data = this.getDataByLanguage(lng);
+      const n = data && Object.keys(data) || [];
+      return !!n.find((v) => data[v] && Object.keys(data[v]).length > 0);
+    }
+    toJSON() {
+      return this.data;
+    }
+  };
+  postProcessor = {
+    processors: {},
+    addPostProcessor(module) {
+      this.processors[module.name] = module;
+    },
+    handle(processors, value, key, options, translator) {
+      processors.forEach((processor) => {
+        value = this.processors[processor]?.process(value, key, options, translator) ?? value;
+      });
+      return value;
+    }
+  };
+  PATH_KEY = Symbol("i18next/PATH_KEY");
+  checkedLoadedFor = {};
+  Translator = class Translator extends EventEmitter {
+    constructor(services, options = {}) {
+      super();
+      copy(["resourceStore", "languageUtils", "pluralResolver", "interpolator", "backendConnector", "i18nFormat", "utils"], services, this);
+      this.options = options;
+      if (this.options.keySeparator === undefined) {
+        this.options.keySeparator = ".";
+      }
+      this.logger = baseLogger.create("translator");
+    }
+    changeLanguage(lng) {
+      if (lng)
+        this.language = lng;
+    }
+    exists(key, o = {
+      interpolation: {}
+    }) {
+      const opt = {
+        ...o
+      };
+      if (key == null)
+        return false;
+      const resolved = this.resolve(key, opt);
+      if (resolved?.res === undefined)
+        return false;
+      const isObject = shouldHandleAsObject(resolved.res);
+      if (opt.returnObjects === false && isObject) {
+        return false;
+      }
+      return true;
+    }
+    extractFromKey(key, opt) {
+      let nsSeparator = opt.nsSeparator !== undefined ? opt.nsSeparator : this.options.nsSeparator;
+      if (nsSeparator === undefined)
+        nsSeparator = ":";
+      const keySeparator = opt.keySeparator !== undefined ? opt.keySeparator : this.options.keySeparator;
+      let namespaces = opt.ns || this.options.defaultNS || [];
+      const wouldCheckForNsInKey = nsSeparator && key.indexOf(nsSeparator) > -1;
+      const seemsNaturalLanguage = !this.options.userDefinedKeySeparator && !opt.keySeparator && !this.options.userDefinedNsSeparator && !opt.nsSeparator && !looksLikeObjectPath(key, nsSeparator, keySeparator);
+      if (wouldCheckForNsInKey && !seemsNaturalLanguage) {
+        const m = key.match(this.interpolator.nestingRegexp);
+        if (m && m.length > 0) {
+          return {
+            key,
+            namespaces: isString(namespaces) ? [namespaces] : namespaces
+          };
+        }
+        const parts = key.split(nsSeparator);
+        if (nsSeparator !== keySeparator || nsSeparator === keySeparator && this.options.ns.indexOf(parts[0]) > -1)
+          namespaces = parts.shift();
+        key = parts.join(keySeparator);
+      }
+      return {
+        key,
+        namespaces: isString(namespaces) ? [namespaces] : namespaces
+      };
+    }
+    translate(keys, o, lastKey) {
+      let opt = typeof o === "object" ? {
+        ...o
+      } : o;
+      if (typeof opt !== "object" && this.options.overloadTranslationOptionHandler) {
+        opt = this.options.overloadTranslationOptionHandler(arguments);
+      }
+      if (typeof opt === "object")
+        opt = {
+          ...opt
+        };
+      if (!opt)
+        opt = {};
+      if (keys == null)
+        return "";
+      if (typeof keys === "function")
+        keys = keysFromSelector(keys, {
+          ...this.options,
+          ...opt
+        });
+      if (!Array.isArray(keys))
+        keys = [String(keys)];
+      const returnDetails = opt.returnDetails !== undefined ? opt.returnDetails : this.options.returnDetails;
+      const keySeparator = opt.keySeparator !== undefined ? opt.keySeparator : this.options.keySeparator;
+      const {
+        key,
+        namespaces
+      } = this.extractFromKey(keys[keys.length - 1], opt);
+      const namespace = namespaces[namespaces.length - 1];
+      let nsSeparator = opt.nsSeparator !== undefined ? opt.nsSeparator : this.options.nsSeparator;
+      if (nsSeparator === undefined)
+        nsSeparator = ":";
+      const lng = opt.lng || this.language;
+      const appendNamespaceToCIMode = opt.appendNamespaceToCIMode || this.options.appendNamespaceToCIMode;
+      if (lng?.toLowerCase() === "cimode") {
+        if (appendNamespaceToCIMode) {
+          if (returnDetails) {
+            return {
+              res: `${namespace}${nsSeparator}${key}`,
+              usedKey: key,
+              exactUsedKey: key,
+              usedLng: lng,
+              usedNS: namespace,
+              usedParams: this.getUsedParamsDetails(opt)
+            };
+          }
+          return `${namespace}${nsSeparator}${key}`;
+        }
+        if (returnDetails) {
+          return {
+            res: key,
+            usedKey: key,
+            exactUsedKey: key,
+            usedLng: lng,
+            usedNS: namespace,
+            usedParams: this.getUsedParamsDetails(opt)
+          };
+        }
+        return key;
+      }
+      const resolved = this.resolve(keys, opt);
+      let res = resolved?.res;
+      const resUsedKey = resolved?.usedKey || key;
+      const resExactUsedKey = resolved?.exactUsedKey || key;
+      const noObject = ["[object Number]", "[object Function]", "[object RegExp]"];
+      const joinArrays = opt.joinArrays !== undefined ? opt.joinArrays : this.options.joinArrays;
+      const handleAsObjectInI18nFormat = !this.i18nFormat || this.i18nFormat.handleAsObject;
+      const needsPluralHandling = opt.count !== undefined && !isString(opt.count);
+      const hasDefaultValue = Translator.hasDefaultValue(opt);
+      const defaultValueSuffix = needsPluralHandling ? this.pluralResolver.getSuffix(lng, opt.count, opt) : "";
+      const defaultValueSuffixOrdinalFallback = opt.ordinal && needsPluralHandling ? this.pluralResolver.getSuffix(lng, opt.count, {
+        ordinal: false
+      }) : "";
+      const needsZeroSuffixLookup = needsPluralHandling && !opt.ordinal && opt.count === 0;
+      const defaultValue = needsZeroSuffixLookup && opt[`defaultValue${this.options.pluralSeparator}zero`] || opt[`defaultValue${defaultValueSuffix}`] || opt[`defaultValue${defaultValueSuffixOrdinalFallback}`] || opt.defaultValue;
+      let resForObjHndl = res;
+      if (handleAsObjectInI18nFormat && !res && hasDefaultValue) {
+        resForObjHndl = defaultValue;
+      }
+      const handleAsObject = shouldHandleAsObject(resForObjHndl);
+      const resType = Object.prototype.toString.apply(resForObjHndl);
+      if (handleAsObjectInI18nFormat && resForObjHndl && handleAsObject && noObject.indexOf(resType) < 0 && !(isString(joinArrays) && Array.isArray(resForObjHndl))) {
+        if (!opt.returnObjects && !this.options.returnObjects) {
+          if (!this.options.returnedObjectHandler) {
+            this.logger.warn("accessing an object - but returnObjects options is not enabled!");
+          }
+          const r = this.options.returnedObjectHandler ? this.options.returnedObjectHandler(resUsedKey, resForObjHndl, {
+            ...opt,
+            ns: namespaces
+          }) : `key '${key} (${this.language})' returned an object instead of string.`;
+          if (returnDetails) {
+            resolved.res = r;
+            resolved.usedParams = this.getUsedParamsDetails(opt);
+            return resolved;
+          }
+          return r;
+        }
+        if (keySeparator) {
+          const resTypeIsArray = Array.isArray(resForObjHndl);
+          const copy2 = resTypeIsArray ? [] : {};
+          const newKeyToUse = resTypeIsArray ? resExactUsedKey : resUsedKey;
+          for (const m in resForObjHndl) {
+            if (Object.prototype.hasOwnProperty.call(resForObjHndl, m)) {
+              const deepKey = `${newKeyToUse}${keySeparator}${m}`;
+              if (hasDefaultValue && !res) {
+                copy2[m] = this.translate(deepKey, {
+                  ...opt,
+                  defaultValue: shouldHandleAsObject(defaultValue) ? defaultValue[m] : undefined,
+                  ...{
+                    joinArrays: false,
+                    ns: namespaces
+                  }
+                });
+              } else {
+                copy2[m] = this.translate(deepKey, {
+                  ...opt,
+                  ...{
+                    joinArrays: false,
+                    ns: namespaces
+                  }
+                });
+              }
+              if (copy2[m] === deepKey)
+                copy2[m] = resForObjHndl[m];
+            }
+          }
+          res = copy2;
+        }
+      } else if (handleAsObjectInI18nFormat && isString(joinArrays) && Array.isArray(res)) {
+        res = res.join(joinArrays);
+        if (res)
+          res = this.extendTranslation(res, keys, opt, lastKey);
+      } else {
+        let usedDefault = false;
+        let usedKey = false;
+        if (!this.isValidLookup(res) && hasDefaultValue) {
+          usedDefault = true;
+          res = defaultValue;
+        }
+        if (!this.isValidLookup(res)) {
+          usedKey = true;
+          res = key;
+        }
+        const missingKeyNoValueFallbackToKey = opt.missingKeyNoValueFallbackToKey || this.options.missingKeyNoValueFallbackToKey;
+        const resForMissing = missingKeyNoValueFallbackToKey && usedKey ? undefined : res;
+        const updateMissing = hasDefaultValue && defaultValue !== res && this.options.updateMissing;
+        if (usedKey || usedDefault || updateMissing) {
+          this.logger.log(updateMissing ? "updateKey" : "missingKey", lng, namespace, key, updateMissing ? defaultValue : res);
+          if (keySeparator) {
+            const fk = this.resolve(key, {
+              ...opt,
+              keySeparator: false
+            });
+            if (fk && fk.res)
+              this.logger.warn("Seems the loaded translations were in flat JSON format instead of nested. Either set keySeparator: false on init or make sure your translations are published in nested format.");
+          }
+          let lngs = [];
+          const fallbackLngs = this.languageUtils.getFallbackCodes(this.options.fallbackLng, opt.lng || this.language);
+          if (this.options.saveMissingTo === "fallback" && fallbackLngs && fallbackLngs[0]) {
+            for (let i = 0;i < fallbackLngs.length; i++) {
+              lngs.push(fallbackLngs[i]);
+            }
+          } else if (this.options.saveMissingTo === "all") {
+            lngs = this.languageUtils.toResolveHierarchy(opt.lng || this.language);
+          } else {
+            lngs.push(opt.lng || this.language);
+          }
+          const send = (l, k, specificDefaultValue) => {
+            const defaultForMissing = hasDefaultValue && specificDefaultValue !== res ? specificDefaultValue : resForMissing;
+            if (this.options.missingKeyHandler) {
+              this.options.missingKeyHandler(l, namespace, k, defaultForMissing, updateMissing, opt);
+            } else if (this.backendConnector?.saveMissing) {
+              this.backendConnector.saveMissing(l, namespace, k, defaultForMissing, updateMissing, opt);
+            }
+            this.emit("missingKey", l, namespace, k, res);
+          };
+          if (this.options.saveMissing) {
+            if (this.options.saveMissingPlurals && needsPluralHandling) {
+              lngs.forEach((language) => {
+                const suffixes = this.pluralResolver.getSuffixes(language, opt);
+                if (needsZeroSuffixLookup && opt[`defaultValue${this.options.pluralSeparator}zero`] && suffixes.indexOf(`${this.options.pluralSeparator}zero`) < 0) {
+                  suffixes.push(`${this.options.pluralSeparator}zero`);
+                }
+                suffixes.forEach((suffix) => {
+                  send([language], key + suffix, opt[`defaultValue${suffix}`] || defaultValue);
+                });
+              });
+            } else {
+              send(lngs, key, defaultValue);
+            }
+          }
+        }
+        res = this.extendTranslation(res, keys, opt, resolved, lastKey);
+        if (usedKey && res === key && this.options.appendNamespaceToMissingKey) {
+          res = `${namespace}${nsSeparator}${key}`;
+        }
+        if ((usedKey || usedDefault) && this.options.parseMissingKeyHandler) {
+          res = this.options.parseMissingKeyHandler(this.options.appendNamespaceToMissingKey ? `${namespace}${nsSeparator}${key}` : key, usedDefault ? res : undefined, opt);
+        }
+      }
+      if (returnDetails) {
+        resolved.res = res;
+        resolved.usedParams = this.getUsedParamsDetails(opt);
+        return resolved;
+      }
+      return res;
+    }
+    extendTranslation(res, key, opt, resolved, lastKey) {
+      if (this.i18nFormat?.parse) {
+        res = this.i18nFormat.parse(res, {
+          ...this.options.interpolation.defaultVariables,
+          ...opt
+        }, opt.lng || this.language || resolved.usedLng, resolved.usedNS, resolved.usedKey, {
+          resolved
+        });
+      } else if (!opt.skipInterpolation) {
+        if (opt.interpolation)
+          this.interpolator.init({
+            ...opt,
+            ...{
+              interpolation: {
+                ...this.options.interpolation,
+                ...opt.interpolation
+              }
+            }
+          });
+        const skipOnVariables = isString(res) && (opt?.interpolation?.skipOnVariables !== undefined ? opt.interpolation.skipOnVariables : this.options.interpolation.skipOnVariables);
+        let nestBef;
+        if (skipOnVariables) {
+          const nb = res.match(this.interpolator.nestingRegexp);
+          nestBef = nb && nb.length;
+        }
+        let data = opt.replace && !isString(opt.replace) ? opt.replace : opt;
+        if (this.options.interpolation.defaultVariables)
+          data = {
+            ...this.options.interpolation.defaultVariables,
+            ...data
+          };
+        res = this.interpolator.interpolate(res, data, opt.lng || this.language || resolved.usedLng, opt);
+        if (skipOnVariables) {
+          const na = res.match(this.interpolator.nestingRegexp);
+          const nestAft = na && na.length;
+          if (nestBef < nestAft)
+            opt.nest = false;
+        }
+        if (!opt.lng && resolved && resolved.res)
+          opt.lng = this.language || resolved.usedLng;
+        if (opt.nest !== false)
+          res = this.interpolator.nest(res, (...args) => {
+            if (lastKey?.[0] === args[0] && !opt.context) {
+              this.logger.warn(`It seems you are nesting recursively key: ${args[0]} in key: ${key[0]}`);
+              return null;
+            }
+            return this.translate(...args, key);
+          }, opt);
+        if (opt.interpolation)
+          this.interpolator.reset();
+      }
+      const postProcess = opt.postProcess || this.options.postProcess;
+      const postProcessorNames = isString(postProcess) ? [postProcess] : postProcess;
+      if (res != null && postProcessorNames?.length && opt.applyPostProcessor !== false) {
+        res = postProcessor.handle(postProcessorNames, res, key, this.options && this.options.postProcessPassResolved ? {
+          i18nResolved: {
+            ...resolved,
+            usedParams: this.getUsedParamsDetails(opt)
+          },
+          ...opt
+        } : opt, this);
+      }
+      return res;
+    }
+    resolve(keys, opt = {}) {
+      let found;
+      let usedKey;
+      let exactUsedKey;
+      let usedLng;
+      let usedNS;
+      if (isString(keys))
+        keys = [keys];
+      keys.forEach((k) => {
+        if (this.isValidLookup(found))
+          return;
+        const extracted = this.extractFromKey(k, opt);
+        const key = extracted.key;
+        usedKey = key;
+        let namespaces = extracted.namespaces;
+        if (this.options.fallbackNS)
+          namespaces = namespaces.concat(this.options.fallbackNS);
+        const needsPluralHandling = opt.count !== undefined && !isString(opt.count);
+        const needsZeroSuffixLookup = needsPluralHandling && !opt.ordinal && opt.count === 0;
+        const needsContextHandling = opt.context !== undefined && (isString(opt.context) || typeof opt.context === "number") && opt.context !== "";
+        const codes = opt.lngs ? opt.lngs : this.languageUtils.toResolveHierarchy(opt.lng || this.language, opt.fallbackLng);
+        namespaces.forEach((ns) => {
+          if (this.isValidLookup(found))
+            return;
+          usedNS = ns;
+          if (!checkedLoadedFor[`${codes[0]}-${ns}`] && this.utils?.hasLoadedNamespace && !this.utils?.hasLoadedNamespace(usedNS)) {
+            checkedLoadedFor[`${codes[0]}-${ns}`] = true;
+            this.logger.warn(`key "${usedKey}" for languages "${codes.join(", ")}" won't get resolved as namespace "${usedNS}" was not yet loaded`, "This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!");
+          }
+          codes.forEach((code) => {
+            if (this.isValidLookup(found))
+              return;
+            usedLng = code;
+            const finalKeys = [key];
+            if (this.i18nFormat?.addLookupKeys) {
+              this.i18nFormat.addLookupKeys(finalKeys, key, code, ns, opt);
+            } else {
+              let pluralSuffix;
+              if (needsPluralHandling)
+                pluralSuffix = this.pluralResolver.getSuffix(code, opt.count, opt);
+              const zeroSuffix = `${this.options.pluralSeparator}zero`;
+              const ordinalPrefix = `${this.options.pluralSeparator}ordinal${this.options.pluralSeparator}`;
+              if (needsPluralHandling) {
+                if (opt.ordinal && pluralSuffix.indexOf(ordinalPrefix) === 0) {
+                  finalKeys.push(key + pluralSuffix.replace(ordinalPrefix, this.options.pluralSeparator));
+                }
+                finalKeys.push(key + pluralSuffix);
+                if (needsZeroSuffixLookup) {
+                  finalKeys.push(key + zeroSuffix);
+                }
+              }
+              if (needsContextHandling) {
+                const contextKey = `${key}${this.options.contextSeparator || "_"}${opt.context}`;
+                finalKeys.push(contextKey);
+                if (needsPluralHandling) {
+                  if (opt.ordinal && pluralSuffix.indexOf(ordinalPrefix) === 0) {
+                    finalKeys.push(contextKey + pluralSuffix.replace(ordinalPrefix, this.options.pluralSeparator));
+                  }
+                  finalKeys.push(contextKey + pluralSuffix);
+                  if (needsZeroSuffixLookup) {
+                    finalKeys.push(contextKey + zeroSuffix);
+                  }
+                }
+              }
+            }
+            let possibleKey;
+            while (possibleKey = finalKeys.pop()) {
+              if (!this.isValidLookup(found)) {
+                exactUsedKey = possibleKey;
+                found = this.getResource(code, ns, possibleKey, opt);
+              }
+            }
+          });
+        });
+      });
+      return {
+        res: found,
+        usedKey,
+        exactUsedKey,
+        usedLng,
+        usedNS
+      };
+    }
+    isValidLookup(res) {
+      return res !== undefined && !(!this.options.returnNull && res === null) && !(!this.options.returnEmptyString && res === "");
+    }
+    getResource(code, ns, key, options = {}) {
+      if (this.i18nFormat?.getResource)
+        return this.i18nFormat.getResource(code, ns, key, options);
+      return this.resourceStore.getResource(code, ns, key, options);
+    }
+    getUsedParamsDetails(options = {}) {
+      const optionsKeys = ["defaultValue", "ordinal", "context", "replace", "lng", "lngs", "fallbackLng", "ns", "keySeparator", "nsSeparator", "returnObjects", "returnDetails", "joinArrays", "postProcess", "interpolation"];
+      const useOptionsReplaceForData = options.replace && !isString(options.replace);
+      let data = useOptionsReplaceForData ? options.replace : options;
+      if (useOptionsReplaceForData && typeof options.count !== "undefined") {
+        data.count = options.count;
+      }
+      if (this.options.interpolation.defaultVariables) {
+        data = {
+          ...this.options.interpolation.defaultVariables,
+          ...data
+        };
+      }
+      if (!useOptionsReplaceForData) {
+        data = {
+          ...data
+        };
+        for (const key of optionsKeys) {
+          delete data[key];
+        }
+      }
+      return data;
+    }
+    static hasDefaultValue(options) {
+      const prefix = "defaultValue";
+      for (const option in options) {
+        if (Object.prototype.hasOwnProperty.call(options, option) && prefix === option.substring(0, prefix.length) && options[option] !== undefined) {
+          return true;
+        }
+      }
+      return false;
+    }
+  };
+  suffixesOrder = {
+    zero: 0,
+    one: 1,
+    two: 2,
+    few: 3,
+    many: 4,
+    other: 5
+  };
+  dummyRule = {
+    select: (count) => count === 1 ? "one" : "other",
+    resolvedOptions: () => ({
+      pluralCategories: ["one", "other"]
+    })
+  };
+  Connector = class Connector extends EventEmitter {
+    constructor(backend, store, services, options = {}) {
+      super();
+      this.backend = backend;
+      this.store = store;
+      this.services = services;
+      this.languageUtils = services.languageUtils;
+      this.options = options;
+      this.logger = baseLogger.create("backendConnector");
+      this.waitingReads = [];
+      this.maxParallelReads = options.maxParallelReads || 10;
+      this.readingCalls = 0;
+      this.maxRetries = options.maxRetries >= 0 ? options.maxRetries : 5;
+      this.retryTimeout = options.retryTimeout >= 1 ? options.retryTimeout : 350;
+      this.state = {};
+      this.queue = [];
+      this.backend?.init?.(services, options.backend, options);
+    }
+    queueLoad(languages, namespaces, options, callback) {
+      const toLoad = {};
+      const pending = {};
+      const toLoadLanguages = {};
+      const toLoadNamespaces = {};
+      languages.forEach((lng) => {
+        let hasAllNamespaces = true;
+        namespaces.forEach((ns) => {
+          const name = `${lng}|${ns}`;
+          if (!options.reload && this.store.hasResourceBundle(lng, ns)) {
+            this.state[name] = 2;
+          } else if (this.state[name] < 0)
+            ;
+          else if (this.state[name] === 1) {
+            if (pending[name] === undefined)
+              pending[name] = true;
+          } else {
+            this.state[name] = 1;
+            hasAllNamespaces = false;
+            if (pending[name] === undefined)
+              pending[name] = true;
+            if (toLoad[name] === undefined)
+              toLoad[name] = true;
+            if (toLoadNamespaces[ns] === undefined)
+              toLoadNamespaces[ns] = true;
+          }
+        });
+        if (!hasAllNamespaces)
+          toLoadLanguages[lng] = true;
+      });
+      if (Object.keys(toLoad).length || Object.keys(pending).length) {
+        this.queue.push({
+          pending,
+          pendingCount: Object.keys(pending).length,
+          loaded: {},
+          errors: [],
+          callback
+        });
+      }
+      return {
+        toLoad: Object.keys(toLoad),
+        pending: Object.keys(pending),
+        toLoadLanguages: Object.keys(toLoadLanguages),
+        toLoadNamespaces: Object.keys(toLoadNamespaces)
+      };
+    }
+    loaded(name, err, data) {
+      const s = name.split("|");
+      const lng = s[0];
+      const ns = s[1];
+      if (err)
+        this.emit("failedLoading", lng, ns, err);
+      if (!err && data) {
+        this.store.addResourceBundle(lng, ns, data, undefined, undefined, {
+          skipCopy: true
+        });
+      }
+      this.state[name] = err ? -1 : 2;
+      if (err && data)
+        this.state[name] = 0;
+      const loaded = {};
+      this.queue.forEach((q) => {
+        pushPath(q.loaded, [lng], ns);
+        removePending(q, name);
+        if (err)
+          q.errors.push(err);
+        if (q.pendingCount === 0 && !q.done) {
+          Object.keys(q.loaded).forEach((l) => {
+            if (!loaded[l])
+              loaded[l] = {};
+            const loadedKeys = q.loaded[l];
+            if (loadedKeys.length) {
+              loadedKeys.forEach((n) => {
+                if (loaded[l][n] === undefined)
+                  loaded[l][n] = true;
+              });
+            }
+          });
+          q.done = true;
+          if (q.errors.length) {
+            q.callback(q.errors);
+          } else {
+            q.callback();
+          }
+        }
+      });
+      this.emit("loaded", loaded);
+      this.queue = this.queue.filter((q) => !q.done);
+    }
+    read(lng, ns, fcName, tried = 0, wait = this.retryTimeout, callback) {
+      if (!lng.length)
+        return callback(null, {});
+      if (this.readingCalls >= this.maxParallelReads) {
+        this.waitingReads.push({
+          lng,
+          ns,
+          fcName,
+          tried,
+          wait,
+          callback
+        });
+        return;
+      }
+      this.readingCalls++;
+      const resolver = (err, data) => {
+        this.readingCalls--;
+        if (this.waitingReads.length > 0) {
+          const next = this.waitingReads.shift();
+          this.read(next.lng, next.ns, next.fcName, next.tried, next.wait, next.callback);
+        }
+        if (err && data && tried < this.maxRetries) {
+          setTimeout(() => {
+            this.read.call(this, lng, ns, fcName, tried + 1, wait * 2, callback);
+          }, wait);
+          return;
+        }
+        callback(err, data);
+      };
+      const fc = this.backend[fcName].bind(this.backend);
+      if (fc.length === 2) {
+        try {
+          const r = fc(lng, ns);
+          if (r && typeof r.then === "function") {
+            r.then((data) => resolver(null, data)).catch(resolver);
+          } else {
+            resolver(null, r);
+          }
+        } catch (err) {
+          resolver(err);
+        }
+        return;
+      }
+      return fc(lng, ns, resolver);
+    }
+    prepareLoading(languages, namespaces, options = {}, callback) {
+      if (!this.backend) {
+        this.logger.warn("No backend was added via i18next.use. Will not load resources.");
+        return callback && callback();
+      }
+      if (isString(languages))
+        languages = this.languageUtils.toResolveHierarchy(languages);
+      if (isString(namespaces))
+        namespaces = [namespaces];
+      const toLoad = this.queueLoad(languages, namespaces, options, callback);
+      if (!toLoad.toLoad.length) {
+        if (!toLoad.pending.length)
+          callback();
+        return null;
+      }
+      toLoad.toLoad.forEach((name) => {
+        this.loadOne(name);
+      });
+    }
+    load(languages, namespaces, callback) {
+      this.prepareLoading(languages, namespaces, {}, callback);
+    }
+    reload(languages, namespaces, callback) {
+      this.prepareLoading(languages, namespaces, {
+        reload: true
+      }, callback);
+    }
+    loadOne(name, prefix = "") {
+      const s = name.split("|");
+      const lng = s[0];
+      const ns = s[1];
+      this.read(lng, ns, "read", undefined, undefined, (err, data) => {
+        if (err)
+          this.logger.warn(`${prefix}loading namespace ${ns} for language ${lng} failed`, err);
+        if (!err && data)
+          this.logger.log(`${prefix}loaded namespace ${ns} for language ${lng}`, data);
+        this.loaded(name, err, data);
+      });
+    }
+    saveMissing(languages, namespace, key, fallbackValue, isUpdate, options = {}, clb = () => {}) {
+      if (this.services?.utils?.hasLoadedNamespace && !this.services?.utils?.hasLoadedNamespace(namespace)) {
+        this.logger.warn(`did not save key "${key}" as the namespace "${namespace}" was not yet loaded`, "This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!");
+        return;
+      }
+      if (key === undefined || key === null || key === "")
+        return;
+      if (this.backend?.create) {
+        const opts = {
+          ...options,
+          isUpdate
+        };
+        const fc = this.backend.create.bind(this.backend);
+        if (fc.length < 6) {
+          try {
+            let r;
+            if (fc.length === 5) {
+              r = fc(languages, namespace, key, fallbackValue, opts);
+            } else {
+              r = fc(languages, namespace, key, fallbackValue);
+            }
+            if (r && typeof r.then === "function") {
+              r.then((data) => clb(null, data)).catch(clb);
+            } else {
+              clb(null, r);
+            }
+          } catch (err) {
+            clb(err);
+          }
+        } else {
+          fc(languages, namespace, key, fallbackValue, clb, opts);
+        }
+      }
+      if (!languages || !languages[0])
+        return;
+      this.store.addResource(languages[0], namespace, key, fallbackValue);
+    }
+  };
+  I18n = class I18n extends EventEmitter {
+    constructor(options = {}, callback) {
+      super();
+      this.options = transformOptions(options);
+      this.services = {};
+      this.logger = baseLogger;
+      this.modules = {
+        external: []
+      };
+      bindMemberFunctions(this);
+      if (callback && !this.isInitialized && !options.isClone) {
+        if (!this.options.initAsync) {
+          this.init(options, callback);
+          return this;
+        }
+        setTimeout(() => {
+          this.init(options, callback);
+        }, 0);
+      }
+    }
+    init(options = {}, callback) {
+      this.isInitializing = true;
+      if (typeof options === "function") {
+        callback = options;
+        options = {};
+      }
+      if (options.defaultNS == null && options.ns) {
+        if (isString(options.ns)) {
+          options.defaultNS = options.ns;
+        } else if (options.ns.indexOf("translation") < 0) {
+          options.defaultNS = options.ns[0];
+        }
+      }
+      const defOpts = get();
+      this.options = {
+        ...defOpts,
+        ...this.options,
+        ...transformOptions(options)
+      };
+      this.options.interpolation = {
+        ...defOpts.interpolation,
+        ...this.options.interpolation
+      };
+      if (options.keySeparator !== undefined) {
+        this.options.userDefinedKeySeparator = options.keySeparator;
+      }
+      if (options.nsSeparator !== undefined) {
+        this.options.userDefinedNsSeparator = options.nsSeparator;
+      }
+      const createClassOnDemand = (ClassOrObject) => {
+        if (!ClassOrObject)
+          return null;
+        if (typeof ClassOrObject === "function")
+          return new ClassOrObject;
+        return ClassOrObject;
+      };
+      if (!this.options.isClone) {
+        if (this.modules.logger) {
+          baseLogger.init(createClassOnDemand(this.modules.logger), this.options);
+        } else {
+          baseLogger.init(null, this.options);
+        }
+        let formatter;
+        if (this.modules.formatter) {
+          formatter = this.modules.formatter;
+        } else {
+          formatter = Formatter;
+        }
+        const lu = new LanguageUtil(this.options);
+        this.store = new ResourceStore(this.options.resources, this.options);
+        const s = this.services;
+        s.logger = baseLogger;
+        s.resourceStore = this.store;
+        s.languageUtils = lu;
+        s.pluralResolver = new PluralResolver(lu, {
+          prepend: this.options.pluralSeparator,
+          simplifyPluralSuffix: this.options.simplifyPluralSuffix
+        });
+        const usingLegacyFormatFunction = this.options.interpolation.format && this.options.interpolation.format !== defOpts.interpolation.format;
+        if (usingLegacyFormatFunction) {
+          this.logger.deprecate(`init: you are still using the legacy format function, please use the new approach: https://www.i18next.com/translation-function/formatting`);
+        }
+        if (formatter && (!this.options.interpolation.format || this.options.interpolation.format === defOpts.interpolation.format)) {
+          s.formatter = createClassOnDemand(formatter);
+          if (s.formatter.init)
+            s.formatter.init(s, this.options);
+          this.options.interpolation.format = s.formatter.format.bind(s.formatter);
+        }
+        s.interpolator = new Interpolator(this.options);
+        s.utils = {
+          hasLoadedNamespace: this.hasLoadedNamespace.bind(this)
+        };
+        s.backendConnector = new Connector(createClassOnDemand(this.modules.backend), s.resourceStore, s, this.options);
+        s.backendConnector.on("*", (event, ...args) => {
+          this.emit(event, ...args);
+        });
+        if (this.modules.languageDetector) {
+          s.languageDetector = createClassOnDemand(this.modules.languageDetector);
+          if (s.languageDetector.init)
+            s.languageDetector.init(s, this.options.detection, this.options);
+        }
+        if (this.modules.i18nFormat) {
+          s.i18nFormat = createClassOnDemand(this.modules.i18nFormat);
+          if (s.i18nFormat.init)
+            s.i18nFormat.init(this);
+        }
+        this.translator = new Translator(this.services, this.options);
+        this.translator.on("*", (event, ...args) => {
+          this.emit(event, ...args);
+        });
+        this.modules.external.forEach((m) => {
+          if (m.init)
+            m.init(this);
+        });
+      }
+      this.format = this.options.interpolation.format;
+      if (!callback)
+        callback = noop;
+      if (this.options.fallbackLng && !this.services.languageDetector && !this.options.lng) {
+        const codes = this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);
+        if (codes.length > 0 && codes[0] !== "dev")
+          this.options.lng = codes[0];
+      }
+      if (!this.services.languageDetector && !this.options.lng) {
+        this.logger.warn("init: no languageDetector is used and no lng is defined");
+      }
+      const storeApi = ["getResource", "hasResourceBundle", "getResourceBundle", "getDataByLanguage"];
+      storeApi.forEach((fcName) => {
+        this[fcName] = (...args) => this.store[fcName](...args);
+      });
+      const storeApiChained = ["addResource", "addResources", "addResourceBundle", "removeResourceBundle"];
+      storeApiChained.forEach((fcName) => {
+        this[fcName] = (...args) => {
+          this.store[fcName](...args);
+          return this;
+        };
+      });
+      const deferred = defer2();
+      const load2 = () => {
+        const finish = (err, t) => {
+          this.isInitializing = false;
+          if (this.isInitialized && !this.initializedStoreOnce)
+            this.logger.warn("init: i18next is already initialized. You should call init just once!");
+          this.isInitialized = true;
+          if (!this.options.isClone)
+            this.logger.log("initialized", this.options);
+          this.emit("initialized", this.options);
+          deferred.resolve(t);
+          callback(err, t);
+        };
+        if (this.languages && !this.isInitialized)
+          return finish(null, this.t.bind(this));
+        this.changeLanguage(this.options.lng, finish);
+      };
+      if (this.options.resources || !this.options.initAsync) {
+        load2();
+      } else {
+        setTimeout(load2, 0);
+      }
+      return deferred;
+    }
+    loadResources(language, callback = noop) {
+      let usedCallback = callback;
+      const usedLng = isString(language) ? language : this.language;
+      if (typeof language === "function")
+        usedCallback = language;
+      if (!this.options.resources || this.options.partialBundledLanguages) {
+        if (usedLng?.toLowerCase() === "cimode" && (!this.options.preload || this.options.preload.length === 0))
+          return usedCallback();
+        const toLoad = [];
+        const append = (lng) => {
+          if (!lng)
+            return;
+          if (lng === "cimode")
+            return;
+          const lngs = this.services.languageUtils.toResolveHierarchy(lng);
+          lngs.forEach((l) => {
+            if (l === "cimode")
+              return;
+            if (toLoad.indexOf(l) < 0)
+              toLoad.push(l);
+          });
+        };
+        if (!usedLng) {
+          const fallbacks = this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);
+          fallbacks.forEach((l) => append(l));
+        } else {
+          append(usedLng);
+        }
+        this.options.preload?.forEach?.((l) => append(l));
+        this.services.backendConnector.load(toLoad, this.options.ns, (e) => {
+          if (!e && !this.resolvedLanguage && this.language)
+            this.setResolvedLanguage(this.language);
+          usedCallback(e);
+        });
+      } else {
+        usedCallback(null);
+      }
+    }
+    reloadResources(lngs, ns, callback) {
+      const deferred = defer2();
+      if (typeof lngs === "function") {
+        callback = lngs;
+        lngs = undefined;
+      }
+      if (typeof ns === "function") {
+        callback = ns;
+        ns = undefined;
+      }
+      if (!lngs)
+        lngs = this.languages;
+      if (!ns)
+        ns = this.options.ns;
+      if (!callback)
+        callback = noop;
+      this.services.backendConnector.reload(lngs, ns, (err) => {
+        deferred.resolve();
+        callback(err);
+      });
+      return deferred;
+    }
+    use(module) {
+      if (!module)
+        throw new Error("You are passing an undefined module! Please check the object you are passing to i18next.use()");
+      if (!module.type)
+        throw new Error("You are passing a wrong module! Please check the object you are passing to i18next.use()");
+      if (module.type === "backend") {
+        this.modules.backend = module;
+      }
+      if (module.type === "logger" || module.log && module.warn && module.error) {
+        this.modules.logger = module;
+      }
+      if (module.type === "languageDetector") {
+        this.modules.languageDetector = module;
+      }
+      if (module.type === "i18nFormat") {
+        this.modules.i18nFormat = module;
+      }
+      if (module.type === "postProcessor") {
+        postProcessor.addPostProcessor(module);
+      }
+      if (module.type === "formatter") {
+        this.modules.formatter = module;
+      }
+      if (module.type === "3rdParty") {
+        this.modules.external.push(module);
+      }
+      return this;
+    }
+    setResolvedLanguage(l) {
+      if (!l || !this.languages)
+        return;
+      if (["cimode", "dev"].indexOf(l) > -1)
+        return;
+      for (let li = 0;li < this.languages.length; li++) {
+        const lngInLngs = this.languages[li];
+        if (["cimode", "dev"].indexOf(lngInLngs) > -1)
+          continue;
+        if (this.store.hasLanguageSomeTranslations(lngInLngs)) {
+          this.resolvedLanguage = lngInLngs;
+          break;
+        }
+      }
+      if (!this.resolvedLanguage && this.languages.indexOf(l) < 0 && this.store.hasLanguageSomeTranslations(l)) {
+        this.resolvedLanguage = l;
+        this.languages.unshift(l);
+      }
+    }
+    changeLanguage(lng, callback) {
+      this.isLanguageChangingTo = lng;
+      const deferred = defer2();
+      this.emit("languageChanging", lng);
+      const setLngProps = (l) => {
+        this.language = l;
+        this.languages = this.services.languageUtils.toResolveHierarchy(l);
+        this.resolvedLanguage = undefined;
+        this.setResolvedLanguage(l);
+      };
+      const done = (err, l) => {
+        if (l) {
+          if (this.isLanguageChangingTo === lng) {
+            setLngProps(l);
+            this.translator.changeLanguage(l);
+            this.isLanguageChangingTo = undefined;
+            this.emit("languageChanged", l);
+            this.logger.log("languageChanged", l);
+          }
+        } else {
+          this.isLanguageChangingTo = undefined;
+        }
+        deferred.resolve((...args) => this.t(...args));
+        if (callback)
+          callback(err, (...args) => this.t(...args));
+      };
+      const setLng = (lngs) => {
+        if (!lng && !lngs && this.services.languageDetector)
+          lngs = [];
+        const fl = isString(lngs) ? lngs : lngs && lngs[0];
+        const l = this.store.hasLanguageSomeTranslations(fl) ? fl : this.services.languageUtils.getBestMatchFromCodes(isString(lngs) ? [lngs] : lngs);
+        if (l) {
+          if (!this.language) {
+            setLngProps(l);
+          }
+          if (!this.translator.language)
+            this.translator.changeLanguage(l);
+          this.services.languageDetector?.cacheUserLanguage?.(l);
+        }
+        this.loadResources(l, (err) => {
+          done(err, l);
+        });
+      };
+      if (!lng && this.services.languageDetector && !this.services.languageDetector.async) {
+        setLng(this.services.languageDetector.detect());
+      } else if (!lng && this.services.languageDetector && this.services.languageDetector.async) {
+        if (this.services.languageDetector.detect.length === 0) {
+          this.services.languageDetector.detect().then(setLng);
+        } else {
+          this.services.languageDetector.detect(setLng);
+        }
+      } else {
+        setLng(lng);
+      }
+      return deferred;
+    }
+    getFixedT(lng, ns, keyPrefix) {
+      const fixedT = (key, opts, ...rest) => {
+        let o;
+        if (typeof opts !== "object") {
+          o = this.options.overloadTranslationOptionHandler([key, opts].concat(rest));
+        } else {
+          o = {
+            ...opts
+          };
+        }
+        o.lng = o.lng || fixedT.lng;
+        o.lngs = o.lngs || fixedT.lngs;
+        o.ns = o.ns || fixedT.ns;
+        if (o.keyPrefix !== "")
+          o.keyPrefix = o.keyPrefix || keyPrefix || fixedT.keyPrefix;
+        const keySeparator = this.options.keySeparator || ".";
+        let resultKey;
+        if (o.keyPrefix && Array.isArray(key)) {
+          resultKey = key.map((k) => {
+            if (typeof k === "function")
+              k = keysFromSelector(k, {
+                ...this.options,
+                ...opts
+              });
+            return `${o.keyPrefix}${keySeparator}${k}`;
+          });
+        } else {
+          if (typeof key === "function")
+            key = keysFromSelector(key, {
+              ...this.options,
+              ...opts
+            });
+          resultKey = o.keyPrefix ? `${o.keyPrefix}${keySeparator}${key}` : key;
+        }
+        return this.t(resultKey, o);
+      };
+      if (isString(lng)) {
+        fixedT.lng = lng;
+      } else {
+        fixedT.lngs = lng;
+      }
+      fixedT.ns = ns;
+      fixedT.keyPrefix = keyPrefix;
+      return fixedT;
+    }
+    t(...args) {
+      return this.translator?.translate(...args);
+    }
+    exists(...args) {
+      return this.translator?.exists(...args);
+    }
+    setDefaultNamespace(ns) {
+      this.options.defaultNS = ns;
+    }
+    hasLoadedNamespace(ns, options = {}) {
+      if (!this.isInitialized) {
+        this.logger.warn("hasLoadedNamespace: i18next was not initialized", this.languages);
+        return false;
+      }
+      if (!this.languages || !this.languages.length) {
+        this.logger.warn("hasLoadedNamespace: i18n.languages were undefined or empty", this.languages);
+        return false;
+      }
+      const lng = options.lng || this.resolvedLanguage || this.languages[0];
+      const fallbackLng = this.options ? this.options.fallbackLng : false;
+      const lastLng = this.languages[this.languages.length - 1];
+      if (lng.toLowerCase() === "cimode")
+        return true;
+      const loadNotPending = (l, n) => {
+        const loadState = this.services.backendConnector.state[`${l}|${n}`];
+        return loadState === -1 || loadState === 0 || loadState === 2;
+      };
+      if (options.precheck) {
+        const preResult = options.precheck(this, loadNotPending);
+        if (preResult !== undefined)
+          return preResult;
+      }
+      if (this.hasResourceBundle(lng, ns))
+        return true;
+      if (!this.services.backendConnector.backend || this.options.resources && !this.options.partialBundledLanguages)
+        return true;
+      if (loadNotPending(lng, ns) && (!fallbackLng || loadNotPending(lastLng, ns)))
+        return true;
+      return false;
+    }
+    loadNamespaces(ns, callback) {
+      const deferred = defer2();
+      if (!this.options.ns) {
+        if (callback)
+          callback();
+        return Promise.resolve();
+      }
+      if (isString(ns))
+        ns = [ns];
+      ns.forEach((n) => {
+        if (this.options.ns.indexOf(n) < 0)
+          this.options.ns.push(n);
+      });
+      this.loadResources((err) => {
+        deferred.resolve();
+        if (callback)
+          callback(err);
+      });
+      return deferred;
+    }
+    loadLanguages(lngs, callback) {
+      const deferred = defer2();
+      if (isString(lngs))
+        lngs = [lngs];
+      const preloaded = this.options.preload || [];
+      const newLngs = lngs.filter((lng) => preloaded.indexOf(lng) < 0 && this.services.languageUtils.isSupportedCode(lng));
+      if (!newLngs.length) {
+        if (callback)
+          callback();
+        return Promise.resolve();
+      }
+      this.options.preload = preloaded.concat(newLngs);
+      this.loadResources((err) => {
+        deferred.resolve();
+        if (callback)
+          callback(err);
+      });
+      return deferred;
+    }
+    dir(lng) {
+      if (!lng)
+        lng = this.resolvedLanguage || (this.languages?.length > 0 ? this.languages[0] : this.language);
+      if (!lng)
+        return "rtl";
+      try {
+        const l = new Intl.Locale(lng);
+        if (l && l.getTextInfo) {
+          const ti = l.getTextInfo();
+          if (ti && ti.direction)
+            return ti.direction;
+        }
+      } catch (e) {}
+      const rtlLngs = ["ar", "shu", "sqr", "ssh", "xaa", "yhd", "yud", "aao", "abh", "abv", "acm", "acq", "acw", "acx", "acy", "adf", "ads", "aeb", "aec", "afb", "ajp", "apc", "apd", "arb", "arq", "ars", "ary", "arz", "auz", "avl", "ayh", "ayl", "ayn", "ayp", "bbz", "pga", "he", "iw", "ps", "pbt", "pbu", "pst", "prp", "prd", "ug", "ur", "ydd", "yds", "yih", "ji", "yi", "hbo", "men", "xmn", "fa", "jpr", "peo", "pes", "prs", "dv", "sam", "ckb"];
+      const languageUtils = this.services?.languageUtils || new LanguageUtil(get());
+      if (lng.toLowerCase().indexOf("-latn") > 1)
+        return "ltr";
+      return rtlLngs.indexOf(languageUtils.getLanguagePartFromCode(lng)) > -1 || lng.toLowerCase().indexOf("-arab") > 1 ? "rtl" : "ltr";
+    }
+    static createInstance(options = {}, callback) {
+      const instance = new I18n(options, callback);
+      instance.createInstance = I18n.createInstance;
+      return instance;
+    }
+    cloneInstance(options = {}, callback = noop) {
+      const forkResourceStore = options.forkResourceStore;
+      if (forkResourceStore)
+        delete options.forkResourceStore;
+      const mergedOptions = {
+        ...this.options,
+        ...options,
+        ...{
+          isClone: true
+        }
+      };
+      const clone = new I18n(mergedOptions);
+      if (options.debug !== undefined || options.prefix !== undefined) {
+        clone.logger = clone.logger.clone(options);
+      }
+      const membersToCopy = ["store", "services", "language"];
+      membersToCopy.forEach((m) => {
+        clone[m] = this[m];
+      });
+      clone.services = {
+        ...this.services
+      };
+      clone.services.utils = {
+        hasLoadedNamespace: clone.hasLoadedNamespace.bind(clone)
+      };
+      if (forkResourceStore) {
+        const clonedData = Object.keys(this.store.data).reduce((prev, l) => {
+          prev[l] = {
+            ...this.store.data[l]
+          };
+          prev[l] = Object.keys(prev[l]).reduce((acc, n) => {
+            acc[n] = {
+              ...prev[l][n]
+            };
+            return acc;
+          }, prev[l]);
+          return prev;
+        }, {});
+        clone.store = new ResourceStore(clonedData, mergedOptions);
+        clone.services.resourceStore = clone.store;
+      }
+      clone.translator = new Translator(clone.services, mergedOptions);
+      clone.translator.on("*", (event, ...args) => {
+        clone.emit(event, ...args);
+      });
+      clone.init(mergedOptions, callback);
+      clone.translator.options = mergedOptions;
+      clone.translator.backendConnector.services.utils = {
+        hasLoadedNamespace: clone.hasLoadedNamespace.bind(clone)
+      };
+      return clone;
+    }
+    toJSON() {
+      return {
+        options: this.options,
+        store: this.store,
+        language: this.language,
+        languages: this.languages,
+        resolvedLanguage: this.resolvedLanguage
+      };
+    }
+  };
+  instance = I18n.createInstance();
+  createInstance = instance.createInstance;
+  dir = instance.dir;
+  init = instance.init;
+  loadResources = instance.loadResources;
+  reloadResources = instance.reloadResources;
+  use = instance.use;
+  changeLanguage = instance.changeLanguage;
+  getFixedT = instance.getFixedT;
+  t = instance.t;
+  exists = instance.exists;
+  setDefaultNamespace = instance.setDefaultNamespace;
+  hasLoadedNamespace = instance.hasLoadedNamespace;
+  loadNamespaces = instance.loadNamespaces;
+  loadLanguages = instance.loadLanguages;
+});
+
+// src/i18n/locales/en.json
+var en_default;
+var init_en = __esm(() => {
+  en_default = {
+    common: {
+      yes: "Yes",
+      no: "No",
+      cancel: "Cancel",
+      back: "Back",
+      exit: "Exit",
+      success: "✅ Success!",
+      error: "❌ Error!",
+      loading: "⏳ Loading..."
+    },
+    auth: {
+      notAuthenticated: "🔐 You are not authenticated!",
+      enterToken: "Please enter your Trello token:",
+      tokenInvalid: "❌ Invalid token! Token must start with 'ATTA' and be at least 11 characters long.",
+      tokenSaved: "✅ Token saved successfully!",
+      authenticated: "✅ You are already authenticated!"
+    },
+    menu: {
+      title: "� Main Menu - Trello CLI Unofficial",
+      boards: "📋 View my boards",
+      explore: "📝 Explore board",
+      create: "➕ Create card",
+      config: "⚙️  Settings",
+      exit: "🚪 Exit",
+      goodbye: "👋 Goodbye!",
+      exploreInDevelopment: "� Explore board - Under development",
+      configTitle: "⚙️ Settings",
+      configToken: "🔑 Configure token",
+      configView: "👀 View current configuration",
+      configReset: "🔄 Reset configuration",
+      configBack: "⬅️  Back",
+      currentConfig: "� Current configuration:",
+      tokenConfigured: "Token configured:",
+      configFile: "Config file: ~/.trello-cli-unofficial/config.json",
+      confirmReset: "Are you sure you want to reset all configuration?",
+      configResetted: "✅ Configuration resetted!",
+      selectBoard: "Select a board:",
+      selectList: "Select a list:",
+      selectCard: "Select a card:"
+    },
+    board: {
+      loading: "⏳ Loading boards...",
+      empty: "📋 No boards found.",
+      notFound: '❌ Board "{{name}}" not found',
+      lists: "📝 Lists of Board: {{name}}",
+      yourBoards: "📋 Your Trello Boards:"
+    },
+    list: {
+      loading: "⏳ Loading lists...",
+      empty: "📝 No lists found in this board.",
+      notFound: '❌ List "{{listName}}" not found in board "{{boardName}}"',
+      cards: "🃏 Cards of List: {{name}}",
+      boardLists: '📋 Lists from board "{{boardName}}":'
+    },
+    card: {
+      loading: "⏳ Loading cards...",
+      empty: "🃏 No cards found in this list.",
+      notFound: '❌ Card with ID "{{cardId}}" not found',
+      created: "✅ Card created successfully!",
+      updated: "✅ Card updated successfully!",
+      deleted: "✅ Card deleted successfully!",
+      moved: "✅ Card moved successfully!",
+      enterName: "Card name:",
+      enterDescription: "Description (optional):",
+      confirmDelete: 'Are you sure you want to delete "{{name}}"?',
+      listCards: '📋 Cards from list "{{listName}}" in board "{{boardName}}":',
+      emptyList: "📭 This list is empty.",
+      selectBoard: "Select board:",
+      selectList: "Select list:",
+      selectCard: "Select a card:",
+      whatToDo: "What would you like to do?",
+      newName: "New name:",
+      newDescription: "New description:",
+      moveToWhichList: "Move to which list?",
+      cardName: "📝 Name: {{name}}",
+      cardUrl: "🔗 URL: {{url}}",
+      cardId: "🆔 ID: {{id}}",
+      movedTo: "➡️  To: {{listName}}",
+      actions: {
+        view: "👁️  View Details",
+        create: "➕ Create Card",
+        edit: "✏️  Edit Card",
+        move: "🔄 Move Card",
+        delete: "🗑️  Delete Card",
+        back: "⬅️  Back"
+      }
+    },
+    errors: {
+      general: "❌ An error occurred: {{message}}",
+      generic: "❌ Error:",
+      network: "❌ Network error. Check your connection.",
+      invalidInput: "❌ Invalid input: {{field}}",
+      required: "❌ Required field: {{field}}"
+    },
+    commands: {
+      boards: {
+        description: "List all available boards",
+        success: "📋 Boards loaded successfully!"
+      },
+      lists: {
+        description: "List the lists of a specific board",
+        boardRequired: "❌ Board name is required",
+        success: "📝 Lists loaded successfully!"
+      },
+      cards: {
+        description: "List the cards of a specific list",
+        boardRequired: "❌ Board name is required",
+        listRequired: "❌ List name is required",
+        success: "🃏 Cards loaded successfully!"
+      },
+      createCard: {
+        description: "Create a new card in a list",
+        nameRequired: "❌ Card name is required",
+        success: "✅ Card '{{name}}' created successfully!"
+      },
+      moveCard: {
+        description: "Move a card to another list",
+        cardIdRequired: "❌ Card ID is required",
+        targetListRequired: "❌ Target list ID is required",
+        success: "✅ Card moved successfully!"
+      },
+      deleteCard: {
+        description: "Delete a card",
+        cardIdRequired: "❌ Card ID is required",
+        success: "✅ Card deleted successfully!"
+      }
+    }
+  };
+});
+
+// src/i18n/locales/pt-BR.json
+var pt_BR_default;
+var init_pt_BR = __esm(() => {
+  pt_BR_default = {
+    common: {
+      yes: "Sim",
+      no: "Não",
+      cancel: "Cancelar",
+      back: "Voltar",
+      exit: "Sair",
+      success: "✅ Sucesso!",
+      error: "❌ Erro!",
+      loading: "⏳ Carregando..."
+    },
+    auth: {
+      notAuthenticated: "🔐 Você não está autenticado!",
+      enterToken: "Por favor, insira seu token do Trello:",
+      tokenInvalid: "❌ Token inválido! O token deve começar com 'ATTA' e ter pelo menos 11 caracteres.",
+      tokenSaved: "✅ Token salvo com sucesso!",
+      authenticated: "✅ Você já está autenticado!"
+    },
+    menu: {
+      title: "� Menu Principal - Trello CLI Unofficial",
+      boards: "📋 Ver meus quadros",
+      explore: "📝 Explorar quadro",
+      create: "➕ Criar cartão",
+      config: "⚙️  Configurações",
+      exit: "🚪 Sair",
+      goodbye: "👋 Até logo!",
+      exploreInDevelopment: "🚧 Explorar quadro - Em desenvolvimento",
+      configTitle: "⚙️ Configurações",
+      configToken: "� Configurar token",
+      configView: "👀 Ver configuração atual",
+      configReset: "🔄 Resetar configuração",
+      configBack: "⬅️  Voltar",
+      currentConfig: "� Configuração atual:",
+      tokenConfigured: "Token configurado:",
+      configFile: "Arquivo de config: ~/.trello-cli-unofficial/config.json",
+      confirmReset: "Tem certeza que deseja resetar toda a configuração?",
+      configResetted: "✅ Configuração resetada!",
+      selectBoard: "Selecione um board:",
+      selectList: "Selecione uma lista:",
+      selectCard: "Selecione um card:"
+    },
+    board: {
+      loading: "⏳ Carregando boards...",
+      empty: "📋 Nenhum board encontrado.",
+      notFound: '❌ Quadro "{{name}}" não encontrado',
+      lists: "📝 Listas do Board: {{name}}",
+      yourBoards: "📋 Seus Quadros do Trello:"
+    },
+    list: {
+      loading: "⏳ Carregando listas...",
+      empty: "📝 Nenhuma lista encontrada neste board.",
+      notFound: '❌ Lista "{{listName}}" não encontrada no quadro "{{boardName}}"',
+      cards: "🃏 Cards da Lista: {{name}}",
+      boardLists: '📋 Listas do quadro "{{boardName}}":'
+    },
+    card: {
+      loading: "⏳ Carregando cards...",
+      empty: "🃏 Nenhum card encontrado nesta lista.",
+      notFound: '❌ Cartão com ID "{{cardId}}" não encontrado',
+      created: "✅ Cartão criado com sucesso!",
+      updated: "✅ Cartão atualizado com sucesso!",
+      deleted: "✅ Cartão deletado com sucesso!",
+      moved: "✅ Cartão movido com sucesso!",
+      enterName: "Nome do cartão:",
+      enterDescription: "Descrição (opcional):",
+      confirmDelete: 'Tem certeza que deseja deletar "{{name}}"?',
+      listCards: '📋 Cartões da lista "{{listName}}" no quadro "{{boardName}}":',
+      emptyList: "📭 Esta lista está vazia.",
+      selectBoard: "Selecione o quadro:",
+      selectList: "Selecione a lista:",
+      selectCard: "Selecione um cartão:",
+      whatToDo: "O que deseja fazer?",
+      newName: "Novo nome:",
+      newDescription: "Nova descrição:",
+      moveToWhichList: "Mover para qual lista?",
+      cardName: "📝 Nome: {{name}}",
+      cardUrl: "🔗 URL: {{url}}",
+      cardId: "🆔 ID: {{id}}",
+      movedTo: "➡️  Para: {{listName}}",
+      actions: {
+        view: "👁️  Ver Detalhes",
+        create: "➕ Criar Card",
+        edit: "✏️  Editar Card",
+        move: "🔄 Mover Card",
+        delete: "🗑️  Deletar Card",
+        back: "⬅️  Voltar"
+      }
+    },
+    errors: {
+      general: "❌ Ocorreu um erro: {{message}}",
+      generic: "❌ Erro:",
+      network: "❌ Erro de rede. Verifique sua conexão.",
+      invalidInput: "❌ Entrada inválida: {{field}}",
+      required: "❌ Campo obrigatório: {{field}}"
+    },
+    commands: {
+      boards: {
+        description: "Lista todos os boards disponíveis",
+        success: "📋 Boards carregados com sucesso!"
+      },
+      lists: {
+        description: "Lista as listas de um board específico",
+        boardRequired: "❌ Nome do board é obrigatório",
+        success: "📝 Listas carregadas com sucesso!"
+      },
+      cards: {
+        description: "Lista os cards de uma lista específica",
+        boardRequired: "❌ Nome do board é obrigatório",
+        listRequired: "❌ Nome da lista é obrigatório",
+        success: "🃏 Cards carregados com sucesso!"
+      },
+      createCard: {
+        description: "Cria um novo card em uma lista",
+        nameRequired: "❌ Nome do card é obrigatório",
+        success: "✅ Card '{{name}}' criado com sucesso!"
+      },
+      moveCard: {
+        description: "Move um card para outra lista",
+        cardIdRequired: "❌ ID do card é obrigatório",
+        targetListRequired: "❌ ID da lista de destino é obrigatório",
+        success: "✅ Card movido com sucesso!"
+      },
+      deleteCard: {
+        description: "Deleta um card",
+        cardIdRequired: "❌ ID do card é obrigatório",
+        success: "✅ Card deletado com sucesso!"
+      }
+    }
+  };
+});
+
+// src/i18n/index.ts
+function detectLanguage() {
+  const lang = process.env.LANG || process.env.LANGUAGE || "en_US";
+  if (lang.startsWith("pt")) {
+    return "pt-BR";
+  }
+  return "en";
+}
+function t2(key, options) {
+  return instance.t(key, options);
+}
+var init_i18n = __esm(() => {
+  init_i18next();
+  init_en();
+  init_pt_BR();
+  instance.init({
+    lng: detectLanguage(),
+    fallbackLng: "en",
+    resources: {
+      "pt-BR": {
+        translation: pt_BR_default
+      },
+      en: {
+        translation: en_default
+      }
+    },
+    interpolation: {
+      escapeValue: false
+    }
+  });
+});
+
 // src/presentation/cli/AuthController.ts
 class AuthController {
   configRepository;
@@ -23189,7 +25836,7 @@ class AuthController {
   async ensureAuthenticated() {
     const result = await this.authenticateUseCase.execute();
     if (!result.success) {
-      console.log(result.message);
+      console.log(t2("auth.notAuthenticated"));
       await this.setupToken();
     }
   }
@@ -23198,12 +25845,12 @@ class AuthController {
       {
         type: "input",
         name: "token",
-        message: "Digite seu token do Trello (ATTA...):",
-        validate: (input) => input.startsWith("ATTA") || "Token deve começar com ATTA"
+        message: t2("auth.enterToken"),
+        validate: (input) => input.startsWith("ATTA") || t2("auth.tokenInvalid")
       }
     ]);
     const result = await this.authenticateUseCase.execute(token);
-    console.log(result.message);
+    console.log(result.success ? t2("auth.tokenSaved") : result.message);
   }
   async getConfig() {
     return await this.authenticateUseCase.getConfig();
@@ -23212,6 +25859,7 @@ class AuthController {
 var init_AuthController = __esm(() => {
   init_use_cases();
   init_esm16();
+  init_i18n();
 });
 
 // src/presentation/cli/BoardController.ts
@@ -23226,7 +25874,7 @@ class BoardController {
   }
   async showBoards() {
     const boards = await this.getBoardsUseCase.execute();
-    console.log("\uD83D\uDCCB Seus Quadros do Trello:");
+    console.log(t2("board.yourBoards"));
     boards.forEach((board, index) => {
       console.log(`${index + 1}. ${board.name}`);
       console.log(`   \uD83D\uDD17 ${board.url}`);
@@ -23238,10 +25886,10 @@ class BoardController {
     const boards = await this.getBoardsUseCase.execute();
     const board = boards.find((b) => b.name === boardName);
     if (!board) {
-      throw new Error(`Quadro "${boardName}" não encontrado`);
+      throw new Error(t2("board.notFound", { name: boardName }));
     }
     const lists = await this.getListsUseCase.execute(board.id);
-    console.log(`\uD83D\uDCCB Listas do quadro "${boardName}":`);
+    console.log(t2("list.boardLists", { boardName }));
     lists.forEach((list, index) => {
       console.log(`${index + 1}. ${list.name}`);
       console.log(`   \uD83C\uDD94 ${list.id}
@@ -23252,17 +25900,17 @@ class BoardController {
     const boards = await this.getBoardsUseCase.execute();
     const board = boards.find((b) => b.name === boardName);
     if (!board) {
-      throw new Error(`Quadro "${boardName}" não encontrado`);
+      throw new Error(t2("board.notFound", { name: boardName }));
     }
     const lists = await this.getListsUseCase.execute(board.id);
     const list = lists.find((l) => l.name === listName);
     if (!list) {
-      throw new Error(`Lista "${listName}" não encontrada no quadro "${boardName}"`);
+      throw new Error(t2("list.notFound", { listName, boardName }));
     }
     const cards = await this.getCardsUseCase.execute(list.id);
-    console.log(`\uD83D\uDCCB Cartões da lista "${listName}" no quadro "${boardName}":`);
+    console.log(t2("card.listCards", { listName, boardName }));
     if (cards.length === 0) {
-      console.log("\uD83D\uDCED Esta lista está vazia.");
+      console.log(t2("card.emptyList"));
       return;
     }
     cards.forEach((card, index) => {
@@ -23283,6 +25931,7 @@ class BoardController {
 }
 var init_BoardController = __esm(() => {
   init_use_cases();
+  init_i18n();
 });
 
 // src/shared/types.ts
@@ -23331,8 +25980,11 @@ class CardController {
       {
         type: "list",
         name: "selectedBoard",
-        message: "Selecione o quadro:",
-        choices: boards.map((board) => ({ name: board.name, value: board.id }))
+        message: t2("card.selectBoard"),
+        choices: boards.map((board) => ({
+          name: board.name,
+          value: board.id
+        }))
       }
     ]);
     const lists = await this.boardController.getLists(selectedBoard);
@@ -23340,21 +25992,24 @@ class CardController {
       {
         type: "list",
         name: "selectedList",
-        message: "Selecione a lista:",
-        choices: lists.map((list) => ({ name: list.name, value: list.id }))
+        message: t2("card.selectList"),
+        choices: lists.map((list) => ({
+          name: list.name,
+          value: list.id
+        }))
       }
     ]);
     const { cardName, cardDesc } = await esm_default12.prompt([
       {
         type: "input",
         name: "cardName",
-        message: "Nome do cartão:",
+        message: t2("card.enterName"),
         validate: (input) => input.length > 0 || "Nome é obrigatório"
       },
       {
         type: "input",
         name: "cardDesc",
-        message: "Descrição (opcional):"
+        message: t2("card.enterDescription")
       }
     ]);
     const newCard = await this.createCardUseCase.execute({
@@ -23362,22 +26017,22 @@ class CardController {
       desc: cardDesc,
       listId: selectedList
     });
-    console.log("✅ Cartão criado com sucesso!");
-    console.log(`\uD83D\uDCDD Nome: ${newCard.name}`);
-    console.log(`\uD83D\uDD17 URL: ${newCard.url}`);
+    console.log(t2("card.created"));
+    console.log(t2("card.cardName", { name: newCard.name }));
+    console.log(t2("card.cardUrl", { url: newCard.url }));
   }
   async exploreCards(boardId, lists) {
     const { selectedList } = await esm_default12.prompt([
       {
         type: "list",
         name: "selectedList",
-        message: "Selecione uma lista:",
+        message: t2("card.selectList"),
         choices: lists.map((list) => ({ name: list.name, value: list.id }))
       }
     ]);
     const cards = await this.boardController.getCards(selectedList);
     if (cards.length === 0) {
-      console.log("\uD83D\uDCED Esta lista está vazia.");
+      console.log(t2("card.emptyList"));
       return;
     }
     console.log(`\uD83C\uDCCF Cartões em "${lists.find((l) => l.id === selectedList)?.name}":`);
@@ -23394,11 +26049,11 @@ class CardController {
       {
         type: "list",
         name: "nextAction",
-        message: "O que deseja fazer?",
+        message: t2("card.whatToDo"),
         choices: [
-          { name: "⬅️  Voltar ao menu", value: CARD_ACTIONS.BACK },
-          { name: "\uD83D\uDCDD Editar cartão", value: CARD_ACTIONS.EDIT },
-          { name: "\uD83D\uDDD1️  Deletar cartão", value: CARD_ACTIONS.DELETE },
+          { name: t2("card.actions.back"), value: CARD_ACTIONS.BACK },
+          { name: t2("card.actions.edit"), value: CARD_ACTIONS.EDIT },
+          { name: t2("card.actions.delete"), value: CARD_ACTIONS.DELETE },
           { name: "\uD83D\uDCE6 Mover cartão", value: CARD_ACTIONS.MOVE }
         ]
       }
@@ -23408,8 +26063,11 @@ class CardController {
         {
           type: "list",
           name: "selectedCard",
-          message: "Selecione um cartão:",
-          choices: cards.map((card) => ({ name: card.name, value: card.id }))
+          message: t2("card.selectCard"),
+          choices: cards.map((card) => ({
+            name: card.name,
+            value: card.id
+          }))
         }
       ]);
       const selectedCardEntity = cards.find((c) => c.id === selectedCard);
@@ -23431,13 +26089,13 @@ class CardController {
       {
         type: "input",
         name: "newName",
-        message: "Novo nome:",
+        message: t2("card.newName"),
         default: card.name
       },
       {
         type: "input",
         name: "newDesc",
-        message: "Nova descrição:",
+        message: t2("card.newDescription"),
         default: card.desc || ""
       }
     ]);
@@ -23445,14 +26103,14 @@ class CardController {
       name: newName,
       desc: newDesc
     });
-    console.log("✅ Cartão atualizado com sucesso!");
+    console.log(t2("card.updated"));
   }
   async deleteCardInteractive(cardId, card) {
     const { confirm } = await esm_default12.prompt([
       {
         type: "confirm",
         name: "confirm",
-        message: `Tem certeza que deseja deletar "${card.name}"?`,
+        message: t2("card.confirmDelete", { name: card.name }),
         default: false
       }
     ]);
@@ -23465,7 +26123,7 @@ class CardController {
       {
         type: "list",
         name: "targetList",
-        message: "Mover para qual lista?",
+        message: t2("card.moveToWhichList"),
         choices: lists.map((list) => ({ name: list.name, value: list.id }))
       }
     ]);
@@ -23478,22 +26136,22 @@ class CardController {
     const boards = await this.boardController.getBoards();
     const board = boards.find((b) => b.name === boardName);
     if (!board) {
-      throw new Error(`Quadro "${boardName}" não encontrado`);
+      throw new Error(t2("board.notFound", { name: boardName }));
     }
     const lists = await this.boardController.getLists(board.id);
     const list = lists.find((l) => l.name === listName);
     if (!list) {
-      throw new Error(`Lista "${listName}" não encontrada no quadro "${boardName}"`);
+      throw new Error(t2("list.notFound", { listName, boardName }));
     }
     const newCard = await this.createCardUseCase.execute({
       name: cardName,
       desc: description || "",
       listId: list.id
     });
-    console.log("✅ Cartão criado com sucesso!");
-    console.log(`\uD83D\uDCDD Nome: ${newCard.name}`);
-    console.log(`\uD83D\uDD17 URL: ${newCard.url}`);
-    console.log(`\uD83C\uDD94 ID: ${newCard.id}`);
+    console.log(t2("card.created"));
+    console.log(t2("card.cardName", { name: newCard.name }));
+    console.log(t2("card.cardUrl", { url: newCard.url }));
+    console.log(t2("card.cardId", { id: newCard.id }));
   }
   async moveCard(cardId, targetListName) {
     const boards = await this.boardController.getBoards();
@@ -23506,12 +26164,15 @@ class CardController {
           if (card) {
             const targetList = lists.find((l) => l.name === targetListName);
             if (!targetList) {
-              throw new Error(`Lista "${targetListName}" não encontrada no quadro "${board.name}"`);
+              throw new Error(t2("list.notFound", {
+                listName: targetListName,
+                boardName: board.name
+              }));
             }
             await this.moveCardUseCase.execute(cardId, targetList.id);
-            console.log("✅ Cartão movido com sucesso!");
-            console.log(`\uD83D\uDCDD Cartão: ${card.name}`);
-            console.log(`➡️  Para: ${targetList.name}`);
+            console.log(t2("card.moved"));
+            console.log(t2("card.cardName", { name: card.name }));
+            console.log(t2("card.movedTo", { listName: targetList.name }));
             return;
           }
         } catch {
@@ -23519,7 +26180,7 @@ class CardController {
         }
       }
     }
-    throw new Error(`Cartão com ID "${cardId}" não encontrado`);
+    throw new Error(t2("card.notFound", { cardId }));
   }
   async deleteCard(cardId, card) {
     if (!card) {
@@ -23542,18 +26203,19 @@ class CardController {
         }
       }
       if (!card) {
-        throw new Error(`Cartão com ID "${cardId}" não encontrado`);
+        throw new Error(t2("card.notFound", { cardId }));
       }
     }
     await this.deleteCardUseCase.execute(cardId);
-    console.log("✅ Cartão deletado com sucesso!");
-    console.log(`\uD83D\uDCDD Nome: ${card.name}`);
+    console.log(t2("card.deleted"));
+    console.log(t2("card.cardName", { name: card.name }));
   }
 }
 var init_CardController = __esm(() => {
   init_use_cases();
   init_types();
   init_esm16();
+  init_i18n();
 });
 
 // src/domain/entities/Board.ts
@@ -24072,13 +26734,13 @@ var require_clone = __commonJS((exports, module) => {
     if (obj === null || typeof obj !== "object")
       return obj;
     if (obj instanceof Object)
-      var copy = { __proto__: getPrototypeOf(obj) };
+      var copy2 = { __proto__: getPrototypeOf(obj) };
     else
-      var copy = Object.create(null);
+      var copy2 = Object.create(null);
     Object.getOwnPropertyNames(obj).forEach(function(key) {
-      Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      Object.defineProperty(copy2, key, Object.getOwnPropertyDescriptor(obj, key));
     });
-    return copy;
+    return copy2;
   }
 });
 
@@ -24098,7 +26760,7 @@ var require_graceful_fs = __commonJS((exports, module) => {
     gracefulQueue = "___graceful-fs.queue";
     previousSymbol = "___graceful-fs.previous";
   }
-  function noop() {}
+  function noop2() {}
   function publishQueue(context, queue2) {
     Object.defineProperty(context, gracefulQueue, {
       get: function() {
@@ -24106,7 +26768,7 @@ var require_graceful_fs = __commonJS((exports, module) => {
       }
     });
   }
-  var debug = noop;
+  var debug = noop2;
   if (util.debuglog)
     debug = util.debuglog("gfs4");
   else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
@@ -24578,16 +27240,16 @@ var require_make_dir = __commonJS((exports, module) => {
       return options;
     return { ...defaults, ...options }.mode;
   };
-  exports.makeDir = async (dir, options) => {
-    checkPath(dir);
-    return fs.mkdir(dir, {
+  exports.makeDir = async (dir2, options) => {
+    checkPath(dir2);
+    return fs.mkdir(dir2, {
       mode: getMode(options),
       recursive: true
     });
   };
-  exports.makeDirSync = (dir, options) => {
-    checkPath(dir);
-    return fs.mkdirSync(dir, {
+  exports.makeDirSync = (dir2, options) => {
+    checkPath(dir2);
+    return fs.mkdirSync(dir2, {
       mode: getMode(options),
       recursive: true
     });
@@ -24811,7 +27473,7 @@ var require_copy = __commonJS((exports, module) => {
   var { utimesMillis } = require_utimes();
   var stat = require_stat();
   var { asyncIteratorConcurrentProcess } = require_async2();
-  async function copy(src, dest, opts = {}) {
+  async function copy2(src, dest, opts = {}) {
     if (typeof opts === "function") {
       opts = { filter: opts };
     }
@@ -24927,7 +27589,7 @@ var require_copy = __commonJS((exports, module) => {
     await fs.unlink(dest);
     return fs.symlink(resolvedSrc, dest);
   }
-  module.exports = copy;
+  module.exports = copy2;
 });
 
 // node_modules/fs-extra/lib/copy/copy-sync.js
@@ -25021,14 +27683,14 @@ var require_copy_sync = __commonJS((exports, module) => {
     return setDestMode(dest, srcMode);
   }
   function copyDir(src, dest, opts) {
-    const dir = fs.opendirSync(src);
+    const dir2 = fs.opendirSync(src);
     try {
       let dirent;
-      while ((dirent = dir.readSync()) !== null) {
+      while ((dirent = dir2.readSync()) !== null) {
         copyDirItem(dirent.name, src, dest, opts);
       }
     } finally {
-      dir.closeSync();
+      dir2.closeSync();
     }
   }
   function copyDirItem(item, src, dest, opts) {
@@ -25106,24 +27768,24 @@ var require_empty2 = __commonJS((exports, module) => {
   var path2 = __require("path");
   var mkdir = require_mkdirs();
   var remove = require_remove();
-  var emptyDir = u(async function emptyDir(dir) {
+  var emptyDir = u(async function emptyDir(dir2) {
     let items;
     try {
-      items = await fs.readdir(dir);
+      items = await fs.readdir(dir2);
     } catch {
-      return mkdir.mkdirs(dir);
+      return mkdir.mkdirs(dir2);
     }
-    return Promise.all(items.map((item) => remove.remove(path2.join(dir, item))));
+    return Promise.all(items.map((item) => remove.remove(path2.join(dir2, item))));
   });
-  function emptyDirSync(dir) {
+  function emptyDirSync(dir2) {
     let items;
     try {
-      items = fs.readdirSync(dir);
+      items = fs.readdirSync(dir2);
     } catch {
-      return mkdir.mkdirsSync(dir);
+      return mkdir.mkdirsSync(dir2);
     }
     items.forEach((item) => {
-      item = path2.join(dir, item);
+      item = path2.join(dir2, item);
       remove.removeSync(item);
     });
   }
@@ -25148,13 +27810,13 @@ var require_file = __commonJS((exports, module) => {
     } catch {}
     if (stats && stats.isFile())
       return;
-    const dir = path2.dirname(file);
+    const dir2 = path2.dirname(file);
     let dirStats = null;
     try {
-      dirStats = await fs.stat(dir);
+      dirStats = await fs.stat(dir2);
     } catch (err) {
       if (err.code === "ENOENT") {
-        await mkdir.mkdirs(dir);
+        await mkdir.mkdirs(dir2);
         await fs.writeFile(file, "");
         return;
       } else {
@@ -25164,7 +27826,7 @@ var require_file = __commonJS((exports, module) => {
     if (dirStats.isDirectory()) {
       await fs.writeFile(file, "");
     } else {
-      await fs.readdir(dir);
+      await fs.readdir(dir2);
     }
   }
   function createFileSync(file) {
@@ -25174,14 +27836,14 @@ var require_file = __commonJS((exports, module) => {
     } catch {}
     if (stats && stats.isFile())
       return;
-    const dir = path2.dirname(file);
+    const dir2 = path2.dirname(file);
     try {
-      if (!fs.statSync(dir).isDirectory()) {
-        fs.readdirSync(dir);
+      if (!fs.statSync(dir2).isDirectory()) {
+        fs.readdirSync(dir2);
       }
     } catch (err) {
       if (err && err.code === "ENOENT")
-        mkdir.mkdirsSync(dir);
+        mkdir.mkdirsSync(dir2);
       else
         throw err;
     }
@@ -25215,10 +27877,10 @@ var require_link = __commonJS((exports, module) => {
     }
     if (dstStat && areIdentical(srcStat, dstStat))
       return;
-    const dir = path2.dirname(dstpath);
-    const dirExists = await pathExists(dir);
+    const dir2 = path2.dirname(dstpath);
+    const dirExists = await pathExists(dir2);
     if (!dirExists) {
-      await mkdir.mkdirs(dir);
+      await mkdir.mkdirs(dir2);
     }
     await fs.link(srcpath, dstpath);
   }
@@ -25235,11 +27897,11 @@ var require_link = __commonJS((exports, module) => {
       err.message = err.message.replace("lstat", "ensureLink");
       throw err;
     }
-    const dir = path2.dirname(dstpath);
-    const dirExists = fs.existsSync(dir);
+    const dir2 = path2.dirname(dstpath);
+    const dirExists = fs.existsSync(dir2);
     if (dirExists)
       return fs.linkSync(srcpath, dstpath);
-    mkdir.mkdirsSync(dir);
+    mkdir.mkdirsSync(dir2);
     return fs.linkSync(srcpath, dstpath);
   }
   module.exports = {
@@ -25269,8 +27931,8 @@ var require_symlink_paths = __commonJS((exports, module) => {
     }
     const dstdir = path2.dirname(dstpath);
     const relativeToDst = path2.join(dstdir, srcpath);
-    const exists = await pathExists(relativeToDst);
-    if (exists) {
+    const exists2 = await pathExists(relativeToDst);
+    if (exists2) {
       return {
         toCwd: relativeToDst,
         toDst: srcpath
@@ -25289,8 +27951,8 @@ var require_symlink_paths = __commonJS((exports, module) => {
   }
   function symlinkPathsSync(srcpath, dstpath) {
     if (path2.isAbsolute(srcpath)) {
-      const exists2 = fs.existsSync(srcpath);
-      if (!exists2)
+      const exists3 = fs.existsSync(srcpath);
+      if (!exists3)
         throw new Error("absolute srcpath does not exist");
       return {
         toCwd: srcpath,
@@ -25299,8 +27961,8 @@ var require_symlink_paths = __commonJS((exports, module) => {
     }
     const dstdir = path2.dirname(dstpath);
     const relativeToDst = path2.join(dstdir, srcpath);
-    const exists = fs.existsSync(relativeToDst);
-    if (exists) {
+    const exists2 = fs.existsSync(relativeToDst);
+    if (exists2) {
       return {
         toCwd: relativeToDst,
         toDst: srcpath
@@ -25378,9 +28040,9 @@ var require_symlink = __commonJS((exports, module) => {
     const relative = await symlinkPaths(srcpath, dstpath);
     srcpath = relative.toDst;
     const toType = await symlinkType(relative.toCwd, type);
-    const dir = path2.dirname(dstpath);
-    if (!await pathExists(dir)) {
-      await mkdirs(dir);
+    const dir2 = path2.dirname(dstpath);
+    if (!await pathExists(dir2)) {
+      await mkdirs(dir2);
     }
     return fs.symlink(srcpath, dstpath, toType);
   }
@@ -25398,11 +28060,11 @@ var require_symlink = __commonJS((exports, module) => {
     const relative = symlinkPathsSync(srcpath, dstpath);
     srcpath = relative.toDst;
     type = symlinkTypeSync(relative.toCwd, type);
-    const dir = path2.dirname(dstpath);
-    const exists = fs.existsSync(dir);
-    if (exists)
+    const dir2 = path2.dirname(dstpath);
+    const exists2 = fs.existsSync(dir2);
+    if (exists2)
       return fs.symlinkSync(srcpath, dstpath, type);
-    mkdirsSync(dir);
+    mkdirsSync(dir2);
     return fs.symlinkSync(srcpath, dstpath, type);
   }
   module.exports = {
@@ -25537,16 +28199,16 @@ var require_output_file = __commonJS((exports, module) => {
   var mkdir = require_mkdirs();
   var pathExists = require_path_exists().pathExists;
   async function outputFile(file, data, encoding = "utf-8") {
-    const dir = path2.dirname(file);
-    if (!await pathExists(dir)) {
-      await mkdir.mkdirs(dir);
+    const dir2 = path2.dirname(file);
+    if (!await pathExists(dir2)) {
+      await mkdir.mkdirs(dir2);
     }
     return fs.writeFile(file, data, encoding);
   }
   function outputFileSync(file, ...args) {
-    const dir = path2.dirname(file);
-    if (!fs.existsSync(dir)) {
-      mkdir.mkdirsSync(dir);
+    const dir2 = path2.dirname(file);
+    if (!fs.existsSync(dir2)) {
+      mkdir.mkdirsSync(dir2);
     }
     fs.writeFileSync(file, ...args);
   }
@@ -25597,7 +28259,7 @@ var require_json = __commonJS((exports, module) => {
 var require_move = __commonJS((exports, module) => {
   var fs = require_fs();
   var path2 = __require("path");
-  var { copy } = require_copy2();
+  var { copy: copy2 } = require_copy2();
   var { remove } = require_remove();
   var { mkdirp } = require_mkdirs();
   var { pathExists } = require_path_exists();
@@ -25636,7 +28298,7 @@ var require_move = __commonJS((exports, module) => {
       errorOnExist: true,
       preserveTimestamps: true
     };
-    await copy(src, dest, opts);
+    await copy2(src, dest, opts);
     return remove(src);
   }
   module.exports = move;
@@ -26562,7 +29224,7 @@ var require_suggestSimilar = __commonJS((exports) => {
 
 // node_modules/commander/lib/command.js
 var require_command = __commonJS((exports) => {
-  var EventEmitter = __require("node:events").EventEmitter;
+  var EventEmitter2 = __require("node:events").EventEmitter;
   var childProcess = __require("node:child_process");
   var path3 = __require("node:path");
   var fs2 = __require("node:fs");
@@ -26573,7 +29235,7 @@ var require_command = __commonJS((exports) => {
   var { Option, DualOptions } = require_option();
   var { suggestSimilar } = require_suggestSimilar();
 
-  class Command extends EventEmitter {
+  class Command extends EventEmitter2 {
     constructor(name) {
       super();
       this.commands = [];
@@ -28101,12 +30763,12 @@ class ConfigController {
         {
           type: "list",
           name: "configAction",
-          message: "⚙️ Configurações",
+          message: t2("menu.configTitle"),
           choices: [
-            { name: "\uD83D\uDD11 Configurar token", value: CONFIG_ACTIONS.TOKEN },
-            { name: "\uD83D\uDC40 Ver configuração atual", value: CONFIG_ACTIONS.VIEW },
-            { name: "\uD83D\uDD04 Resetar configuração", value: CONFIG_ACTIONS.RESET },
-            { name: "⬅️  Voltar", value: CONFIG_ACTIONS.BACK }
+            { name: t2("menu.configToken"), value: CONFIG_ACTIONS.TOKEN },
+            { name: t2("menu.configView"), value: CONFIG_ACTIONS.VIEW },
+            { name: t2("menu.configReset"), value: CONFIG_ACTIONS.RESET },
+            { name: t2("menu.configBack"), value: CONFIG_ACTIONS.BACK }
           ]
         }
       ]);
@@ -28116,22 +30778,23 @@ class ConfigController {
           break;
         case CONFIG_ACTIONS.VIEW:
           const config = await this.authController.getConfig();
-          console.log("\uD83D\uDCCB Configuração atual:");
+          console.log(t2("menu.currentConfig"));
           console.log(`API Key: ${config.apiKey}`);
-          console.log(`Token configurado: ${config.hasValidToken() ? "✅ Sim" : "❌ Não"}`);
-          console.log(`Arquivo de config: ~/.trello-cli-unofficial/config.json`);
+          const tokenStatus = config.hasValidToken() ? `✅ ${t2("common.yes")}` : `❌ ${t2("common.no")}`;
+          console.log(`${t2("menu.tokenConfigured")} ${tokenStatus}`);
+          console.log(t2("menu.configFile"));
           break;
         case CONFIG_ACTIONS.RESET:
           const { confirm } = await esm_default12.prompt([
             {
               type: "confirm",
               name: "confirm",
-              message: "Tem certeza que deseja resetar toda a configuração?",
+              message: t2("menu.confirmReset"),
               default: false
             }
           ]);
           if (confirm) {
-            console.log("✅ Configuração resetada!");
+            console.log(t2("menu.configResetted"));
           }
           break;
         case CONFIG_ACTIONS.BACK:
@@ -28143,6 +30806,7 @@ class ConfigController {
 var init_ConfigController = __esm(() => {
   init_types();
   init_esm16();
+  init_i18n();
 });
 
 // src/presentation/cli/MainMenuController.ts
@@ -28161,13 +30825,13 @@ class MainMenuController {
         {
           type: "list",
           name: "action",
-          message: "\uD83C\uDFE0 Menu Principal - Trello CLI Unofficial",
+          message: t2("menu.title"),
           choices: [
-            { name: "\uD83D\uDCCB Ver meus quadros", value: MENU_ACTIONS.BOARDS },
-            { name: "\uD83D\uDCDD Explorar quadro", value: MENU_ACTIONS.EXPLORE },
-            { name: "➕ Criar cartão", value: MENU_ACTIONS.CREATE },
-            { name: "⚙️  Configurações", value: MENU_ACTIONS.CONFIG },
-            { name: "\uD83D\uDEAA Sair", value: MENU_ACTIONS.EXIT }
+            { name: t2("menu.boards"), value: MENU_ACTIONS.BOARDS },
+            { name: t2("menu.explore"), value: MENU_ACTIONS.EXPLORE },
+            { name: t2("menu.create"), value: MENU_ACTIONS.CREATE },
+            { name: t2("menu.config"), value: MENU_ACTIONS.CONFIG },
+            { name: t2("menu.exit"), value: MENU_ACTIONS.EXIT }
           ]
         }
       ]);
@@ -28186,11 +30850,11 @@ class MainMenuController {
             await this.configController.showConfigMenu();
             break;
           case MENU_ACTIONS.EXIT:
-            console.log("\uD83D\uDC4B Até logo!");
+            console.log(t2("menu.goodbye"));
             return;
         }
       } catch (error) {
-        console.error("❌ Erro:", error.message);
+        console.error(t2("errors.generic"), error.message);
       }
       console.log(`
 ${"=".repeat(50)}
@@ -28198,12 +30862,13 @@ ${"=".repeat(50)}
     }
   }
   async exploreBoard() {
-    console.log("\uD83D\uDEA7 Explorar quadro - Em desenvolvimento");
+    console.log(t2("menu.exploreInDevelopment"));
   }
 }
 var init_MainMenuController = __esm(() => {
   init_types();
   init_esm16();
+  init_i18n();
 });
 
 // src/presentation/cli/index.ts