npm - @hua-labs/i18n-core - Versions diffs - 2.0.0 → 2.0.4 - Mend

@hua-labs/i18n-core 2.0.0 → 2.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (78) hide show

package/README.md +57 -597
package/dist/chunk-F4PDBJLO.mjs +973 -0
package/dist/chunk-F4PDBJLO.mjs.map +1 -0
package/dist/index.d.mts +249 -0
package/dist/index.d.ts +117 -30
package/dist/index.js +1818 -177
package/dist/index.js.map +1 -1
package/dist/index.mjs +845 -0
package/dist/index.mjs.map +1 -0
package/dist/server-4TeBq6hp.d.mts +367 -0
package/dist/server-4TeBq6hp.d.ts +367 -0
package/dist/server.d.mts +1 -0
package/dist/server.d.ts +1 -0
package/dist/server.js +977 -0
package/dist/server.js.map +1 -0
package/dist/server.mjs +3 -0
package/dist/server.mjs.map +1 -0
package/package.json +42 -19
package/src/__tests__/debug-tools.test.ts +359 -0
package/src/__tests__/default-translations.test.ts +179 -0
package/src/__tests__/i18n-resource.test.ts +137 -0
package/src/__tests__/lazy-loader.test.ts +109 -0
package/src/__tests__/missing-key-overlay.test.tsx +339 -0
package/src/__tests__/translator-factory.test.ts +120 -0
package/src/__tests__/translator.test.ts +442 -0
package/src/__tests__/types.test.ts +211 -0
package/src/__tests__/useI18n.test.tsx +181 -0
package/src/__tests__/useTranslation.test.tsx +110 -0
package/src/components/MissingKeyOverlay.tsx +1 -1
package/src/core/lazy-loader.ts +2 -2
package/src/core/translator.tsx +151 -62
package/src/hooks/useI18n.tsx +96 -115
package/src/hooks/useTranslation.tsx +12 -10
package/src/index.ts +102 -5
package/src/server.ts +9 -0
package/src/types/index.ts +67 -12
package/LICENSE +0 -21
package/dist/components/MissingKeyOverlay.d.ts +0 -33
package/dist/components/MissingKeyOverlay.d.ts.map +0 -1
package/dist/components/MissingKeyOverlay.js +0 -138
package/dist/components/MissingKeyOverlay.js.map +0 -1
package/dist/core/debug-tools.d.ts +0 -37
package/dist/core/debug-tools.d.ts.map +0 -1
package/dist/core/debug-tools.js +0 -241
package/dist/core/debug-tools.js.map +0 -1
package/dist/core/i18n-resource.d.ts +0 -59
package/dist/core/i18n-resource.d.ts.map +0 -1
package/dist/core/i18n-resource.js +0 -153
package/dist/core/i18n-resource.js.map +0 -1
package/dist/core/lazy-loader.d.ts +0 -82
package/dist/core/lazy-loader.d.ts.map +0 -1
package/dist/core/lazy-loader.js +0 -193
package/dist/core/lazy-loader.js.map +0 -1
package/dist/core/translator-factory.d.ts +0 -50
package/dist/core/translator-factory.d.ts.map +0 -1
package/dist/core/translator-factory.js +0 -117
package/dist/core/translator-factory.js.map +0 -1
package/dist/core/translator.d.ts +0 -202
package/dist/core/translator.d.ts.map +0 -1
package/dist/core/translator.js +0 -912
package/dist/core/translator.js.map +0 -1
package/dist/hooks/useI18n.d.ts +0 -39
package/dist/hooks/useI18n.d.ts.map +0 -1
package/dist/hooks/useI18n.js +0 -531
package/dist/hooks/useI18n.js.map +0 -1
package/dist/hooks/useTranslation.d.ts +0 -55
package/dist/hooks/useTranslation.d.ts.map +0 -1
package/dist/hooks/useTranslation.js +0 -58
package/dist/hooks/useTranslation.js.map +0 -1
package/dist/index.d.ts.map +0 -1
package/dist/types/index.d.ts +0 -162
package/dist/types/index.d.ts.map +0 -1
package/dist/types/index.js +0 -191
package/dist/types/index.js.map +0 -1
package/dist/utils/default-translations.d.ts +0 -20
package/dist/utils/default-translations.d.ts.map +0 -1
package/dist/utils/default-translations.js +0 -123
package/dist/utils/default-translations.js.map +0 -1

package/dist/index.js CHANGED Viewed

@@ -1,191 +1,1832 @@
-/**
- * @hua-labs/i18n-core - 핵심 기능 전용 엔트리포인트
- *
- * 이 모듈은 기본적인 번역 기능만 필요한 경우 사용합니다.
- * 플러그인, 고급 기능, 디버깅 도구 없이 순수한 번역 기능만 제공합니다.
- */
-import React from 'react';
-import { I18nProvider, useI18n } from './hooks/useI18n';
-import { useTranslation, useLanguageChange } from './hooks/useTranslation';
-import { Translator, ssrTranslate, serverTranslate } from './core/translator';
-// 기본 언어 설정
-const defaultLanguages = [
-    { code: 'ko', name: 'Korean', nativeName: '한국어' },
-    { code: 'en', name: 'English', nativeName: 'English' },
-];
-/**
- * 핵심 기능용 설정 함수
- *
- * @example
- * ```tsx
- * // app/layout.tsx (Next.js App Router)
- * import { createCoreI18n } from '@hua-labs/i18n-core';
- *
- * export default function RootLayout({ children }) {
- *   return (
- *     <html>
- *       <body>
- *         {createCoreI18n({
- *           defaultLanguage: 'ko',
- *           fallbackLanguage: 'en',
- *           namespaces: ['common', 'auth']
- *         })({ children })}
- *       </body>
- *     </html>
- *   );
- * }
- * ```
- */
-export function createCoreI18n(options) {
-    const { defaultLanguage = 'ko', fallbackLanguage = 'en', namespaces = ['common'], debug = false, loadTranslations, translationLoader = 'api', translationApiPath = '/api/translations', initialTranslations, autoLanguageSync = false // 기본값 false (Zustand 어댑터 등 외부에서 직접 처리)
-     } = options || {};
-    // API route 기반 로더 (기본값, 권장)
-    const apiRouteLoader = async (language, namespace) => {
+'use strict';
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+var React__default = /*#__PURE__*/_interopDefault(React);
+// src/index.ts
+// src/types/index.ts
+var PLURAL_CATEGORIES = /* @__PURE__ */ new Set(["zero", "one", "two", "few", "many", "other"]);
+function isPluralValue(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  const keys = Object.keys(obj);
+  return keys.length > 0 && keys.every((k) => PLURAL_CATEGORIES.has(k)) && Object.values(obj).every((v) => typeof v === "string") && typeof obj.other === "string";
+}
+function isTranslationNamespace(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLanguageConfig(value) {
+  return typeof value === "object" && value !== null && typeof value.code === "string" && typeof value.name === "string" && typeof value.nativeName === "string";
+}
+function validateI18nConfig(config) {
+  if (!config || typeof config !== "object") {
+    return false;
+  }
+  const c = config;
+  return typeof c.defaultLanguage === "string" && Array.isArray(c.supportedLanguages) && c.supportedLanguages.every(isLanguageConfig) && typeof c.loadTranslations === "function";
+}
+function isRecoverableError(error) {
+  const recoverableCodes = [
+    "LOAD_FAILED",
+    "NETWORK_ERROR",
+    "CACHE_ERROR"
+  ];
+  return recoverableCodes.includes(error.code) && (error.retryCount || 0) < (error.maxRetries || 3);
+}
+// src/core/translator.tsx
+var Translator = class {
+  constructor(config) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.pluralRulesCache = /* @__PURE__ */ new Map();
+    this.loadedNamespaces = /* @__PURE__ */ new Set();
+    this.loadingPromises = /* @__PURE__ */ new Map();
+    this.allTranslations = {};
+    this.isInitialized = false;
+    this.initializationError = null;
+    this.currentLang = "en";
+    this.cacheStats = {
+      hits: 0,
+      misses: 0
+    };
+    // 번역 로드 완료 시 React 리렌더링을 위한 콜백
+    this.onTranslationLoadedCallbacks = /* @__PURE__ */ new Set();
+    // 언어 변경 시 React 리렌더링을 위한 콜백
+    this.onLanguageChangedCallbacks = /* @__PURE__ */ new Set();
+    // 디바운싱을 위한 타이머
+    this.notifyTimer = null;
+    // 최근 알림한 네임스페이스 (중복 알림 방지)
+    this.recentlyNotified = /* @__PURE__ */ new Set();
+    if (!validateI18nConfig(config)) {
+      throw new Error("Invalid I18nConfig provided");
+    }
+    this.config = {
+      fallbackLanguage: "en",
+      namespaces: ["common"],
+      debug: false,
+      missingKeyHandler: (key) => key,
+      errorHandler: (error) => {
+      },
+      ...config
+    };
+    this.currentLang = config.defaultLanguage;
+    if (config.initialTranslations) {
+      this.allTranslations = config.initialTranslations;
+      for (const [language, namespaces] of Object.entries(config.initialTranslations)) {
+        for (const namespace of Object.keys(namespaces)) {
+          this.loadedNamespaces.add(`${language}:${namespace}`);
+        }
+      }
+      this.isInitialized = true;
+    }
+  }
+  /**
+   * 번역 로드 완료 콜백 등록
+   */
+  onTranslationLoaded(callback) {
+    this.onTranslationLoadedCallbacks.add(callback);
+    return () => {
+      this.onTranslationLoadedCallbacks.delete(callback);
+    };
+  }
+  /**
+   * 언어 변경 콜백 등록
+   */
+  onLanguageChanged(callback) {
+    this.onLanguageChangedCallbacks.add(callback);
+    return () => {
+      this.onLanguageChangedCallbacks.delete(callback);
+    };
+  }
+  /**
+   * 언어 변경 이벤트 발생
+   */
+  notifyLanguageChanged(language) {
+    this.onLanguageChangedCallbacks.forEach((callback) => {
+      try {
+        callback(language);
+      } catch (error) {
+        if (this.config.debug) {
+          console.error("Error in language changed callback:", error);
+        }
+      }
+    });
+  }
+  /**
+   * 번역 로드 완료 이벤트 발생 (디바운싱 적용)
+   */
+  notifyTranslationLoaded(language, namespace) {
+    const cacheKey = `${language}:${namespace}`;
+    if (this.recentlyNotified.has(cacheKey)) {
+      return;
+    }
+    this.recentlyNotified.add(cacheKey);
+    if (this.notifyTimer) {
+      clearTimeout(this.notifyTimer);
+    }
+    this.notifyTimer = setTimeout(() => {
+      this.onTranslationLoadedCallbacks.forEach((callback) => {
         try {
-            // 클라이언트 사이드에서만 동적 로드
-            if (typeof window !== 'undefined') {
-                const apiUrl = `${translationApiPath}/${language}/${namespace}`;
-                const response = await fetch(apiUrl);
-                if (response.ok) {
-                    const data = await response.json();
-                    if (debug) {
-                        console.log(`✅ Loaded translation from API: ${language}/${namespace}`);
-                    }
-                    return data;
-                }
-                else if (response.status === 404) {
-                    if (debug) {
-                        console.warn(`⚠️ Translation not found in API: ${language}/${namespace}`);
-                    }
+          callback();
+        } catch (error) {
+          if (this.config.debug) {
+            console.warn("Error in translation loaded callback:", error);
+          }
+        }
+      });
+      setTimeout(() => {
+        this.recentlyNotified.clear();
+      }, 100);
+      this.notifyTimer = null;
+    }, 50);
+  }
+  /**
+   * 모든 번역 데이터를 미리 로드 (hua-api 스타일)
+   */
+  async initialize() {
+    if (this.isInitialized) {
+      if (this.config.debug) {
+        console.log("\u{1F6AB} [TRANSLATOR] Already initialized, skipping");
+      }
+      return;
+    }
+    if (this.config.debug) {
+      console.log("\u{1F680} [TRANSLATOR] Starting initialization...");
+    }
+    try {
+      if (!this.allTranslations) {
+        this.allTranslations = {};
+      }
+      const languages = [this.currentLang];
+      if (this.config.fallbackLanguage && this.config.fallbackLanguage !== this.currentLang) {
+        languages.push(this.config.fallbackLanguage);
+      }
+      const skipNamespaces = /* @__PURE__ */ new Set();
+      for (const language of languages) {
+        if (this.allTranslations[language]) {
+          for (const namespace of Object.keys(this.allTranslations[language])) {
+            skipNamespaces.add(`${language}:${namespace}`);
+          }
+        }
+      }
+      if (this.config.debug) {
+        console.log("\u{1F30D} [TRANSLATOR] Initializing translator with languages:", languages);
+        console.log("\u{1F4CD} [TRANSLATOR] Current language:", this.currentLang);
+        console.log("\u{1F4E6} [TRANSLATOR] Config namespaces:", this.config.namespaces);
+      }
+      for (const language of languages) {
+        if (this.config.debug) {
+          console.log("Processing language:", language);
+        }
+        if (!this.allTranslations[language]) {
+          this.allTranslations[language] = {};
+        }
+        for (const namespace of this.config.namespaces || []) {
+          const cacheKey = `${language}:${namespace}`;
+          if (skipNamespaces.has(cacheKey)) {
+            if (this.config.debug) {
+              console.log("\u23ED\uFE0F [TRANSLATOR] Skipping", namespace, "for", language, "(already loaded from SSR)");
+            }
+            continue;
+          }
+          if (this.config.debug) {
+            console.log("Loading namespace:", namespace, "for language:", language);
+          }
+          try {
+            const data = await this.safeLoadTranslations(language, namespace);
+            if (this.config.debug) {
+              console.log("Loaded data for", language, namespace, ":", data);
+            }
+            this.allTranslations[language][namespace] = data;
+            this.loadedNamespaces.add(`${language}:${namespace}`);
+          } catch (error) {
+            const translationError = this.createTranslationError(
+              "LOAD_FAILED",
+              error,
+              language,
+              namespace
+            );
+            this.logError(translationError);
+            if (isRecoverableError(translationError)) {
+              if (language !== this.config.fallbackLanguage) {
+                try {
+                  const fallbackData = await this.safeLoadTranslations(this.config.fallbackLanguage || "en", namespace);
+                  this.allTranslations[language][namespace] = fallbackData;
+                  this.loadedNamespaces.add(`${language}:${namespace}`);
+                  if (this.config.debug) {
+                    console.log("Using fallback data for", language, namespace);
+                  }
+                } catch (fallbackError) {
+                  const fallbackTranslationError = this.createTranslationError(
+                    "FALLBACK_LOAD_FAILED",
+                    fallbackError,
+                    this.config.fallbackLanguage,
+                    namespace
+                  );
+                  this.logError(fallbackTranslationError);
+                  this.allTranslations[language][namespace] = {};
                 }
+              } else {
+                this.allTranslations[language][namespace] = {};
+              }
+            } else {
+              this.allTranslations[language][namespace] = {};
             }
-            // SSR 또는 API 실패 시 기본 번역 반환
-            return getDefaultTranslations(language, namespace);
+          }
         }
-        catch (error) {
-            if (debug) {
-                console.warn(`Failed to load translation from API: ${language}/${namespace}`, error);
-            }
-            return getDefaultTranslations(language, namespace);
+      }
+      this.isInitialized = true;
+      if (this.config.debug) {
+        console.log("Translator initialized successfully");
+        console.log("Loaded translations:", this.allTranslations);
+      }
+    } catch (error) {
+      this.initializationError = this.createTranslationError(
+        "INITIALIZATION_FAILED",
+        error
+      );
+      this.logError(this.initializationError);
+      this.isInitialized = true;
+      if (this.config.debug) {
+        console.warn("Translator initialized with errors, using fallback translations");
+      }
+    }
+  }
+  /**
+   * 초기화되지 않은 상태에서 번역 시도
+   */
+  translateBeforeInitialized(key, targetLang) {
+    if (this.config.debug) {
+      console.warn("Translator not initialized. Call initialize() first.");
+    }
+    const { namespace, key: actualKey } = this.parseKey(key);
+    const result = this.findInNamespace(namespace, actualKey, targetLang);
+    if (result) {
+      if (this.config.debug) {
+        console.log(`\u2705 [TRANSLATOR] Found fallback translation from initialTranslations:`, result);
+      }
+      return result;
+    }
+    if (this.config.debug) {
+      const translations = this.allTranslations[targetLang]?.[namespace];
+      console.log(`\u{1F50D} [TRANSLATOR] Not initialized, fallback failed:`, {
+        namespace,
+        actualKey,
+        hasTranslations: !!translations,
+        translationsKeys: translations ? Object.keys(translations) : []
+      });
+    }
+    return this.config.missingKeyHandler?.(key, targetLang, "default") || key;
+  }
+  /**
+   * 다른 로드된 언어에서 번역 찾기 (언어 변경 중 깜빡임 방지)
+   */
+  findInOtherLanguages(namespace, key, targetLang) {
+    if (!this.allTranslations || Object.keys(this.allTranslations).length === 0) {
+      return null;
+    }
+    const loadedLanguages = Object.keys(this.allTranslations);
+    for (const lang of loadedLanguages) {
+      if (lang !== targetLang) {
+        const result = this.findInNamespace(namespace, key, lang);
+        if (result) {
+          return result;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * 폴백 언어에서 번역 찾기
+   */
+  findInFallbackLanguage(namespace, key, targetLang) {
+    const fallbackLang = this.config.fallbackLanguage || "en";
+    if (targetLang === fallbackLang) {
+      return null;
+    }
+    const result = this.findInNamespace(namespace, key, fallbackLang);
+    if (result) {
+      this.cacheStats.hits++;
+      return result;
+    }
+    return null;
+  }
+  /**
+   * 번역 키를 번역된 텍스트로 변환
+   */
+  translate(key, paramsOrLang, language) {
+    let params;
+    let targetLang;
+    if (typeof paramsOrLang === "string") {
+      targetLang = paramsOrLang;
+    } else if (typeof paramsOrLang === "object" && paramsOrLang !== null) {
+      params = paramsOrLang;
+      targetLang = language || this.currentLang;
+    } else {
+      targetLang = this.currentLang;
+    }
+    if (!this.isInitialized) {
+      const raw = this.translateBeforeInitialized(key, targetLang);
+      return params ? this.interpolate(raw, params) : raw;
+    }
+    const { namespace, key: actualKey } = this.parseKey(key);
+    let result = this.findInNamespace(namespace, actualKey, targetLang);
+    if (result) {
+      this.cacheStats.hits++;
+      return params ? this.interpolate(result, params) : result;
+    }
+    result = this.findInOtherLanguages(namespace, actualKey, targetLang);
+    if (result) {
+      return params ? this.interpolate(result, params) : result;
+    }
+    result = this.findInFallbackLanguage(namespace, actualKey, targetLang);
+    if (result) {
+      return params ? this.interpolate(result, params) : result;
+    }
+    this.cacheStats.misses++;
+    if (this.config.debug) {
+      const missing = this.config.missingKeyHandler?.(key, targetLang, namespace) || key;
+      return params ? this.interpolate(missing, params) : missing;
+    }
+    return "";
+  }
+  /**
+   * 네임스페이스에서 키 찾기
+   */
+  findInNamespace(namespace, key, language) {
+    const translations = this.allTranslations[language]?.[namespace];
+    if (!translations) {
+      const cacheKey = `${language}:${namespace}`;
+      if (!this.loadedNamespaces.has(cacheKey) && !this.loadingPromises.has(cacheKey)) {
+        this.loadTranslationData(language, namespace).catch((error) => {
+          if (this.config.debug) {
+            console.warn(`\u26A0\uFE0F [TRANSLATOR] Auto-load failed for ${language}/${namespace}:`, error);
+          }
+        });
+        if (this.config.debug) {
+          console.warn(`\u274C [TRANSLATOR] No translations found for ${language}/${namespace}, attempting auto-load...`);
+        }
+      }
+      return "";
+    }
+    const directValue = translations[key];
+    if (this.isStringValue(directValue)) {
+      return directValue;
+    }
+    if (this.isStringArray(directValue)) {
+      return directValue[Math.floor(Math.random() * directValue.length)];
+    }
+    const nestedValue = this.getNestedValue(translations, key);
+    if (this.isStringValue(nestedValue)) {
+      return nestedValue;
+    }
+    if (this.isStringArray(nestedValue)) {
+      return nestedValue[Math.floor(Math.random() * nestedValue.length)];
+    }
+    if (this.config.debug) {
+      console.warn(`\u274C [TRANSLATOR] No match found for key: ${key} in ${language}/${namespace}`);
+    }
+    return "";
+  }
+  /**
+   * 중첩된 객체에서 값을 가져오기
+   * 배열도 지원: 최종 값이 string[]이면 그대로 반환
+   */
+  getNestedValue(obj, path) {
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+      return void 0;
+    }
+    return path.split(".").reduce((current, key) => {
+      if (current == null) return void 0;
+      if (Array.isArray(current)) {
+        const idx = Number(key);
+        return Number.isInteger(idx) ? current[idx] : void 0;
+      }
+      if (typeof current === "object" && key in current) {
+        return current[key];
+      }
+      return void 0;
+    }, obj);
+  }
+  /**
+   * 문자열 값인지 확인하는 타입 가드
+   */
+  isStringValue(value) {
+    return typeof value === "string" && value.length > 0;
+  }
+  /**
+   * string[] 배열인지 확인하는 타입 가드
+   * 배열 값이 t()에 전달되면 랜덤으로 하나를 선택하여 반환
+   */
+  isStringArray(value) {
+    return Array.isArray(value) && value.length > 0 && value.every((v) => typeof v === "string");
+  }
+  /**
+   * 원시 값 가져오기 (배열, 객체 포함)
+   */
+  getRawValue(key, language) {
+    const targetLang = language || this.currentLang;
+    if (!this.isInitialized) {
+      if (this.config.debug) {
+        console.warn("Translator not initialized. Call initialize() first.");
+      }
+      return void 0;
+    }
+    const { namespace, key: actualKey } = this.parseKey(key);
+    const translations = this.allTranslations[targetLang]?.[namespace];
+    if (!translations) {
+      return void 0;
+    }
+    if (actualKey in translations) {
+      return translations[actualKey];
+    }
+    const nestedValue = this.getNestedValue(translations, actualKey);
+    if (nestedValue !== void 0) {
+      return nestedValue;
+    }
+    if (targetLang !== this.config.fallbackLanguage) {
+      const fallbackTranslations = this.allTranslations[this.config.fallbackLanguage || "en"]?.[namespace];
+      if (fallbackTranslations) {
+        if (actualKey in fallbackTranslations) {
+          return fallbackTranslations[actualKey];
+        }
+        const fallbackNestedValue = this.getNestedValue(fallbackTranslations, actualKey);
+        if (fallbackNestedValue !== void 0) {
+          return fallbackNestedValue;
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * 배열 번역 값 가져오기 (타입 안전)
+   */
+  tArray(key, language) {
+    const raw = this.getRawValue(key, language);
+    if (Array.isArray(raw) && raw.every((v) => typeof v === "string")) {
+      return raw;
+    }
+    if (process.env.NODE_ENV === "development") {
+      console.warn(`tArray: "${key}" is not a string array`);
+    }
+    return [];
+  }
+  /**
+   * Intl.PluralRules 인스턴스 (언어별 캐시)
+   */
+  getPluralRules(language) {
+    let rules = this.pluralRulesCache.get(language);
+    if (!rules) {
+      rules = new Intl.PluralRules(language);
+      this.pluralRulesCache.set(language, rules);
+    }
+    return rules;
+  }
+  /**
+   * 복수형 번역 (ICU / Intl.PluralRules 기반)
+   *
+   * JSON: { "other": "총 {count}개" }  (ko)
+   *       { "one": "{count} item", "other": "{count} items" }  (en)
+   *
+   * tPlural('common:total_count', 1) → en: "1 item" / ko: "총 1개"
+   * tPlural('common:total_count', 5) → en: "5 items" / ko: "총 5개"
+   */
+  tPlural(key, count, params, language) {
+    const targetLang = language || this.currentLang;
+    const raw = this.getRawValue(key, targetLang);
+    const mergedParams = { count, ...params };
+    if (isPluralValue(raw)) {
+      const category = this.getPluralRules(targetLang).select(count);
+      const text = raw[category] ?? raw.other;
+      return this.interpolate(text, mergedParams);
+    }
+    if (typeof raw === "string") {
+      return this.interpolate(raw, mergedParams);
+    }
+    if (this.config.debug) {
+      return this.interpolate(key, mergedParams);
+    }
+    return "";
+  }
+  /**
+   * 매개변수 보간
+   *
+   * 지원 형식:
+   * - {key} - 단일 중괄호 (일반적인 i18n 형식)
+   * - {{key}} - 이중 중괄호 (하위 호환성)
+   */
+  interpolate(text, params) {
+    return text.replace(/\{\{?(\w+)\}?\}/g, (match, key) => {
+      const value = params[key];
+      return value !== void 0 ? String(value) : match;
+    });
+  }
+  /**
+   * 언어 설정
+   */
+  setLanguage(language) {
+    if (this.currentLang === language) {
+      return;
+    }
+    const previousLanguage = this.currentLang;
+    this.currentLang = language;
+    this.notifyLanguageChanged(language);
+    if (!this.allTranslations[language]) {
+      this.loadLanguageData(language).catch((error) => {
+        if (this.config.debug) {
+          console.warn("Failed to load language data:", error);
         }
+      });
+    }
+    if (this.config.debug) {
+      console.log(`\u{1F310} [TRANSLATOR] Language changed: ${previousLanguage} -> ${language}`);
+    }
+  }
+  /**
+   * 언어 데이터 로드
+   */
+  async loadLanguageData(language) {
+    if (!this.allTranslations[language]) {
+      this.allTranslations[language] = {};
+    }
+    for (const namespace of this.config.namespaces || []) {
+      try {
+        const data = await this.safeLoadTranslations(language, namespace);
+        this.allTranslations[language][namespace] = data;
+        this.loadedNamespaces.add(`${language}:${namespace}`);
+        this.notifyTranslationLoaded(language, namespace);
+      } catch (error) {
+        const translationError = this.createTranslationError(
+          "LOAD_FAILED",
+          error,
+          language,
+          namespace
+        );
+        this.logError(translationError);
+        if (isRecoverableError(translationError)) {
+          this.allTranslations[language][namespace] = {};
+        } else {
+          this.allTranslations[language][namespace] = {};
+        }
+      }
+    }
+  }
+  /**
+   * 현재 언어 가져오기
+   */
+  getCurrentLanguage() {
+    return this.currentLang;
+  }
+  /**
+   * 지원되는 언어 목록 가져오기
+   */
+  getSupportedLanguages() {
+    return this.config.supportedLanguages?.map((lang) => lang.code) || [];
+  }
+  /**
+   * 초기화 완료 여부 확인
+   */
+  isReady() {
+    return this.isInitialized && !this.initializationError;
+  }
+  /**
+   * 초기화 오류 가져오기
+   */
+  getInitializationError() {
+    return this.initializationError;
+  }
+  /**
+   * 캐시 클리어
+   */
+  clearCache() {
+    this.cache.clear();
+    this.cacheStats = { hits: 0, misses: 0 };
+    if (this.config.debug) {
+      console.log("Cache cleared");
+    }
+  }
+  /**
+   * 캐시 엔트리 설정
+   */
+  setCacheEntry(key, data) {
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now(),
+      ttl: 5 * 60 * 1e3
+      // 5분
+    });
+  }
+  /**
+   * 캐시 엔트리 가져오기
+   */
+  getCacheEntry(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() - entry.timestamp > entry.ttl) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  /**
+   * 번역 오류 생성
+   */
+  createTranslationError(code, originalError, language, namespace, key) {
+    return {
+      name: "TranslationError",
+      code,
+      message: originalError.message,
+      originalError,
+      language,
+      namespace,
+      key,
+      timestamp: Date.now(),
+      stack: originalError.stack
     };
-    // 정적 파일 로더 (하위 호환성)
-    const staticFileLoader = async (language, namespace) => {
-        try {
-            let data = null;
-            // 클라이언트 사이드에서만 동적 로드 시도
-            if (typeof window !== 'undefined') {
-                const possiblePaths = [
-                    `/translations/${language}/${namespace}.json`,
-                    `../translations/${language}/${namespace}.json`,
-                    `./translations/${language}/${namespace}.json`,
-                    `translations/${language}/${namespace}.json`,
-                    `../../translations/${language}/${namespace}.json`,
-                ];
-                for (const path of possiblePaths) {
-                    try {
-                        const response = await fetch(path);
-                        if (response.ok) {
-                            data = await response.json();
-                            if (debug) {
-                                console.log(`✅ Loaded translation from static path: ${path}`);
-                            }
-                            break;
-                        }
-                    }
-                    catch (pathError) {
-                        continue;
-                    }
-                }
-            }
-            if (data) {
-                return data;
-            }
-            return getDefaultTranslations(language, namespace);
+  }
+  /**
+   * 오류 로깅
+   */
+  logError(error) {
+    if (this.config.errorHandler) {
+      this.config.errorHandler(error, error.language || "", error.namespace || "");
+    }
+  }
+  /**
+   * 재시도 작업
+   */
+  async retryOperation(operation, error, context) {
+    const maxRetries = 3;
+    let lastError = error;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (retryError) {
+        lastError = this.createTranslationError(
+          "RETRY_FAILED",
+          retryError,
+          context.language,
+          context.namespace,
+          context.key
+        );
+        if (attempt === maxRetries) {
+          break;
         }
-        catch (error) {
-            if (debug) {
-                console.warn(`Failed to load translation file: ${language}/${namespace}.json`);
-            }
-            return getDefaultTranslations(language, namespace);
+        await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3));
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * 안전한 번역 로드
+   */
+  async safeLoadTranslations(language, namespace) {
+    if (this.config.debug) {
+      console.log(`\u{1F4E5} [TRANSLATOR] safeLoadTranslations called:`, { language, namespace });
+    }
+    const loadOperation = async () => {
+      if (!this.config.loadTranslations) {
+        throw new Error("No translation loader configured");
+      }
+      if (this.config.debug) {
+        console.log(`\u{1F504} [TRANSLATOR] Calling loadTranslations for:`, { language, namespace });
+      }
+      const data = await this.config.loadTranslations(language, namespace);
+      if (this.config.debug) {
+        console.log(`\u{1F4E6} [TRANSLATOR] loadTranslations returned:`, data);
+      }
+      if (!isTranslationNamespace(data)) {
+        throw new Error(`Invalid translation data for ${language}:${namespace}`);
+      }
+      return data;
+    };
+    try {
+      return await loadOperation();
+    } catch (error) {
+      const translationError = this.createTranslationError(
+        "LOAD_FAILED",
+        error,
+        language,
+        namespace
+      );
+      return this.retryOperation(loadOperation, translationError, { language, namespace });
+    }
+  }
+  /**
+   * 디버그 정보
+   */
+  debug() {
+    return {
+      isInitialized: this.isInitialized,
+      currentLanguage: this.currentLang,
+      loadedNamespaces: Array.from(this.loadedNamespaces),
+      cacheStats: this.cacheStats,
+      cacheSize: this.cache.size,
+      allTranslations: this.allTranslations,
+      initializationError: this.initializationError,
+      config: this.config
+    };
+  }
+  /**
+   * SSR에서 하이드레이션
+   */
+  hydrateFromSSR(translations) {
+    this.allTranslations = translations;
+    this.isInitialized = true;
+    for (const [language, namespaces] of Object.entries(translations)) {
+      for (const namespace of Object.keys(namespaces)) {
+        this.loadedNamespaces.add(`${language}:${namespace}`);
+      }
+    }
+  }
+  /**
+   * 비동기 번역 (고급 기능)
+   */
+  async translateAsync(key, params) {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+    const translated = this.translate(key);
+    if (!params) {
+      return translated;
+    }
+    return this.interpolate(translated, params);
+  }
+  /**
+   * 동기 번역 (고급 기능)
+   */
+  translateSync(key, params) {
+    if (!this.isInitialized) {
+      if (this.config.debug) {
+        console.warn("Translator not initialized for sync translation");
+      }
+      const { namespace } = this.parseKey(key);
+      return this.config.missingKeyHandler?.(key, this.currentLang, namespace) || key;
+    }
+    const translated = this.translate(key);
+    if (!params) {
+      return translated;
+    }
+    return this.interpolate(translated, params);
+  }
+  /**
+   * 키 파싱 (네임스페이스:키 형식)
+   *
+   * - 콜론(:)만 네임스페이스 구분자로 사용
+   * - 점(.)은 키 이름의 일부로 취급 (중첩 객체 접근용)
+   *
+   * @example
+   * parseKey("home:hero.badge") → { namespace: "home", key: "hero.badge" }
+   * parseKey("hero.badge") → { namespace: "common", key: "hero.badge" }
+   * parseKey("save") → { namespace: "common", key: "save" }
+   */
+  parseKey(key) {
+    const colonIndex = key.indexOf(":");
+    if (colonIndex !== -1) {
+      return { namespace: key.substring(0, colonIndex), key: key.substring(colonIndex + 1) };
+    }
+    return { namespace: "common", key };
+  }
+  /**
+   * 번역 데이터 로드 (고급 기능)
+   */
+  async loadTranslationData(language, namespace) {
+    const cacheKey = `${language}:${namespace}`;
+    if (this.loadedNamespaces.has(cacheKey)) {
+      const existing = this.allTranslations[language]?.[namespace];
+      if (existing) {
+        return existing;
+      }
+    }
+    const cached = this.getCacheEntry(cacheKey);
+    if (cached) {
+      if (!this.allTranslations[language]) {
+        this.allTranslations[language] = {};
+      }
+      this.allTranslations[language][namespace] = cached;
+      this.loadedNamespaces.add(cacheKey);
+      return cached;
+    }
+    const loadingPromise = this.loadingPromises.get(cacheKey);
+    if (loadingPromise) {
+      return loadingPromise;
+    }
+    const loadPromise = this._loadTranslationData(language, namespace);
+    this.loadingPromises.set(cacheKey, loadPromise);
+    try {
+      const data = await loadPromise;
+      if (!this.allTranslations[language]) {
+        this.allTranslations[language] = {};
+      }
+      this.allTranslations[language][namespace] = data;
+      this.loadedNamespaces.add(cacheKey);
+      this.setCacheEntry(cacheKey, data);
+      if (this.config.debug) {
+        console.log(`\u2705 [TRANSLATOR] Auto-loaded and saved ${language}/${namespace}`);
+      }
+      this.notifyTranslationLoaded(language, namespace);
+      return data;
+    } finally {
+      this.loadingPromises.delete(cacheKey);
+    }
+  }
+  /**
+   * 실제 번역 데이터 로드
+   */
+  async _loadTranslationData(language, namespace) {
+    if (!this.config.loadTranslations) {
+      throw new Error("No translation loader configured");
+    }
+    try {
+      const data = await this.config.loadTranslations(language, namespace);
+      if (!isTranslationNamespace(data)) {
+        throw new Error(`Invalid translation data for ${language}:${namespace}`);
+      }
+      return data;
+    } catch (error) {
+      const translationError = this.createTranslationError(
+        "LOAD_FAILED",
+        error,
+        language,
+        namespace
+      );
+      this.logError(translationError);
+      return {};
+    }
+  }
+};
+function ssrTranslate({
+  translations,
+  key,
+  language = "ko",
+  fallbackLanguage = "en",
+  missingKeyHandler = (key2) => key2
+}) {
+  const { namespace, key: actualKey } = parseKey(key);
+  let result = ssrFindInNamespace(translations, namespace, actualKey, language);
+  if (result) {
+    return result;
+  }
+  if (language !== fallbackLanguage) {
+    result = ssrFindInNamespace(translations, namespace, actualKey, fallbackLanguage);
+    if (result) {
+      return result;
+    }
+  }
+  return missingKeyHandler(key);
+}
+function ssrFindInNamespace(translations, namespace, key, language, fallbackLanguage, missingKeyHandler) {
+  const namespaceData = translations[language]?.[namespace];
+  if (!namespaceData) {
+    return "";
+  }
+  const directValue = namespaceData[key];
+  if (isStringValue(directValue)) {
+    return directValue;
+  }
+  const nestedValue = getNestedValue(namespaceData, key);
+  if (isStringValue(nestedValue)) {
+    return nestedValue;
+  }
+  return "";
+}
+function getNestedValue(obj, path) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+    return void 0;
+  }
+  return path.split(".").reduce((current, key) => {
+    if (current && typeof current === "object" && !Array.isArray(current) && key in current) {
+      return current[key];
+    }
+    return void 0;
+  }, obj);
+}
+function isStringValue(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function parseKey(key) {
+  const colonIndex = key.indexOf(":");
+  if (colonIndex !== -1) {
+    return { namespace: key.substring(0, colonIndex), key: key.substring(colonIndex + 1) };
+  }
+  return { namespace: "common", key };
+}
+function serverTranslate({
+  translations,
+  key,
+  language = "ko",
+  fallbackLanguage = "en",
+  missingKeyHandler = (key2) => key2,
+  options = {}
+}) {
+  const { cache, metrics, debug } = options;
+  if (cache) {
+    const cacheKey = `${language}:${key}`;
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      if (metrics) metrics.hits++;
+      if (debug) console.log(`[CACHE HIT] ${cacheKey}`);
+      return cached;
+    }
+  }
+  const result = findInTranslations(translations, key, language, fallbackLanguage);
+  if (cache && result) {
+    const cacheKey = `${language}:${key}`;
+    cache.set(cacheKey, result);
+  }
+  if (metrics) metrics.misses++;
+  if (debug) console.log(`[TRANSLATE] ${key} -> ${result}`);
+  return result;
+}
+function findInTranslations(translations, key, language, fallbackLanguage, missingKeyHandler) {
+  const { namespace, key: actualKey } = parseKey(key);
+  let result = findInNamespace(translations, namespace, actualKey, language);
+  if (result) {
+    return result;
+  }
+  if (language !== fallbackLanguage) {
+    result = findInNamespace(translations, namespace, actualKey, fallbackLanguage);
+    if (result) {
+      return result;
+    }
+  }
+  return "";
+}
+function findInNamespace(translations, namespace, key, language) {
+  const languageData = translations[language];
+  if (!languageData || typeof languageData !== "object" || Array.isArray(languageData)) {
+    return "";
+  }
+  const namespaceData = languageData[namespace];
+  if (!namespaceData || typeof namespaceData !== "object" || Array.isArray(namespaceData)) {
+    return "";
+  }
+  const data = namespaceData;
+  if (data[key] && typeof data[key] === "string") {
+    return data[key];
+  }
+  const nestedValue = getNestedValue(namespaceData, key);
+  if (typeof nestedValue === "string") {
+    return nestedValue;
+  }
+  return "";
+}
+// src/core/translator-factory.ts
+var TranslatorFactory = class {
+  // 최대 인스턴스 수 제한
+  /**
+   * Config를 기반으로 고유 키 생성
+   */
+  static generateConfigKey(config) {
+    const keyParts = [
+      config.defaultLanguage,
+      config.fallbackLanguage || "en",
+      config.namespaces?.join(",") || "common",
+      config.debug ? "debug" : "prod"
+    ];
+    return keyParts.join("|");
+  }
+  /**
+   * Config가 변경되었는지 확인
+   */
+  static isConfigChanged(configKey, newConfig) {
+    const cachedConfig = this.configCache.get(configKey);
+    if (!cachedConfig) return true;
+    return cachedConfig.defaultLanguage !== newConfig.defaultLanguage || cachedConfig.fallbackLanguage !== newConfig.fallbackLanguage || JSON.stringify(cachedConfig.namespaces) !== JSON.stringify(newConfig.namespaces) || cachedConfig.debug !== newConfig.debug;
+  }
+  /**
+   * Translator 인스턴스 생성 또는 반환
+   */
+  static create(config) {
+    const configKey = this.generateConfigKey(config);
+    if (!this.instances.has(configKey) || this.isConfigChanged(configKey, config)) {
+      if (this.instances.size >= this.MAX_INSTANCES && !this.instances.has(configKey)) {
+        const oldestKey = this.instances.keys().next().value;
+        if (oldestKey) {
+          const oldInstance = this.instances.get(oldestKey);
+          if (oldInstance) {
+            oldInstance.clearCache();
+          }
+          this.instances.delete(oldestKey);
+          this.configCache.delete(oldestKey);
         }
+      }
+      if (this.instances.has(configKey)) {
+        const oldInstance = this.instances.get(configKey);
+        oldInstance.clearCache();
+      }
+      const newInstance = new Translator(config);
+      this.instances.set(configKey, newInstance);
+      this.configCache.set(configKey, { ...config });
+    }
+    return this.instances.get(configKey);
+  }
+  /**
+   * 특정 Config 키의 Translator 인스턴스 반환
+   */
+  static get(config) {
+    const configKey = this.generateConfigKey(config);
+    return this.instances.get(configKey) || null;
+  }
+  /**
+   * 모든 Translator 인스턴스 정리 (테스트용)
+   */
+  static clear() {
+    for (const instance of this.instances.values()) {
+      instance.clearCache();
+    }
+    this.instances.clear();
+    this.configCache.clear();
+  }
+  /**
+   * 특정 Config 키의 인스턴스만 정리
+   */
+  static clearConfig(config) {
+    const configKey = this.generateConfigKey(config);
+    const instance = this.instances.get(configKey);
+    if (instance) {
+      instance.clearCache();
+      this.instances.delete(configKey);
+      this.configCache.delete(configKey);
+    }
+  }
+  /**
+   * 현재 관리 중인 인스턴스 수 반환
+   */
+  static getInstanceCount() {
+    return this.instances.size;
+  }
+  /**
+   * 디버깅용: 모든 인스턴스 정보 반환
+   */
+  static debug() {
+    return {
+      instanceCount: this.instances.size,
+      configKeys: Array.from(this.instances.keys()),
+      instances: this.instances
     };
-    // 기본 파일 로더 선택
-    const defaultFileLoader = translationLoader === 'api'
-        ? apiRouteLoader
-        : translationLoader === 'static'
-            ? staticFileLoader
-            : loadTranslations || apiRouteLoader;
-    const config = {
-        defaultLanguage,
-        fallbackLanguage,
-        supportedLanguages: defaultLanguages,
-        namespaces,
-        loadTranslations: translationLoader === 'custom' && loadTranslations
-            ? loadTranslations
-            : defaultFileLoader,
-        initialTranslations, // SSR 번역 데이터 전달
-        debug,
-        missingKeyHandler: (key, language, namespace) => {
-            if (debug) {
-                console.warn(`Missing translation key: ${key}`);
-                // Debug SDK와 연동하여 누락 키 추적
-                if (typeof window !== 'undefined' && window.__I18N_DEBUG_MISSING_KEYS__) {
-                    const missingKeys = window.__I18N_DEBUG_MISSING_KEYS__;
-                    const keyPath = `${language || 'unknown'}:${namespace || 'unknown'}`;
-                    missingKeys[keyPath] = missingKeys[keyPath] || [];
-                    if (!missingKeys[keyPath].includes(key)) {
-                        missingKeys[keyPath].push(key);
-                    }
-                }
-                return `[MISSING: ${key}]`;
-            }
-            return key.split('.').pop() || key;
-        },
-        errorHandler: (error, language, namespace) => {
-            if (debug) {
-                console.error(`Translation error for ${language}:${namespace}:`, error);
+  }
+};
+TranslatorFactory.instances = /* @__PURE__ */ new Map();
+TranslatorFactory.configCache = /* @__PURE__ */ new Map();
+TranslatorFactory.MAX_INSTANCES = 10;
+// src/utils/default-translations.ts
+var DEFAULT_TRANSLATIONS = {
+  ko: {
+    common: {
+      welcome: "\uD658\uC601\uD569\uB2C8\uB2E4",
+      greeting: "\uC548\uB155\uD558\uC138\uC694",
+      goodbye: "\uC548\uB155\uD788 \uAC00\uC138\uC694",
+      loading: "\uB85C\uB529 \uC911...",
+      error: "\uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4",
+      success: "\uC131\uACF5\uD588\uC2B5\uB2C8\uB2E4",
+      cancel: "\uCDE8\uC18C",
+      confirm: "\uD655\uC778",
+      save: "\uC800\uC7A5",
+      delete: "\uC0AD\uC81C",
+      edit: "\uD3B8\uC9D1",
+      add: "\uCD94\uAC00",
+      search: "\uAC80\uC0C9",
+      filter: "\uD544\uD130",
+      sort: "\uC815\uB82C",
+      refresh: "\uC0C8\uB85C\uACE0\uCE68",
+      back: "\uB4A4\uB85C",
+      next: "\uB2E4\uC74C",
+      previous: "\uC774\uC804",
+      home: "\uD648",
+      about: "\uC18C\uAC1C",
+      contact: "\uC5F0\uB77D\uCC98",
+      settings: "\uC124\uC815",
+      profile: "\uD504\uB85C\uD544",
+      logout: "\uB85C\uADF8\uC544\uC6C3",
+      login: "\uB85C\uADF8\uC778",
+      register: "\uD68C\uC6D0\uAC00\uC785"
+    },
+    auth: {
+      login: "\uB85C\uADF8\uC778",
+      logout: "\uB85C\uADF8\uC544\uC6C3",
+      register: "\uD68C\uC6D0\uAC00\uC785",
+      email: "\uC774\uBA54\uC77C",
+      password: "\uBE44\uBC00\uBC88\uD638",
+      forgot_password: "\uBE44\uBC00\uBC88\uD638 \uCC3E\uAE30",
+      remember_me: "\uB85C\uADF8\uC778 \uC0C1\uD0DC \uC720\uC9C0"
+    },
+    errors: {
+      not_found: "\uD398\uC774\uC9C0\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+      server_error: "\uC11C\uBC84 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4",
+      network_error: "\uB124\uD2B8\uC6CC\uD06C \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4",
+      unauthorized: "\uC778\uC99D\uC774 \uD544\uC694\uD569\uB2C8\uB2E4",
+      forbidden: "\uC811\uADFC\uC774 \uAC70\uBD80\uB418\uC5C8\uC2B5\uB2C8\uB2E4"
+    }
+  },
+  en: {
+    common: {
+      welcome: "Welcome",
+      greeting: "Hello",
+      goodbye: "Goodbye",
+      loading: "Loading...",
+      error: "An error occurred",
+      success: "Success",
+      cancel: "Cancel",
+      confirm: "Confirm",
+      save: "Save",
+      delete: "Delete",
+      edit: "Edit",
+      add: "Add",
+      search: "Search",
+      filter: "Filter",
+      sort: "Sort",
+      refresh: "Refresh",
+      back: "Back",
+      next: "Next",
+      previous: "Previous",
+      home: "Home",
+      about: "About",
+      contact: "Contact",
+      settings: "Settings",
+      profile: "Profile",
+      logout: "Logout",
+      login: "Login",
+      register: "Register"
+    },
+    auth: {
+      login: "Login",
+      logout: "Logout",
+      register: "Register",
+      email: "Email",
+      password: "Password",
+      forgot_password: "Forgot Password",
+      remember_me: "Remember Me"
+    },
+    errors: {
+      not_found: "Page not found",
+      server_error: "Server error occurred",
+      network_error: "Network error occurred",
+      unauthorized: "Authentication required",
+      forbidden: "Access denied"
+    }
+  }
+};
+function getDefaultTranslations(language, namespace) {
+  return DEFAULT_TRANSLATIONS[language]?.[namespace] || {};
+}
+var I18nContext = React.createContext(null);
+function I18nProvider({
+  config,
+  children
+}) {
+  const [currentLanguage, setCurrentLanguageState] = React.useState(config.defaultLanguage);
+  const [isLoading, setIsLoading] = React.useState(true);
+  const [isInitialized, setIsInitialized] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const [translationVersion, setTranslationVersion] = React.useState(0);
+  React.useEffect(() => {
+    if (!isInitialized && config.defaultLanguage !== currentLanguage) {
+      setCurrentLanguageState(config.defaultLanguage);
+    }
+  }, [config.defaultLanguage, currentLanguage, isInitialized]);
+  const translator = React.useMemo(() => {
+    if (!validateI18nConfig(config)) {
+      throw new Error("Invalid I18nConfig provided to I18nProvider");
+    }
+    return TranslatorFactory.create(config);
+  }, [config]);
+  React.useEffect(() => {
+    if (isInitialized) {
+      const translatorLang = translator.getCurrentLanguage();
+      if (translatorLang !== currentLanguage) {
+        if (config.debug) {
+          console.log(`\u{1F504} [USEI18N] Syncing translator language: ${translatorLang} -> ${currentLanguage} (already initialized)`);
+        }
+        translator.setLanguage(currentLanguage);
+      }
+      return;
+    }
+    if (config.debug) {
+      console.log("\u{1F504} [USEI18N] useEffect triggered:", {
+        hasTranslator: !!translator,
+        currentLanguage,
+        debug: config.debug,
+        isInitialized
+      });
+    }
+    const initializeTranslator = async () => {
+      try {
+        setIsLoading(true);
+        setError(null);
+        if (config.debug) {
+          console.log("\u{1F680} [USEI18N] Starting translator initialization...");
+        }
+        translator.setLanguage(currentLanguage);
+        await translator.initialize();
+        setIsInitialized(true);
+        if (config.debug) {
+          console.log("\u2705 [USEI18N] Translator initialization completed successfully");
+        }
+      } catch (err) {
+        const initError = err;
+        setError(initError);
+        if (config.debug) {
+          console.error("\u274C [USEI18N] Failed to initialize translator:", initError);
+        }
+        setIsInitialized(true);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    initializeTranslator();
+  }, [translator, currentLanguage, config.debug, isInitialized]);
+  React.useEffect(() => {
+    if (!translator || !isInitialized) {
+      return;
+    }
+    const unsubscribe = translator.onTranslationLoaded(() => {
+      setTranslationVersion((prev) => prev + 1);
+      if (config.debug) {
+        console.log("\u{1F504} [USEI18N] Translation loaded, triggering re-render");
+      }
+    });
+    return unsubscribe;
+  }, [translator, isInitialized, config.debug]);
+  React.useEffect(() => {
+    if (!translator || !isInitialized) {
+      return;
+    }
+    const unsubscribe = translator.onLanguageChanged((newLanguage) => {
+      if (newLanguage !== currentLanguage) {
+        if (config.debug) {
+          console.log(`\u{1F504} [USEI18N] Language changed event: ${currentLanguage} -> ${newLanguage}`);
+        }
+        setCurrentLanguageState(newLanguage);
+        setTranslationVersion((prev) => prev + 1);
+      }
+    });
+    return unsubscribe;
+  }, [translator, isInitialized, currentLanguage, config.debug]);
+  React.useEffect(() => {
+    if (!config.autoLanguageSync || typeof window === "undefined") {
+      return;
+    }
+    const handleLanguageChange = (event) => {
+      const newLanguage = event.detail;
+      if (typeof newLanguage === "string" && newLanguage !== currentLanguage) {
+        if (config.debug) {
+          console.log("\u{1F310} Auto language sync:", newLanguage);
+        }
+        setLanguage(newLanguage);
+      }
+    };
+    window.addEventListener("huaI18nLanguageChange", handleLanguageChange);
+    window.addEventListener("i18nLanguageChanged", handleLanguageChange);
+    return () => {
+      window.removeEventListener("huaI18nLanguageChange", handleLanguageChange);
+      window.removeEventListener("i18nLanguageChanged", handleLanguageChange);
+    };
+  }, [config.autoLanguageSync, currentLanguage]);
+  const setLanguage = React.useCallback(async (language) => {
+    if (!translator) {
+      return;
+    }
+    const currentLang = translator.getCurrentLanguage();
+    if (currentLang === language) {
+      if (config.debug) {
+        console.log(`\u23ED\uFE0F [USEI18N] Language unchanged, skipping: ${language}`);
+      }
+      return;
+    }
+    if (config.debug) {
+      if (config.debug) {
+        console.log(`\u{1F504} [USEI18N] setLanguage called: ${currentLang} -> ${language}`);
+      }
+    }
+    setIsLoading(true);
+    try {
+      translator.setLanguage(language);
+      setCurrentLanguageState(language);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      if (config.debug) {
+        console.log(`\u2705 [USEI18N] Language changed to ${language}`);
+      }
+    } catch (error2) {
+      if (config.debug) {
+        console.error(`\u274C [USEI18N] Failed to change language to ${language}:`, error2);
+      }
+    } finally {
+      setIsLoading(false);
+    }
+  }, [translator, config.debug]);
+  const parseKey2 = React.useCallback((key) => {
+    const parts = key.split(":");
+    if (parts.length >= 2) {
+      return { namespace: parts[0], key: parts.slice(1).join(":") };
+    }
+    return { namespace: "common", key };
+  }, []);
+  const resolveNestedKey = React.useCallback((obj, key) => {
+    if (key in obj && typeof obj[key] === "string") {
+      return obj[key];
+    }
+    const parts = key.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current && typeof current === "object" && current !== null && part in current) {
+        current = current[part];
+      } else {
+        return null;
+      }
+    }
+    return typeof current === "string" ? current : null;
+  }, []);
+  const findInSSRTranslations = React.useCallback((key, targetLang) => {
+    if (!config.initialTranslations) {
+      return null;
+    }
+    const { namespace, key: actualKey } = parseKey2(key);
+    const ssrTranslations = config.initialTranslations[targetLang]?.[namespace];
+    if (ssrTranslations) {
+      const value2 = resolveNestedKey(ssrTranslations, actualKey);
+      if (value2 !== null) {
+        return value2;
+      }
+    }
+    const fallbackLang = config.fallbackLanguage || "en";
+    if (targetLang !== fallbackLang) {
+      const fallbackTranslations = config.initialTranslations[fallbackLang]?.[namespace];
+      if (fallbackTranslations) {
+        const value2 = resolveNestedKey(fallbackTranslations, actualKey);
+        if (value2 !== null) {
+          return value2;
+        }
+      }
+    }
+    return null;
+  }, [config.initialTranslations, config.fallbackLanguage, parseKey2, resolveNestedKey]);
+  const findInDefaultTranslations = React.useCallback((key, targetLang) => {
+    const { namespace, key: actualKey } = parseKey2(key);
+    const defaultTranslations = getDefaultTranslations(targetLang, namespace);
+    const fallbackTranslations = getDefaultTranslations(config.fallbackLanguage || "en", namespace);
+    return resolveNestedKey(defaultTranslations, actualKey) || resolveNestedKey(fallbackTranslations, actualKey) || null;
+  }, [config.fallbackLanguage, parseKey2, resolveNestedKey]);
+  const t = React.useCallback((key, paramsOrLang, language) => {
+    if (!translator) {
+      return key;
+    }
+    let params;
+    let lang;
+    if (typeof paramsOrLang === "string") {
+      lang = paramsOrLang;
+    } else if (typeof paramsOrLang === "object" && paramsOrLang !== null) {
+      params = paramsOrLang;
+      lang = language;
+    }
+    const targetLang = lang || currentLanguage;
+    try {
+      const result = translator.translate(key, params || lang, params ? lang : void 0);
+      if (result && result !== key && result !== "") {
+        return result;
+      }
+    } catch (error2) {
+    }
+    const interpolate = (text) => {
+      if (!params) return text;
+      return text.replace(/\{\{(\w+)\}\}/g, (match, k) => {
+        const value2 = params[k];
+        return value2 !== void 0 ? String(value2) : match;
+      });
+    };
+    const ssrResult = findInSSRTranslations(key, targetLang);
+    if (ssrResult) {
+      return interpolate(ssrResult);
+    }
+    const defaultResult = findInDefaultTranslations(key, targetLang);
+    if (defaultResult) {
+      return interpolate(defaultResult);
+    }
+    if (config.debug) {
+      return interpolate(key);
+    }
+    return "";
+  }, [translator, config.debug, currentLanguage, config.fallbackLanguage, translationVersion, findInSSRTranslations, findInDefaultTranslations]);
+  const tAsync = React.useCallback(async (key, params) => {
+    if (!translator) {
+      if (config.debug) {
+        console.warn("Translator not initialized");
+      }
+      return key;
+    }
+    setIsLoading(true);
+    try {
+      const result = await translator.translateAsync(key, params);
+      return result;
+    } catch (error2) {
+      if (config.debug) {
+        console.error("Translation error:", error2);
+      }
+      return key;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [translator, config.debug]);
+  const tSync = React.useCallback((key, namespace, params) => {
+    if (!translator) {
+      if (config.debug) {
+        console.warn("Translator not initialized");
+      }
+      return key;
+    }
+    return translator.translateSync(key, params);
+  }, [translator, config.debug]);
+  const getRawValue = React.useCallback((key, language) => {
+    if (!translator || !isInitialized) {
+      return void 0;
+    }
+    return translator.getRawValue(key, language);
+  }, [translator, isInitialized]);
+  const tArray = React.useCallback((key, language) => {
+    if (!translator || !isInitialized) {
+      return [];
+    }
+    return translator.tArray(key, language);
+  }, [translator, isInitialized, translationVersion, currentLanguage]);
+  const tPlural = React.useCallback((key, count, params, language) => {
+    if (!translator || !isInitialized) {
+      return key;
+    }
+    return translator.tPlural(key, count, params, language);
+  }, [translator, isInitialized, translationVersion, currentLanguage]);
+  const debug = React.useMemo(() => ({
+    getCurrentLanguage: () => {
+      try {
+        return translator?.getCurrentLanguage() || currentLanguage;
+      } catch {
+        return currentLanguage;
+      }
+    },
+    getSupportedLanguages: () => {
+      try {
+        return translator?.getSupportedLanguages() || config.supportedLanguages?.map((l) => l.code) || [];
+      } catch {
+        return config.supportedLanguages?.map((l) => l.code) || [];
+      }
+    },
+    getLoadedNamespaces: () => {
+      try {
+        const debugInfo = translator?.debug();
+        if (debugInfo && debugInfo.loadedNamespaces) {
+          return Array.from(debugInfo.loadedNamespaces);
+        }
+        if (debugInfo && debugInfo.allTranslations) {
+          const namespaces = /* @__PURE__ */ new Set();
+          Object.values(debugInfo.allTranslations).forEach((langData) => {
+            if (langData && typeof langData === "object") {
+              Object.keys(langData).forEach((namespace) => {
+                namespaces.add(namespace);
+              });
             }
+          });
+          return Array.from(namespaces);
+        }
+        return [];
+      } catch (error2) {
+        return [];
+      }
+    },
+    getAllTranslations: () => {
+      try {
+        return translator?.debug()?.allTranslations || {};
+      } catch (error2) {
+        return {};
+      }
+    },
+    isReady: () => {
+      try {
+        return translator?.isReady() || isInitialized;
+      } catch {
+        return isInitialized;
+      }
+    },
+    getInitializationError: () => {
+      try {
+        return translator?.getInitializationError() || error;
+      } catch {
+        return error;
+      }
+    },
+    clearCache: () => {
+      try {
+        translator?.clearCache();
+      } catch {
+      }
+    },
+    getCacheStats: () => {
+      try {
+        const debugInfo = translator?.debug();
+        if (debugInfo && debugInfo.cacheStats) {
+          return {
+            size: debugInfo.cacheSize || 0,
+            hits: debugInfo.cacheStats.hits || 0,
+            misses: debugInfo.cacheStats.misses || 0
+          };
+        }
+        return { size: 0, hits: 0, misses: 0 };
+      } catch (error2) {
+        return { size: 0, hits: 0, misses: 0 };
+      }
+    },
+    reloadTranslations: async () => {
+      if (translator) {
+        setIsLoading(true);
+        setError(null);
+        try {
+          await translator.initialize();
+        } catch (err) {
+          setError(err);
+        } finally {
+          setIsLoading(false);
+        }
+      }
+    }
+  }), [translator, currentLanguage, error, isInitialized, config.supportedLanguages]);
+  const value = React.useMemo(() => ({
+    currentLanguage,
+    setLanguage,
+    t,
+    tPlural,
+    tArray,
+    tAsync,
+    tSync,
+    getRawValue,
+    isLoading,
+    error,
+    supportedLanguages: config.supportedLanguages,
+    debug,
+    isInitialized,
+    translationVersion
+  }), [currentLanguage, setLanguage, t, tPlural, tArray, tAsync, tSync, getRawValue, isLoading, error, config.supportedLanguages, debug, isInitialized, translationVersion]);
+  return /* @__PURE__ */ jsxRuntime.jsx(I18nContext.Provider, { value, children });
+}
+function useI18n() {
+  const context = React.useContext(I18nContext);
+  if (!context) {
+    return {
+      currentLanguage: "ko",
+      setLanguage: () => {
+      },
+      t: (key) => key,
+      tPlural: (key) => key,
+      tAsync: async (key) => key,
+      tSync: (key) => key,
+      getRawValue: () => void 0,
+      tArray: () => [],
+      isLoading: false,
+      error: null,
+      supportedLanguages: [
+        { code: "ko", name: "Korean", nativeName: "\uD55C\uAD6D\uC5B4" },
+        { code: "en", name: "English", nativeName: "English" }
+      ],
+      isInitialized: false,
+      debug: {
+        getCurrentLanguage: () => "ko",
+        getSupportedLanguages: () => ["ko", "en"],
+        getLoadedNamespaces: () => [],
+        getAllTranslations: () => ({}),
+        isReady: () => false,
+        getInitializationError: () => null,
+        clearCache: () => {
         },
-        // autoLanguageSync는 기본적으로 false (Zustand 어댑터 등 외부에서 직접 처리하는 경우)
-        // 필요시 options에서 명시적으로 true로 설정 가능
-        autoLanguageSync: options?.autoLanguageSync ?? false
-    };
-    // Provider 컴포넌트 반환
-    return function CoreI18nProvider({ children }) {
-        return React.createElement(I18nProvider, { config, children });
+        getCacheStats: () => ({ size: 0, hits: 0, misses: 0 }),
+        reloadTranslations: async () => {
+        }
+      }
     };
+  }
+  return context;
+}
+function useTranslation() {
+  const { t, tPlural, tArray, currentLanguage, setLanguage, getRawValue, isLoading, error, supportedLanguages, debug, isInitialized } = useI18n();
+  return {
+    t,
+    tPlural,
+    tArray,
+    currentLanguage,
+    setLanguage,
+    getRawValue,
+    isLoading,
+    error,
+    supportedLanguages,
+    debug,
+    isInitialized
+  };
+}
+function useLanguageChange() {
+  const { currentLanguage, setLanguage, supportedLanguages } = useI18n();
+  const changeLanguage = React.useCallback((language) => {
+    const supported = supportedLanguages.find((lang) => lang.code === language);
+    if (supported) {
+      setLanguage(language);
+    } else {
+      if (process.env.NODE_ENV !== "production") console.warn(`Language ${language} is not supported`);
+    }
+  }, [setLanguage, supportedLanguages]);
+  return {
+    currentLanguage,
+    changeLanguage,
+    supportedLanguages
+  };
+}
+// src/index.ts
+var defaultLanguages = [
+  { code: "ko", name: "Korean", nativeName: "\uD55C\uAD6D\uC5B4" },
+  { code: "en", name: "English", nativeName: "English" },
+  { code: "en-IN", name: "English (India)", nativeName: "English (India)" },
+  { code: "ja", name: "Japanese", nativeName: "\u65E5\u672C\u8A9E" },
+  { code: "zh", name: "Chinese (Simplified)", nativeName: "\u7B80\u4F53\u4E2D\u6587" },
+  { code: "zh-TW", name: "Chinese (Traditional)", nativeName: "\u7E41\u9AD4\u4E2D\u6587" },
+  { code: "es", name: "Spanish", nativeName: "Espa\xF1ol" },
+  { code: "ru", name: "Russian", nativeName: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439" },
+  { code: "de", name: "German", nativeName: "Deutsch" },
+  { code: "fr", name: "French", nativeName: "Fran\xE7ais" }
+];
+function createCoreI18n(options) {
+  const {
+    defaultLanguage = "ko",
+    fallbackLanguage = "en",
+    namespaces = ["common"],
+    debug = false,
+    loadTranslations,
+    translationLoader = "api",
+    translationApiPath = "/api/translations",
+    initialTranslations,
+    supportedLanguages: providedSupportedLanguages,
+    autoLanguageSync = false,
+    // 기본값 false (Zustand 어댑터 등 외부에서 직접 처리)
+    baseUrl,
+    localFallbackBaseUrl
+  } = options || {};
+  let supportedLanguagesConfig;
+  if (providedSupportedLanguages) {
+    if (Array.isArray(providedSupportedLanguages) && providedSupportedLanguages.length > 0) {
+      if (typeof providedSupportedLanguages[0] === "string") {
+        const languageMap = {
+          ko: { name: "Korean", nativeName: "\uD55C\uAD6D\uC5B4" },
+          en: { name: "English", nativeName: "English" },
+          ja: { name: "Japanese", nativeName: "\u65E5\u672C\u8A9E" },
+          zh: { name: "Chinese", nativeName: "\u4E2D\u6587" },
+          es: { name: "Spanish", nativeName: "Espa\xF1ol" },
+          fr: { name: "French", nativeName: "Fran\xE7ais" },
+          de: { name: "German", nativeName: "Deutsch" },
+          pt: { name: "Portuguese", nativeName: "Portugu\xEAs" },
+          it: { name: "Italian", nativeName: "Italiano" },
+          ru: { name: "Russian", nativeName: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439" }
+        };
+        supportedLanguagesConfig = providedSupportedLanguages.map((code) => ({
+          code,
+          name: languageMap[code]?.name || code,
+          nativeName: languageMap[code]?.nativeName || code
+        }));
+      } else {
+        supportedLanguagesConfig = providedSupportedLanguages;
+      }
+    } else {
+      supportedLanguagesConfig = defaultLanguages;
+    }
+  } else {
+    supportedLanguagesConfig = defaultLanguages;
+  }
+  const apiRouteLoader = async (language, namespace) => {
+    try {
+      if (typeof window !== "undefined") {
+        const apiUrl = `${translationApiPath}/${language}/${namespace}`;
+        const response = await fetch(apiUrl);
+        if (response.ok) {
+          const data = await response.json();
+          if (debug) {
+            console.log(`\u2705 Loaded translation from API: ${language}/${namespace}`);
+          }
+          return data;
+        } else if (response.status === 404) {
+          if (debug) {
+            console.warn(`\u26A0\uFE0F Translation not found in API: ${language}/${namespace}`);
+          }
+        }
+      }
+      return getDefaultTranslations(language, namespace);
+    } catch (error) {
+      if (debug) {
+        console.warn(`Failed to load translation from API: ${language}/${namespace}`, error);
+      }
+      return getDefaultTranslations(language, namespace);
+    }
+  };
+  const staticFileLoader = async (language, namespace) => {
+    try {
+      let data = null;
+      if (typeof window !== "undefined") {
+        const possiblePaths = [
+          `/translations/${language}/${namespace}.json`,
+          `../translations/${language}/${namespace}.json`,
+          `./translations/${language}/${namespace}.json`,
+          `translations/${language}/${namespace}.json`,
+          `../../translations/${language}/${namespace}.json`
+        ];
+        for (const path of possiblePaths) {
+          try {
+            const response = await fetch(path);
+            if (response.ok) {
+              data = await response.json();
+              if (debug) {
+                console.log(`\u2705 Loaded translation from static path: ${path}`);
+              }
+              break;
+            }
+          } catch (pathError) {
+            continue;
+          }
+        }
+      }
+      if (data) {
+        return data;
+      }
+      return getDefaultTranslations(language, namespace);
+    } catch (error) {
+      if (debug) {
+        console.warn(`Failed to load translation file: ${language}/${namespace}.json`);
+      }
+      return getDefaultTranslations(language, namespace);
+    }
+  };
+  const defaultFileLoader = translationLoader === "api" ? apiRouteLoader : translationLoader === "static" ? staticFileLoader : loadTranslations || apiRouteLoader;
+  const config = {
+    defaultLanguage,
+    fallbackLanguage,
+    supportedLanguages: supportedLanguagesConfig,
+    namespaces,
+    loadTranslations: translationLoader === "custom" && loadTranslations ? loadTranslations : defaultFileLoader,
+    initialTranslations,
+    // SSR 번역 데이터 전달
+    debug,
+    missingKeyHandler: (key, language, namespace) => {
+      if (debug) {
+        console.warn(`Missing translation key: ${key}`);
+        if (typeof window !== "undefined" && window.__I18N_DEBUG_MISSING_KEYS__) {
+          const missingKeys = window.__I18N_DEBUG_MISSING_KEYS__;
+          const keyPath = `${language || "unknown"}:${namespace || "unknown"}`;
+          missingKeys[keyPath] = missingKeys[keyPath] || [];
+          if (!missingKeys[keyPath].includes(key)) {
+            missingKeys[keyPath].push(key);
+          }
+        }
+        return `[MISSING: ${key}]`;
+      }
+      return key.split(".").pop() || key;
+    },
+    errorHandler: (error, language, namespace) => {
+      if (debug) {
+        console.error(`Translation error for ${language}:${namespace}:`, error);
+      }
+    },
+    // autoLanguageSync는 기본적으로 false (Zustand 어댑터 등 외부에서 직접 처리하는 경우)
+    // 필요시 options에서 명시적으로 true로 설정 가능
+    autoLanguageSync: options?.autoLanguageSync ?? false
+  };
+  return function CoreI18nProvider({ children }) {
+    return React__default.default.createElement(I18nProvider, { config, children });
+  };
+}
+function CoreProvider({ children }) {
+  return createCoreI18n()({ children });
+}
+function createLanguageProvider(language) {
+  return createCoreI18n({ defaultLanguage: language });
+}
+function createNamespaceProvider(namespaces) {
+  return createCoreI18n({ namespaces });
+}
+function createCustomLoaderProvider(loadTranslations) {
+  return createCoreI18n({ loadTranslations });
 }
-// 기본 번역 데이터는 공통 유틸리티에서 가져옴
-import { getDefaultTranslations } from './utils/default-translations';
-/**
- * 가장 기본적인 Provider (최소한의 설정)
- */
-export function CoreProvider({ children }) {
-    return createCoreI18n()({ children });
-}
-/**
- * 언어별 Provider (언어만 지정)
- */
-export function createLanguageProvider(language) {
-    return createCoreI18n({ defaultLanguage: language });
-}
-/**
- * 네임스페이스별 Provider (네임스페이스만 지정)
- */
-export function createNamespaceProvider(namespaces) {
-    return createCoreI18n({ namespaces });
-}
-/**
- * 커스텀 로더 Provider (사용자 정의 번역 로더 사용)
- */
-export function createCustomLoaderProvider(loadTranslations) {
-    return createCoreI18n({ loadTranslations });
-}
-// 핵심 훅들 export
-export { useTranslation, useLanguageChange, useI18n };
-// Provider export
-export { I18nProvider };
-// 핵심 클래스/함수들 export
-export { Translator, ssrTranslate, serverTranslate };
+exports.CoreProvider = CoreProvider;
+exports.I18nProvider = I18nProvider;
+exports.Translator = Translator;
+exports.createCoreI18n = createCoreI18n;
+exports.createCustomLoaderProvider = createCustomLoaderProvider;
+exports.createLanguageProvider = createLanguageProvider;
+exports.createNamespaceProvider = createNamespaceProvider;
+exports.serverTranslate = serverTranslate;
+exports.ssrTranslate = ssrTranslate;
+exports.useI18n = useI18n;
+exports.useLanguageChange = useLanguageChange;
+exports.useTranslation = useTranslation;
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map