@vobs/i18n 1.1.0 → 1.2.1

package/dist/index.cjs

@@ -0,0 +1,685 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// packages/reactivity/src/debug.ts
+var activeDebugHooks = null;
+var signalNames = /* @__PURE__ */ new WeakMap();
+function hasDebugHooks() {
+  return activeDebugHooks !== null;
+}
+__name(hasDebugHooks, "hasDebugHooks");
+function setSignalDebugName(signal, name) {
+  signalNames.set(signal, name);
+  invokeDebug("signalNamed", signal, name);
+}
+__name(setSignalDebugName, "setSignalDebugName");
+function invokeDebug(name, ...args) {
+  return;
+}
+__name(invokeDebug, "invokeDebug");
+
+// packages/reactivity/src/owner.ts
+var currentOwner = null;
+function getCurrentOwner() {
+  return currentOwner;
+}
+__name(getCurrentOwner, "getCurrentOwner");
+function onDispose(cleanup) {
+  throw new Error("Vobs: onDispose \u5FC5\u987B\u5728 Owner \u4F5C\u7528\u57DF\u5185\u8C03\u7528");
+}
+__name(onDispose, "onDispose");
+
+// packages/reactivity/src/signal.ts
+var currentSubscriber = null;
+function getCurrentSubscriber() {
+  return currentSubscriber;
+}
+__name(getCurrentSubscriber, "getCurrentSubscriber");
+function trackDependency(dependency) {
+  return;
+}
+__name(trackDependency, "trackDependency");
+function state(initialValue, debugName) {
+  let value = initialValue;
+  let disposed = false;
+  const subscribers = /* @__PURE__ */ new Set();
+  const signalInstance = {
+    get value() {
+      return value;
+    },
+    set value(nextValue) {
+      if (disposed || Object.is(value, nextValue)) return;
+      value = nextValue;
+      for (const subscriber of [...subscribers]) subscriber.notify();
+    },
+    unsubscribe(subscriber) {
+      subscribers.delete(subscriber);
+    },
+    // 与 `.value =` 赋值同一条路径：判等短路、debug hook、notify 全部一致。
+    // 以闭包实现，可安全地作为回调直接传递（无 this 绑定问题）。
+    set(next) {
+      signalInstance.value = next;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      subscribers.clear();
+    }
+  };
+  if (debugName?.trim()) setSignalDebugName(signalInstance, debugName.trim());
+  return signalInstance;
+}
+__name(state, "state");
+
+// packages/reactivity/src/scheduler.ts
+var _Scheduler = class _Scheduler {
+  constructor() {
+    this.dirtyEffects = /* @__PURE__ */ new Set();
+    this.lowPriorityEffects = /* @__PURE__ */ new Set();
+    // flush 不可重入（flushing 标志保证），缓冲数组可在轮次间安全复用，避免每轮分配。
+    this.normalBuffer = [];
+    this.lowBuffer = [];
+    this.flushing = false;
+    this.scheduled = false;
+    this.batchDepth = 0;
+  }
+  schedule(effect2) {
+    if (effect2.disposed) return;
+    this.dirtyEffects.add(effect2);
+    this.lowPriorityEffects.delete(effect2);
+    this.ensureScheduled();
+  }
+  /** Queue an effect behind normal updates while preserving deterministic order. */
+  scheduleLow(effect2) {
+    if (effect2.disposed) return;
+    if (!this.dirtyEffects.has(effect2)) this.lowPriorityEffects.add(effect2);
+    this.ensureScheduled();
+  }
+  ensureScheduled() {
+    if (this.batchDepth === 0 && !this.flushing && !this.scheduled) {
+      this.scheduled = true;
+      queueMicrotask(() => {
+        this.scheduled = false;
+        this.flush();
+      });
+    }
+  }
+  remove(effect2) {
+    this.dirtyEffects.delete(effect2);
+    this.lowPriorityEffects.delete(effect2);
+  }
+  batch(fn) {
+    this.batchDepth++;
+    try {
+      return fn();
+    } finally {
+      this.batchDepth--;
+      if (this.batchDepth === 0) this.flush();
+    }
+  }
+  flush() {
+    if (this.flushing || this.batchDepth > 0) return;
+    this.flushing = true;
+    let rounds = 0;
+    let firstError;
+    let hasError = false;
+    try {
+      while (this.dirtyEffects.size > 0 || this.lowPriorityEffects.size > 0) {
+        if (++rounds > 100) {
+          this.dirtyEffects.clear();
+          this.lowPriorityEffects.clear();
+          throw new Error("Vobs: \u54CD\u5E94\u5F0F\u66F4\u65B0\u8D85\u8FC7 100 \u8F6E\uFF0C\u53EF\u80FD\u5B58\u5728\u5FAA\u73AF\u4F9D\u8D56");
+        }
+        this.collectRunnable(this.dirtyEffects, this.normalBuffer);
+        this.collectRunnable(this.lowPriorityEffects, this.lowBuffer);
+        sortEffects(this.normalBuffer);
+        sortEffects(this.lowBuffer);
+        for (const effect2 of this.normalBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        for (const effect2 of this.lowBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        this.normalBuffer.length = 0;
+        this.lowBuffer.length = 0;
+      }
+    } finally {
+      this.normalBuffer.length = 0;
+      this.lowBuffer.length = 0;
+      this.flushing = false;
+    }
+    if (hasError) throw firstError;
+  }
+  /** 收集未 disposed 的 effect 并清空源集合；run() 期间新调度的 effect 留给下一轮。 */
+  collectRunnable(source, target) {
+    for (const effect2 of source) {
+      if (!effect2.disposed) target.push(effect2);
+    }
+    source.clear();
+  }
+};
+__name(_Scheduler, "Scheduler");
+function sortEffects(effects) {
+  if (effects.length > 1) {
+    effects.sort((a, b) => b.depth - a.depth || a.order - b.order);
+  }
+}
+__name(sortEffects, "sortEffects");
+
+// packages/runtime/src/debug.ts
+var activeRuntimeDebugHooks = null;
+function getRuntimeDebugHooks() {
+  return activeRuntimeDebugHooks;
+}
+__name(getRuntimeDebugHooks, "getRuntimeDebugHooks");
+function invokeRuntimeDebug(name, ...args) {
+  return;
+}
+__name(invokeRuntimeDebug, "invokeRuntimeDebug");
+function describeDebugNode(node) {
+  if (!node || typeof node !== "object") return "node";
+  const value = node;
+  const name = typeof value.tagName === "string" ? value.tagName.toLowerCase() : typeof value.nodeName === "string" ? value.nodeName.toLowerCase() : "node";
+  const id = typeof value.id === "string" && value.id ? `#${value.id}` : "";
+  const className = typeof value.className === "string" && value.className ? `.${value.className.trim().split(/\s+/).filter(Boolean).join(".")}` : "";
+  return `${name}${id}${className}`;
+}
+__name(describeDebugNode, "describeDebugNode");
+
+// packages/runtime/src/hmr.ts
+var globalTarget = globalThis;
+var hmrGlobal = globalTarget.__VOBS_HMR__ ?? { modules: /* @__PURE__ */ new Map() };
+globalTarget.__VOBS_HMR__ = hmrGlobal;
+function markHmrInstanceMounted(node, parent) {
+  const instance = hmrInstances.get(node);
+  if (instance) instance.parent = parent;
+}
+__name(markHmrInstanceMounted, "markHmrInstanceMounted");
+var hmrInstances = /* @__PURE__ */ new WeakMap();
+function getRenderer() {
+  {
+    throw new Error("\u6E32\u67D3\u5668\u672A\u521D\u59CB\u5316");
+  }
+}
+__name(getRenderer, "getRenderer");
+function createComment(content) {
+  return getRenderer().createComment(content);
+}
+__name(createComment, "createComment");
+function insertBefore(parent, child, anchor) {
+  if (isVobsFragment(child)) {
+    child.mount(parent, isVobsFragment(anchor) ? anchor.start : anchor);
+    return;
+  }
+  getRenderer().insertBefore(parent, child, isVobsFragment(anchor) ? anchor.start : anchor);
+  markHmrInstanceMounted(child, parent);
+}
+__name(insertBefore, "insertBefore");
+
+// packages/runtime/src/fragment.ts
+function createFragment(factory) {
+  const start = createComment("vobs:fragment:start");
+  const end = createComment("vobs:fragment:end");
+  let parent = null;
+  let initialized = false;
+  const fragment = {
+    kind: "vobs-fragment",
+    start,
+    end,
+    mount(nextParent, anchor) {
+      if (parent && parent !== nextParent) {
+        throw new Error("Vobs Fragment: \u4E0D\u80FD\u8DE8\u7236\u8282\u70B9\u79FB\u52A8 Fragment");
+      }
+      if (initialized) {
+        moveRange(nextParent, start, end, anchor);
+        return;
+      }
+      const renderer = getRenderer();
+      renderer.insertBefore(nextParent, start, anchor);
+      renderer.insertBefore(nextParent, end, anchor);
+      parent = nextParent;
+      initialized = true;
+      factory(nextParent, end);
+    },
+    unmount(nextParent) {
+      if (!initialized || parent !== nextParent) {
+        throw new Error("Vobs Fragment: Fragment \u4E0D\u5C5E\u4E8E\u6307\u5B9A\u7236\u8282\u70B9");
+      }
+      const renderer = getRenderer();
+      let current = renderer.nextSibling(start);
+      while (current && current !== end) {
+        const next = renderer.nextSibling(current);
+        renderer.removeChild(nextParent, current);
+        current = next;
+      }
+      renderer.removeChild(nextParent, start);
+      renderer.removeChild(nextParent, end);
+      parent = null;
+      initialized = false;
+    }
+  };
+  return fragment;
+}
+__name(createFragment, "createFragment");
+function isVobsFragment(value) {
+  return Boolean(value) && typeof value === "object" && value.kind === "vobs-fragment";
+}
+__name(isVobsFragment, "isVobsFragment");
+function moveRange(parent, start, end, anchor) {
+  const renderer = getRenderer();
+  const nodes = [start];
+  let current = renderer.nextSibling(start);
+  while (current) {
+    nodes.push(current);
+    if (current === end) break;
+    current = renderer.nextSibling(current);
+  }
+  if (nodes[nodes.length - 1] !== end) {
+    throw new Error("Vobs Fragment: \u627E\u4E0D\u5230\u7ED3\u675F\u951A\u70B9");
+  }
+  for (const node of nodes) renderer.insertBefore(parent, node, anchor);
+}
+__name(moveRange, "moveRange");
+
+// packages/vobs/src/context.ts
+var ownerProviders = /* @__PURE__ */ new WeakMap();
+function provide(key, value, options = {}) {
+  throw new Error("Vobs: provide \u5FC5\u987B\u5728\u7EC4\u4EF6\u6216 Owner \u4F5C\u7528\u57DF\u5185\u8C03\u7528");
+}
+__name(provide, "provide");
+function inject(key, fallback) {
+  const owner = getCurrentOwner();
+  const value = owner ? injectFromOwner(owner, key) : void 0;
+  return value === void 0 ? fallback : value;
+}
+__name(inject, "inject");
+function provideToOwner(owner, key, value, options = {}) {
+  let providers = ownerProviders.get(owner);
+  if (!providers) {
+    providers = /* @__PURE__ */ new Map();
+    ownerProviders.set(owner, providers);
+    owner.onDispose(() => ownerProviders.delete(owner));
+  }
+  if (providers.has(key) && !options.override) {
+    throw new Error(`Vobs: \u6CE8\u5165\u9879 ${String(key)} \u5DF2\u5B58\u5728\uFF1B\u5982\u9700\u8986\u76D6\u8BF7\u4F20\u5165 override: true`);
+  }
+  providers.set(key, value);
+}
+__name(provideToOwner, "provideToOwner");
+function injectFromOwner(owner, key) {
+  let current = owner;
+  while (current) {
+    const providers = ownerProviders.get(current);
+    if (providers?.has(key)) return providers.get(key);
+    current = current.parent;
+  }
+  return void 0;
+}
+__name(injectFromOwner, "injectFromOwner");
+
+// packages/vobs/src/app.ts
+function createInjectionKey(description) {
+  return Symbol(description);
+}
+__name(createInjectionKey, "createInjectionKey");
+
+// packages/i18n/src/index.ts
+var I18N_KEY = createInjectionKey("vobs.i18n");
+var DATE_PRESETS = {
+  short: {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  },
+  medium: {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  },
+  long: {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    weekday: "long"
+  },
+  full: {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    weekday: "long",
+    hour: "2-digit",
+    minute: "2-digit"
+  }
+};
+function createI18n(options) {
+  const defaultLocale = validateLocale(options.defaultLocale);
+  const fallbackLocale = options.fallbackLocale === void 0 ? defaultLocale : validateLocale(options.fallbackLocale);
+  const initialMessages = validateLocaleMessages(options.messages ?? {});
+  const locale = state(defaultLocale);
+  const messages = state({ ...initialMessages });
+  const formatters = new Map(Object.entries(options.formatters ?? {}));
+  const loadedLocales = new Set(Object.keys(initialMessages));
+  const pendingLoads = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const context = {
+    locale,
+    messages,
+    fallbackLocale,
+    timeZone: options.timeZone,
+    dehydrate() {
+      ensureActive();
+      return { version: 1, locale: locale.value, messages: messages.value };
+    },
+    hydrate(snapshot) {
+      ensureActive();
+      const restored = parseDehydratedState(snapshot);
+      locale.value = restored.locale;
+      messages.value = restored.messages;
+      loadedLocales.clear();
+      for (const loadedLocale of Object.keys(restored.messages)) loadedLocales.add(loadedLocale);
+    },
+    setLocale(nextLocale) {
+      ensureActive();
+      locale.value = validateLocale(nextLocale);
+    },
+    setMessages(nextLocale, nextMessages) {
+      ensureActive();
+      const normalizedLocale = validateLocale(nextLocale);
+      const normalizedMessages = validateMessages(nextMessages);
+      messages.value = {
+        ...messages.value,
+        [normalizedLocale]: mergeMessages(messages.value[normalizedLocale], normalizedMessages)
+      };
+      loadedLocales.add(normalizedLocale);
+    },
+    loadLocale(nextLocale, loader) {
+      ensureActive();
+      const normalizedLocale = validateLocale(nextLocale);
+      if (loadedLocales.has(normalizedLocale)) return Promise.resolve();
+      const pending = pendingLoads.get(normalizedLocale);
+      if (pending) return pending;
+      const source = loader ?? options.localeLoaders?.[normalizedLocale];
+      if (!source) return Promise.reject(new Error(`Vobs I18n: locale ${normalizedLocale} \u6CA1\u6709\u53EF\u7528\u7684 loader`));
+      const task = Promise.resolve().then(() => source()).then((nextMessages) => {
+        context.setMessages(normalizedLocale, nextMessages);
+      }).finally(() => {
+        pendingLoads.delete(normalizedLocale);
+      });
+      pendingLoads.set(normalizedLocale, task);
+      return task;
+    },
+    isLocaleLoaded(nextLocale) {
+      ensureActive();
+      return loadedLocales.has(validateLocale(nextLocale));
+    },
+    t(key, params) {
+      ensureActive();
+      if (!key) return "";
+      const allMessages = messages.value;
+      const template = findMessage(allMessages, locale.value, fallbackLocale, key);
+      if (template === void 0) return key;
+      return interpolate(template, params, context, formatters);
+    },
+    formatDate(value, presetOrOptions, dateOptions) {
+      ensureActive();
+      const date = toDate(value);
+      if (!date) return "";
+      const resolvedOptions = resolveDateOptions(presetOrOptions, dateOptions);
+      return new Intl.DateTimeFormat(locale.value, withTimeZone(resolvedOptions, options.timeZone)).format(date);
+    },
+    formatNumber(value, presetOrOptions) {
+      ensureActive();
+      if (!Number.isFinite(value)) return "";
+      const numberOptions = typeof presetOrOptions === "string" ? presetOrOptions === "percent" ? { style: "percent" } : {} : presetOrOptions;
+      return new Intl.NumberFormat(locale.value, numberOptions).format(value);
+    },
+    formatCurrency(value, currency, currencyOptions) {
+      ensureActive();
+      if (!Number.isFinite(value)) return "";
+      if (!currency) throw new Error("Vobs I18n: currency \u4E0D\u80FD\u4E3A\u7A7A");
+      return new Intl.NumberFormat(locale.value, {
+        ...currencyOptions,
+        style: "currency",
+        currency
+      }).format(value);
+    },
+    formatRelativeTime(value, now = Date.now()) {
+      ensureActive();
+      const target = toDate(value)?.getTime();
+      const current = toDate(now)?.getTime();
+      if (target === void 0 || current === void 0) return "";
+      const difference = current - target;
+      const units = [
+        ["year", 365 * 24 * 60 * 60 * 1e3],
+        ["month", 30 * 24 * 60 * 60 * 1e3],
+        ["day", 24 * 60 * 60 * 1e3],
+        ["hour", 60 * 60 * 1e3],
+        ["minute", 60 * 1e3],
+        ["second", 1e3]
+      ];
+      for (const [unit, milliseconds] of units) {
+        const amount = Math.round(difference / milliseconds);
+        if (Math.abs(amount) >= 1) {
+          return new Intl.RelativeTimeFormat(locale.value, { numeric: "auto" }).format(-amount, unit);
+        }
+      }
+      return new Intl.RelativeTimeFormat(locale.value, { numeric: "auto" }).format(0, "second");
+    },
+    registerFormatter(name, formatter) {
+      ensureActive();
+      if (!name) throw new Error("Vobs I18n: formatter \u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A");
+      const previous = formatters.get(name);
+      formatters.set(name, formatter);
+      return () => {
+        if (previous) formatters.set(name, previous);
+        else formatters.delete(name);
+      };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      locale.dispose();
+      messages.dispose();
+      formatters.clear();
+      pendingLoads.clear();
+    }
+  };
+  return context;
+  function ensureActive() {
+    if (disposed) throw new Error("Vobs I18n: \u5DF2\u9500\u6BC1\u7684\u4E0A\u4E0B\u6587\u4E0D\u80FD\u7EE7\u7EED\u4F7F\u7528");
+  }
+}
+__name(createI18n, "createI18n");
+function parseDehydratedState(snapshot) {
+  let value = snapshot;
+  if (typeof snapshot === "string") {
+    try {
+      value = JSON.parse(snapshot);
+    } catch {
+      throw new Error("Vobs I18n: \u521D\u59CB\u72B6\u6001\u4E0D\u662F\u6709\u6548 JSON");
+    }
+  }
+  if (!value || typeof value !== "object") throw new Error("Vobs I18n: \u521D\u59CB\u72B6\u6001\u683C\u5F0F\u65E0\u6548");
+  const candidate = value;
+  if (candidate.version !== 1 || typeof candidate.locale !== "string" || !candidate.messages || typeof candidate.messages !== "object") {
+    throw new Error("Vobs I18n: \u521D\u59CB\u72B6\u6001\u7248\u672C\u6216\u5B57\u6BB5\u65E0\u6548");
+  }
+  return {
+    version: 1,
+    locale: validateLocale(candidate.locale),
+    messages: validateLocaleMessages(candidate.messages)
+  };
+}
+__name(parseDehydratedState, "parseDehydratedState");
+function i18nPlugin(options = {}) {
+  return {
+    name: "@vobs/i18n",
+    version: "0.1.0",
+    install(context) {
+      const ownedI18n = options.i18n ? void 0 : createI18n({
+        defaultLocale: options.defaultLocale ?? "en-US",
+        messages: options.messages,
+        localeLoaders: options.localeLoaders,
+        fallbackLocale: options.fallbackLocale,
+        timeZone: options.timeZone,
+        formatters: options.formatters
+      });
+      const i18n = options.i18n ?? ownedI18n;
+      context.provide(I18N_KEY, i18n);
+      return () => ownedI18n?.dispose();
+    }
+  };
+}
+__name(i18nPlugin, "i18nPlugin");
+function useI18n() {
+  const i18n = inject(I18N_KEY);
+  if (!i18n) throw new Error("Vobs I18n: \u627E\u4E0D\u5230\u4E0A\u4E0B\u6587\uFF0C\u8BF7\u5B89\u88C5 i18nPlugin");
+  return i18n;
+}
+__name(useI18n, "useI18n");
+function I18nBoundary(props = {}) {
+  const parent = useI18n();
+  createI18n({
+    defaultLocale: props.locale ?? parent.locale.value,
+    messages: parent.messages.value,
+    fallbackLocale: parent.fallbackLocale,
+    timeZone: parent.timeZone
+  });
+  provide();
+  return createFragment((parentNode, anchor) => {
+    const child = typeof props.children === "function" ? props.children() : props.children;
+    if (child) insertBefore(parentNode, child, anchor);
+  });
+}
+__name(I18nBoundary, "I18nBoundary");
+function findMessage(allMessages, locale, fallbackLocale, key) {
+  const locales = unique([
+    locale,
+    locale.split("-")[0],
+    fallbackLocale,
+    fallbackLocale?.split("-")[0]
+  ]);
+  for (const candidate of locales) {
+    const message = getMessage(allMessages[candidate], key);
+    if (message !== void 0) return message;
+  }
+  return void 0;
+}
+__name(findMessage, "findMessage");
+function getMessage(messages, key) {
+  if (!messages) return void 0;
+  const direct = messages[key];
+  if (typeof direct === "string") return direct;
+  let current = messages;
+  for (const segment of key.split(".")) {
+    if (!isMessages(current)) return void 0;
+    current = current[segment];
+  }
+  return typeof current === "string" ? current : void 0;
+}
+__name(getMessage, "getMessage");
+function interpolate(template, params, context, formatters) {
+  if (!params) return template;
+  return template.replace(
+    /\{([\w.-]+)(?:,\s*([\w-]+)(?:,\s*([^}]+))?)?\}/g,
+    (match, key, formatter, argument) => {
+      if (!(key in params)) return match;
+      const value = params[key];
+      if (!formatter) return String(value);
+      if (formatter === "date") return context.formatDate(toDate(value) ?? Number.NaN, argument);
+      if (formatter === "number") return context.formatNumber(Number(value));
+      if (formatter === "currency") return context.formatCurrency(Number(value), argument ?? "USD");
+      if (formatter === "relativeTime") return context.formatRelativeTime(toDate(value) ?? Number.NaN);
+      const custom = formatters.get(formatter);
+      return custom ? custom(value, context.locale.value, argument) : String(value);
+    }
+  );
+}
+__name(interpolate, "interpolate");
+function toDate(value) {
+  const date = value instanceof Date ? new Date(value.getTime()) : typeof value === "number" ? new Date(value) : void 0;
+  return date && Number.isFinite(date.getTime()) ? date : void 0;
+}
+__name(toDate, "toDate");
+function resolveDateOptions(presetOrOptions, options) {
+  if (presetOrOptions === void 0) return DATE_PRESETS.medium;
+  if (typeof presetOrOptions === "object") return presetOrOptions;
+  if (presetOrOptions === "custom") return options ?? {};
+  return { ...DATE_PRESETS[presetOrOptions], ...options };
+}
+__name(resolveDateOptions, "resolveDateOptions");
+function withTimeZone(options, timeZone) {
+  return timeZone && options.timeZone === void 0 ? { ...options, timeZone } : options;
+}
+__name(withTimeZone, "withTimeZone");
+function validateLocale(locale) {
+  if (typeof locale !== "string" || !locale.trim()) throw new Error("Vobs I18n: locale \u4E0D\u80FD\u4E3A\u7A7A");
+  return locale;
+}
+__name(validateLocale, "validateLocale");
+function validateMessages(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Vobs I18n: messages \u5FC5\u987B\u662F\u5BF9\u8C61");
+  }
+  for (const [key, message] of Object.entries(value)) {
+    if (typeof message === "string") continue;
+    if (!message || typeof message !== "object" || Array.isArray(message)) {
+      throw new Error(`Vobs I18n: \u7FFB\u8BD1\u5B57\u6BB5 ${key} \u7684\u503C\u65E0\u6548`);
+    }
+    validateMessages(message);
+  }
+  return value;
+}
+__name(validateMessages, "validateMessages");
+function validateLocaleMessages(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Vobs I18n: locale messages \u5FC5\u987B\u662F\u5BF9\u8C61");
+  }
+  for (const [locale, messages] of Object.entries(value)) {
+    validateLocale(locale);
+    validateMessages(messages);
+  }
+  return value;
+}
+__name(validateLocaleMessages, "validateLocaleMessages");
+function mergeMessages(parent, next) {
+  const merged = { ...parent ?? {} };
+  for (const [key, value] of Object.entries(next)) {
+    const previous = merged[key];
+    merged[key] = typeof value === "object" && typeof previous === "object" ? mergeMessages(previous, value) : value;
+  }
+  return merged;
+}
+__name(mergeMessages, "mergeMessages");
+function isMessages(value) {
+  return Boolean(value) && typeof value === "object";
+}
+__name(isMessages, "isMessages");
+function unique(values) {
+  return [...new Set(values.filter((value) => value !== void 0))];
+}
+__name(unique, "unique");
+
+exports.I18N_KEY = I18N_KEY;
+exports.I18nBoundary = I18nBoundary;
+exports.createI18n = createI18n;
+exports.i18nPlugin = i18nPlugin;
+exports.useI18n = useI18n;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map