初始化

uni_modules/UniDevTools/node_modules/vue-i18n/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 kazuya kawaguchi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

uni_modules/UniDevTools/node_modules/vue-i18n/README.md

@@ -0,0 +1,68 @@
+# vue-i18n
+
+Internationalization plugin for Vue.js
+
+## Which dist file to use?
+
+### From CDN or without a Bundler
+
+- **`vue-i18n(.runtime).global(.prod).js`**:
+
+  - For direct use via `<script src="...">` in the browser. Exposes the `VueI18n` global
+  - Note that global builds are not [UMD](https://github.com/umdjs/umd) builds. They are built as [IIFEs](https://developer.mozilla.org/en-US/docs/Glossary/IIFE) and is only meant for direct use via `<script src="...">`
+  - In-browser locale messages compilation:
+    - **`vue-i18n.global.js`** is the "full" build that includes both the compiler and the runtime so it supports compiling locale messages on the fly
+    - **`vue-i18n.runtime.global.js`** contains only the runtime and requires locale messages to be pre-compiled during a build step
+  - Inlines internal the bellow packages - i.e. it’s a single file with no dependencies on other files. This means you **must** import everything from this file and this file only to ensure you are getting the same instance of code
+    - `@intlify/shared`
+    - `@intlify/message-compiler`
+    - `@intlify/core`
+  - Contains hard-coded prod/dev branches, and the prod build is pre-minified. Use the `*.prod.js` files for production
+
+- **`vue-i18n(.runtime).esm-browser(.prod).js`**:
+  - For usage via native ES modules imports (in browser via `<script type="module">`)
+  - Shares the same runtime compilation, dependency inlining and hard-coded prod/dev behavior with the global build
+
+### With a Bundler
+
+- **`vue-i18n(.runtime).esm-bundler.js`**:
+  - For use with bundlers like `webpack`, `rollup` and `parcel`
+  - Leaves prod/dev branches with `process.env.NODE_ENV` guards (must be replaced by bundler)
+  - Does not ship minified builds (to be done together with the rest of the code after bundling)
+  - Imports dependencies (e.g. `@intlify/core-base`, `@intlify/message-compiler`)
+    - Imported dependencies are also `esm-bundler` builds and will in turn import their dependencies (e.g. `@intlify/message-compiler` imports `@intlify/shared`)
+    - This means you **can** install/import these deps individually without ending up with different instances of these dependencies, but you must make sure they all resolve to the same version
+  - In-browser locale messages compilation:
+    - **`vue-i18n.runtime.esm-bundler.js` (default)** is runtime only, and requires all locale messages to be pre-compiled. This is the default entry for bundlers (via `module` field in `package.json`) because when using a bundler templates are typically pre-compiled (e.g. in `*.json` files)
+    - **`vue-i18n.esm-bundler.js`**: includes the runtime compiler. Use this if you are using a bundler but still want locale messages compilation (e.g. templates via inline JavaScript strings)
+
+### For Node.js (Server-Side)
+
+- **`vue-i18n.cjs(.prod).js`**:
+  - For use in Node.js via `require()`
+  - If you bundle your app with webpack with `target: 'node'` and properly externalize `vue-i18n`, this is the build that will be loaded
+  - The dev/prod files are pre-built, but the appropriate file is automatically required based on `process.env.NODE_ENV`
+
+## For Bundler feature flags
+
+### Build Feature Flags
+
+The `esm-bundler` builds now exposes global feature flags that can be overwritten at compile time:
+
+- `__VUE_I18N_FULL_INSTALL__` (enable/disable, in addition to vue-i18n APIs, components and directives all fully support installation: `true`)
+- `__VUE_I18N_LEGACY_API__` (enable/disable vue-i18n legacy style APIs support, default: `true`)
+- `__INTLIFY_PROD_DEVTOOLS__` (enable/disable `@intlify/devtools` support in production, default: `false`)
+
+> NOTE: `__INTLIFY_PROD_DEVTOOLS__` flag is experimental, and `@intlify/devtools` is WIP yet.
+
+The build will work without configuring these flags, however it is **strongly recommended** to properly configure them in order to get proper tree shaking in the final bundle. To configure these flags:
+
+- webpack: use [DefinePlugin](https://webpack.js.org/plugins/define-plugin/)
+- Rollup: use [@rollup/plugin-replace](https://github.com/rollup/plugins/tree/master/packages/replace)
+- Vite: configured by default, but can be overwritten using the [`define` option](https://github.com/vitejs/vite/blob/a4133c073e640b17276b2de6e91a6857bdf382e1/src/node/config.ts#L72-L76)
+
+Note: the replacement value **must be boolean literals** and cannot be strings, otherwise the bundler/minifier will not be able to properly evaluate the conditions.
+
+## :copyright: License
+
+[MIT](http://opensource.org/licenses/MIT)

uni_modules/UniDevTools/node_modules/vue-i18n/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/vue-i18n.cjs.prod.js')
+} else {
+  module.exports = require('./dist/vue-i18n.cjs.js')
+}

uni_modules/UniDevTools/node_modules/vue-i18n/index.mjs

@@ -0,0 +1 @@
+export * from './index.js'

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/core-base/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 kazuya kawaguchi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/core-base/README.md

@@ -0,0 +1,7 @@
+# @intlify/core-base
+
+The intlify core base module
+
+## :copyright: License
+
+[MIT](http://opensource.org/licenses/MIT)

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/core-base/dist/core-base.d.ts

@@ -0,0 +1,920 @@
+import { CompileError } from '@intlify/message-compiler';
+import { CompileErrorCodes } from '@intlify/message-compiler';
+import type { CompileOptions } from '@intlify/message-compiler';
+import { createCompileError } from '@intlify/message-compiler';
+import type { IntlifyDevToolsEmitter } from '@intlify/devtools-if';
+import type { IntlifyDevToolsHookPayloads } from '@intlify/devtools-if';
+import { IntlifyDevToolsHooks } from '@intlify/devtools-if';
+import type { VueDevToolsEmitter } from '@intlify/vue-devtools';
+
+declare type __ResourceFormatPath<T, Key extends keyof T> = Key extends string ? T[Key] extends Record<string, any> ? `${Key}` : never : never;
+
+export declare type __ResourcePath<T, Key extends keyof T> = Key extends string ? T[Key] extends Record<string, any> ? `${Key}.${__ResourcePath<T[Key], Exclude<keyof T[Key], keyof any[]>> & string}` | `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}` : never : never;
+
+export declare function clearCompileCache(): void;
+
+/* Excluded from this release type: clearDateTimeFormat */
+
+/* Excluded from this release type: clearNumberFormat */
+export { CompileError }
+export { CompileErrorCodes }
+
+export declare function compileToFunction<T = string>(source: string, options?: CompileOptions): MessageFunction<T>;
+
+export declare interface CoreCommonContext<Message = string, Locales = 'en-US'> {
+    cid: number;
+    version: string;
+    locale: Locales;
+    fallbackLocale: FallbackLocales<Locales>;
+    missing: CoreMissingHandler<Message> | null;
+    missingWarn: boolean | RegExp;
+    fallbackWarn: boolean | RegExp;
+    fallbackFormat: boolean;
+    unresolving: boolean;
+    localeFallbacker: LocaleFallbacker;
+    onWarn(msg: string, err?: Error): void;
+}
+
+export declare type CoreContext<Message = string, Messages = {}, DateTimeFormats = {}, NumberFormats = {}, ResourceLocales = PickupLocales<NonNullable<Messages>> | PickupLocales<NonNullable<DateTimeFormats>> | PickupLocales<NonNullable<NumberFormats>>, Locales = [ResourceLocales] extends [never] ? Locale : ResourceLocales> = CoreCommonContext<Message, Locales> & CoreTranslationContext<NonNullable<Messages>, Message> & CoreDateTimeContext<NonNullable<DateTimeFormats>> & CoreNumberContext<NonNullable<NumberFormats>> & {
+    fallbackContext?: CoreContext<Message, Messages, DateTimeFormats, NumberFormats, ResourceLocales, Locales>;
+};
+
+export declare interface CoreDateTimeContext<DateTimeFormats = {}> {
+    datetimeFormats: {
+        [K in keyof DateTimeFormats]: DateTimeFormats[K];
+    };
+}
+
+export declare interface CoreError extends CompileError {
+    code: CoreErrorCodes;
+}
+
+export declare const CoreErrorCodes: {
+    readonly INVALID_ARGUMENT: 15;
+    readonly INVALID_DATE_ARGUMENT: number;
+    readonly INVALID_ISO_DATE_ARGUMENT: number;
+    readonly __EXTEND_POINT__: number;
+};
+
+export declare type CoreErrorCodes = typeof CoreErrorCodes[keyof typeof CoreErrorCodes];
+
+export declare interface CoreInternalContext {
+    __datetimeFormatters: Map<string, Intl.DateTimeFormat>;
+    __numberFormatters: Map<string, Intl.NumberFormat>;
+    __localeChainCache?: Map<Locale, Locale[]>;
+    __v_emitter?: VueDevToolsEmitter;
+    __meta: MetaInfo;
+}
+
+export declare interface CoreInternalOptions {
+    __datetimeFormatters?: Map<string, Intl.DateTimeFormat>;
+    __numberFormatters?: Map<string, Intl.NumberFormat>;
+    __v_emitter?: VueDevToolsEmitter;
+    __meta?: MetaInfo;
+}
+
+export declare type CoreMissingHandler<Message = string> = (context: CoreContext<Message>, locale: Locale, key: Path, type: CoreMissingType, ...values: unknown[]) => string | void;
+
+export declare type CoreMissingType = 'translate' | 'datetime format' | 'number format';
+
+export declare interface CoreNumberContext<NumberFormats = {}> {
+    numberFormats: {
+        [K in keyof NumberFormats]: NumberFormats[K];
+    };
+}
+
+export declare interface CoreOptions<Message = string, Schema extends {
+    message?: unknown;
+    datetime?: unknown;
+    number?: unknown;
+} = {
+    message: LocaleMessage<Message>;
+    datetime: DateTimeFormat;
+    number: NumberFormat;
+}, Locales extends {
+    messages: unknown;
+    datetimeFormats: unknown;
+    numberFormats: unknown;
+} | string = Locale, MessagesLocales = Locales extends {
+    messages: infer M;
+} ? M : Locales extends string ? Locales : Locale, DateTimeFormatsLocales = Locales extends {
+    datetimeFormats: infer D;
+} ? D : Locales extends string ? Locales : Locale, NumberFormatsLocales = Locales extends {
+    numberFormats: infer N;
+} ? N : Locales extends string ? Locales : Locale, MessageSchema = Schema extends {
+    message: infer M;
+} ? M : LocaleMessage<Message>, DateTimeSchema = Schema extends {
+    datetime: infer D;
+} ? D : DateTimeFormat, NumberSchema = Schema extends {
+    number: infer N;
+} ? N : NumberFormat, _Messages extends LocaleMessages<MessageSchema, MessagesLocales, Message> = LocaleMessages<MessageSchema, MessagesLocales, Message>, _DateTimeFormats extends DateTimeFormats<DateTimeSchema, DateTimeFormatsLocales> = DateTimeFormats<DateTimeSchema, DateTimeFormatsLocales>, _NumberFormats extends NumberFormats<NumberSchema, NumberFormatsLocales> = NumberFormats<NumberSchema, NumberFormatsLocales>> {
+    version?: string;
+    locale?: Locale;
+    fallbackLocale?: FallbackLocale;
+    messages?: {
+        [K in keyof _Messages]: MessageSchema;
+    };
+    datetimeFormats?: {
+        [K in keyof _DateTimeFormats]: DateTimeSchema;
+    };
+    numberFormats?: {
+        [K in keyof _NumberFormats]: NumberSchema;
+    };
+    modifiers?: LinkedModifiers<Message>;
+    pluralRules?: PluralizationRules;
+    missing?: CoreMissingHandler<Message>;
+    missingWarn?: boolean | RegExp;
+    fallbackWarn?: boolean | RegExp;
+    fallbackFormat?: boolean;
+    unresolving?: boolean;
+    postTranslation?: PostTranslationHandler<Message>;
+    processor?: MessageProcessor<Message>;
+    warnHtmlMessage?: boolean;
+    escapeParameter?: boolean;
+    messageCompiler?: MessageCompiler<Message>;
+    messageResolver?: MessageResolver;
+    localeFallbacker?: LocaleFallbacker;
+    fallbackContext?: CoreContext<Message, MessagesLocales, DateTimeFormatsLocales, NumberFormatsLocales>;
+    onWarn?: (msg: string, err?: Error) => void;
+}
+
+export declare interface CoreTranslationContext<Messages = {}, Message = string> {
+    messages: {
+        [K in keyof Messages]: Messages[K];
+    };
+    modifiers: LinkedModifiers<Message>;
+    pluralRules?: PluralizationRules;
+    postTranslation: PostTranslationHandler<Message> | null;
+    processor: MessageProcessor<Message> | null;
+    warnHtmlMessage: boolean;
+    escapeParameter: boolean;
+    messageCompiler: MessageCompiler<Message> | null;
+    messageResolver: MessageResolver;
+}
+
+export declare const CoreWarnCodes: {
+    readonly NOT_FOUND_KEY: 1;
+    readonly FALLBACK_TO_TRANSLATE: 2;
+    readonly CANNOT_FORMAT_NUMBER: 3;
+    readonly FALLBACK_TO_NUMBER_FORMAT: 4;
+    readonly CANNOT_FORMAT_DATE: 5;
+    readonly FALLBACK_TO_DATE_FORMAT: 6;
+    readonly __EXTEND_POINT__: 7;
+};
+
+export declare type CoreWarnCodes = typeof CoreWarnCodes[keyof typeof CoreWarnCodes];
+export { createCompileError }
+
+export declare function createCoreContext<Message = string, Options extends CoreOptions<Message> = CoreOptions<Message>, Messages = Options['messages'] extends object ? Options['messages'] : {}, DateTimeFormats = Options['datetimeFormats'] extends object ? Options['datetimeFormats'] : {}, NumberFormats = Options['numberFormats'] extends object ? Options['numberFormats'] : {}>(options: Options): CoreContext<Message, Messages, DateTimeFormats, NumberFormats>;
+
+export declare function createCoreContext<Schema = LocaleMessage, Locales = 'en-US', Message = string, Options extends CoreOptions<Message, SchemaParams<Schema, Message>, LocaleParams<Locales>> = CoreOptions<Message, SchemaParams<Schema, Message>, LocaleParams<Locales>>, Messages = Options['messages'] extends object ? Options['messages'] : {}, DateTimeFormats = Options['datetimeFormats'] extends object ? Options['datetimeFormats'] : {}, NumberFormats = Options['numberFormats'] extends object ? Options['numberFormats'] : {}>(options: Options): CoreContext<Message, Messages, DateTimeFormats, NumberFormats>;
+
+export declare function createCoreError(code: CoreErrorCodes): CoreError;
+
+export declare function createMessageContext<T = string, N = {}>(options?: MessageContextOptions<T, N>): MessageContext<T>;
+
+/**
+ *  number
+ */
+export declare type CurrencyDisplay = 'symbol' | 'code' | 'name';
+
+export declare interface CurrencyNumberFormatOptions extends Intl.NumberFormatOptions {
+    style: 'currency';
+    currency: string;
+    currencyDisplay?: CurrencyDisplay;
+    localeMatcher?: LocaleMatcher;
+    formatMatcher?: FormatMatcher;
+}
+
+/**
+ * `datetime` function overloads
+ */
+export declare function datetime<Context extends CoreContext<Message, {}, Context['datetimeFormats'], {}>, Message = string>(context: Context, value: number | string | Date): string | number | Intl.DateTimeFormatPart[];
+
+export declare function datetime<Context extends CoreContext<Message, {}, Context['datetimeFormats'], {}>, Value extends number | string | Date = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['datetimeFormats']> = PickupFormatKeys<Context['datetimeFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | DateTimeOptions<Key | ResourceKeys, Context['locale']>): string | number | Intl.DateTimeFormatPart[];
+
+export declare function datetime<Context extends CoreContext<Message, {}, Context['datetimeFormats'], {}>, Value extends number | string | Date = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['datetimeFormats']> = PickupFormatKeys<Context['datetimeFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | DateTimeOptions<Key | ResourceKeys, Context['locale']>, locale: Context['locale']): string | number | Intl.DateTimeFormatPart[];
+
+export declare function datetime<Context extends CoreContext<Message, {}, Context['datetimeFormats'], {}>, Value extends number | string | Date = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['datetimeFormats']> = PickupFormatKeys<Context['datetimeFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | DateTimeOptions<Key | ResourceKeys, Context['locale']>, override: Intl.DateTimeFormatOptions): string | number | Intl.DateTimeFormatPart[];
+
+export declare function datetime<Context extends CoreContext<Message, {}, Context['datetimeFormats'], {}>, Value extends number | string | Date = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['datetimeFormats']> = PickupFormatKeys<Context['datetimeFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | DateTimeOptions<Key | ResourceKeys, Context['locale']>, locale: Context['locale'], override: Intl.DateTimeFormatOptions): string | number | Intl.DateTimeFormatPart[];
+
+/* Excluded from this release type: DATETIME_FORMAT_OPTIONS_KEYS */
+
+export declare type DateTimeDigital = 'numeric' | '2-digit';
+
+export declare type DateTimeFormat = {
+    [key: string]: DateTimeFormatOptions;
+};
+
+export declare type DateTimeFormatOptions = Intl.DateTimeFormatOptions | SpecificDateTimeFormatOptions;
+
+export declare type DateTimeFormats<Schema = DateTimeFormat, Locales = Locale> = LocaleRecord<UnionToTuple<Locales>, Schema>;
+
+/**
+ *  datetime
+ */
+export declare type DateTimeHumanReadable = 'long' | 'short' | 'narrow';
+
+/**
+ *  # datetime
+ *
+ *  ## usages:
+ *    // for example `context.datetimeFormats` below
+ *    'en-US': {
+ *      short: {
+ *        year: 'numeric', month: '2-digit', day: '2-digit',
+ *        hour: '2-digit', minute: '2-digit'
+ *      }
+ *    },
+ *    'ja-JP': { ... }
+ *
+ *    // datetimeable value only
+ *    datetime(context, value)
+ *
+ *    // key argument
+ *    datetime(context, value, 'short')
+ *
+ *    // key & locale argument
+ *    datetime(context, value, 'short', 'ja-JP')
+ *
+ *    // object sytle argument
+ *    datetime(context, value, { key: 'short', locale: 'ja-JP' })
+ *
+ *    // suppress localize miss warning option, override context.missingWarn
+ *    datetime(context, value, { key: 'short', locale: 'ja-JP', missingWarn: false })
+ *
+ *    // suppress localize fallback warning option, override context.fallbackWarn
+ *    datetime(context, value, { key: 'short', locale: 'ja-JP', fallbackWarn: false })
+ *
+ *    // if you specify `part` options, you can get an array of objects containing the formatted datetime in parts
+ *    datetime(context, value, { key: 'short', part: true })
+ *
+ *    // orverride context.datetimeFormats[locale] options with functino options
+ *    datetime(cnotext, value, 'short', { year: '2-digit' })
+ *    datetime(cnotext, value, 'short', 'ja-JP', { year: '2-digit' })
+ *    datetime(context, value, { key: 'short', part: true, year: '2-digit' })
+ */
+/**
+ * DateTime options
+ *
+ * @remarks
+ * Options for Datetime formatting API
+ *
+ * @VueI18nGeneral
+ */
+export declare interface DateTimeOptions<Key = string, Locales = Locale> extends Intl.DateTimeFormatOptions {
+    /**
+     * @remarks
+     * The target format key
+     */
+    key?: Key;
+    /**
+     * @remarks
+     * The locale of localization
+     */
+    locale?: Locales;
+    /**
+     * @remarks
+     * Whether suppress warnings outputted when localization fails
+     */
+    missingWarn?: boolean;
+    /**
+     * @remarks
+     * Whether do resolve on format keys when your language lacks a formatting for a key
+     */
+    fallbackWarn?: boolean;
+    /**
+     * @remarks
+     * Whether to use [Intel.DateTimeFormat#formatToParts](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatToParts)
+     */
+    part?: boolean;
+}
+
+export declare const DEFAULT_LOCALE = "en-US";
+
+export declare const DEFAULT_MESSAGE_DATA_TYPE = "text";
+
+declare type ExtractToStringFunction<T> = T[ExtractToStringKey<T>];
+
+declare type ExtractToStringKey<T> = Extract<keyof T, 'toString'>;
+
+/** @VueI18nGeneral */
+export declare type FallbackLocale = Locale | Locale[] | {
+    [locale in string]: Locale[];
+} | false;
+
+export declare type FallbackLocales<Locales = 'en-US'> = Locales | Array<Locales> | {
+    [locale in string]: Array<PickupFallbackLocales<UnionToTuple<Locales>>>;
+} | false;
+
+/**
+ * Fallback with locale chain
+ *
+ * @remarks
+ * A fallback locale function implemented with a fallback chain algorithm. It's used in VueI18n as default.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nSee [Fallbacking](../guide/essentials/fallback)
+ *
+ * @VueI18nGeneral
+ */
+export declare function fallbackWithLocaleChain<Message = string>(ctx: CoreContext<Message>, fallback: FallbackLocale, start: Locale): Locale[];
+
+/**
+ * Fallback with simple implemenation
+ *
+ * @remarks
+ * A fallback locale function implemented with a simple fallback algorithm.
+ *
+ * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nGeneral
+ */
+export declare function fallbackWithSimple<Message = string>(ctx: CoreContext<Message>, fallback: FallbackLocale, start: Locale): Locale[];
+
+export declare type First<T extends readonly any[]> = T[0];
+
+export declare type FormatMatcher = 'basic' | 'best fit';
+
+export declare type FormattedNumberPart = {
+    type: FormattedNumberPartType;
+    value: string;
+};
+
+export declare type FormattedNumberPartType = 'currency' | 'decimal' | 'fraction' | 'group' | 'infinity' | 'integer' | 'literal' | 'minusSign' | 'nan' | 'plusSign' | 'percentSign';
+
+export declare const getAdditionalMeta: () => MetaInfo | null;
+
+export declare function getDevToolsHook(): IntlifyDevToolsEmitter | null;
+
+export declare const getFallbackContext: () => CoreContext | null;
+
+export declare function getWarnMessage(code: CoreWarnCodes, ...args: unknown[]): string;
+
+/* Excluded from this release type: handleMissing */
+
+export declare function initI18nDevTools(i18n: unknown, version: string, meta?: Record<string, unknown>): void;
+
+export declare type IsEmptyObject<T> = [keyof T] extends [never] ? true : false;
+
+export declare const isMessageFunction: <T>(val: unknown) => val is MessageFunction<T>;
+
+export declare type IsNever<T> = [T] extends [never] ? true : false;
+
+/* Excluded from this release type: isTranslateFallbackWarn */
+
+/* Excluded from this release type: isTranslateMissingWarn */
+
+export declare type IsUnion<T, B = T> = T extends B ? [B] extends [T] ? false : true : never;
+
+export declare type LastInUnion<U> = UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+
+/** @VueI18nGeneral */
+export declare type LinkedModifiers<T = string> = {
+    [key: string]: LinkedModify<T>;
+};
+
+export declare type LinkedModify<T = string> = (value: T, type: string) => MessageType<T>;
+
+export declare interface LinkedOptions {
+    type?: string;
+    modifier?: string;
+}
+
+/** @VueI18nGeneral */
+export declare type Locale = string;
+
+/**
+ * The locale fallbacker
+ *
+ * @VueI18nGeneral
+ */
+export declare type LocaleFallbacker = <Message = string>(ctx: CoreContext<Message>, fallback: FallbackLocale, start: Locale) => Locale[];
+
+export declare type LocaleMatcher = 'lookup' | 'best fit';
+
+/** @VueI18nGeneral */
+export declare type LocaleMessage<Message = string> = Record<string, LocaleMessageValue<Message>>;
+
+/** @VueI18nGeneral */
+export declare type LocaleMessageDictionary<T, Message = string> = {
+    [K in keyof T]: LocaleMessageType<T[K], Message>;
+};
+
+/** @VueI18nGeneral */
+export declare type LocaleMessages<Schema, Locales = Locale, Message = string> = LocaleRecord<UnionToTuple<Locales>, Schema>;
+
+/** @VueI18nGeneral */
+export declare type LocaleMessageType<T, Message = string> = T extends string ? string : T extends () => Promise<infer P> ? LocaleMessageDictionary<P, Message> : T extends (...args: infer Arguments) => any ? (...args: Arguments) => ReturnType<T> : T extends Record<string, any> ? LocaleMessageDictionary<T, Message> : T extends Array<T> ? {
+    [K in keyof T]: T[K];
+} : T;
+
+/** @VueI18nGeneral */
+export declare type LocaleMessageValue<Message = string> = LocaleMessageDictionary<any, Message> | string;
+
+export declare type LocaleParams<T, Default = 'en-US'> = T extends IsUnion<T> ? {
+    messages: T;
+    datetimeFormats: T;
+    numberFormats: T;
+} : T extends {
+    messages?: infer M;
+    datetimeFormats?: infer D;
+    numberFormats?: infer N;
+} ? {
+    messages: LocaleParamsType<M, Default>;
+    datetimeFormats: LocaleParamsType<D, Default>;
+    numberFormats: LocaleParamsType<N, Default>;
+} : T extends string ? {
+    messages: T;
+    datetimeFormats: T;
+    numberFormats: T;
+} : {
+    messages: Default;
+    datetimeFormats: Default;
+    numberFormats: Default;
+};
+
+declare type LocaleParamsType<T, R> = T extends IsUnion<T> ? T : T extends string ? T : R;
+
+export declare type LocaleRecord<T extends any[], R> = {
+    [K in T[number]]: R;
+};
+
+export declare type MessageCompiler<Message = string> = (source: string, options?: CompileOptions) => MessageFunction<Message>;
+
+export declare interface MessageContext<T = string> {
+    list(index: number): unknown;
+    named(key: string): unknown;
+    plural(messages: T[]): T;
+    linked(key: Path, modifier?: string): MessageType<T>;
+    linked(key: Path, modifier?: string, type?: string): MessageType<T>;
+    linked(key: Path, optoins?: LinkedOptions): MessageType<T>;
+    message(key: Path): MessageFunction<T>;
+    type: string;
+    interpolate: MessageInterpolate<T>;
+    normalize: MessageNormalize<T>;
+}
+
+export declare interface MessageContextOptions<T = string, N = {}> {
+    parent?: MessageContext<T>;
+    locale?: string;
+    list?: unknown[];
+    named?: NamedValue<N>;
+    modifiers?: LinkedModifiers<T>;
+    pluralIndex?: number;
+    pluralRules?: PluralizationRules;
+    messages?: MessageFunctions<T> | MessageResolveFunction<T>;
+    processor?: MessageProcessor<T>;
+}
+
+export declare type MessageFunction<T = string> = MessageFunctionCallable | MessageFunctionInternal<T>;
+
+export declare type MessageFunctionCallable = <T = string>(ctx: MessageContext<T>) => MessageType<T>;
+
+export declare type MessageFunctionInternal<T = string> = {
+    (ctx: MessageContext<T>): MessageType<T>;
+    key?: string;
+    locale?: string;
+    source?: string;
+};
+
+export declare type MessageFunctions<T = string> = Record<string, MessageFunction<T>>;
+
+export declare type MessageInterpolate<T = string> = (val: unknown) => MessageType<T>;
+
+export declare type MessageNormalize<T = string> = (values: MessageType<string | T>[]) => MessageType<T | T[]>;
+
+export declare interface MessageProcessor<T = string> {
+    type?: string;
+    interpolate?: MessageInterpolate<T>;
+    normalize?: MessageNormalize<T>;
+}
+
+export declare type MessageResolveFunction<T = string> = (key: string) => MessageFunction<T>;
+
+/** @VueI18nGeneral */
+export declare type MessageResolver = (obj: unknown, path: Path) => PathValue;
+
+export declare type MessageType<T = string> = T extends string ? string : StringConvertable<T>;
+
+export declare interface MetaInfo {
+    [field: string]: unknown;
+}
+
+export declare const MISSING_RESOLVE_VALUE = "";
+
+/** @VueI18nGeneral */
+export declare type NamedValue<T = {}> = T & Record<string, unknown>;
+
+export declare const NOT_REOSLVED = -1;
+
+/**
+ * `number` function overloads
+ */
+export declare function number<Context extends CoreContext<Message, {}, {}, Context['numberFormats']>, Message = string>(context: Context, value: number): string | number | Intl.NumberFormatPart[];
+
+export declare function number<Context extends CoreContext<Message, {}, {}, Context['numberFormats']>, Value extends number = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['numberFormats']> = PickupFormatKeys<Context['numberFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | NumberOptions<Key | ResourceKeys, Context['locale']>): string | number | Intl.NumberFormatPart[];
+
+export declare function number<Context extends CoreContext<Message, {}, {}, Context['numberFormats']>, Value extends number = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['numberFormats']> = PickupFormatKeys<Context['numberFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | NumberOptions<Key | ResourceKeys, Context['locale']>, locale: Context['locale']): string | number | Intl.NumberFormatPart[];
+
+export declare function number<Context extends CoreContext<Message, {}, {}, Context['numberFormats']>, Value extends number = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['numberFormats']> = PickupFormatKeys<Context['numberFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | NumberOptions<Key | ResourceKeys, Context['locale']>, override: Intl.NumberFormatOptions): string | number | Intl.NumberFormatPart[];
+
+export declare function number<Context extends CoreContext<Message, {}, {}, Context['numberFormats']>, Value extends number = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['numberFormats']> = PickupFormatKeys<Context['numberFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | NumberOptions<Key | ResourceKeys, Context['locale']>, locale: Context['locale'], override: Intl.NumberFormatOptions): string | number | Intl.NumberFormatPart[];
+
+/* Excluded from this release type: NUMBER_FORMAT_OPTIONS_KEYS */
+
+export declare type NumberFormat = {
+    [key: string]: NumberFormatOptions;
+};
+
+export declare type NumberFormatOptions = Intl.NumberFormatOptions | SpecificNumberFormatOptions | CurrencyNumberFormatOptions;
+
+export declare type NumberFormats<Schema = NumberFormat, Locales = Locale> = LocaleRecord<UnionToTuple<Locales>, Schema>;
+
+export declare type NumberFormatToPartsResult = {
+    [index: number]: FormattedNumberPart;
+};
+
+/**
+ *  # number
+ *
+ *  ## usages
+ *    // for example `context.numberFormats` below
+ *    'en-US': {
+ *      'currency': {
+ *        style: 'currency', currency: 'USD', currencyDisplay: 'symbol'
+ *      }
+ *    },
+ *    'ja-JP: { ... }
+ *
+ *    // value only
+ *    number(context, value)
+ *
+ *    // key argument
+ *    number(context, value, 'currency')
+ *
+ *    // key & locale argument
+ *    number(context, value, 'currency', 'ja-JP')
+ *
+ *    // object sytle argument
+ *    number(context, value, { key: 'currency', locale: 'ja-JP' })
+ *
+ *    // suppress localize miss warning option, override context.missingWarn
+ *    number(context, value, { key: 'currency', locale: 'ja-JP', missingWarn: false })
+ *
+ *    // suppress localize fallback warning option, override context.fallbackWarn
+ *    number(context, value, { key: 'currency', locale: 'ja-JP', fallbackWarn: false })
+ *
+ *    // if you specify `part` options, you can get an array of objects containing the formatted number in parts
+ *    number(context, value, { key: 'currenty', part: true })
+ *
+ *    // orverride context.numberFormats[locale] options with functino options
+ *    number(cnotext, value, 'currency', { year: '2-digit' })
+ *    number(cnotext, value, 'currency', 'ja-JP', { year: '2-digit' })
+ *    number(context, value, { key: 'currenty', locale: 'ja-JP', part: true, year: '2-digit'})
+ */
+/**
+ * Number Options
+ *
+ * @remarks
+ * Options for Number formatting API
+ *
+ * @VueI18nGeneral
+ */
+export declare interface NumberOptions<Key = string, Locales = Locale> extends Intl.NumberFormatOptions {
+    /**
+     * @remarks
+     * The target format key
+     */
+    key?: Key;
+    /**
+     * @remarks
+     * The locale of localization
+     */
+    locale?: Locales;
+    /**
+     * @remarks
+     * Whether suppress warnings outputted when localization fails
+     */
+    missingWarn?: boolean;
+    /**
+     * @remarks
+     * Whether do resolve on format keys when your language lacks a formatting for a key
+     */
+    fallbackWarn?: boolean;
+    /**
+     * @remarks
+     * Whether to use [Intel.NumberFormat#formatToParts](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/formatToParts)
+     */
+    part?: boolean;
+}
+
+/**
+ * Parse a string path into an array of segments
+ */
+export declare function parse(path: Path): string[] | undefined;
+
+/* Excluded from this release type: parseDateTimeArgs */
+
+/* Excluded from this release type: parseNumberArgs */
+
+/* Excluded from this release type: parseTranslateArgs */
+
+/** @VueI18nGeneral */
+export declare type Path = string;
+
+/** @VueI18nGeneral */
+export declare type PathValue = string | number | boolean | Function | null | {
+    [key: string]: PathValue;
+} | PathValue[];
+
+export declare type PickupFallbackLocales<T extends any[]> = T[number] | `${T[number]}!`;
+
+export declare type PickupFormatKeys<T extends Record<string, any>, K = keyof T> = K extends string ? ResourceFormatPath<T[K]> : never;
+
+export declare type PickupFormatPathKeys<T extends object> = ResourceFormatPath<T>;
+
+export declare type PickupKeys<T extends Record<string, any>, K = keyof T> = K extends string ? ResourcePath<T[K]> : never;
+
+export declare type PickupLocales<T extends Record<string, any>, K = keyof T> = K extends string ? K : never;
+
+export declare type PickupPaths<T extends object> = ResourcePath<T>;
+
+export declare type PluralizationProps = {
+    n?: number;
+    count?: number;
+};
+
+export declare type PluralizationRule = (choice: number, choicesLength: number, orgRule?: PluralizationRule) => number;
+
+/** @VueI18nGeneral */
+export declare type PluralizationRules = {
+    [locale: string]: PluralizationRule;
+};
+
+/** @VueI18nGeneral */
+export declare type PostTranslationHandler<Message = string> = (translated: MessageType<Message>, key: string) => MessageType<Message>;
+
+/**
+ * Register the locale fallbacker
+ *
+ * @param fallbacker - A {@link LocaleFallbacker} function
+ *
+ * @VueI18nGeneral
+ */
+export declare function registerLocaleFallbacker(fallbacker: LocaleFallbacker): void;
+
+export declare function registerMessageCompiler<Message>(compiler: MessageCompiler<Message>): void;
+
+/**
+ * Register the message resolver
+ *
+ * @param resolver - A {@link MessageResolver} function
+ *
+ * @VueI18nGeneral
+ */
+export declare function registerMessageResolver(resolver: MessageResolver): void;
+
+export declare type RemoveIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
+};
+
+/**
+ * message resolver
+ *
+ * @remarks
+ * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+export declare function resolveValue(obj: unknown, path: Path): PathValue;
+
+/**
+ * key-value message resolver
+ *
+ * @remarks
+ * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+export declare function resolveWithKeyValue(obj: unknown, path: Path): PathValue;
+
+export declare type ResourceFormatPath<T> = _ResourceFormatPath<T> extends string | keyof T ? _ResourceFormatPath<T> : keyof T;
+
+declare type _ResourceFormatPath<T> = __ResourceFormatPath<T, keyof T> | keyof T;
+
+export declare type ResourcePath<T> = _ResourcePath<T> extends string | keyof T ? _ResourcePath<T> : keyof T;
+
+export declare type _ResourcePath<T> = __ResourcePath<T, keyof T> | keyof T;
+
+export declare type ResourceValue<T, P extends ResourcePath<T>> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? Rest extends ResourcePath<T[Key]> ? ResourceValue<T[Key], Rest> : never : never : P extends keyof T ? T[P] : never;
+
+export declare type SchemaParams<T, Message = string> = T extends readonly any[] ? {
+    message: First<T>;
+    datetime: DateTimeFormat;
+    number: NumberFormat;
+} : T extends {
+    message?: infer M;
+    datetime?: infer D;
+    number?: infer N;
+} ? {
+    message: M extends LocaleMessage<Message> ? M : LocaleMessage<Message>;
+    datetime: D extends DateTimeFormat ? D : DateTimeFormat;
+    number: N extends NumberFormat ? N : NumberFormat;
+} : {
+    message: LocaleMessage<Message>;
+    datetime: DateTimeFormat;
+    number: NumberFormat;
+};
+
+export declare const setAdditionalMeta: (meta: MetaInfo | null) => void;
+
+export declare function setDevToolsHook(hook: IntlifyDevToolsEmitter | null): void;
+
+export declare const setFallbackContext: (context: CoreContext | null) => void;
+
+export declare interface SpecificDateTimeFormatOptions extends Intl.DateTimeFormatOptions {
+    year?: DateTimeDigital;
+    month?: DateTimeDigital | DateTimeHumanReadable;
+    day?: DateTimeDigital;
+    hour?: DateTimeDigital;
+    minute?: DateTimeDigital;
+    second?: DateTimeDigital;
+    weekday?: DateTimeHumanReadable;
+    era?: DateTimeHumanReadable;
+    timeZoneName?: 'long' | 'short';
+    localeMatcher?: LocaleMatcher;
+    formatMatcher?: FormatMatcher;
+}
+
+export declare interface SpecificNumberFormatOptions extends Intl.NumberFormatOptions {
+    style?: 'decimal' | 'percent';
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    localeMatcher?: LocaleMatcher;
+    formatMatcher?: FormatMatcher;
+}
+
+declare type StringConvertable<T> = ExtractToStringKey<T> extends never ? unknown : ExtractToStringFunction<T> extends (...args: any) => string ? T : unknown;
+
+/**
+ * `translate` function overloads
+ */
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>): MessageType<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, plural: number): MessageType<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, plural: number, options: TranslateOptions<Context['locale']>): MessageType<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, defaultMsg: string): MessageType<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, defaultMsg: string, options: TranslateOptions<Context['locale']>): MessageType<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, list: unknown[]): MessageType<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, list: unknown[], plural: number): MessageType<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, list: unknown[], defaultMsg: string): MessageType<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, list: unknown[], options: TranslateOptions<Context['locale']>): MessageType<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, named: NamedValue): MessageType<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, named: NamedValue, plural: number): MessageType<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, named: NamedValue, defaultMsg: string): MessageType<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, Context['messages'], {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, named: NamedValue, options: TranslateOptions<Context['locale']>): MessageType<Message> | number;
+
+export declare const translateDevTools: (payloads: IntlifyDevToolsHookPayloads[IntlifyDevToolsHooks]) => void | null;
+
+/**
+ *  # translate
+ *
+ *  ## usages:
+ *    // for example, locale messages key
+ *    { 'foo.bar': 'hi {0} !' or 'hi {name} !' }
+ *
+ *    // no argument, context & path only
+ *    translate(context, 'foo.bar')
+ *
+ *    // list argument
+ *    translate(context, 'foo.bar', ['kazupon'])
+ *
+ *    // named argument
+ *    translate(context, 'foo.bar', { name: 'kazupon' })
+ *
+ *    // plural choice number
+ *    translate(context, 'foo.bar', 2)
+ *
+ *    // plural choice number with name argument
+ *    translate(context, 'foo.bar', { name: 'kazupon' }, 2)
+ *
+ *    // default message argument
+ *    translate(context, 'foo.bar', 'this is default message')
+ *
+ *    // default message with named argument
+ *    translate(context, 'foo.bar', { name: 'kazupon' }, 'Hello {name} !')
+ *
+ *    // use key as default message
+ *    translate(context, 'hi {0} !', ['kazupon'], { default: true })
+ *
+ *    // locale option, override context.locale
+ *    translate(context, 'foo.bar', { name: 'kazupon' }, { locale: 'ja' })
+ *
+ *    // suppress localize miss warning option, override context.missingWarn
+ *    translate(context, 'foo.bar', { name: 'kazupon' }, { missingWarn: false })
+ *
+ *    // suppress localize fallback warning option, override context.fallbackWarn
+ *    translate(context, 'foo.bar', { name: 'kazupon' }, { fallbackWarn: false })
+ *
+ *    // escape parameter option, override context.escapeParameter
+ *    translate(context, 'foo.bar', { name: 'kazupon' }, { escapeParameter: true })
+ */
+/**
+ * Translate Options
+ *
+ * @remarks
+ * Options for Translation API
+ *
+ * @VueI18nGeneral
+ */
+export declare interface TranslateOptions<Locales = Locale> {
+    /**
+     * @remarks
+     * List interpolation
+     */
+    list?: unknown[];
+    /**
+     * @remarks
+     * Named interpolation
+     */
+    named?: NamedValue;
+    /**
+     * @remarks
+     * Plulralzation choice number
+     */
+    plural?: number;
+    /**
+     * @remarks
+     * Default message when is occurred translation missing
+     */
+    default?: string | boolean;
+    /**
+     * @remarks
+     * The locale of localization
+     */
+    locale?: Locales;
+    /**
+     * @remarks
+     * Whether suppress warnings outputted when localization fails
+     */
+    missingWarn?: boolean;
+    /**
+     * @remarks
+     * Whether do template interpolation on translation keys when your language lacks a translation for a key
+     */
+    fallbackWarn?: boolean;
+    /**
+     * @remarks
+     * Whether do escape parameter for list or named interpolation values
+     */
+    escapeParameter?: boolean;
+    /**
+     * @remarks
+     * Whether the message has been resolved
+     */
+    resolvedMessage?: boolean;
+}
+
+export declare type UnionToIntersection<U> = (U extends any ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
+
+export declare type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, Last>>, Last];
+
+/* Excluded from this release type: updateFallbackLocale */
+
+/* Excluded from this release type: VERSION */
+
+export { }

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/core-base/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/core-base.cjs.prod.js')
+} else {
+  module.exports = require('./dist/core-base.cjs.js')
+}

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/core-base/index.mjs

@@ -0,0 +1 @@
+export * from './index.js'

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/core-base/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@intlify/core-base",
+  "version": "9.2.2",
+  "description": "@intlify/core-base",
+  "keywords": [
+    "core",
+    "fundamental",
+    "i18n",
+    "internationalization",
+    "intlify"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n-next/tree/master/packages/core-base#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n-next.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n-next/issues"
+  },
+  "files": [
+    "index.js",
+    "index.mjs",
+    "dist"
+  ],
+  "main": "index.js",
+  "module": "dist/core-base.esm-bundler.js",
+  "unpkg": "dist/core-base.global.js",
+  "jsdelivr": "dist/core-base.global.js",
+  "types": "dist/core-base.d.ts",
+  "dependencies": {
+    "@intlify/devtools-if": "9.2.2",
+    "@intlify/message-compiler": "9.2.2",
+    "@intlify/shared": "9.2.2",
+    "@intlify/vue-devtools": "9.2.2"
+  },
+  "engines": {
+    "node": ">= 14"
+  },
+  "buildOptions": {
+    "name": "IntlifyCoreBase",
+    "formats": [
+      "esm-bundler",
+      "esm-browser",
+      "cjs",
+      "global"
+    ]
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "node": "./index.mjs",
+        "default": "./dist/core-base.esm-bundler.js"
+      },
+      "require": "./index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./index.mjs": "./index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/devtools-if/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 kazuya kawaguchi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/devtools-if/README.md

@@ -0,0 +1,13 @@
+# @intlify/devtools-if
+
+The [`@intlify/devtools`](https://github.com/intlify/devtools) interface(I/F:if) for intlify projects
+
+## :warning: NOTE:
+
+This is experimental.
+
+Don’t use in production yet.
+
+## :copyright: License
+
+[MIT](http://opensource.org/licenses/MIT)

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/devtools-if/dist/devtools-if.cjs.js

@@ -0,0 +1,15 @@
+/*!
+  * devtools-if v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const IntlifyDevToolsHooks =  {
+    I18nInit: 'i18n:init',
+    FunctionTranslate: 'function:translate'
+};
+
+exports.IntlifyDevToolsHooks = IntlifyDevToolsHooks;

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/devtools-if/dist/devtools-if.cjs.prod.js

@@ -0,0 +1,15 @@
+/*!
+  * devtools-if v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const IntlifyDevToolsHooks =  {
+    I18nInit: 'i18n:init',
+    FunctionTranslate: 'function:translate'
+};
+
+exports.IntlifyDevToolsHooks = IntlifyDevToolsHooks;

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/devtools-if/dist/devtools-if.d.ts

@@ -0,0 +1,43 @@
+import type { Emittable } from '@intlify/shared';
+
+export declare type AdditionalPayloads = {
+    meta?: Record<string, unknown>;
+};
+
+export declare type IntlifyDevToolsEmitter = Emittable<IntlifyDevToolsEmitterHooks>;
+
+export declare type IntlifyDevToolsEmitterHooks = {
+    [IntlifyDevToolsHooks.I18nInit]: IntlifyDevToolsHookPayloads[typeof IntlifyDevToolsHooks.I18nInit];
+    [IntlifyDevToolsHooks.FunctionTranslate]: IntlifyDevToolsHookPayloads[typeof IntlifyDevToolsHooks.FunctionTranslate];
+};
+
+export declare type IntlifyDevToolsHookPayloads = {
+    [IntlifyDevToolsHooks.I18nInit]: {
+        timestamp: number;
+        i18n: unknown;
+        version: string;
+    } & AdditionalPayloads;
+    [IntlifyDevToolsHooks.FunctionTranslate]: {
+        timestamp: number;
+        message: string | number;
+        key: string;
+        locale: string;
+        format?: string;
+    } & AdditionalPayloads;
+};
+
+export declare const IntlifyDevToolsHooks: {
+    readonly I18nInit: "i18n:init";
+    readonly FunctionTranslate: "function:translate";
+};
+
+export declare type IntlifyDevToolsHooks = typeof IntlifyDevToolsHooks[keyof typeof IntlifyDevToolsHooks];
+
+export declare interface IntlifyRecord {
+    id: number;
+    i18n: unknown;
+    version: string;
+    types: Record<string, string | Symbol>;
+}
+
+export { }

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/devtools-if/dist/devtools-if.esm-bundler.js

@@ -0,0 +1,11 @@
+/*!
+  * devtools-if v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+const IntlifyDevToolsHooks =  {
+    I18nInit: 'i18n:init',
+    FunctionTranslate: 'function:translate'
+};
+
+export { IntlifyDevToolsHooks };

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/devtools-if/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/devtools-if.cjs.prod.js')
+} else {
+  module.exports = require('./dist/devtools-if.cjs.js')
+}

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/devtools-if/index.mjs

@@ -0,0 +1 @@
+export * from './index.js'

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/devtools-if/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@intlify/devtools-if",
+  "version": "9.2.2",
+  "description": "@intlify/devtools-if",
+  "keywords": [
+    "devtools",
+    "i18n",
+    "internationalization",
+    "intlify"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n-next/tree/master/packages/devtools-if#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n-next.git",
+    "directory": "packages/devtools-if"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n-next/issues"
+  },
+  "files": [
+    "index.js",
+    "index.mjs",
+    "dist"
+  ],
+  "main": "index.js",
+  "module": "dist/devtools-if.esm-bundler.js",
+  "types": "dist/devtools-if.d.ts",
+  "dependencies": {
+    "@intlify/shared": "9.2.2"
+  },
+  "engines": {
+    "node": ">= 14"
+  },
+  "buildOptions": {
+    "name": "IntlifyDevToolsIf",
+    "formats": [
+      "esm-bundler",
+      "cjs"
+    ]
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "node": "./index.mjs",
+        "default": "./dist/devtools-if.esm-bundler.js"
+      },
+      "require": "./index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./index.mjs": "./index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/message-compiler/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 kazuya kawaguchi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/message-compiler/README.md

@@ -0,0 +1,7 @@
+# @intlify/message-compiler
+
+The message compiler for intlify project
+
+## :copyright: License
+
+[MIT](http://opensource.org/licenses/MIT)

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/message-compiler/dist/message-compiler.d.ts

@@ -0,0 +1,199 @@
+import { RawSourceMap } from 'source-map';
+
+export declare function baseCompile(source: string, options?: CompileOptions): CodeGenResult;
+
+export declare interface CodeGenOptions {
+    mode?: 'normal' | 'arrow';
+    breakLineCode?: '\n' | ';';
+    needIndent?: boolean;
+    onError?: CompileErrorHandler;
+    sourceMap?: boolean;
+    filename?: string;
+}
+
+declare interface CodeGenResult {
+    code: string;
+    ast: ResourceNode;
+    map?: RawSourceMap;
+}
+
+export declare type CompileCacheKeyHandler = (source: string) => string;
+
+export declare type CompileDomain = 'tokenizer' | 'parser' | 'generator' | 'transformer' | 'compiler';
+
+export declare interface CompileError extends SyntaxError {
+    code: number;
+    domain?: CompileDomain;
+    location?: SourceLocation;
+}
+
+export declare const CompileErrorCodes: {
+    readonly EXPECTED_TOKEN: 1;
+    readonly INVALID_TOKEN_IN_PLACEHOLDER: 2;
+    readonly UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3;
+    readonly UNKNOWN_ESCAPE_SEQUENCE: 4;
+    readonly INVALID_UNICODE_ESCAPE_SEQUENCE: 5;
+    readonly UNBALANCED_CLOSING_BRACE: 6;
+    readonly UNTERMINATED_CLOSING_BRACE: 7;
+    readonly EMPTY_PLACEHOLDER: 8;
+    readonly NOT_ALLOW_NEST_PLACEHOLDER: 9;
+    readonly INVALID_LINKED_FORMAT: 10;
+    readonly MUST_HAVE_MESSAGES_IN_PLURAL: 11;
+    readonly UNEXPECTED_EMPTY_LINKED_MODIFIER: 12;
+    readonly UNEXPECTED_EMPTY_LINKED_KEY: 13;
+    readonly UNEXPECTED_LEXICAL_ANALYSIS: 14;
+    readonly __EXTEND_POINT__: 15;
+};
+
+export declare type CompileErrorCodes = typeof CompileErrorCodes[keyof typeof CompileErrorCodes];
+
+export declare type CompileErrorHandler = (error: CompileError) => void;
+
+export declare type CompileOptions = {
+    warnHtmlMessage?: boolean;
+    onCacheKey?: CompileCacheKeyHandler;
+} & TransformOptions & CodeGenOptions & ParserOptions & TokenizeOptions;
+
+export declare function createCompileError<T extends number>(code: T, loc: SourceLocation | null, options?: CreateCompileErrorOptions): CompileError;
+
+export declare interface CreateCompileErrorOptions {
+    domain?: CompileDomain;
+    messages?: {
+        [code: number]: string;
+    };
+    args?: unknown[];
+}
+
+export declare function createLocation(start: Position, end: Position, source?: string): SourceLocation;
+
+export declare function createParser(options?: ParserOptions): Parser;
+
+export declare function createPosition(line: number, column: number, offset: number): Position;
+
+/* Excluded from this release type: defaultOnError */
+
+export declare const ERROR_DOMAIN = "parser";
+
+/* Excluded from this release type: errorMessages */
+
+export declare const enum HelperNameMap {
+    LIST = "list",
+    NAMED = "named",
+    PLURAL = "plural",
+    LINKED = "linked",
+    MESSAGE = "message",
+    TYPE = "type",
+    INTERPOLATE = "interpolate",
+    NORMALIZE = "normalize"
+}
+
+export declare type Identifier = string;
+
+export declare interface LinkedKeyNode extends Node_2 {
+    type: NodeTypes.LinkedKey;
+    value: string;
+}
+
+export declare interface LinkedModifierNode extends Node_2 {
+    type: NodeTypes.LinkedModifier;
+    value: Identifier;
+}
+
+export declare interface LinkedNode extends Node_2 {
+    type: NodeTypes.Linked;
+    modifier?: LinkedModifierNode;
+    key: LinkedKeyNode | NamedNode | ListNode | LiteralNode;
+}
+
+export declare interface ListNode extends Node_2 {
+    type: NodeTypes.List;
+    index: number;
+}
+
+export declare interface LiteralNode extends Node_2 {
+    type: NodeTypes.Literal;
+    value: string;
+}
+
+export declare const LocationStub: SourceLocation;
+
+declare type MessageElementNode = TextNode | NamedNode | ListNode | LiteralNode | LinkedNode;
+
+export declare interface MessageNode extends Node_2 {
+    type: NodeTypes.Message;
+    items: MessageElementNode[];
+}
+
+export declare interface NamedNode extends Node_2 {
+    type: NodeTypes.Named;
+    key: Identifier;
+}
+
+declare interface Node_2 {
+    type: NodeTypes;
+    start: number;
+    end: number;
+    loc?: SourceLocation;
+}
+export { Node_2 as Node }
+
+export declare const enum NodeTypes {
+    Resource = 0,
+    Plural = 1,
+    Message = 2,
+    Text = 3,
+    Named = 4,
+    List = 5,
+    Linked = 6,
+    LinkedKey = 7,
+    LinkedModifier = 8,
+    Literal = 9
+}
+
+export declare interface Parser {
+    parse(source: string): ResourceNode;
+}
+
+export declare interface ParserOptions {
+    location?: boolean;
+    onError?: CompileErrorHandler;
+}
+
+export declare interface PluralNode extends Node_2 {
+    type: NodeTypes.Plural;
+    cases: MessageNode[];
+}
+
+export declare interface Position {
+    offset: number;
+    line: number;
+    column: number;
+}
+
+export declare interface ResourceNode extends Node_2 {
+    type: NodeTypes.Resource;
+    body: MessageNode | PluralNode;
+    helpers?: string[];
+}
+
+export declare interface SourceLocation {
+    start: Position;
+    end: Position;
+    source?: string;
+}
+
+export declare interface TextNode extends Node_2 {
+    type: NodeTypes.Text;
+    value: string;
+}
+
+export declare interface TokenizeOptions {
+    location?: boolean;
+    onError?: CompileErrorHandler;
+}
+
+export declare interface TransformOptions {
+    onError?: CompileErrorHandler;
+}
+
+export { }

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/message-compiler/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/message-compiler.cjs.prod.js')
+} else {
+  module.exports = require('./dist/message-compiler.cjs.js')
+}

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/message-compiler/index.mjs

@@ -0,0 +1 @@
+export * from './index.js'

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/message-compiler/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@intlify/message-compiler",
+  "version": "9.2.2",
+  "description": "@intlify/message-compiler",
+  "keywords": [
+    "compiler",
+    "i18n",
+    "internationalization",
+    "intlify",
+    "message-format"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n-next/tree/master/packages/message-compiler#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n-next.git",
+    "directory": "packages/message-compiler"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n-next/issues"
+  },
+  "files": [
+    "index.js",
+    "index.mjs",
+    "dist"
+  ],
+  "main": "index.js",
+  "module": "dist/message-compiler.esm-bundler.js",
+  "unpkg": "dist/message-compiler.global.js",
+  "jsdelivr": "dist/message-compiler.global.js",
+  "types": "dist/message-compiler.d.ts",
+  "dependencies": {
+    "@intlify/shared": "9.2.2",
+    "source-map": "0.6.1"
+  },
+  "engines": {
+    "node": ">= 14"
+  },
+  "buildOptions": {
+    "name": "IntlifyMessageCompiler",
+    "formats": [
+      "esm-bundler",
+      "esm-browser",
+      "cjs",
+      "global"
+    ],
+    "enableFullBundleForEsmBrowser": true
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "node": "./index.mjs",
+        "default": "./dist/message-compiler.esm-bundler.js"
+      },
+      "require": "./index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./index.mjs": "./index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/shared/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 kazuya kawaguchi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/shared/README.md

@@ -0,0 +1,18 @@
+# @intlify/shared
+
+The shared utility package for intlify project
+
+## Forks
+The implementation of this module is contains code forked from other packages or projects:
+
+- [@vue/shared](https://github.com/vuejs/vue-next/tree/master/packages/shared)
+  - Useful Utilities at `utils.ts`
+    - Author: Evan You
+    - License: MIT
+  - Event Emitter at `emitter.ts` and `emittable.ts`
+    - Author: Jason Miller
+    - License: MIT
+
+## :copyright: License
+
+[MIT](http://opensource.org/licenses/MIT)

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/shared/dist/shared.cjs.js

@@ -0,0 +1,222 @@
+/*!
+  * shared v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+const inBrowser = typeof window !== 'undefined';
+exports.mark = void 0;
+exports.measure = void 0;
+{
+    const perf = inBrowser && window.performance;
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        exports.mark = (tag) => perf.mark(tag);
+        exports.measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+        };
+    }
+}
+const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+/* eslint-disable */
+function format(message, ...args) {
+    if (args.length === 1 && isObject(args[0])) {
+        args = args[0];
+    }
+    if (!args || !args.hasOwnProperty) {
+        args = {};
+    }
+    return message.replace(RE_ARGS, (match, identifier) => {
+        return args.hasOwnProperty(identifier) ? args[identifier] : '';
+    });
+}
+const hasSymbol = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
+const makeSymbol = (name) => hasSymbol ? Symbol(name) : name;
+const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
+const friendlyJSONstringify = (json) => JSON.stringify(json)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/\u0027/g, '\\u0027');
+const isNumber = (val) => typeof val === 'number' && isFinite(val);
+const isDate = (val) => toTypeString(val) === '[object Date]';
+const isRegExp = (val) => toTypeString(val) === '[object RegExp]';
+const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
+function warn(msg, err) {
+    if (typeof console !== 'undefined') {
+        console.warn(`[intlify] ` + msg);
+        /* istanbul ignore if */
+        if (err) {
+            console.warn(err.stack);
+        }
+    }
+}
+const assign = Object.assign;
+let _globalThis;
+const getGlobalThis = () => {
+    // prettier-ignore
+    return (_globalThis ||
+        (_globalThis =
+            typeof globalThis !== 'undefined'
+                ? globalThis
+                : typeof self !== 'undefined'
+                    ? self
+                    : typeof window !== 'undefined'
+                        ? window
+                        : typeof global !== 'undefined'
+                            ? global
+                            : {}));
+};
+function escapeHtml(rawText) {
+    return rawText
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/* eslint-enable */
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+const isArray = Array.isArray;
+const isFunction = (val) => typeof val === 'function';
+const isString = (val) => typeof val === 'string';
+const isBoolean = (val) => typeof val === 'boolean';
+const isSymbol = (val) => typeof val === 'symbol';
+const isObject = (val) => // eslint-disable-line
+ val !== null && typeof val === 'object';
+const isPromise = (val) => {
+    return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const isPlainObject = (val) => toTypeString(val) === '[object Object]';
+// for converting list and named values to displayed strings.
+const toDisplayString = (val) => {
+    return val == null
+        ? ''
+        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+};
+const RANGE = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+
+/**
+ * Event emitter, forked from the below:
+ * - original repository url: https://github.com/developit/mitt
+ * - code url: https://github.com/developit/mitt/blob/master/src/index.ts
+ * - author: Jason Miller (https://github.com/developit)
+ * - license: MIT
+ */
+/**
+ * Create a event emitter
+ *
+ * @returns An event emitter
+ */
+function createEmitter() {
+    const events = new Map();
+    const emitter = {
+        events,
+        on(event, handler) {
+            const handlers = events.get(event);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                events.set(event, [handler]);
+            }
+        },
+        off(event, handler) {
+            const handlers = events.get(event);
+            if (handlers) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit(event, payload) {
+            (events.get(event) || [])
+                .slice()
+                .map(handler => handler(payload));
+            (events.get('*') || [])
+                .slice()
+                .map(handler => handler(event, payload));
+        }
+    };
+    return emitter;
+}
+
+exports.assign = assign;
+exports.createEmitter = createEmitter;
+exports.escapeHtml = escapeHtml;
+exports.format = format;
+exports.friendlyJSONstringify = friendlyJSONstringify;
+exports.generateCodeFrame = generateCodeFrame;
+exports.generateFormatCacheKey = generateFormatCacheKey;
+exports.getGlobalThis = getGlobalThis;
+exports.hasOwn = hasOwn;
+exports.inBrowser = inBrowser;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isEmptyObject = isEmptyObject;
+exports.isFunction = isFunction;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.makeSymbol = makeSymbol;
+exports.objectToString = objectToString;
+exports.toDisplayString = toDisplayString;
+exports.toTypeString = toTypeString;
+exports.warn = warn;

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/shared/dist/shared.cjs.prod.js

@@ -0,0 +1,209 @@
+/*!
+  * shared v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+const inBrowser = typeof window !== 'undefined';
+let mark;
+let measure;
+const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+/* eslint-disable */
+function format(message, ...args) {
+    if (args.length === 1 && isObject(args[0])) {
+        args = args[0];
+    }
+    if (!args || !args.hasOwnProperty) {
+        args = {};
+    }
+    return message.replace(RE_ARGS, (match, identifier) => {
+        return args.hasOwnProperty(identifier) ? args[identifier] : '';
+    });
+}
+const hasSymbol = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
+const makeSymbol = (name) => hasSymbol ? Symbol(name) : name;
+const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
+const friendlyJSONstringify = (json) => JSON.stringify(json)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/\u0027/g, '\\u0027');
+const isNumber = (val) => typeof val === 'number' && isFinite(val);
+const isDate = (val) => toTypeString(val) === '[object Date]';
+const isRegExp = (val) => toTypeString(val) === '[object RegExp]';
+const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
+function warn(msg, err) {
+    if (typeof console !== 'undefined') {
+        console.warn(`[intlify] ` + msg);
+        /* istanbul ignore if */
+        if (err) {
+            console.warn(err.stack);
+        }
+    }
+}
+const assign = Object.assign;
+let _globalThis;
+const getGlobalThis = () => {
+    // prettier-ignore
+    return (_globalThis ||
+        (_globalThis =
+            typeof globalThis !== 'undefined'
+                ? globalThis
+                : typeof self !== 'undefined'
+                    ? self
+                    : typeof window !== 'undefined'
+                        ? window
+                        : typeof global !== 'undefined'
+                            ? global
+                            : {}));
+};
+function escapeHtml(rawText) {
+    return rawText
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/* eslint-enable */
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+const isArray = Array.isArray;
+const isFunction = (val) => typeof val === 'function';
+const isString = (val) => typeof val === 'string';
+const isBoolean = (val) => typeof val === 'boolean';
+const isSymbol = (val) => typeof val === 'symbol';
+const isObject = (val) => // eslint-disable-line
+ val !== null && typeof val === 'object';
+const isPromise = (val) => {
+    return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const isPlainObject = (val) => toTypeString(val) === '[object Object]';
+// for converting list and named values to displayed strings.
+const toDisplayString = (val) => {
+    return val == null
+        ? ''
+        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+};
+const RANGE = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+
+/**
+ * Event emitter, forked from the below:
+ * - original repository url: https://github.com/developit/mitt
+ * - code url: https://github.com/developit/mitt/blob/master/src/index.ts
+ * - author: Jason Miller (https://github.com/developit)
+ * - license: MIT
+ */
+/**
+ * Create a event emitter
+ *
+ * @returns An event emitter
+ */
+function createEmitter() {
+    const events = new Map();
+    const emitter = {
+        events,
+        on(event, handler) {
+            const handlers = events.get(event);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                events.set(event, [handler]);
+            }
+        },
+        off(event, handler) {
+            const handlers = events.get(event);
+            if (handlers) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit(event, payload) {
+            (events.get(event) || [])
+                .slice()
+                .map(handler => handler(payload));
+            (events.get('*') || [])
+                .slice()
+                .map(handler => handler(event, payload));
+        }
+    };
+    return emitter;
+}
+
+exports.assign = assign;
+exports.createEmitter = createEmitter;
+exports.escapeHtml = escapeHtml;
+exports.format = format;
+exports.friendlyJSONstringify = friendlyJSONstringify;
+exports.generateCodeFrame = generateCodeFrame;
+exports.generateFormatCacheKey = generateFormatCacheKey;
+exports.getGlobalThis = getGlobalThis;
+exports.hasOwn = hasOwn;
+exports.inBrowser = inBrowser;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isEmptyObject = isEmptyObject;
+exports.isFunction = isFunction;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.makeSymbol = makeSymbol;
+exports.mark = mark;
+exports.measure = measure;
+exports.objectToString = objectToString;
+exports.toDisplayString = toDisplayString;
+exports.toTypeString = toTypeString;
+exports.warn = warn;

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/shared/dist/shared.d.ts

@@ -0,0 +1,145 @@
+
+export declare const assign: {
+    <T, U>(target: T, source: U): T & U;
+    <T_1, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+};
+
+/**
+ * Create a event emitter
+ *
+ * @returns An event emitter
+ */
+export declare function createEmitter<Events extends Record<EventType, unknown>>(): Emittable<Events>;
+
+/**
+ * Event emitter interface
+ */
+export declare interface Emittable<Events extends Record<EventType, unknown> = {}> {
+    /**
+     * A map of event names of registered event handlers
+     */
+    events: EventHandlerMap<Events>;
+    /**
+     * Register an event handler with the event type
+     *
+     * @param event - An {@link EventType}
+     * @param handler - An {@link EventHandler}, or a {@link WildcardEventHandler} if you are specified "*"
+     */
+    on<Key extends keyof Events>(event: Key | '*', handler: EventHandler<Events[keyof Events]> | WildcardEventHandler<Events>): void;
+    /**
+     * Unregister an event handler for the event type
+     *
+     * @param event - An {@link EventType}
+     * @param handler - An {@link EventHandler}, or a {@link WildcardEventHandler} if you are specified "*"
+     */
+    off<Key extends keyof Events>(event: Key | '*', handler: EventHandler<Events[keyof Events]> | WildcardEventHandler<Events>): void;
+    /**
+     * Invoke all handlers with the event type
+     *
+     * @remarks
+     * Note Manually firing "*" handlers should be not supported
+     *
+     * @param event - An {@link EventType}
+     * @param payload - An event payload, optional
+     */
+    emit<Key extends keyof Events>(event: Key, payload?: Events[keyof Events]): void;
+}
+
+export declare function escapeHtml(rawText: string): string;
+
+/**
+ * Event handler
+ */
+export declare type EventHandler<T = unknown> = (payload?: T) => void;
+
+/**
+ * Event handler list
+ */
+export declare type EventHandlerList<T = unknown> = Array<EventHandler<T>>;
+
+/**
+ * Event handler map
+ */
+export declare type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | '*', EventHandlerList<Events[keyof Events]> | WildcardEventHandlerList<Events>>;
+
+/**
+ * Event type
+ */
+export declare type EventType = string | symbol;
+
+export declare function format(message: string, ...args: any): string;
+
+export declare const friendlyJSONstringify: (json: unknown) => string;
+
+export declare function generateCodeFrame(source: string, start?: number, end?: number): string;
+
+export declare const generateFormatCacheKey: (locale: string, key: string, source: string) => string;
+
+export declare const getGlobalThis: () => any;
+
+export declare function hasOwn(obj: object | Array<any>, key: string): boolean;
+
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+export declare const inBrowser: boolean;
+
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+export declare const isArray: (arg: any) => arg is any[];
+
+export declare const isBoolean: (val: unknown) => val is boolean;
+
+export declare const isDate: (val: unknown) => val is Date;
+
+export declare const isEmptyObject: (val: unknown) => val is boolean;
+
+export declare const isFunction: (val: unknown) => val is Function;
+
+export declare const isNumber: (val: unknown) => val is number;
+
+export declare const isObject: (val: unknown) => val is Record<any, any>;
+
+export declare const isPlainObject: (val: unknown) => val is object;
+
+export declare const isPromise: <T = any>(val: unknown) => val is Promise<T>;
+
+export declare const isRegExp: (val: unknown) => val is RegExp;
+
+export declare const isString: (val: unknown) => val is string;
+
+export declare const isSymbol: (val: unknown) => val is symbol;
+
+export declare const makeSymbol: (name: string) => symbol | string;
+
+export declare let mark: (tag: string) => void | undefined;
+
+export declare let measure: (name: string, startTag: string, endTag: string) => void | undefined;
+
+export declare const objectToString: () => string;
+
+export declare const toDisplayString: (val: unknown) => string;
+
+export declare const toTypeString: (value: unknown) => string;
+
+export declare function warn(msg: string, err?: Error): void;
+
+/**
+ * Wildcard event handler
+ */
+export declare type WildcardEventHandler<T = Record<string, unknown>> = (event: keyof T, payload?: T[keyof T]) => void;
+
+/**
+ * Wildcard event handler list
+ */
+export declare type WildcardEventHandlerList<T = Record<string, unknown>> = Array<WildcardEventHandler<T>>;
+
+export { }

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/shared/dist/shared.esm-bundler.js

@@ -0,0 +1,192 @@
+/*!
+  * shared v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+const inBrowser = typeof window !== 'undefined';
+let mark;
+let measure;
+if ((process.env.NODE_ENV !== 'production')) {
+    const perf = inBrowser && window.performance;
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+        };
+    }
+}
+const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+/* eslint-disable */
+function format(message, ...args) {
+    if (args.length === 1 && isObject(args[0])) {
+        args = args[0];
+    }
+    if (!args || !args.hasOwnProperty) {
+        args = {};
+    }
+    return message.replace(RE_ARGS, (match, identifier) => {
+        return args.hasOwnProperty(identifier) ? args[identifier] : '';
+    });
+}
+const hasSymbol = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
+const makeSymbol = (name) => hasSymbol ? Symbol(name) : name;
+const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
+const friendlyJSONstringify = (json) => JSON.stringify(json)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/\u0027/g, '\\u0027');
+const isNumber = (val) => typeof val === 'number' && isFinite(val);
+const isDate = (val) => toTypeString(val) === '[object Date]';
+const isRegExp = (val) => toTypeString(val) === '[object RegExp]';
+const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
+function warn(msg, err) {
+    if (typeof console !== 'undefined') {
+        console.warn(`[intlify] ` + msg);
+        /* istanbul ignore if */
+        if (err) {
+            console.warn(err.stack);
+        }
+    }
+}
+const assign = Object.assign;
+let _globalThis;
+const getGlobalThis = () => {
+    // prettier-ignore
+    return (_globalThis ||
+        (_globalThis =
+            typeof globalThis !== 'undefined'
+                ? globalThis
+                : typeof self !== 'undefined'
+                    ? self
+                    : typeof window !== 'undefined'
+                        ? window
+                        : typeof global !== 'undefined'
+                            ? global
+                            : {}));
+};
+function escapeHtml(rawText) {
+    return rawText
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/* eslint-enable */
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+const isArray = Array.isArray;
+const isFunction = (val) => typeof val === 'function';
+const isString = (val) => typeof val === 'string';
+const isBoolean = (val) => typeof val === 'boolean';
+const isSymbol = (val) => typeof val === 'symbol';
+const isObject = (val) => // eslint-disable-line
+ val !== null && typeof val === 'object';
+const isPromise = (val) => {
+    return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const isPlainObject = (val) => toTypeString(val) === '[object Object]';
+// for converting list and named values to displayed strings.
+const toDisplayString = (val) => {
+    return val == null
+        ? ''
+        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+};
+const RANGE = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+
+/**
+ * Event emitter, forked from the below:
+ * - original repository url: https://github.com/developit/mitt
+ * - code url: https://github.com/developit/mitt/blob/master/src/index.ts
+ * - author: Jason Miller (https://github.com/developit)
+ * - license: MIT
+ */
+/**
+ * Create a event emitter
+ *
+ * @returns An event emitter
+ */
+function createEmitter() {
+    const events = new Map();
+    const emitter = {
+        events,
+        on(event, handler) {
+            const handlers = events.get(event);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                events.set(event, [handler]);
+            }
+        },
+        off(event, handler) {
+            const handlers = events.get(event);
+            if (handlers) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit(event, payload) {
+            (events.get(event) || [])
+                .slice()
+                .map(handler => handler(payload));
+            (events.get('*') || [])
+                .slice()
+                .map(handler => handler(event, payload));
+        }
+    };
+    return emitter;
+}
+
+export { assign, createEmitter, escapeHtml, format, friendlyJSONstringify, generateCodeFrame, generateFormatCacheKey, getGlobalThis, hasOwn, inBrowser, isArray, isBoolean, isDate, isEmptyObject, isFunction, isNumber, isObject, isPlainObject, isPromise, isRegExp, isString, isSymbol, makeSymbol, mark, measure, objectToString, toDisplayString, toTypeString, warn };

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/shared/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/shared.cjs.prod.js')
+} else {
+  module.exports = require('./dist/shared.cjs.js')
+}

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/shared/index.mjs

@@ -0,0 +1 @@
+export * from './index.js'

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/shared/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@intlify/shared",
+  "version": "9.2.2",
+  "description": "@intlify/shared",
+  "keywords": [
+    "i18n",
+    "internationalization",
+    "intlify",
+    "utitlity"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n-next/tree/master/packages/shared#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n-next.git",
+    "directory": "packages/shared"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n-next/issues"
+  },
+  "files": [
+    "index.js",
+    "index.mjs",
+    "dist"
+  ],
+  "main": "index.js",
+  "module": "dist/shared.esm-bundler.js",
+  "types": "dist/shared.d.ts",
+  "engines": {
+    "node": ">= 14"
+  },
+  "buildOptions": {
+    "name": "IntlifyShared",
+    "formats": [
+      "esm-bundler",
+      "cjs"
+    ]
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "node": "./index.mjs",
+        "default": "./dist/shared.esm-bundler.js"
+      },
+      "require": "./index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./index.mjs": "./index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/vue-devtools/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 kazuya kawaguchi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/vue-devtools/README.md

@@ -0,0 +1,7 @@
+# @intlify/vue-devtools
+
+The Vue DevTools I/F package for intlify project
+
+## :copyright: License
+
+[MIT](http://opensource.org/licenses/MIT)

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/vue-devtools/dist/vue-devtools.cjs.js

@@ -0,0 +1,24 @@
+/*!
+  * vue-devtools v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const VueDevToolsLabels = {
+    ["vue-devtools-plugin-vue-i18n" /* PLUGIN */]: 'Vue I18n devtools',
+    ["vue-i18n-resource-inspector" /* CUSTOM_INSPECTOR */]: 'I18n Resources',
+    ["vue-i18n-timeline" /* TIMELINE */]: 'Vue I18n'
+};
+const VueDevToolsPlaceholders = {
+    ["vue-i18n-resource-inspector" /* CUSTOM_INSPECTOR */]: 'Search for scopes ...'
+};
+const VueDevToolsTimelineColors = {
+    ["vue-i18n-timeline" /* TIMELINE */]: 0xffcd19
+};
+
+exports.VueDevToolsLabels = VueDevToolsLabels;
+exports.VueDevToolsPlaceholders = VueDevToolsPlaceholders;
+exports.VueDevToolsTimelineColors = VueDevToolsTimelineColors;

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/vue-devtools/dist/vue-devtools.cjs.prod.js

@@ -0,0 +1,24 @@
+/*!
+  * vue-devtools v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const VueDevToolsLabels = {
+    ["vue-devtools-plugin-vue-i18n" /* PLUGIN */]: 'Vue I18n devtools',
+    ["vue-i18n-resource-inspector" /* CUSTOM_INSPECTOR */]: 'I18n Resources',
+    ["vue-i18n-timeline" /* TIMELINE */]: 'Vue I18n'
+};
+const VueDevToolsPlaceholders = {
+    ["vue-i18n-resource-inspector" /* CUSTOM_INSPECTOR */]: 'Search for scopes ...'
+};
+const VueDevToolsTimelineColors = {
+    ["vue-i18n-timeline" /* TIMELINE */]: 0xffcd19
+};
+
+exports.VueDevToolsLabels = VueDevToolsLabels;
+exports.VueDevToolsPlaceholders = VueDevToolsPlaceholders;
+exports.VueDevToolsTimelineColors = VueDevToolsTimelineColors;

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/vue-devtools/dist/vue-devtools.d.ts

@@ -0,0 +1,81 @@
+import type { CoreMissingType } from '@intlify/core-base';
+import type { Emittable } from '@intlify/shared';
+import type { Locale } from '@intlify/core-base';
+import type { Path } from '@intlify/core-base';
+import type { PathValue } from '@intlify/core-base';
+
+export declare type VueDevToolsEmitter = Emittable<VueDevToolsEmitterEvents>;
+
+export declare type VueDevToolsEmitterEvents = {
+    [VueDevToolsTimelineEvents.COMPILE_ERROR]: VueDevToolsTimelineEventPayloads[VueDevToolsTimelineEvents.COMPILE_ERROR];
+    [VueDevToolsTimelineEvents.MISSING]: VueDevToolsTimelineEventPayloads[VueDevToolsTimelineEvents.MISSING];
+    [VueDevToolsTimelineEvents.FALBACK]: VueDevToolsTimelineEventPayloads[VueDevToolsTimelineEvents.FALBACK];
+    [VueDevToolsTimelineEvents.MESSAGE_RESOLVE]: VueDevToolsTimelineEventPayloads[VueDevToolsTimelineEvents.MESSAGE_RESOLVE];
+    [VueDevToolsTimelineEvents.MESSAGE_COMPILATION]: VueDevToolsTimelineEventPayloads[VueDevToolsTimelineEvents.MESSAGE_COMPILATION];
+    [VueDevToolsTimelineEvents.MESSAGE_EVALUATION]: VueDevToolsTimelineEventPayloads[VueDevToolsTimelineEvents.MESSAGE_EVALUATION];
+};
+
+export declare const enum VueDevToolsIDs {
+    PLUGIN = "vue-devtools-plugin-vue-i18n",
+    CUSTOM_INSPECTOR = "vue-i18n-resource-inspector",
+    TIMELINE = "vue-i18n-timeline"
+}
+
+export declare const VueDevToolsLabels: Record<string, string>;
+
+export declare const VueDevToolsPlaceholders: Record<string, string>;
+
+export declare const VueDevToolsTimelineColors: Record<string, number>;
+
+export declare type VueDevToolsTimelineEventPayloads = {
+    [VueDevToolsTimelineEvents.COMPILE_ERROR]: {
+        message: PathValue;
+        error: string;
+        start?: number;
+        end?: number;
+        groupId?: string;
+    };
+    [VueDevToolsTimelineEvents.MISSING]: {
+        locale: Locale;
+        key: Path;
+        type: CoreMissingType;
+        groupId?: string;
+    };
+    [VueDevToolsTimelineEvents.FALBACK]: {
+        key: Path;
+        type: CoreMissingType;
+        from?: Locale;
+        to: Locale | 'global';
+        groupId?: string;
+    };
+    [VueDevToolsTimelineEvents.MESSAGE_RESOLVE]: {
+        type: VueDevToolsTimelineEvents.MESSAGE_RESOLVE;
+        key: Path;
+        message: PathValue;
+        time: number;
+        groupId?: string;
+    };
+    [VueDevToolsTimelineEvents.MESSAGE_COMPILATION]: {
+        type: VueDevToolsTimelineEvents.MESSAGE_COMPILATION;
+        message: PathValue;
+        time: number;
+        groupId?: string;
+    };
+    [VueDevToolsTimelineEvents.MESSAGE_EVALUATION]: {
+        type: VueDevToolsTimelineEvents.MESSAGE_EVALUATION;
+        value: unknown;
+        time: number;
+        groupId?: string;
+    };
+};
+
+export declare const enum VueDevToolsTimelineEvents {
+    COMPILE_ERROR = "compile-error",
+    MISSING = "missing",
+    FALBACK = "fallback",
+    MESSAGE_RESOLVE = "message-resolve",
+    MESSAGE_COMPILATION = "message-compilation",
+    MESSAGE_EVALUATION = "message-evaluation"
+}
+
+export { }

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/vue-devtools/dist/vue-devtools.esm-bundler.js

@@ -0,0 +1,18 @@
+/*!
+  * vue-devtools v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+const VueDevToolsLabels = {
+    ["vue-devtools-plugin-vue-i18n" /* PLUGIN */]: 'Vue I18n devtools',
+    ["vue-i18n-resource-inspector" /* CUSTOM_INSPECTOR */]: 'I18n Resources',
+    ["vue-i18n-timeline" /* TIMELINE */]: 'Vue I18n'
+};
+const VueDevToolsPlaceholders = {
+    ["vue-i18n-resource-inspector" /* CUSTOM_INSPECTOR */]: 'Search for scopes ...'
+};
+const VueDevToolsTimelineColors = {
+    ["vue-i18n-timeline" /* TIMELINE */]: 0xffcd19
+};
+
+export { VueDevToolsLabels, VueDevToolsPlaceholders, VueDevToolsTimelineColors };

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/vue-devtools/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/vue-devtools.cjs.prod.js')
+} else {
+  module.exports = require('./dist/vue-devtools.cjs.js')
+}

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/vue-devtools/index.mjs

@@ -0,0 +1 @@
+export * from './index.js'

uni_modules/UniDevTools/node_modules/vue-i18n/node_modules/@intlify/vue-devtools/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@intlify/vue-devtools",
+  "version": "9.2.2",
+  "description": "@intlify/vue-devtools",
+  "keywords": [
+    "i18n",
+    "internationalization",
+    "intlify",
+    "vue-devtools"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n-next/tree/master/packages/vue-devtools#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n-next.git",
+    "directory": "packages/vue-devtools"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n-next/issues"
+  },
+  "files": [
+    "index.js",
+    "index.mjs",
+    "dist"
+  ],
+  "main": "index.js",
+  "module": "dist/vue-devtools.esm-bundler.js",
+  "types": "dist/vue-devtools.d.ts",
+  "dependencies": {
+    "@intlify/core-base": "9.2.2",
+    "@intlify/shared": "9.2.2"
+  },
+  "engines": {
+    "node": ">= 14"
+  },
+  "buildOptions": {
+    "name": "IntlifyVueDevtools",
+    "formats": [
+      "esm-bundler",
+      "cjs"
+    ]
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "node": "./index.mjs",
+        "default": "./dist/vue-devtools.esm-bundler.js"
+      },
+      "require": "./index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./index.mjs": "./index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}

uni_modules/UniDevTools/node_modules/vue-i18n/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "vue-i18n",
+  "version": "9.2.2",
+  "description": "Internationalization plugin for Vue.js",
+  "keywords": [
+    "i18n",
+    "internationalization",
+    "intlify",
+    "plugin",
+    "vue",
+    "vue.js"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n-next/tree/master/packages/vue-i18n#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n-next.git",
+    "directory": "packages/vue-i18n"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n-next/issues"
+  },
+  "files": [
+    "index.js",
+    "index.mjs",
+    "dist",
+    "vetur"
+  ],
+  "main": "index.js",
+  "module": "dist/vue-i18n.esm-bundler.js",
+  "unpkg": "dist/vue-i18n.global.js",
+  "jsdelivr": "dist/vue-i18n.global.js",
+  "types": "dist/vue-i18n.d.ts",
+  "dependencies": {
+    "@intlify/core-base": "9.2.2",
+    "@intlify/shared": "9.2.2",
+    "@intlify/vue-devtools": "9.2.2",
+    "@vue/devtools-api": "^6.2.1"
+  },
+  "devDependencies": {
+    "@intlify/devtools-if": "9.2.2"
+  },
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  },
+  "engines": {
+    "node": ">= 14"
+  },
+  "buildOptions": {
+    "name": "VueI18n",
+    "formats": [
+      "esm-bundler",
+      "esm-bundler-runtime",
+      "esm-browser",
+      "esm-browser-runtime",
+      "cjs",
+      "global",
+      "global-runtime"
+    ]
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "node": "./index.mjs",
+        "default": "./dist/vue-i18n.esm-bundler.js"
+      },
+      "require": "./index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./index.mjs": "./index.mjs",
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "vetur": {
+    "tags": "vetur/tags.json",
+    "attributes": "vetur/attributes.json"
+  }
+}

uni_modules/UniDevTools/node_modules/vue-i18n/vetur/attributes.json

@@ -0,0 +1,62 @@
+{
+  "i18n-t/keypath": {
+    "description": "[required]\nThe locale message key can be specified prop",
+    "type": "string"
+  },
+  "i18n-t/plural": {
+    "description": "[optional]\nThe Plural Choosing the message number prop",
+    "type": "number|string"
+  },
+  "i18n-t/locale": {
+    "description": "[optional]\nThe locale to be used for the component",
+    "type": "string"
+  },
+  "i18n-t/scope": {
+    "description": "[optional]\tThe scope to be used in the target component.\nYou can specify either `global` or `parent`",
+    "type": "string"
+  },
+  "i18n-t/tag": {
+    "description": "[optional]\nUsed to wrap the content that is distribute in the slot.\nIf omitted, the slot content is treated as Fragments",
+    "type": "string|object"
+  },
+  "i18n-d/value": {
+    "description": "[required]\nThe value specified for the target component",
+    "type": "number|date"
+  },
+  "i18n-d/format": {
+    "description": "[optional]\nThe format to use in the target component",
+    "type": "string|object"
+  },
+  "i18n-d/locale": {
+    "description": "[optional]\nThe locale to be used for the component",
+    "type": "string"
+  },
+  "i18n-d/scope": {
+    "description": "[optional]\tThe scope to be used in the target component.\nYou can specify either `global` or `parent`",
+    "type": "string"
+  },
+  "i18n-d/tag": {
+    "description": "[optional]\nUsed to wrap the content that is distribute in the slot.\nIf omitted, the slot content is treated as Fragments",
+    "type": "string|object"
+  },
+  "i18n-n/value": {
+    "description": "[required]\nThe value specified for the target component",
+    "type": "number"
+  },
+  "i18n-n/format": {
+    "description": "[optional]\nThe format to use in the target component",
+    "type": "string|object"
+  },
+  "i18n-n/locale": {
+    "description": "[optional]\nThe locale to be used for the component",
+    "type": "string"
+  },
+  "i18n-n/scope": {
+    "description": "[optional]\tThe scope to be used in the target component.\nYou can specify either `global` or `parent`",
+    "type": "string"
+  },
+  "i18n-n/tag": {
+    "description": "[optional]\nUsed to wrap the content that is distribute in the slot.\nIf omitted, the slot content is treated as Fragments",
+    "type": "string|object"
+  }
+}

uni_modules/UniDevTools/node_modules/vue-i18n/vetur/tags.json

@@ -0,0 +1,14 @@
+{
+  "i18n-t": {
+    "attributes": ["keypath", "locale", "tag", "plural", "scope"],
+    "description": "This is Translation component that can be used when HTML interpolation is needed.\n\nhttps://vue-i18n.intlify.dev/guide/advanced/component.html#basic-usage"
+  },
+  "i18n-d": {
+    "attributes": ["value", "format", "locale", "tag", "scope"],
+    "description": "This is Datetime Format component provides a way to use HTML interpolation in pair with number formatting.\n\nhttps://vue-i18n.intlify.dev/guide/essentials/datetime.html#custom-formatting"
+  },
+  "i18n-n": {
+    "attributes": ["value", "format", "locale", "tag", "scope"],
+    "description": "This is Number Format component provides a way to use HTML interpolation in pair with number formatting.\n\nhttps://vue-i18n.intlify.dev/guide/essentials/number.html#custom-formatting"
+  }
+}