service-flow-designer 0.0.1-beta.1 → 0.0.1-beta.4

package/dist/lib/node_modules/.pnpm/vue-i18n@9.13.1_vue@3.4.27/node_modules/vue-i18n/dist/vue-i18n.js

@@ -0,0 +1,2383 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const shared = require("../../../../@intlify_shared@9.13.1/node_modules/@intlify/shared/dist/shared.js");
+const coreBase = require("../../../../@intlify_core-base@9.13.1/node_modules/@intlify/core-base/dist/core-base.js");
+const Vue = require("vue");
+const index = require("../../../../@vue_devtools-api@6.6.3/node_modules/@vue/devtools-api/lib/esm/index.js");
+const messageCompiler_esmBrowser = require("../../../../@intlify_message-compiler@9.13.1/node_modules/@intlify/message-compiler/dist/message-compiler.esm-browser.js");
+/*!
+  * vue-i18n v9.13.1
+  * (c) 2024 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+const VERSION = "9.13.1";
+function initFeatureFlags() {
+  if (typeof __VUE_I18N_FULL_INSTALL__ !== "boolean") {
+    shared.getGlobalThis().__VUE_I18N_FULL_INSTALL__ = true;
+  }
+  if (typeof __VUE_I18N_LEGACY_API__ !== "boolean") {
+    shared.getGlobalThis().__VUE_I18N_LEGACY_API__ = true;
+  }
+  if (typeof __INTLIFY_JIT_COMPILATION__ !== "boolean") {
+    shared.getGlobalThis().__INTLIFY_JIT_COMPILATION__ = false;
+  }
+  if (typeof __INTLIFY_DROP_MESSAGE_COMPILER__ !== "boolean") {
+    shared.getGlobalThis().__INTLIFY_DROP_MESSAGE_COMPILER__ = false;
+  }
+  if (typeof __INTLIFY_PROD_DEVTOOLS__ !== "boolean") {
+    shared.getGlobalThis().__INTLIFY_PROD_DEVTOOLS__ = false;
+  }
+}
+const code$1 = coreBase.CoreWarnCodes.__EXTEND_POINT__;
+const inc$1 = shared.incrementer(code$1);
+const I18nWarnCodes = {
+  FALLBACK_TO_ROOT: code$1,
+  // 9
+  NOT_SUPPORTED_PRESERVE: inc$1(),
+  // 10
+  NOT_SUPPORTED_FORMATTER: inc$1(),
+  // 11
+  NOT_SUPPORTED_PRESERVE_DIRECTIVE: inc$1(),
+  // 12
+  NOT_SUPPORTED_GET_CHOICE_INDEX: inc$1(),
+  // 13
+  COMPONENT_NAME_LEGACY_COMPATIBLE: inc$1(),
+  // 14
+  NOT_FOUND_PARENT_SCOPE: inc$1(),
+  // 15
+  IGNORE_OBJ_FLATTEN: inc$1(),
+  // 16
+  NOTICE_DROP_ALLOW_COMPOSITION: inc$1(),
+  // 17
+  NOTICE_DROP_TRANSLATE_EXIST_COMPATIBLE_FLAG: inc$1()
+  // 18
+};
+const warnMessages = {
+  [I18nWarnCodes.FALLBACK_TO_ROOT]: `Fall back to {type} '{key}' with root locale.`,
+  [I18nWarnCodes.NOT_SUPPORTED_PRESERVE]: `Not supported 'preserve'.`,
+  [I18nWarnCodes.NOT_SUPPORTED_FORMATTER]: `Not supported 'formatter'.`,
+  [I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE]: `Not supported 'preserveDirectiveContent'.`,
+  [I18nWarnCodes.NOT_SUPPORTED_GET_CHOICE_INDEX]: `Not supported 'getChoiceIndex'.`,
+  [I18nWarnCodes.COMPONENT_NAME_LEGACY_COMPATIBLE]: `Component name legacy compatible: '{name}' -> 'i18n'`,
+  [I18nWarnCodes.NOT_FOUND_PARENT_SCOPE]: `Not found parent scope. use the global scope.`,
+  [I18nWarnCodes.IGNORE_OBJ_FLATTEN]: `Ignore object flatten: '{key}' key has an string value`,
+  [I18nWarnCodes.NOTICE_DROP_ALLOW_COMPOSITION]: `'allowComposition' option will be dropped in the next major version. For more information, please see 👉 https://tinyurl.com/2p97mcze`,
+  [I18nWarnCodes.NOTICE_DROP_TRANSLATE_EXIST_COMPATIBLE_FLAG]: `'translateExistCompatible' option will be dropped in the next major version.`
+};
+function getWarnMessage(code2, ...args) {
+  return shared.format(warnMessages[code2], ...args);
+}
+const code = coreBase.CoreErrorCodes.__EXTEND_POINT__;
+const inc = shared.incrementer(code);
+const I18nErrorCodes = {
+  // composer module errors
+  UNEXPECTED_RETURN_TYPE: code,
+  // 24
+  // legacy module errors
+  INVALID_ARGUMENT: inc(),
+  // 25
+  // i18n module errors
+  MUST_BE_CALL_SETUP_TOP: inc(),
+  // 26
+  NOT_INSTALLED: inc(),
+  // 27
+  NOT_AVAILABLE_IN_LEGACY_MODE: inc(),
+  // 28
+  // directive module errors
+  REQUIRED_VALUE: inc(),
+  // 29
+  INVALID_VALUE: inc(),
+  // 30
+  // vue-devtools errors
+  CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN: inc(),
+  // 31
+  NOT_INSTALLED_WITH_PROVIDE: inc(),
+  // 32
+  // unexpected error
+  UNEXPECTED_ERROR: inc(),
+  // 33
+  // not compatible legacy vue-i18n constructor
+  NOT_COMPATIBLE_LEGACY_VUE_I18N: inc(),
+  // 34
+  // bridge support vue 2.x only
+  BRIDGE_SUPPORT_VUE_2_ONLY: inc(),
+  // 35
+  // need to define `i18n` option in `allowComposition: true` and `useScope: 'local' at `useI18n``
+  MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION: inc(),
+  // 36
+  // Not available Compostion API in Legacy API mode. Please make sure that the legacy API mode is working properly
+  NOT_AVAILABLE_COMPOSITION_IN_LEGACY: inc(),
+  // 37
+  // for enhancement
+  __EXTEND_POINT__: inc()
+  // 38
+};
+function createI18nError(code2, ...args) {
+  return messageCompiler_esmBrowser.createCompileError(code2, null, process.env.NODE_ENV !== "production" ? { messages: errorMessages, args } : void 0);
+}
+const errorMessages = {
+  [I18nErrorCodes.UNEXPECTED_RETURN_TYPE]: "Unexpected return type in composer",
+  [I18nErrorCodes.INVALID_ARGUMENT]: "Invalid argument",
+  [I18nErrorCodes.MUST_BE_CALL_SETUP_TOP]: "Must be called at the top of a `setup` function",
+  [I18nErrorCodes.NOT_INSTALLED]: "Need to install with `app.use` function",
+  [I18nErrorCodes.UNEXPECTED_ERROR]: "Unexpected error",
+  [I18nErrorCodes.NOT_AVAILABLE_IN_LEGACY_MODE]: "Not available in legacy mode",
+  [I18nErrorCodes.REQUIRED_VALUE]: `Required in value: {0}`,
+  [I18nErrorCodes.INVALID_VALUE]: `Invalid value`,
+  [I18nErrorCodes.CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN]: `Cannot setup vue-devtools plugin`,
+  [I18nErrorCodes.NOT_INSTALLED_WITH_PROVIDE]: "Need to install with `provide` function",
+  [I18nErrorCodes.NOT_COMPATIBLE_LEGACY_VUE_I18N]: "Not compatible legacy VueI18n.",
+  [I18nErrorCodes.BRIDGE_SUPPORT_VUE_2_ONLY]: "vue-i18n-bridge support Vue 2.x only",
+  [I18nErrorCodes.MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION]: "Must define ‘i18n’ option or custom block in Composition API with using local scope in Legacy API mode",
+  [I18nErrorCodes.NOT_AVAILABLE_COMPOSITION_IN_LEGACY]: "Not available Compostion API in Legacy API mode. Please make sure that the legacy API mode is working properly"
+};
+const TranslateVNodeSymbol = /* @__PURE__ */ shared.makeSymbol("__translateVNode");
+const DatetimePartsSymbol = /* @__PURE__ */ shared.makeSymbol("__datetimeParts");
+const NumberPartsSymbol = /* @__PURE__ */ shared.makeSymbol("__numberParts");
+const EnableEmitter = /* @__PURE__ */ shared.makeSymbol("__enableEmitter");
+const DisableEmitter = /* @__PURE__ */ shared.makeSymbol("__disableEmitter");
+const SetPluralRulesSymbol = shared.makeSymbol("__setPluralRules");
+const InejctWithOptionSymbol = /* @__PURE__ */ shared.makeSymbol("__injectWithOption");
+const DisposeSymbol = /* @__PURE__ */ shared.makeSymbol("__dispose");
+function handleFlatJson(obj) {
+  if (!shared.isObject(obj)) {
+    return obj;
+  }
+  for (const key in obj) {
+    if (!shared.hasOwn(obj, key)) {
+      continue;
+    }
+    if (!key.includes(".")) {
+      if (shared.isObject(obj[key])) {
+        handleFlatJson(obj[key]);
+      }
+    } else {
+      const subKeys = key.split(".");
+      const lastIndex = subKeys.length - 1;
+      let currentObj = obj;
+      let hasStringValue = false;
+      for (let i = 0; i < lastIndex; i++) {
+        if (!(subKeys[i] in currentObj)) {
+          currentObj[subKeys[i]] = {};
+        }
+        if (!shared.isObject(currentObj[subKeys[i]])) {
+          process.env.NODE_ENV !== "production" && shared.warn(getWarnMessage(I18nWarnCodes.IGNORE_OBJ_FLATTEN, {
+            key: subKeys[i]
+          }));
+          hasStringValue = true;
+          break;
+        }
+        currentObj = currentObj[subKeys[i]];
+      }
+      if (!hasStringValue) {
+        currentObj[subKeys[lastIndex]] = obj[key];
+        delete obj[key];
+      }
+      if (shared.isObject(currentObj[subKeys[lastIndex]])) {
+        handleFlatJson(currentObj[subKeys[lastIndex]]);
+      }
+    }
+  }
+  return obj;
+}
+function getLocaleMessages(locale, options) {
+  const { messages, __i18n, messageResolver, flatJson } = options;
+  const ret = shared.isPlainObject(messages) ? messages : shared.isArray(__i18n) ? {} : { [locale]: {} };
+  if (shared.isArray(__i18n)) {
+    __i18n.forEach((custom) => {
+      if ("locale" in custom && "resource" in custom) {
+        const { locale: locale2, resource } = custom;
+        if (locale2) {
+          ret[locale2] = ret[locale2] || {};
+          shared.deepCopy(resource, ret[locale2]);
+        } else {
+          shared.deepCopy(resource, ret);
+        }
+      } else {
+        shared.isString(custom) && shared.deepCopy(JSON.parse(custom), ret);
+      }
+    });
+  }
+  if (messageResolver == null && flatJson) {
+    for (const key in ret) {
+      if (shared.hasOwn(ret, key)) {
+        handleFlatJson(ret[key]);
+      }
+    }
+  }
+  return ret;
+}
+function getComponentOptions(instance) {
+  return instance.type;
+}
+function adjustI18nResources(gl, options, componentOptions) {
+  let messages = shared.isObject(options.messages) ? options.messages : {};
+  if ("__i18nGlobal" in componentOptions) {
+    messages = getLocaleMessages(gl.locale.value, {
+      messages,
+      __i18n: componentOptions.__i18nGlobal
+    });
+  }
+  const locales = Object.keys(messages);
+  if (locales.length) {
+    locales.forEach((locale) => {
+      gl.mergeLocaleMessage(locale, messages[locale]);
+    });
+  }
+  {
+    if (shared.isObject(options.datetimeFormats)) {
+      const locales2 = Object.keys(options.datetimeFormats);
+      if (locales2.length) {
+        locales2.forEach((locale) => {
+          gl.mergeDateTimeFormat(locale, options.datetimeFormats[locale]);
+        });
+      }
+    }
+    if (shared.isObject(options.numberFormats)) {
+      const locales2 = Object.keys(options.numberFormats);
+      if (locales2.length) {
+        locales2.forEach((locale) => {
+          gl.mergeNumberFormat(locale, options.numberFormats[locale]);
+        });
+      }
+    }
+  }
+}
+function createTextNode(key) {
+  return Vue.createVNode(Vue.Text, null, key, 0);
+}
+const DEVTOOLS_META = "__INTLIFY_META__";
+const NOOP_RETURN_ARRAY = () => [];
+const NOOP_RETURN_FALSE = () => false;
+let composerID = 0;
+function defineCoreMissingHandler(missing) {
+  return (ctx, locale, key, type) => {
+    return missing(locale, key, Vue.getCurrentInstance() || void 0, type);
+  };
+}
+const getMetaInfo = /* @__NO_SIDE_EFFECTS__ */ () => {
+  const instance = Vue.getCurrentInstance();
+  let meta = null;
+  return instance && (meta = getComponentOptions(instance)[DEVTOOLS_META]) ? { [DEVTOOLS_META]: meta } : null;
+};
+function createComposer(options = {}, VueI18nLegacy) {
+  const { __root, __injectWithOption } = options;
+  const _isGlobal = __root === void 0;
+  const flatJson = options.flatJson;
+  const _ref = shared.inBrowser ? Vue.ref : Vue.shallowRef;
+  const translateExistCompatible = !!options.translateExistCompatible;
+  if (process.env.NODE_ENV !== "production") {
+    if (translateExistCompatible && true) {
+      shared.warnOnce(getWarnMessage(I18nWarnCodes.NOTICE_DROP_TRANSLATE_EXIST_COMPATIBLE_FLAG));
+    }
+  }
+  let _inheritLocale = shared.isBoolean(options.inheritLocale) ? options.inheritLocale : true;
+  const _locale = _ref(
+    // prettier-ignore
+    __root && _inheritLocale ? __root.locale.value : shared.isString(options.locale) ? options.locale : coreBase.DEFAULT_LOCALE
+  );
+  const _fallbackLocale = _ref(
+    // prettier-ignore
+    __root && _inheritLocale ? __root.fallbackLocale.value : shared.isString(options.fallbackLocale) || shared.isArray(options.fallbackLocale) || shared.isPlainObject(options.fallbackLocale) || options.fallbackLocale === false ? options.fallbackLocale : _locale.value
+  );
+  const _messages = _ref(getLocaleMessages(_locale.value, options));
+  const _datetimeFormats = _ref(shared.isPlainObject(options.datetimeFormats) ? options.datetimeFormats : { [_locale.value]: {} });
+  const _numberFormats = _ref(shared.isPlainObject(options.numberFormats) ? options.numberFormats : { [_locale.value]: {} });
+  let _missingWarn = __root ? __root.missingWarn : shared.isBoolean(options.missingWarn) || shared.isRegExp(options.missingWarn) ? options.missingWarn : true;
+  let _fallbackWarn = __root ? __root.fallbackWarn : shared.isBoolean(options.fallbackWarn) || shared.isRegExp(options.fallbackWarn) ? options.fallbackWarn : true;
+  let _fallbackRoot = __root ? __root.fallbackRoot : shared.isBoolean(options.fallbackRoot) ? options.fallbackRoot : true;
+  let _fallbackFormat = !!options.fallbackFormat;
+  let _missing = shared.isFunction(options.missing) ? options.missing : null;
+  let _runtimeMissing = shared.isFunction(options.missing) ? defineCoreMissingHandler(options.missing) : null;
+  let _postTranslation = shared.isFunction(options.postTranslation) ? options.postTranslation : null;
+  let _warnHtmlMessage = __root ? __root.warnHtmlMessage : shared.isBoolean(options.warnHtmlMessage) ? options.warnHtmlMessage : true;
+  let _escapeParameter = !!options.escapeParameter;
+  const _modifiers = __root ? __root.modifiers : shared.isPlainObject(options.modifiers) ? options.modifiers : {};
+  let _pluralRules = options.pluralRules || __root && __root.pluralRules;
+  let _context;
+  const getCoreContext = () => {
+    _isGlobal && coreBase.setFallbackContext(null);
+    const ctxOptions = {
+      version: VERSION,
+      locale: _locale.value,
+      fallbackLocale: _fallbackLocale.value,
+      messages: _messages.value,
+      modifiers: _modifiers,
+      pluralRules: _pluralRules,
+      missing: _runtimeMissing === null ? void 0 : _runtimeMissing,
+      missingWarn: _missingWarn,
+      fallbackWarn: _fallbackWarn,
+      fallbackFormat: _fallbackFormat,
+      unresolving: true,
+      postTranslation: _postTranslation === null ? void 0 : _postTranslation,
+      warnHtmlMessage: _warnHtmlMessage,
+      escapeParameter: _escapeParameter,
+      messageResolver: options.messageResolver,
+      messageCompiler: options.messageCompiler,
+      __meta: { framework: "vue" }
+    };
+    {
+      ctxOptions.datetimeFormats = _datetimeFormats.value;
+      ctxOptions.numberFormats = _numberFormats.value;
+      ctxOptions.__datetimeFormatters = shared.isPlainObject(_context) ? _context.__datetimeFormatters : void 0;
+      ctxOptions.__numberFormatters = shared.isPlainObject(_context) ? _context.__numberFormatters : void 0;
+    }
+    if (process.env.NODE_ENV !== "production") {
+      ctxOptions.__v_emitter = shared.isPlainObject(_context) ? _context.__v_emitter : void 0;
+    }
+    const ctx = coreBase.createCoreContext(ctxOptions);
+    _isGlobal && coreBase.setFallbackContext(ctx);
+    return ctx;
+  };
+  _context = getCoreContext();
+  coreBase.updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
+  function trackReactivityValues() {
+    return [
+      _locale.value,
+      _fallbackLocale.value,
+      _messages.value,
+      _datetimeFormats.value,
+      _numberFormats.value
+    ];
+  }
+  const locale = Vue.computed({
+    get: () => _locale.value,
+    set: (val) => {
+      _locale.value = val;
+      _context.locale = _locale.value;
+    }
+  });
+  const fallbackLocale = Vue.computed({
+    get: () => _fallbackLocale.value,
+    set: (val) => {
+      _fallbackLocale.value = val;
+      _context.fallbackLocale = _fallbackLocale.value;
+      coreBase.updateFallbackLocale(_context, _locale.value, val);
+    }
+  });
+  const messages = Vue.computed(() => _messages.value);
+  const datetimeFormats = /* @__PURE__ */ Vue.computed(() => _datetimeFormats.value);
+  const numberFormats = /* @__PURE__ */ Vue.computed(() => _numberFormats.value);
+  function getPostTranslationHandler() {
+    return shared.isFunction(_postTranslation) ? _postTranslation : null;
+  }
+  function setPostTranslationHandler(handler) {
+    _postTranslation = handler;
+    _context.postTranslation = handler;
+  }
+  function getMissingHandler() {
+    return _missing;
+  }
+  function setMissingHandler(handler) {
+    if (handler !== null) {
+      _runtimeMissing = defineCoreMissingHandler(handler);
+    }
+    _missing = handler;
+    _context.missing = _runtimeMissing;
+  }
+  function isResolvedTranslateMessage(type, arg) {
+    return type !== "translate" || !arg.resolvedMessage;
+  }
+  const wrapWithDeps = (fn, argumentParser, warnType, fallbackSuccess, fallbackFail, successCondition) => {
+    trackReactivityValues();
+    let ret;
+    try {
+      if (process.env.NODE_ENV !== "production" || __INTLIFY_PROD_DEVTOOLS__) {
+        coreBase.setAdditionalMeta(/* @__PURE__ */ getMetaInfo());
+      }
+      if (!_isGlobal) {
+        _context.fallbackContext = __root ? coreBase.getFallbackContext() : void 0;
+      }
+      ret = fn(_context);
+    } finally {
+      if (process.env.NODE_ENV !== "production" || __INTLIFY_PROD_DEVTOOLS__) ;
+      if (!_isGlobal) {
+        _context.fallbackContext = void 0;
+      }
+    }
+    if (warnType !== "translate exists" && // for not `te` (e.g `t`)
+    shared.isNumber(ret) && ret === coreBase.NOT_REOSLVED || warnType === "translate exists" && !ret) {
+      const [key, arg2] = argumentParser();
+      if (process.env.NODE_ENV !== "production" && __root && shared.isString(key) && isResolvedTranslateMessage(warnType, arg2)) {
+        if (_fallbackRoot && (coreBase.isTranslateFallbackWarn(_fallbackWarn, key) || coreBase.isTranslateMissingWarn(_missingWarn, key))) {
+          shared.warn(getWarnMessage(I18nWarnCodes.FALLBACK_TO_ROOT, {
+            key,
+            type: warnType
+          }));
+        }
+        if (process.env.NODE_ENV !== "production") {
+          const { __v_emitter: emitter } = _context;
+          if (emitter && _fallbackRoot) {
+            emitter.emit("fallback", {
+              type: warnType,
+              key,
+              to: "global",
+              groupId: `${warnType}:${key}`
+            });
+          }
+        }
+      }
+      return __root && _fallbackRoot ? fallbackSuccess(__root) : fallbackFail(key);
+    } else if (successCondition(ret)) {
+      return ret;
+    } else {
+      throw createI18nError(I18nErrorCodes.UNEXPECTED_RETURN_TYPE);
+    }
+  };
+  function t(...args) {
+    return wrapWithDeps((context) => Reflect.apply(coreBase.translate, null, [context, ...args]), () => coreBase.parseTranslateArgs(...args), "translate", (root) => Reflect.apply(root.t, root, [...args]), (key) => key, (val) => shared.isString(val));
+  }
+  function rt(...args) {
+    const [arg1, arg2, arg3] = args;
+    if (arg3 && !shared.isObject(arg3)) {
+      throw createI18nError(I18nErrorCodes.INVALID_ARGUMENT);
+    }
+    return t(...[arg1, arg2, shared.assign({ resolvedMessage: true }, arg3 || {})]);
+  }
+  function d(...args) {
+    return wrapWithDeps((context) => Reflect.apply(coreBase.datetime, null, [context, ...args]), () => coreBase.parseDateTimeArgs(...args), "datetime format", (root) => Reflect.apply(root.d, root, [...args]), () => coreBase.MISSING_RESOLVE_VALUE, (val) => shared.isString(val));
+  }
+  function n(...args) {
+    return wrapWithDeps((context) => Reflect.apply(coreBase.number, null, [context, ...args]), () => coreBase.parseNumberArgs(...args), "number format", (root) => Reflect.apply(root.n, root, [...args]), () => coreBase.MISSING_RESOLVE_VALUE, (val) => shared.isString(val));
+  }
+  function normalize(values) {
+    return values.map((val) => shared.isString(val) || shared.isNumber(val) || shared.isBoolean(val) ? createTextNode(String(val)) : val);
+  }
+  const interpolate = (val) => val;
+  const processor = {
+    normalize,
+    interpolate,
+    type: "vnode"
+  };
+  function translateVNode(...args) {
+    return wrapWithDeps(
+      (context) => {
+        let ret;
+        const _context2 = context;
+        try {
+          _context2.processor = processor;
+          ret = Reflect.apply(coreBase.translate, null, [_context2, ...args]);
+        } finally {
+          _context2.processor = null;
+        }
+        return ret;
+      },
+      () => coreBase.parseTranslateArgs(...args),
+      "translate",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (root) => root[TranslateVNodeSymbol](...args),
+      (key) => [createTextNode(key)],
+      (val) => shared.isArray(val)
+    );
+  }
+  function numberParts(...args) {
+    return wrapWithDeps(
+      (context) => Reflect.apply(coreBase.number, null, [context, ...args]),
+      () => coreBase.parseNumberArgs(...args),
+      "number format",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (root) => root[NumberPartsSymbol](...args),
+      NOOP_RETURN_ARRAY,
+      (val) => shared.isString(val) || shared.isArray(val)
+    );
+  }
+  function datetimeParts(...args) {
+    return wrapWithDeps(
+      (context) => Reflect.apply(coreBase.datetime, null, [context, ...args]),
+      () => coreBase.parseDateTimeArgs(...args),
+      "datetime format",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (root) => root[DatetimePartsSymbol](...args),
+      NOOP_RETURN_ARRAY,
+      (val) => shared.isString(val) || shared.isArray(val)
+    );
+  }
+  function setPluralRules(rules) {
+    _pluralRules = rules;
+    _context.pluralRules = _pluralRules;
+  }
+  function te(key, locale2) {
+    return wrapWithDeps(() => {
+      if (!key) {
+        return false;
+      }
+      const targetLocale = shared.isString(locale2) ? locale2 : _locale.value;
+      const message = getLocaleMessage(targetLocale);
+      const resolved = _context.messageResolver(message, key);
+      return !translateExistCompatible ? coreBase.isMessageAST(resolved) || coreBase.isMessageFunction(resolved) || shared.isString(resolved) : resolved != null;
+    }, () => [key], "translate exists", (root) => {
+      return Reflect.apply(root.te, root, [key, locale2]);
+    }, NOOP_RETURN_FALSE, (val) => shared.isBoolean(val));
+  }
+  function resolveMessages(key) {
+    let messages2 = null;
+    const locales = coreBase.fallbackWithLocaleChain(_context, _fallbackLocale.value, _locale.value);
+    for (let i = 0; i < locales.length; i++) {
+      const targetLocaleMessages = _messages.value[locales[i]] || {};
+      const messageValue = _context.messageResolver(targetLocaleMessages, key);
+      if (messageValue != null) {
+        messages2 = messageValue;
+        break;
+      }
+    }
+    return messages2;
+  }
+  function tm(key) {
+    const messages2 = resolveMessages(key);
+    return messages2 != null ? messages2 : __root ? __root.tm(key) || {} : {};
+  }
+  function getLocaleMessage(locale2) {
+    return _messages.value[locale2] || {};
+  }
+  function setLocaleMessage(locale2, message) {
+    if (flatJson) {
+      const _message = { [locale2]: message };
+      for (const key in _message) {
+        if (shared.hasOwn(_message, key)) {
+          handleFlatJson(_message[key]);
+        }
+      }
+      message = _message[locale2];
+    }
+    _messages.value[locale2] = message;
+    _context.messages = _messages.value;
+  }
+  function mergeLocaleMessage(locale2, message) {
+    _messages.value[locale2] = _messages.value[locale2] || {};
+    const _message = { [locale2]: message };
+    if (flatJson) {
+      for (const key in _message) {
+        if (shared.hasOwn(_message, key)) {
+          handleFlatJson(_message[key]);
+        }
+      }
+    }
+    message = _message[locale2];
+    shared.deepCopy(message, _messages.value[locale2]);
+    _context.messages = _messages.value;
+  }
+  function getDateTimeFormat(locale2) {
+    return _datetimeFormats.value[locale2] || {};
+  }
+  function setDateTimeFormat(locale2, format2) {
+    _datetimeFormats.value[locale2] = format2;
+    _context.datetimeFormats = _datetimeFormats.value;
+    coreBase.clearDateTimeFormat(_context, locale2, format2);
+  }
+  function mergeDateTimeFormat(locale2, format2) {
+    _datetimeFormats.value[locale2] = shared.assign(_datetimeFormats.value[locale2] || {}, format2);
+    _context.datetimeFormats = _datetimeFormats.value;
+    coreBase.clearDateTimeFormat(_context, locale2, format2);
+  }
+  function getNumberFormat(locale2) {
+    return _numberFormats.value[locale2] || {};
+  }
+  function setNumberFormat(locale2, format2) {
+    _numberFormats.value[locale2] = format2;
+    _context.numberFormats = _numberFormats.value;
+    coreBase.clearNumberFormat(_context, locale2, format2);
+  }
+  function mergeNumberFormat(locale2, format2) {
+    _numberFormats.value[locale2] = shared.assign(_numberFormats.value[locale2] || {}, format2);
+    _context.numberFormats = _numberFormats.value;
+    coreBase.clearNumberFormat(_context, locale2, format2);
+  }
+  composerID++;
+  if (__root && shared.inBrowser) {
+    Vue.watch(__root.locale, (val) => {
+      if (_inheritLocale) {
+        _locale.value = val;
+        _context.locale = val;
+        coreBase.updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
+      }
+    });
+    Vue.watch(__root.fallbackLocale, (val) => {
+      if (_inheritLocale) {
+        _fallbackLocale.value = val;
+        _context.fallbackLocale = val;
+        coreBase.updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
+      }
+    });
+  }
+  const composer = {
+    id: composerID,
+    locale,
+    fallbackLocale,
+    get inheritLocale() {
+      return _inheritLocale;
+    },
+    set inheritLocale(val) {
+      _inheritLocale = val;
+      if (val && __root) {
+        _locale.value = __root.locale.value;
+        _fallbackLocale.value = __root.fallbackLocale.value;
+        coreBase.updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
+      }
+    },
+    get availableLocales() {
+      return Object.keys(_messages.value).sort();
+    },
+    messages,
+    get modifiers() {
+      return _modifiers;
+    },
+    get pluralRules() {
+      return _pluralRules || {};
+    },
+    get isGlobal() {
+      return _isGlobal;
+    },
+    get missingWarn() {
+      return _missingWarn;
+    },
+    set missingWarn(val) {
+      _missingWarn = val;
+      _context.missingWarn = _missingWarn;
+    },
+    get fallbackWarn() {
+      return _fallbackWarn;
+    },
+    set fallbackWarn(val) {
+      _fallbackWarn = val;
+      _context.fallbackWarn = _fallbackWarn;
+    },
+    get fallbackRoot() {
+      return _fallbackRoot;
+    },
+    set fallbackRoot(val) {
+      _fallbackRoot = val;
+    },
+    get fallbackFormat() {
+      return _fallbackFormat;
+    },
+    set fallbackFormat(val) {
+      _fallbackFormat = val;
+      _context.fallbackFormat = _fallbackFormat;
+    },
+    get warnHtmlMessage() {
+      return _warnHtmlMessage;
+    },
+    set warnHtmlMessage(val) {
+      _warnHtmlMessage = val;
+      _context.warnHtmlMessage = val;
+    },
+    get escapeParameter() {
+      return _escapeParameter;
+    },
+    set escapeParameter(val) {
+      _escapeParameter = val;
+      _context.escapeParameter = val;
+    },
+    t,
+    getLocaleMessage,
+    setLocaleMessage,
+    mergeLocaleMessage,
+    getPostTranslationHandler,
+    setPostTranslationHandler,
+    getMissingHandler,
+    setMissingHandler,
+    [SetPluralRulesSymbol]: setPluralRules
+  };
+  {
+    composer.datetimeFormats = datetimeFormats;
+    composer.numberFormats = numberFormats;
+    composer.rt = rt;
+    composer.te = te;
+    composer.tm = tm;
+    composer.d = d;
+    composer.n = n;
+    composer.getDateTimeFormat = getDateTimeFormat;
+    composer.setDateTimeFormat = setDateTimeFormat;
+    composer.mergeDateTimeFormat = mergeDateTimeFormat;
+    composer.getNumberFormat = getNumberFormat;
+    composer.setNumberFormat = setNumberFormat;
+    composer.mergeNumberFormat = mergeNumberFormat;
+    composer[InejctWithOptionSymbol] = __injectWithOption;
+    composer[TranslateVNodeSymbol] = translateVNode;
+    composer[DatetimePartsSymbol] = datetimeParts;
+    composer[NumberPartsSymbol] = numberParts;
+  }
+  if (process.env.NODE_ENV !== "production") {
+    composer[EnableEmitter] = (emitter) => {
+      _context.__v_emitter = emitter;
+    };
+    composer[DisableEmitter] = () => {
+      _context.__v_emitter = void 0;
+    };
+  }
+  return composer;
+}
+function convertComposerOptions(options) {
+  const locale = shared.isString(options.locale) ? options.locale : coreBase.DEFAULT_LOCALE;
+  const fallbackLocale = shared.isString(options.fallbackLocale) || shared.isArray(options.fallbackLocale) || shared.isPlainObject(options.fallbackLocale) || options.fallbackLocale === false ? options.fallbackLocale : locale;
+  const missing = shared.isFunction(options.missing) ? options.missing : void 0;
+  const missingWarn = shared.isBoolean(options.silentTranslationWarn) || shared.isRegExp(options.silentTranslationWarn) ? !options.silentTranslationWarn : true;
+  const fallbackWarn = shared.isBoolean(options.silentFallbackWarn) || shared.isRegExp(options.silentFallbackWarn) ? !options.silentFallbackWarn : true;
+  const fallbackRoot = shared.isBoolean(options.fallbackRoot) ? options.fallbackRoot : true;
+  const fallbackFormat = !!options.formatFallbackMessages;
+  const modifiers = shared.isPlainObject(options.modifiers) ? options.modifiers : {};
+  const pluralizationRules = options.pluralizationRules;
+  const postTranslation = shared.isFunction(options.postTranslation) ? options.postTranslation : void 0;
+  const warnHtmlMessage = shared.isString(options.warnHtmlInMessage) ? options.warnHtmlInMessage !== "off" : true;
+  const escapeParameter = !!options.escapeParameterHtml;
+  const inheritLocale = shared.isBoolean(options.sync) ? options.sync : true;
+  if (process.env.NODE_ENV !== "production" && options.formatter) {
+    shared.warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_FORMATTER));
+  }
+  if (process.env.NODE_ENV !== "production" && options.preserveDirectiveContent) {
+    shared.warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE));
+  }
+  let messages = options.messages;
+  if (shared.isPlainObject(options.sharedMessages)) {
+    const sharedMessages = options.sharedMessages;
+    const locales = Object.keys(sharedMessages);
+    messages = locales.reduce((messages2, locale2) => {
+      const message = messages2[locale2] || (messages2[locale2] = {});
+      shared.assign(message, sharedMessages[locale2]);
+      return messages2;
+    }, messages || {});
+  }
+  const { __i18n, __root, __injectWithOption } = options;
+  const datetimeFormats = options.datetimeFormats;
+  const numberFormats = options.numberFormats;
+  const flatJson = options.flatJson;
+  const translateExistCompatible = options.translateExistCompatible;
+  return {
+    locale,
+    fallbackLocale,
+    messages,
+    flatJson,
+    datetimeFormats,
+    numberFormats,
+    missing,
+    missingWarn,
+    fallbackWarn,
+    fallbackRoot,
+    fallbackFormat,
+    modifiers,
+    pluralRules: pluralizationRules,
+    postTranslation,
+    warnHtmlMessage,
+    escapeParameter,
+    messageResolver: options.messageResolver,
+    inheritLocale,
+    translateExistCompatible,
+    __i18n,
+    __root,
+    __injectWithOption
+  };
+}
+function createVueI18n(options = {}, VueI18nLegacy) {
+  {
+    const composer = createComposer(convertComposerOptions(options));
+    const { __extender } = options;
+    const vueI18n = {
+      // id
+      id: composer.id,
+      // locale
+      get locale() {
+        return composer.locale.value;
+      },
+      set locale(val) {
+        composer.locale.value = val;
+      },
+      // fallbackLocale
+      get fallbackLocale() {
+        return composer.fallbackLocale.value;
+      },
+      set fallbackLocale(val) {
+        composer.fallbackLocale.value = val;
+      },
+      // messages
+      get messages() {
+        return composer.messages.value;
+      },
+      // datetimeFormats
+      get datetimeFormats() {
+        return composer.datetimeFormats.value;
+      },
+      // numberFormats
+      get numberFormats() {
+        return composer.numberFormats.value;
+      },
+      // availableLocales
+      get availableLocales() {
+        return composer.availableLocales;
+      },
+      // formatter
+      get formatter() {
+        process.env.NODE_ENV !== "production" && shared.warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_FORMATTER));
+        return {
+          interpolate() {
+            return [];
+          }
+        };
+      },
+      set formatter(val) {
+        process.env.NODE_ENV !== "production" && shared.warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_FORMATTER));
+      },
+      // missing
+      get missing() {
+        return composer.getMissingHandler();
+      },
+      set missing(handler) {
+        composer.setMissingHandler(handler);
+      },
+      // silentTranslationWarn
+      get silentTranslationWarn() {
+        return shared.isBoolean(composer.missingWarn) ? !composer.missingWarn : composer.missingWarn;
+      },
+      set silentTranslationWarn(val) {
+        composer.missingWarn = shared.isBoolean(val) ? !val : val;
+      },
+      // silentFallbackWarn
+      get silentFallbackWarn() {
+        return shared.isBoolean(composer.fallbackWarn) ? !composer.fallbackWarn : composer.fallbackWarn;
+      },
+      set silentFallbackWarn(val) {
+        composer.fallbackWarn = shared.isBoolean(val) ? !val : val;
+      },
+      // modifiers
+      get modifiers() {
+        return composer.modifiers;
+      },
+      // formatFallbackMessages
+      get formatFallbackMessages() {
+        return composer.fallbackFormat;
+      },
+      set formatFallbackMessages(val) {
+        composer.fallbackFormat = val;
+      },
+      // postTranslation
+      get postTranslation() {
+        return composer.getPostTranslationHandler();
+      },
+      set postTranslation(handler) {
+        composer.setPostTranslationHandler(handler);
+      },
+      // sync
+      get sync() {
+        return composer.inheritLocale;
+      },
+      set sync(val) {
+        composer.inheritLocale = val;
+      },
+      // warnInHtmlMessage
+      get warnHtmlInMessage() {
+        return composer.warnHtmlMessage ? "warn" : "off";
+      },
+      set warnHtmlInMessage(val) {
+        composer.warnHtmlMessage = val !== "off";
+      },
+      // escapeParameterHtml
+      get escapeParameterHtml() {
+        return composer.escapeParameter;
+      },
+      set escapeParameterHtml(val) {
+        composer.escapeParameter = val;
+      },
+      // preserveDirectiveContent
+      get preserveDirectiveContent() {
+        process.env.NODE_ENV !== "production" && shared.warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE));
+        return true;
+      },
+      set preserveDirectiveContent(val) {
+        process.env.NODE_ENV !== "production" && shared.warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE));
+      },
+      // pluralizationRules
+      get pluralizationRules() {
+        return composer.pluralRules || {};
+      },
+      // for internal
+      __composer: composer,
+      // t
+      t(...args) {
+        const [arg1, arg2, arg3] = args;
+        const options2 = {};
+        let list = null;
+        let named = null;
+        if (!shared.isString(arg1)) {
+          throw createI18nError(I18nErrorCodes.INVALID_ARGUMENT);
+        }
+        const key = arg1;
+        if (shared.isString(arg2)) {
+          options2.locale = arg2;
+        } else if (shared.isArray(arg2)) {
+          list = arg2;
+        } else if (shared.isPlainObject(arg2)) {
+          named = arg2;
+        }
+        if (shared.isArray(arg3)) {
+          list = arg3;
+        } else if (shared.isPlainObject(arg3)) {
+          named = arg3;
+        }
+        return Reflect.apply(composer.t, composer, [
+          key,
+          list || named || {},
+          options2
+        ]);
+      },
+      rt(...args) {
+        return Reflect.apply(composer.rt, composer, [...args]);
+      },
+      // tc
+      tc(...args) {
+        const [arg1, arg2, arg3] = args;
+        const options2 = { plural: 1 };
+        let list = null;
+        let named = null;
+        if (!shared.isString(arg1)) {
+          throw createI18nError(I18nErrorCodes.INVALID_ARGUMENT);
+        }
+        const key = arg1;
+        if (shared.isString(arg2)) {
+          options2.locale = arg2;
+        } else if (shared.isNumber(arg2)) {
+          options2.plural = arg2;
+        } else if (shared.isArray(arg2)) {
+          list = arg2;
+        } else if (shared.isPlainObject(arg2)) {
+          named = arg2;
+        }
+        if (shared.isString(arg3)) {
+          options2.locale = arg3;
+        } else if (shared.isArray(arg3)) {
+          list = arg3;
+        } else if (shared.isPlainObject(arg3)) {
+          named = arg3;
+        }
+        return Reflect.apply(composer.t, composer, [
+          key,
+          list || named || {},
+          options2
+        ]);
+      },
+      // te
+      te(key, locale) {
+        return composer.te(key, locale);
+      },
+      // tm
+      tm(key) {
+        return composer.tm(key);
+      },
+      // getLocaleMessage
+      getLocaleMessage(locale) {
+        return composer.getLocaleMessage(locale);
+      },
+      // setLocaleMessage
+      setLocaleMessage(locale, message) {
+        composer.setLocaleMessage(locale, message);
+      },
+      // mergeLocaleMessage
+      mergeLocaleMessage(locale, message) {
+        composer.mergeLocaleMessage(locale, message);
+      },
+      // d
+      d(...args) {
+        return Reflect.apply(composer.d, composer, [...args]);
+      },
+      // getDateTimeFormat
+      getDateTimeFormat(locale) {
+        return composer.getDateTimeFormat(locale);
+      },
+      // setDateTimeFormat
+      setDateTimeFormat(locale, format2) {
+        composer.setDateTimeFormat(locale, format2);
+      },
+      // mergeDateTimeFormat
+      mergeDateTimeFormat(locale, format2) {
+        composer.mergeDateTimeFormat(locale, format2);
+      },
+      // n
+      n(...args) {
+        return Reflect.apply(composer.n, composer, [...args]);
+      },
+      // getNumberFormat
+      getNumberFormat(locale) {
+        return composer.getNumberFormat(locale);
+      },
+      // setNumberFormat
+      setNumberFormat(locale, format2) {
+        composer.setNumberFormat(locale, format2);
+      },
+      // mergeNumberFormat
+      mergeNumberFormat(locale, format2) {
+        composer.mergeNumberFormat(locale, format2);
+      },
+      // getChoiceIndex
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      getChoiceIndex(choice, choicesLength) {
+        process.env.NODE_ENV !== "production" && shared.warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_GET_CHOICE_INDEX));
+        return -1;
+      }
+    };
+    vueI18n.__extender = __extender;
+    if (process.env.NODE_ENV !== "production") {
+      vueI18n.__enableEmitter = (emitter) => {
+        const __composer = composer;
+        __composer[EnableEmitter] && __composer[EnableEmitter](emitter);
+      };
+      vueI18n.__disableEmitter = () => {
+        const __composer = composer;
+        __composer[DisableEmitter] && __composer[DisableEmitter]();
+      };
+    }
+    return vueI18n;
+  }
+}
+const baseFormatProps = {
+  tag: {
+    type: [String, Object]
+  },
+  locale: {
+    type: String
+  },
+  scope: {
+    type: String,
+    // NOTE: avoid https://github.com/microsoft/rushstack/issues/1050
+    validator: (val) => val === "parent" || val === "global",
+    default: "parent"
+    /* ComponentI18nScope */
+  },
+  i18n: {
+    type: Object
+  }
+};
+function getInterpolateArg({ slots }, keys) {
+  if (keys.length === 1 && keys[0] === "default") {
+    const ret = slots.default ? slots.default() : [];
+    return ret.reduce((slot, current) => {
+      return [
+        ...slot,
+        // prettier-ignore
+        ...current.type === Vue.Fragment ? current.children : [current]
+      ];
+    }, []);
+  } else {
+    return keys.reduce((arg, key) => {
+      const slot = slots[key];
+      if (slot) {
+        arg[key] = slot();
+      }
+      return arg;
+    }, {});
+  }
+}
+function getFragmentableTag(tag) {
+  return Vue.Fragment;
+}
+const TranslationImpl = /* @__PURE__ */ Vue.defineComponent({
+  /* eslint-disable */
+  name: "i18n-t",
+  props: shared.assign({
+    keypath: {
+      type: String,
+      required: true
+    },
+    plural: {
+      type: [Number, String],
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      validator: (val) => shared.isNumber(val) || !isNaN(val)
+    }
+  }, baseFormatProps),
+  /* eslint-enable */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setup(props, context) {
+    const { slots, attrs } = context;
+    const i18n = props.i18n || useI18n({
+      useScope: props.scope,
+      __useComponent: true
+    });
+    return () => {
+      const keys = Object.keys(slots).filter((key) => key !== "_");
+      const options = {};
+      if (props.locale) {
+        options.locale = props.locale;
+      }
+      if (props.plural !== void 0) {
+        options.plural = shared.isString(props.plural) ? +props.plural : props.plural;
+      }
+      const arg = getInterpolateArg(context, keys);
+      const children = i18n[TranslateVNodeSymbol](props.keypath, arg, options);
+      const assignedAttrs = shared.assign({}, attrs);
+      const tag = shared.isString(props.tag) || shared.isObject(props.tag) ? props.tag : getFragmentableTag();
+      return Vue.h(tag, assignedAttrs, children);
+    };
+  }
+});
+const Translation = TranslationImpl;
+function isVNode(target) {
+  return shared.isArray(target) && !shared.isString(target[0]);
+}
+function renderFormatter(props, context, slotKeys, partFormatter) {
+  const { slots, attrs } = context;
+  return () => {
+    const options = { part: true };
+    let overrides = {};
+    if (props.locale) {
+      options.locale = props.locale;
+    }
+    if (shared.isString(props.format)) {
+      options.key = props.format;
+    } else if (shared.isObject(props.format)) {
+      if (shared.isString(props.format.key)) {
+        options.key = props.format.key;
+      }
+      overrides = Object.keys(props.format).reduce((options2, prop) => {
+        return slotKeys.includes(prop) ? shared.assign({}, options2, { [prop]: props.format[prop] }) : options2;
+      }, {});
+    }
+    const parts = partFormatter(...[props.value, options, overrides]);
+    let children = [options.key];
+    if (shared.isArray(parts)) {
+      children = parts.map((part, index2) => {
+        const slot = slots[part.type];
+        const node = slot ? slot({ [part.type]: part.value, index: index2, parts }) : [part.value];
+        if (isVNode(node)) {
+          node[0].key = `${part.type}-${index2}`;
+        }
+        return node;
+      });
+    } else if (shared.isString(parts)) {
+      children = [parts];
+    }
+    const assignedAttrs = shared.assign({}, attrs);
+    const tag = shared.isString(props.tag) || shared.isObject(props.tag) ? props.tag : getFragmentableTag();
+    return Vue.h(tag, assignedAttrs, children);
+  };
+}
+const NumberFormatImpl = /* @__PURE__ */ Vue.defineComponent({
+  /* eslint-disable */
+  name: "i18n-n",
+  props: shared.assign({
+    value: {
+      type: Number,
+      required: true
+    },
+    format: {
+      type: [String, Object]
+    }
+  }, baseFormatProps),
+  /* eslint-enable */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setup(props, context) {
+    const i18n = props.i18n || useI18n({
+      useScope: props.scope,
+      __useComponent: true
+    });
+    return renderFormatter(props, context, coreBase.NUMBER_FORMAT_OPTIONS_KEYS, (...args) => (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      i18n[NumberPartsSymbol](...args)
+    ));
+  }
+});
+const NumberFormat = NumberFormatImpl;
+const DatetimeFormatImpl = /* @__PURE__ */ Vue.defineComponent({
+  /* eslint-disable */
+  name: "i18n-d",
+  props: shared.assign({
+    value: {
+      type: [Number, Date],
+      required: true
+    },
+    format: {
+      type: [String, Object]
+    }
+  }, baseFormatProps),
+  /* eslint-enable */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setup(props, context) {
+    const i18n = props.i18n || useI18n({
+      useScope: props.scope,
+      __useComponent: true
+    });
+    return renderFormatter(props, context, coreBase.DATETIME_FORMAT_OPTIONS_KEYS, (...args) => (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      i18n[DatetimePartsSymbol](...args)
+    ));
+  }
+});
+const DatetimeFormat = DatetimeFormatImpl;
+function getComposer$2(i18n, instance) {
+  const i18nInternal = i18n;
+  if (i18n.mode === "composition") {
+    return i18nInternal.__getInstance(instance) || i18n.global;
+  } else {
+    const vueI18n = i18nInternal.__getInstance(instance);
+    return vueI18n != null ? vueI18n.__composer : i18n.global.__composer;
+  }
+}
+function vTDirective(i18n) {
+  const _process = (binding) => {
+    const { instance, modifiers, value } = binding;
+    if (!instance || !instance.$) {
+      throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+    }
+    const composer = getComposer$2(i18n, instance.$);
+    if (process.env.NODE_ENV !== "production" && modifiers.preserve) {
+      shared.warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE));
+    }
+    const parsedValue = parseValue(value);
+    return [
+      Reflect.apply(composer.t, composer, [...makeParams(parsedValue)]),
+      composer
+    ];
+  };
+  const register = (el, binding) => {
+    const [textContent, composer] = _process(binding);
+    if (shared.inBrowser && i18n.global === composer) {
+      el.__i18nWatcher = Vue.watch(composer.locale, () => {
+        binding.instance && binding.instance.$forceUpdate();
+      });
+    }
+    el.__composer = composer;
+    el.textContent = textContent;
+  };
+  const unregister = (el) => {
+    if (shared.inBrowser && el.__i18nWatcher) {
+      el.__i18nWatcher();
+      el.__i18nWatcher = void 0;
+      delete el.__i18nWatcher;
+    }
+    if (el.__composer) {
+      el.__composer = void 0;
+      delete el.__composer;
+    }
+  };
+  const update = (el, { value }) => {
+    if (el.__composer) {
+      const composer = el.__composer;
+      const parsedValue = parseValue(value);
+      el.textContent = Reflect.apply(composer.t, composer, [
+        ...makeParams(parsedValue)
+      ]);
+    }
+  };
+  const getSSRProps = (binding) => {
+    const [textContent] = _process(binding);
+    return { textContent };
+  };
+  return {
+    created: register,
+    unmounted: unregister,
+    beforeUpdate: update,
+    getSSRProps
+  };
+}
+function parseValue(value) {
+  if (shared.isString(value)) {
+    return { path: value };
+  } else if (shared.isPlainObject(value)) {
+    if (!("path" in value)) {
+      throw createI18nError(I18nErrorCodes.REQUIRED_VALUE, "path");
+    }
+    return value;
+  } else {
+    throw createI18nError(I18nErrorCodes.INVALID_VALUE);
+  }
+}
+function makeParams(value) {
+  const { path, locale, args, choice, plural } = value;
+  const options = {};
+  const named = args || {};
+  if (shared.isString(locale)) {
+    options.locale = locale;
+  }
+  if (shared.isNumber(choice)) {
+    options.plural = choice;
+  }
+  if (shared.isNumber(plural)) {
+    options.plural = plural;
+  }
+  return [path, named, options];
+}
+function apply(app, i18n, ...options) {
+  const pluginOptions = shared.isPlainObject(options[0]) ? options[0] : {};
+  const useI18nComponentName = !!pluginOptions.useI18nComponentName;
+  const globalInstall = shared.isBoolean(pluginOptions.globalInstall) ? pluginOptions.globalInstall : true;
+  if (process.env.NODE_ENV !== "production" && globalInstall && useI18nComponentName) {
+    shared.warn(getWarnMessage(I18nWarnCodes.COMPONENT_NAME_LEGACY_COMPATIBLE, {
+      name: Translation.name
+    }));
+  }
+  if (globalInstall) {
+    [!useI18nComponentName ? Translation.name : "i18n", "I18nT"].forEach((name) => app.component(name, Translation));
+    [NumberFormat.name, "I18nN"].forEach((name) => app.component(name, NumberFormat));
+    [DatetimeFormat.name, "I18nD"].forEach((name) => app.component(name, DatetimeFormat));
+  }
+  {
+    app.directive("t", vTDirective(i18n));
+  }
+}
+const VueDevToolsLabels = {
+  [
+    "vue-devtools-plugin-vue-i18n"
+    /* VueDevToolsIDs.PLUGIN */
+  ]: "Vue I18n devtools",
+  [
+    "vue-i18n-resource-inspector"
+    /* VueDevToolsIDs.CUSTOM_INSPECTOR */
+  ]: "I18n Resources",
+  [
+    "vue-i18n-timeline"
+    /* VueDevToolsIDs.TIMELINE */
+  ]: "Vue I18n"
+};
+const VueDevToolsPlaceholders = {
+  [
+    "vue-i18n-resource-inspector"
+    /* VueDevToolsIDs.CUSTOM_INSPECTOR */
+  ]: "Search for scopes ..."
+};
+const VueDevToolsTimelineColors = {
+  [
+    "vue-i18n-timeline"
+    /* VueDevToolsIDs.TIMELINE */
+  ]: 16764185
+};
+const VUE_I18N_COMPONENT_TYPES = "vue-i18n: composer properties";
+let devtoolsApi;
+async function enableDevTools(app, i18n) {
+  return new Promise((resolve, reject) => {
+    try {
+      index.setupDevtoolsPlugin({
+        id: "vue-devtools-plugin-vue-i18n",
+        label: VueDevToolsLabels[
+          "vue-devtools-plugin-vue-i18n"
+          /* VueDevToolsIDs.PLUGIN */
+        ],
+        packageName: "vue-i18n",
+        homepage: "https://vue-i18n.intlify.dev",
+        logo: "https://vue-i18n.intlify.dev/vue-i18n-devtools-logo.png",
+        componentStateTypes: [VUE_I18N_COMPONENT_TYPES],
+        app
+        // eslint-disable-line @typescript-eslint/no-explicit-any
+      }, (api) => {
+        devtoolsApi = api;
+        api.on.visitComponentTree(({ componentInstance, treeNode }) => {
+          updateComponentTreeTags(componentInstance, treeNode, i18n);
+        });
+        api.on.inspectComponent(({ componentInstance, instanceData }) => {
+          if (componentInstance.vnode.el && componentInstance.vnode.el.__VUE_I18N__ && instanceData) {
+            if (i18n.mode === "legacy") {
+              if (componentInstance.vnode.el.__VUE_I18N__ !== i18n.global.__composer) {
+                inspectComposer(instanceData, componentInstance.vnode.el.__VUE_I18N__);
+              }
+            } else {
+              inspectComposer(instanceData, componentInstance.vnode.el.__VUE_I18N__);
+            }
+          }
+        });
+        api.addInspector({
+          id: "vue-i18n-resource-inspector",
+          label: VueDevToolsLabels[
+            "vue-i18n-resource-inspector"
+            /* VueDevToolsIDs.CUSTOM_INSPECTOR */
+          ],
+          icon: "language",
+          treeFilterPlaceholder: VueDevToolsPlaceholders[
+            "vue-i18n-resource-inspector"
+            /* VueDevToolsIDs.CUSTOM_INSPECTOR */
+          ]
+        });
+        api.on.getInspectorTree((payload) => {
+          if (payload.app === app && payload.inspectorId === "vue-i18n-resource-inspector") {
+            registerScope(payload, i18n);
+          }
+        });
+        const roots = /* @__PURE__ */ new Map();
+        api.on.getInspectorState(async (payload) => {
+          if (payload.app === app && payload.inspectorId === "vue-i18n-resource-inspector") {
+            api.unhighlightElement();
+            inspectScope(payload, i18n);
+            if (payload.nodeId === "global") {
+              if (!roots.has(payload.app)) {
+                const [root] = await api.getComponentInstances(payload.app);
+                roots.set(payload.app, root);
+              }
+              api.highlightElement(roots.get(payload.app));
+            } else {
+              const instance = getComponentInstance(payload.nodeId, i18n);
+              instance && api.highlightElement(instance);
+            }
+          }
+        });
+        api.on.editInspectorState((payload) => {
+          if (payload.app === app && payload.inspectorId === "vue-i18n-resource-inspector") {
+            editScope(payload, i18n);
+          }
+        });
+        api.addTimelineLayer({
+          id: "vue-i18n-timeline",
+          label: VueDevToolsLabels[
+            "vue-i18n-timeline"
+            /* VueDevToolsIDs.TIMELINE */
+          ],
+          color: VueDevToolsTimelineColors[
+            "vue-i18n-timeline"
+            /* VueDevToolsIDs.TIMELINE */
+          ]
+        });
+        resolve(true);
+      });
+    } catch (e) {
+      console.error(e);
+      reject(false);
+    }
+  });
+}
+function getI18nScopeLable(instance) {
+  return instance.type.name || instance.type.displayName || instance.type.__file || "Anonymous";
+}
+function updateComponentTreeTags(instance, treeNode, i18n) {
+  const global = i18n.mode === "composition" ? i18n.global : i18n.global.__composer;
+  if (instance && instance.vnode.el && instance.vnode.el.__VUE_I18N__) {
+    if (instance.vnode.el.__VUE_I18N__ !== global) {
+      const tag = {
+        label: `i18n (${getI18nScopeLable(instance)} Scope)`,
+        textColor: 0,
+        backgroundColor: 16764185
+      };
+      treeNode.tags.push(tag);
+    }
+  }
+}
+function inspectComposer(instanceData, composer) {
+  const type = VUE_I18N_COMPONENT_TYPES;
+  instanceData.state.push({
+    type,
+    key: "locale",
+    editable: true,
+    value: composer.locale.value
+  });
+  instanceData.state.push({
+    type,
+    key: "availableLocales",
+    editable: false,
+    value: composer.availableLocales
+  });
+  instanceData.state.push({
+    type,
+    key: "fallbackLocale",
+    editable: true,
+    value: composer.fallbackLocale.value
+  });
+  instanceData.state.push({
+    type,
+    key: "inheritLocale",
+    editable: true,
+    value: composer.inheritLocale
+  });
+  instanceData.state.push({
+    type,
+    key: "messages",
+    editable: false,
+    value: getLocaleMessageValue(composer.messages.value)
+  });
+  {
+    instanceData.state.push({
+      type,
+      key: "datetimeFormats",
+      editable: false,
+      value: composer.datetimeFormats.value
+    });
+    instanceData.state.push({
+      type,
+      key: "numberFormats",
+      editable: false,
+      value: composer.numberFormats.value
+    });
+  }
+}
+function getLocaleMessageValue(messages) {
+  const value = {};
+  Object.keys(messages).forEach((key) => {
+    const v = messages[key];
+    if (shared.isFunction(v) && "source" in v) {
+      value[key] = getMessageFunctionDetails(v);
+    } else if (coreBase.isMessageAST(v) && v.loc && v.loc.source) {
+      value[key] = v.loc.source;
+    } else if (shared.isObject(v)) {
+      value[key] = getLocaleMessageValue(v);
+    } else {
+      value[key] = v;
+    }
+  });
+  return value;
+}
+const ESC = {
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "&": "&amp;"
+};
+function escape(s) {
+  return s.replace(/[<>"&]/g, escapeChar);
+}
+function escapeChar(a) {
+  return ESC[a] || a;
+}
+function getMessageFunctionDetails(func) {
+  const argString = func.source ? `("${escape(func.source)}")` : `(?)`;
+  return {
+    _custom: {
+      type: "function",
+      display: `<span>ƒ</span> ${argString}`
+    }
+  };
+}
+function registerScope(payload, i18n) {
+  payload.rootNodes.push({
+    id: "global",
+    label: "Global Scope"
+  });
+  const global = i18n.mode === "composition" ? i18n.global : i18n.global.__composer;
+  for (const [keyInstance, instance] of i18n.__instances) {
+    const composer = i18n.mode === "composition" ? instance : instance.__composer;
+    if (global === composer) {
+      continue;
+    }
+    payload.rootNodes.push({
+      id: composer.id.toString(),
+      label: `${getI18nScopeLable(keyInstance)} Scope`
+    });
+  }
+}
+function getComponentInstance(nodeId, i18n) {
+  let instance = null;
+  if (nodeId !== "global") {
+    for (const [component, composer] of i18n.__instances.entries()) {
+      if (composer.id.toString() === nodeId) {
+        instance = component;
+        break;
+      }
+    }
+  }
+  return instance;
+}
+function getComposer$1(nodeId, i18n) {
+  if (nodeId === "global") {
+    return i18n.mode === "composition" ? i18n.global : i18n.global.__composer;
+  } else {
+    const instance = Array.from(i18n.__instances.values()).find((item) => item.id.toString() === nodeId);
+    if (instance) {
+      return i18n.mode === "composition" ? instance : instance.__composer;
+    } else {
+      return null;
+    }
+  }
+}
+function inspectScope(payload, i18n) {
+  const composer = getComposer$1(payload.nodeId, i18n);
+  if (composer) {
+    payload.state = makeScopeInspectState(composer);
+  }
+  return null;
+}
+function makeScopeInspectState(composer) {
+  const state = {};
+  const localeType = "Locale related info";
+  const localeStates = [
+    {
+      type: localeType,
+      key: "locale",
+      editable: true,
+      value: composer.locale.value
+    },
+    {
+      type: localeType,
+      key: "fallbackLocale",
+      editable: true,
+      value: composer.fallbackLocale.value
+    },
+    {
+      type: localeType,
+      key: "availableLocales",
+      editable: false,
+      value: composer.availableLocales
+    },
+    {
+      type: localeType,
+      key: "inheritLocale",
+      editable: true,
+      value: composer.inheritLocale
+    }
+  ];
+  state[localeType] = localeStates;
+  const localeMessagesType = "Locale messages info";
+  const localeMessagesStates = [
+    {
+      type: localeMessagesType,
+      key: "messages",
+      editable: false,
+      value: getLocaleMessageValue(composer.messages.value)
+    }
+  ];
+  state[localeMessagesType] = localeMessagesStates;
+  {
+    const datetimeFormatsType = "Datetime formats info";
+    const datetimeFormatsStates = [
+      {
+        type: datetimeFormatsType,
+        key: "datetimeFormats",
+        editable: false,
+        value: composer.datetimeFormats.value
+      }
+    ];
+    state[datetimeFormatsType] = datetimeFormatsStates;
+    const numberFormatsType = "Datetime formats info";
+    const numberFormatsStates = [
+      {
+        type: numberFormatsType,
+        key: "numberFormats",
+        editable: false,
+        value: composer.numberFormats.value
+      }
+    ];
+    state[numberFormatsType] = numberFormatsStates;
+  }
+  return state;
+}
+function addTimelineEvent(event, payload) {
+  if (devtoolsApi) {
+    let groupId;
+    if (payload && "groupId" in payload) {
+      groupId = payload.groupId;
+      delete payload.groupId;
+    }
+    devtoolsApi.addTimelineEvent({
+      layerId: "vue-i18n-timeline",
+      event: {
+        title: event,
+        groupId,
+        time: Date.now(),
+        meta: {},
+        data: payload || {},
+        logType: event === "compile-error" ? "error" : event === "fallback" || event === "missing" ? "warning" : "default"
+      }
+    });
+  }
+}
+function editScope(payload, i18n) {
+  const composer = getComposer$1(payload.nodeId, i18n);
+  if (composer) {
+    const [field] = payload.path;
+    if (field === "locale" && shared.isString(payload.state.value)) {
+      composer.locale.value = payload.state.value;
+    } else if (field === "fallbackLocale" && (shared.isString(payload.state.value) || shared.isArray(payload.state.value) || shared.isObject(payload.state.value))) {
+      composer.fallbackLocale.value = payload.state.value;
+    } else if (field === "inheritLocale" && shared.isBoolean(payload.state.value)) {
+      composer.inheritLocale = payload.state.value;
+    }
+  }
+}
+function defineMixin(vuei18n, composer, i18n) {
+  return {
+    beforeCreate() {
+      const instance = Vue.getCurrentInstance();
+      if (!instance) {
+        throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+      }
+      const options = this.$options;
+      if (options.i18n) {
+        const optionsI18n = options.i18n;
+        if (options.__i18n) {
+          optionsI18n.__i18n = options.__i18n;
+        }
+        optionsI18n.__root = composer;
+        if (this === this.$root) {
+          this.$i18n = mergeToGlobal(vuei18n, optionsI18n);
+        } else {
+          optionsI18n.__injectWithOption = true;
+          optionsI18n.__extender = i18n.__vueI18nExtend;
+          this.$i18n = createVueI18n(optionsI18n);
+          const _vueI18n = this.$i18n;
+          if (_vueI18n.__extender) {
+            _vueI18n.__disposer = _vueI18n.__extender(this.$i18n);
+          }
+        }
+      } else if (options.__i18n) {
+        if (this === this.$root) {
+          this.$i18n = mergeToGlobal(vuei18n, options);
+        } else {
+          this.$i18n = createVueI18n({
+            __i18n: options.__i18n,
+            __injectWithOption: true,
+            __extender: i18n.__vueI18nExtend,
+            __root: composer
+          });
+          const _vueI18n = this.$i18n;
+          if (_vueI18n.__extender) {
+            _vueI18n.__disposer = _vueI18n.__extender(this.$i18n);
+          }
+        }
+      } else {
+        this.$i18n = vuei18n;
+      }
+      if (options.__i18nGlobal) {
+        adjustI18nResources(composer, options, options);
+      }
+      this.$t = (...args) => this.$i18n.t(...args);
+      this.$rt = (...args) => this.$i18n.rt(...args);
+      this.$tc = (...args) => this.$i18n.tc(...args);
+      this.$te = (key, locale) => this.$i18n.te(key, locale);
+      this.$d = (...args) => this.$i18n.d(...args);
+      this.$n = (...args) => this.$i18n.n(...args);
+      this.$tm = (key) => this.$i18n.tm(key);
+      i18n.__setInstance(instance, this.$i18n);
+    },
+    mounted() {
+      if ((process.env.NODE_ENV !== "production" || false) && true && this.$el && this.$i18n) {
+        const _vueI18n = this.$i18n;
+        this.$el.__VUE_I18N__ = _vueI18n.__composer;
+        const emitter = this.__v_emitter = shared.createEmitter();
+        _vueI18n.__enableEmitter && _vueI18n.__enableEmitter(emitter);
+        emitter.on("*", addTimelineEvent);
+      }
+    },
+    unmounted() {
+      const instance = Vue.getCurrentInstance();
+      if (!instance) {
+        throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+      }
+      const _vueI18n = this.$i18n;
+      if ((process.env.NODE_ENV !== "production" || false) && true && this.$el && this.$el.__VUE_I18N__) {
+        if (this.__v_emitter) {
+          this.__v_emitter.off("*", addTimelineEvent);
+          delete this.__v_emitter;
+        }
+        if (this.$i18n) {
+          _vueI18n.__disableEmitter && _vueI18n.__disableEmitter();
+          delete this.$el.__VUE_I18N__;
+        }
+      }
+      delete this.$t;
+      delete this.$rt;
+      delete this.$tc;
+      delete this.$te;
+      delete this.$d;
+      delete this.$n;
+      delete this.$tm;
+      if (_vueI18n.__disposer) {
+        _vueI18n.__disposer();
+        delete _vueI18n.__disposer;
+        delete _vueI18n.__extender;
+      }
+      i18n.__deleteInstance(instance);
+      delete this.$i18n;
+    }
+  };
+}
+function mergeToGlobal(g, options) {
+  g.locale = options.locale || g.locale;
+  g.fallbackLocale = options.fallbackLocale || g.fallbackLocale;
+  g.missing = options.missing || g.missing;
+  g.silentTranslationWarn = options.silentTranslationWarn || g.silentFallbackWarn;
+  g.silentFallbackWarn = options.silentFallbackWarn || g.silentFallbackWarn;
+  g.formatFallbackMessages = options.formatFallbackMessages || g.formatFallbackMessages;
+  g.postTranslation = options.postTranslation || g.postTranslation;
+  g.warnHtmlInMessage = options.warnHtmlInMessage || g.warnHtmlInMessage;
+  g.escapeParameterHtml = options.escapeParameterHtml || g.escapeParameterHtml;
+  g.sync = options.sync || g.sync;
+  g.__composer[SetPluralRulesSymbol](options.pluralizationRules || g.pluralizationRules);
+  const messages = getLocaleMessages(g.locale, {
+    messages: options.messages,
+    __i18n: options.__i18n
+  });
+  Object.keys(messages).forEach((locale) => g.mergeLocaleMessage(locale, messages[locale]));
+  if (options.datetimeFormats) {
+    Object.keys(options.datetimeFormats).forEach((locale) => g.mergeDateTimeFormat(locale, options.datetimeFormats[locale]));
+  }
+  if (options.numberFormats) {
+    Object.keys(options.numberFormats).forEach((locale) => g.mergeNumberFormat(locale, options.numberFormats[locale]));
+  }
+  return g;
+}
+const I18nInjectionKey = /* @__PURE__ */ shared.makeSymbol("global-vue-i18n");
+function createI18n(options = {}, VueI18nLegacy) {
+  const __legacyMode = __VUE_I18N_LEGACY_API__ && shared.isBoolean(options.legacy) ? options.legacy : __VUE_I18N_LEGACY_API__;
+  const __globalInjection = shared.isBoolean(options.globalInjection) ? options.globalInjection : true;
+  const __allowComposition = __VUE_I18N_LEGACY_API__ && __legacyMode ? !!options.allowComposition : true;
+  const __instances = /* @__PURE__ */ new Map();
+  const [globalScope, __global] = createGlobal(options, __legacyMode);
+  const symbol = /* @__PURE__ */ shared.makeSymbol(process.env.NODE_ENV !== "production" ? "vue-i18n" : "");
+  if (process.env.NODE_ENV !== "production") {
+    if (__legacyMode && __allowComposition && true) {
+      shared.warn(getWarnMessage(I18nWarnCodes.NOTICE_DROP_ALLOW_COMPOSITION));
+    }
+  }
+  function __getInstance(component) {
+    return __instances.get(component) || null;
+  }
+  function __setInstance(component, instance) {
+    __instances.set(component, instance);
+  }
+  function __deleteInstance(component) {
+    __instances.delete(component);
+  }
+  {
+    const i18n = {
+      // mode
+      get mode() {
+        return __VUE_I18N_LEGACY_API__ && __legacyMode ? "legacy" : "composition";
+      },
+      // allowComposition
+      get allowComposition() {
+        return __allowComposition;
+      },
+      // install plugin
+      async install(app, ...options2) {
+        if ((process.env.NODE_ENV !== "production" || false) && true) {
+          app.__VUE_I18N__ = i18n;
+        }
+        app.__VUE_I18N_SYMBOL__ = symbol;
+        app.provide(app.__VUE_I18N_SYMBOL__, i18n);
+        if (shared.isPlainObject(options2[0])) {
+          const opts = options2[0];
+          i18n.__composerExtend = opts.__composerExtend;
+          i18n.__vueI18nExtend = opts.__vueI18nExtend;
+        }
+        let globalReleaseHandler = null;
+        if (!__legacyMode && __globalInjection) {
+          globalReleaseHandler = injectGlobalFields(app, i18n.global);
+        }
+        if (__VUE_I18N_FULL_INSTALL__) {
+          apply(app, i18n, ...options2);
+        }
+        if (__VUE_I18N_LEGACY_API__ && __legacyMode) {
+          app.mixin(defineMixin(__global, __global.__composer, i18n));
+        }
+        const unmountApp = app.unmount;
+        app.unmount = () => {
+          globalReleaseHandler && globalReleaseHandler();
+          i18n.dispose();
+          unmountApp();
+        };
+        if ((process.env.NODE_ENV !== "production" || false) && true) {
+          const ret = await enableDevTools(app, i18n);
+          if (!ret) {
+            throw createI18nError(I18nErrorCodes.CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN);
+          }
+          const emitter = shared.createEmitter();
+          if (__legacyMode) {
+            const _vueI18n = __global;
+            _vueI18n.__enableEmitter && _vueI18n.__enableEmitter(emitter);
+          } else {
+            const _composer = __global;
+            _composer[EnableEmitter] && _composer[EnableEmitter](emitter);
+          }
+          emitter.on("*", addTimelineEvent);
+        }
+      },
+      // global accessor
+      get global() {
+        return __global;
+      },
+      dispose() {
+        globalScope.stop();
+      },
+      // @internal
+      __instances,
+      // @internal
+      __getInstance,
+      // @internal
+      __setInstance,
+      // @internal
+      __deleteInstance
+    };
+    return i18n;
+  }
+}
+function useI18n(options = {}) {
+  const instance = Vue.getCurrentInstance();
+  if (instance == null) {
+    throw createI18nError(I18nErrorCodes.MUST_BE_CALL_SETUP_TOP);
+  }
+  if (!instance.isCE && instance.appContext.app != null && !instance.appContext.app.__VUE_I18N_SYMBOL__) {
+    throw createI18nError(I18nErrorCodes.NOT_INSTALLED);
+  }
+  const i18n = getI18nInstance(instance);
+  const gl = getGlobalComposer(i18n);
+  const componentOptions = getComponentOptions(instance);
+  const scope = getScope(options, componentOptions);
+  if (__VUE_I18N_LEGACY_API__) {
+    if (i18n.mode === "legacy" && !options.__useComponent) {
+      if (!i18n.allowComposition) {
+        throw createI18nError(I18nErrorCodes.NOT_AVAILABLE_IN_LEGACY_MODE);
+      }
+      return useI18nForLegacy(instance, scope, gl, options);
+    }
+  }
+  if (scope === "global") {
+    adjustI18nResources(gl, options, componentOptions);
+    return gl;
+  }
+  if (scope === "parent") {
+    let composer2 = getComposer(i18n, instance, options.__useComponent);
+    if (composer2 == null) {
+      if (process.env.NODE_ENV !== "production") {
+        shared.warn(getWarnMessage(I18nWarnCodes.NOT_FOUND_PARENT_SCOPE));
+      }
+      composer2 = gl;
+    }
+    return composer2;
+  }
+  const i18nInternal = i18n;
+  let composer = i18nInternal.__getInstance(instance);
+  if (composer == null) {
+    const composerOptions = shared.assign({}, options);
+    if ("__i18n" in componentOptions) {
+      composerOptions.__i18n = componentOptions.__i18n;
+    }
+    if (gl) {
+      composerOptions.__root = gl;
+    }
+    composer = createComposer(composerOptions);
+    if (i18nInternal.__composerExtend) {
+      composer[DisposeSymbol] = i18nInternal.__composerExtend(composer);
+    }
+    setupLifeCycle(i18nInternal, instance, composer);
+    i18nInternal.__setInstance(instance, composer);
+  }
+  return composer;
+}
+function createGlobal(options, legacyMode, VueI18nLegacy) {
+  const scope = Vue.effectScope();
+  {
+    const obj = __VUE_I18N_LEGACY_API__ && legacyMode ? scope.run(() => createVueI18n(options)) : scope.run(() => createComposer(options));
+    if (obj == null) {
+      throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+    }
+    return [scope, obj];
+  }
+}
+function getI18nInstance(instance) {
+  {
+    const i18n = Vue.inject(!instance.isCE ? instance.appContext.app.__VUE_I18N_SYMBOL__ : I18nInjectionKey);
+    if (!i18n) {
+      throw createI18nError(!instance.isCE ? I18nErrorCodes.UNEXPECTED_ERROR : I18nErrorCodes.NOT_INSTALLED_WITH_PROVIDE);
+    }
+    return i18n;
+  }
+}
+function getScope(options, componentOptions) {
+  return shared.isEmptyObject(options) ? "__i18n" in componentOptions ? "local" : "global" : !options.useScope ? "local" : options.useScope;
+}
+function getGlobalComposer(i18n) {
+  return i18n.mode === "composition" ? i18n.global : i18n.global.__composer;
+}
+function getComposer(i18n, target, useComponent = false) {
+  let composer = null;
+  const root = target.root;
+  let current = getParentComponentInstance(target, useComponent);
+  while (current != null) {
+    const i18nInternal = i18n;
+    if (i18n.mode === "composition") {
+      composer = i18nInternal.__getInstance(current);
+    } else {
+      if (__VUE_I18N_LEGACY_API__) {
+        const vueI18n = i18nInternal.__getInstance(current);
+        if (vueI18n != null) {
+          composer = vueI18n.__composer;
+          if (useComponent && composer && !composer[InejctWithOptionSymbol]) {
+            composer = null;
+          }
+        }
+      }
+    }
+    if (composer != null) {
+      break;
+    }
+    if (root === current) {
+      break;
+    }
+    current = current.parent;
+  }
+  return composer;
+}
+function getParentComponentInstance(target, useComponent = false) {
+  if (target == null) {
+    return null;
+  }
+  {
+    return !useComponent ? target.parent : target.vnode.ctx || target.parent;
+  }
+}
+function setupLifeCycle(i18n, target, composer) {
+  let emitter = null;
+  {
+    Vue.onMounted(() => {
+      if ((process.env.NODE_ENV !== "production" || false) && true && target.vnode.el) {
+        target.vnode.el.__VUE_I18N__ = composer;
+        emitter = shared.createEmitter();
+        const _composer = composer;
+        _composer[EnableEmitter] && _composer[EnableEmitter](emitter);
+        emitter.on("*", addTimelineEvent);
+      }
+    }, target);
+    Vue.onUnmounted(() => {
+      const _composer = composer;
+      if ((process.env.NODE_ENV !== "production" || false) && true && target.vnode.el && target.vnode.el.__VUE_I18N__) {
+        emitter && emitter.off("*", addTimelineEvent);
+        _composer[DisableEmitter] && _composer[DisableEmitter]();
+        delete target.vnode.el.__VUE_I18N__;
+      }
+      i18n.__deleteInstance(target);
+      const dispose = _composer[DisposeSymbol];
+      if (dispose) {
+        dispose();
+        delete _composer[DisposeSymbol];
+      }
+    }, target);
+  }
+}
+function useI18nForLegacy(instance, scope, root, options = {}) {
+  const isLocalScope = scope === "local";
+  const _composer = Vue.shallowRef(null);
+  if (isLocalScope && instance.proxy && !(instance.proxy.$options.i18n || instance.proxy.$options.__i18n)) {
+    throw createI18nError(I18nErrorCodes.MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION);
+  }
+  const _inheritLocale = shared.isBoolean(options.inheritLocale) ? options.inheritLocale : !shared.isString(options.locale);
+  const _locale = Vue.ref(
+    // prettier-ignore
+    !isLocalScope || _inheritLocale ? root.locale.value : shared.isString(options.locale) ? options.locale : coreBase.DEFAULT_LOCALE
+  );
+  const _fallbackLocale = Vue.ref(
+    // prettier-ignore
+    !isLocalScope || _inheritLocale ? root.fallbackLocale.value : shared.isString(options.fallbackLocale) || shared.isArray(options.fallbackLocale) || shared.isPlainObject(options.fallbackLocale) || options.fallbackLocale === false ? options.fallbackLocale : _locale.value
+  );
+  const _messages = Vue.ref(getLocaleMessages(_locale.value, options));
+  const _datetimeFormats = Vue.ref(shared.isPlainObject(options.datetimeFormats) ? options.datetimeFormats : { [_locale.value]: {} });
+  const _numberFormats = Vue.ref(shared.isPlainObject(options.numberFormats) ? options.numberFormats : { [_locale.value]: {} });
+  const _missingWarn = isLocalScope ? root.missingWarn : shared.isBoolean(options.missingWarn) || shared.isRegExp(options.missingWarn) ? options.missingWarn : true;
+  const _fallbackWarn = isLocalScope ? root.fallbackWarn : shared.isBoolean(options.fallbackWarn) || shared.isRegExp(options.fallbackWarn) ? options.fallbackWarn : true;
+  const _fallbackRoot = isLocalScope ? root.fallbackRoot : shared.isBoolean(options.fallbackRoot) ? options.fallbackRoot : true;
+  const _fallbackFormat = !!options.fallbackFormat;
+  const _missing = shared.isFunction(options.missing) ? options.missing : null;
+  const _postTranslation = shared.isFunction(options.postTranslation) ? options.postTranslation : null;
+  const _warnHtmlMessage = isLocalScope ? root.warnHtmlMessage : shared.isBoolean(options.warnHtmlMessage) ? options.warnHtmlMessage : true;
+  const _escapeParameter = !!options.escapeParameter;
+  const _modifiers = isLocalScope ? root.modifiers : shared.isPlainObject(options.modifiers) ? options.modifiers : {};
+  const _pluralRules = options.pluralRules || isLocalScope && root.pluralRules;
+  function trackReactivityValues() {
+    return [
+      _locale.value,
+      _fallbackLocale.value,
+      _messages.value,
+      _datetimeFormats.value,
+      _numberFormats.value
+    ];
+  }
+  const locale = Vue.computed({
+    get: () => {
+      return _composer.value ? _composer.value.locale.value : _locale.value;
+    },
+    set: (val) => {
+      if (_composer.value) {
+        _composer.value.locale.value = val;
+      }
+      _locale.value = val;
+    }
+  });
+  const fallbackLocale = Vue.computed({
+    get: () => {
+      return _composer.value ? _composer.value.fallbackLocale.value : _fallbackLocale.value;
+    },
+    set: (val) => {
+      if (_composer.value) {
+        _composer.value.fallbackLocale.value = val;
+      }
+      _fallbackLocale.value = val;
+    }
+  });
+  const messages = Vue.computed(() => {
+    if (_composer.value) {
+      return _composer.value.messages.value;
+    } else {
+      return _messages.value;
+    }
+  });
+  const datetimeFormats = Vue.computed(() => _datetimeFormats.value);
+  const numberFormats = Vue.computed(() => _numberFormats.value);
+  function getPostTranslationHandler() {
+    return _composer.value ? _composer.value.getPostTranslationHandler() : _postTranslation;
+  }
+  function setPostTranslationHandler(handler) {
+    if (_composer.value) {
+      _composer.value.setPostTranslationHandler(handler);
+    }
+  }
+  function getMissingHandler() {
+    return _composer.value ? _composer.value.getMissingHandler() : _missing;
+  }
+  function setMissingHandler(handler) {
+    if (_composer.value) {
+      _composer.value.setMissingHandler(handler);
+    }
+  }
+  function warpWithDeps(fn) {
+    trackReactivityValues();
+    return fn();
+  }
+  function t(...args) {
+    return _composer.value ? warpWithDeps(() => Reflect.apply(_composer.value.t, null, [...args])) : warpWithDeps(() => "");
+  }
+  function rt(...args) {
+    return _composer.value ? Reflect.apply(_composer.value.rt, null, [...args]) : "";
+  }
+  function d(...args) {
+    return _composer.value ? warpWithDeps(() => Reflect.apply(_composer.value.d, null, [...args])) : warpWithDeps(() => "");
+  }
+  function n(...args) {
+    return _composer.value ? warpWithDeps(() => Reflect.apply(_composer.value.n, null, [...args])) : warpWithDeps(() => "");
+  }
+  function tm(key) {
+    return _composer.value ? _composer.value.tm(key) : {};
+  }
+  function te(key, locale2) {
+    return _composer.value ? _composer.value.te(key, locale2) : false;
+  }
+  function getLocaleMessage(locale2) {
+    return _composer.value ? _composer.value.getLocaleMessage(locale2) : {};
+  }
+  function setLocaleMessage(locale2, message) {
+    if (_composer.value) {
+      _composer.value.setLocaleMessage(locale2, message);
+      _messages.value[locale2] = message;
+    }
+  }
+  function mergeLocaleMessage(locale2, message) {
+    if (_composer.value) {
+      _composer.value.mergeLocaleMessage(locale2, message);
+    }
+  }
+  function getDateTimeFormat(locale2) {
+    return _composer.value ? _composer.value.getDateTimeFormat(locale2) : {};
+  }
+  function setDateTimeFormat(locale2, format2) {
+    if (_composer.value) {
+      _composer.value.setDateTimeFormat(locale2, format2);
+      _datetimeFormats.value[locale2] = format2;
+    }
+  }
+  function mergeDateTimeFormat(locale2, format2) {
+    if (_composer.value) {
+      _composer.value.mergeDateTimeFormat(locale2, format2);
+    }
+  }
+  function getNumberFormat(locale2) {
+    return _composer.value ? _composer.value.getNumberFormat(locale2) : {};
+  }
+  function setNumberFormat(locale2, format2) {
+    if (_composer.value) {
+      _composer.value.setNumberFormat(locale2, format2);
+      _numberFormats.value[locale2] = format2;
+    }
+  }
+  function mergeNumberFormat(locale2, format2) {
+    if (_composer.value) {
+      _composer.value.mergeNumberFormat(locale2, format2);
+    }
+  }
+  const wrapper = {
+    get id() {
+      return _composer.value ? _composer.value.id : -1;
+    },
+    locale,
+    fallbackLocale,
+    messages,
+    datetimeFormats,
+    numberFormats,
+    get inheritLocale() {
+      return _composer.value ? _composer.value.inheritLocale : _inheritLocale;
+    },
+    set inheritLocale(val) {
+      if (_composer.value) {
+        _composer.value.inheritLocale = val;
+      }
+    },
+    get availableLocales() {
+      return _composer.value ? _composer.value.availableLocales : Object.keys(_messages.value);
+    },
+    get modifiers() {
+      return _composer.value ? _composer.value.modifiers : _modifiers;
+    },
+    get pluralRules() {
+      return _composer.value ? _composer.value.pluralRules : _pluralRules;
+    },
+    get isGlobal() {
+      return _composer.value ? _composer.value.isGlobal : false;
+    },
+    get missingWarn() {
+      return _composer.value ? _composer.value.missingWarn : _missingWarn;
+    },
+    set missingWarn(val) {
+      if (_composer.value) {
+        _composer.value.missingWarn = val;
+      }
+    },
+    get fallbackWarn() {
+      return _composer.value ? _composer.value.fallbackWarn : _fallbackWarn;
+    },
+    set fallbackWarn(val) {
+      if (_composer.value) {
+        _composer.value.missingWarn = val;
+      }
+    },
+    get fallbackRoot() {
+      return _composer.value ? _composer.value.fallbackRoot : _fallbackRoot;
+    },
+    set fallbackRoot(val) {
+      if (_composer.value) {
+        _composer.value.fallbackRoot = val;
+      }
+    },
+    get fallbackFormat() {
+      return _composer.value ? _composer.value.fallbackFormat : _fallbackFormat;
+    },
+    set fallbackFormat(val) {
+      if (_composer.value) {
+        _composer.value.fallbackFormat = val;
+      }
+    },
+    get warnHtmlMessage() {
+      return _composer.value ? _composer.value.warnHtmlMessage : _warnHtmlMessage;
+    },
+    set warnHtmlMessage(val) {
+      if (_composer.value) {
+        _composer.value.warnHtmlMessage = val;
+      }
+    },
+    get escapeParameter() {
+      return _composer.value ? _composer.value.escapeParameter : _escapeParameter;
+    },
+    set escapeParameter(val) {
+      if (_composer.value) {
+        _composer.value.escapeParameter = val;
+      }
+    },
+    t,
+    getPostTranslationHandler,
+    setPostTranslationHandler,
+    getMissingHandler,
+    setMissingHandler,
+    rt,
+    d,
+    n,
+    tm,
+    te,
+    getLocaleMessage,
+    setLocaleMessage,
+    mergeLocaleMessage,
+    getDateTimeFormat,
+    setDateTimeFormat,
+    mergeDateTimeFormat,
+    getNumberFormat,
+    setNumberFormat,
+    mergeNumberFormat
+  };
+  function sync(composer) {
+    composer.locale.value = _locale.value;
+    composer.fallbackLocale.value = _fallbackLocale.value;
+    Object.keys(_messages.value).forEach((locale2) => {
+      composer.mergeLocaleMessage(locale2, _messages.value[locale2]);
+    });
+    Object.keys(_datetimeFormats.value).forEach((locale2) => {
+      composer.mergeDateTimeFormat(locale2, _datetimeFormats.value[locale2]);
+    });
+    Object.keys(_numberFormats.value).forEach((locale2) => {
+      composer.mergeNumberFormat(locale2, _numberFormats.value[locale2]);
+    });
+    composer.escapeParameter = _escapeParameter;
+    composer.fallbackFormat = _fallbackFormat;
+    composer.fallbackRoot = _fallbackRoot;
+    composer.fallbackWarn = _fallbackWarn;
+    composer.missingWarn = _missingWarn;
+    composer.warnHtmlMessage = _warnHtmlMessage;
+  }
+  Vue.onBeforeMount(() => {
+    if (instance.proxy == null || instance.proxy.$i18n == null) {
+      throw createI18nError(I18nErrorCodes.NOT_AVAILABLE_COMPOSITION_IN_LEGACY);
+    }
+    const composer = _composer.value = instance.proxy.$i18n.__composer;
+    if (scope === "global") {
+      _locale.value = composer.locale.value;
+      _fallbackLocale.value = composer.fallbackLocale.value;
+      _messages.value = composer.messages.value;
+      _datetimeFormats.value = composer.datetimeFormats.value;
+      _numberFormats.value = composer.numberFormats.value;
+    } else if (isLocalScope) {
+      sync(composer);
+    }
+  });
+  return wrapper;
+}
+const globalExportProps = [
+  "locale",
+  "fallbackLocale",
+  "availableLocales"
+];
+const globalExportMethods = ["t", "rt", "d", "n", "tm", "te"];
+function injectGlobalFields(app, composer) {
+  const i18n = /* @__PURE__ */ Object.create(null);
+  globalExportProps.forEach((prop) => {
+    const desc = Object.getOwnPropertyDescriptor(composer, prop);
+    if (!desc) {
+      throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+    }
+    const wrap = Vue.isRef(desc.value) ? {
+      get() {
+        return desc.value.value;
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      set(val) {
+        desc.value.value = val;
+      }
+    } : {
+      get() {
+        return desc.get && desc.get();
+      }
+    };
+    Object.defineProperty(i18n, prop, wrap);
+  });
+  app.config.globalProperties.$i18n = i18n;
+  globalExportMethods.forEach((method) => {
+    const desc = Object.getOwnPropertyDescriptor(composer, method);
+    if (!desc || !desc.value) {
+      throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+    }
+    Object.defineProperty(app.config.globalProperties, `$${method}`, desc);
+  });
+  const dispose = () => {
+    delete app.config.globalProperties.$i18n;
+    globalExportMethods.forEach((method) => {
+      delete app.config.globalProperties[`$${method}`];
+    });
+  };
+  return dispose;
+}
+{
+  initFeatureFlags();
+}
+if (__INTLIFY_JIT_COMPILATION__) {
+  coreBase.registerMessageCompiler(coreBase.compile);
+} else {
+  coreBase.registerMessageCompiler(coreBase.compileToFunction);
+}
+coreBase.registerMessageResolver(coreBase.resolveValue);
+coreBase.registerLocaleFallbacker(coreBase.fallbackWithLocaleChain);
+if (process.env.NODE_ENV !== "production" || __INTLIFY_PROD_DEVTOOLS__) {
+  const target = shared.getGlobalThis();
+  target.__INTLIFY__ = true;
+  coreBase.setDevToolsHook(target.__INTLIFY_DEVTOOLS_GLOBAL_HOOK__);
+}
+if (process.env.NODE_ENV !== "production") ;
+exports.DatetimeFormat = DatetimeFormat;
+exports.I18nInjectionKey = I18nInjectionKey;
+exports.NumberFormat = NumberFormat;
+exports.Translation = Translation;
+exports.VERSION = VERSION;
+exports.createI18n = createI18n;
+exports.useI18n = useI18n;
+exports.vTDirective = vTDirective;