@intlify/unplugin-vue-i18n 7.0.0-beta.1 → 12.0.0-alpha.0

package/lib/index.cjs

@@ -2,29 +2,34 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const unplugin$1 = require('unplugin');
 const createDebug = require('debug');
-const pc = require('picocolors');
-const path = require('node:path');
-const pathe = require('pathe');
+const unplugin$1 = require('unplugin');
 const shared = require('@intlify/shared');
-const bundleUtils = require('@intlify/bundle-utils');
-const pluginutils = require('@rollup/pluginutils');
-const fg = require('fast-glob');
-const node_fs = require('node:fs');
-const compilerSfc = require('vue/compiler-sfc');
 const vueI18nExtensions = require('@intlify/vue-i18n-extensions');
 const scopeManager = require('@typescript-eslint/scope-manager');
 const typescriptEstree = require('@typescript-eslint/typescript-estree');
+const path = require('node:path');
 const eslintUitls = require('@eslint-community/eslint-utils');
+const pc = require('picocolors');
+const defu = require('defu');
+const bundleUtils = require('@intlify/bundle-utils');
+const pluginutils = require('@rollup/pluginutils');
+const fg = require('fast-glob');
+const knitwork = require('knitwork');
+const mlly = require('mlly');
+const node_crypto = require('node:crypto');
+const fs = require('node:fs');
+const compilerSfc = require('vue/compiler-sfc');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const createDebug__default = /*#__PURE__*/_interopDefaultCompat(createDebug);
-const pc__default = /*#__PURE__*/_interopDefaultCompat(pc);
 const path__default = /*#__PURE__*/_interopDefaultCompat(path);
-const fg__default = /*#__PURE__*/_interopDefaultCompat(fg);
 const eslintUitls__default = /*#__PURE__*/_interopDefaultCompat(eslintUitls);
+const pc__default = /*#__PURE__*/_interopDefaultCompat(pc);
+const defu__default = /*#__PURE__*/_interopDefaultCompat(defu);
+const fg__default = /*#__PURE__*/_interopDefaultCompat(fg);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 
 const PKG_NAME = "unplugin-vue-i18n";
 
@@ -62,64 +67,26 @@ function normalizePath(id) {
   return path__default.posix.normalize(isWindows ? slash(id) : id);
 }
 
-function resolveOptions(options) {
-  const moduleType = options.module || "vue-i18n";
-  let onlyLocales = [];
-  if (options.onlyLocales) {
-    onlyLocales = shared.isArray(options.onlyLocales) ? options.onlyLocales : [options.onlyLocales];
-  }
-  let include = options.include;
-  let exclude = void 0;
-  if (include) {
-    if (shared.isArray(include)) {
-      include = include.map((item) => pathe.normalize(item));
-    } else if (shared.isString(include)) {
-      include = pathe.normalize(include);
-    }
-  } else {
-    exclude = "**/**";
+function createDescriptor(filename, source, { template, compiler }) {
+  const { descriptor, errors } = compiler.parse(source, {
+    filename,
+    templateParseOptions: template?.compilerOptions
+  });
+  return { descriptor, errors };
+}
+function getDescriptor(filename, code, options) {
+  const { descriptor, errors } = createDescriptor(filename, code, options);
+  if (errors.length) {
+    throw errors[0];
   }
-  const forceStringify = !!options.forceStringify;
-  const defaultSFCLang = shared.isString(options.defaultSFCLang) ? options.defaultSFCLang : "json";
-  const globalSFCScope = !!options.globalSFCScope;
-  const runtimeOnly = shared.isBoolean(options.runtimeOnly) ? options.runtimeOnly : true;
-  const dropMessageCompiler = !!options.dropMessageCompiler;
-  const fullInstall = moduleType === "vue-i18n" ? shared.isBoolean(options.fullInstall) ? options.fullInstall : true : false;
-  const ssrBuild = !!options.ssr;
-  const allowDynamic = !!options.allowDynamic;
-  const strictMessage = shared.isBoolean(options.strictMessage) ? options.strictMessage : true;
-  const escapeHtml = !!options.escapeHtml;
-  const optimizeTranslationDirective = shared.isString(options.optimizeTranslationDirective) || shared.isArray(options.optimizeTranslationDirective) ? options.optimizeTranslationDirective : !!options.optimizeTranslationDirective;
-  const translationIdentifiers = /* @__PURE__ */ new Map();
-  const transformI18nBlock = typeof options.transformI18nBlock === "function" ? options.transformI18nBlock : null;
-  return {
-    include,
-    exclude,
-    module: moduleType,
-    onlyLocales,
-    forceStringify,
-    defaultSFCLang,
-    globalSFCScope,
-    runtimeOnly,
-    dropMessageCompiler,
-    fullInstall,
-    ssrBuild,
-    allowDynamic,
-    strictMessage,
-    escapeHtml,
-    optimizeTranslationDirective,
-    translationIdentifiers,
-    transformI18nBlock
-  };
+  return descriptor;
 }
 
 function parseVueRequest(id) {
   const [filename, rawQuery] = id.split(`?`, 2);
   const params = new URLSearchParams(rawQuery);
   const ret = {};
-  const langPart = Object.keys(Object.fromEntries(params)).find(
-    (key) => /lang\./i.test(key)
-  );
+  const langPart = Object.keys(Object.fromEntries(params)).find((key) => /lang\./i.test(key));
   ret.vue = params.has("vue");
   ret.global = params.has("global");
   ret.src = params.has("src");
@@ -163,587 +130,7 @@ function getVuePluginOptions(vuePlugin) {
   };
 }
 
-function createDescriptor(filename, source, { template, compiler }) {
-  const { descriptor, errors } = compiler.parse(source, {
-    filename,
-    templateParseOptions: template?.compilerOptions
-  });
-  return { descriptor, errors };
-}
-function getDescriptor(filename, code, options) {
-  const { descriptor, errors } = createDescriptor(filename, code, options);
-  if (errors.length) {
-    throw errors[0];
-  }
-  return descriptor;
-}
-
-const INTLIFY_BUNDLE_IMPORT_ID = "@intlify/unplugin-vue-i18n/messages";
-const VIRTUAL_PREFIX = "\0";
-const debug$2 = createDebug__default(resolveNamespace("resource"));
-function resourcePlugin({
-  onlyLocales,
-  include,
-  exclude,
-  module,
-  forceStringify,
-  defaultSFCLang,
-  globalSFCScope,
-  runtimeOnly,
-  dropMessageCompiler,
-  fullInstall,
-  ssrBuild,
-  strictMessage,
-  allowDynamic,
-  escapeHtml,
-  transformI18nBlock
-}, meta) {
-  const filter = pluginutils.createFilter(include, exclude);
-  const getVueI18nAliasPath = ({ ssr = false, runtimeOnly: runtimeOnly2 = false }) => {
-    return `${module}/dist/${module}${runtimeOnly2 ? ".runtime" : ""}.${!ssr ? "esm-bundler.js" : "node.js"}`;
-  };
-  let isProduction = false;
-  let sourceMap = false;
-  const vueI18nAliasName = module;
-  debug$2(`vue-i18n alias name: ${vueI18nAliasName}`);
-  let vuePlugin = null;
-  const getSfcParser = () => {
-    return vuePlugin ? getVueCompiler(vuePlugin).parse : compilerSfc.parse;
-  };
-  return {
-    name: resolveNamespace("resource"),
-    /**
-     * NOTE:
-     *
-     * For vite, If we have json (including SFC's custom block),
-     * transform it first because it will be transformed into javascript code by `vite:json` plugin.
-     *
-     * For webpack, This plugin will handle with ‘post’, because vue-loader generate the request query.
-     */
-    enforce: meta.framework === "vite" ? "pre" : "post",
-    vite: {
-      config() {
-        const defineConfig = {
-          define: {
-            __VUE_I18N_FULL_INSTALL__: fullInstall,
-            __INTLIFY_DROP_MESSAGE_COMPILER__: dropMessageCompiler,
-            __VUE_I18N_PROD_DEVTOOLS__: false
-          }
-        };
-        debug$2("define Config:", defineConfig);
-        const aliasConfig = {
-          resolve: {
-            alias: {
-              [vueI18nAliasName]: getVueI18nAliasPath({
-                ssr: ssrBuild,
-                runtimeOnly
-              })
-            }
-          }
-        };
-        debug$2("alias Config:", aliasConfig);
-        return shared.assign(defineConfig, aliasConfig);
-      },
-      configResolved(config) {
-        vuePlugin = getVitePlugin(config, "vite:vue");
-        if (!checkVuePlugin(vuePlugin)) {
-          return;
-        }
-        isProduction = config.isProduction;
-        sourceMap = config.command === "build" ? !!config.build.sourcemap : false;
-        debug$2(
-          `configResolved: isProduction = ${isProduction}, sourceMap = ${sourceMap}`
-        );
-        const jsonPlugin = getVitePlugin(config, "vite:json");
-        if (jsonPlugin) {
-          const orgTransform = jsonPlugin.transform;
-          jsonPlugin.transform = async function(code, id) {
-            if (!/\.json$/.test(id) || filter(id)) {
-              return;
-            }
-            const { query } = parseVueRequest(id);
-            if (query.vue) {
-              return;
-            }
-            debug$2("org json plugin");
-            return orgTransform.apply(this, [code, id]);
-          };
-        }
-        const esbuildPlugin = getVitePlugin(config, "vite:esbuild");
-        if (esbuildPlugin) {
-          const orgTransform = esbuildPlugin.transform;
-          esbuildPlugin.transform = async function(code, id) {
-            const result = await orgTransform.apply(this, [
-              code,
-              id
-            ]);
-            if (result == null) {
-              return result;
-            }
-            const { filename, query } = parseVueRequest(id);
-            if (!query.vue && filter(id) && /\.[c|m]?ts$/.test(id)) {
-              const [_code, inSourceMap] = shared.isString(result) ? [result, void 0] : [result.code, result.map];
-              let langInfo = defaultSFCLang;
-              langInfo = pathe.parse(filename).ext;
-              const generate = getGenerator(langInfo);
-              const parseOptions = getOptions(
-                filename,
-                isProduction,
-                query,
-                sourceMap,
-                {
-                  inSourceMap,
-                  isGlobal: globalSFCScope,
-                  allowDynamic,
-                  strictMessage,
-                  escapeHtml,
-                  jit: true,
-                  onlyLocales,
-                  forceStringify
-                }
-              );
-              debug$2("parseOptions", parseOptions);
-              const { code: generatedCode, map } = generate(_code, parseOptions);
-              debug$2("generated code", generatedCode);
-              debug$2("sourcemap", map, sourceMap);
-              if (_code === generatedCode)
-                return;
-              return {
-                code: generatedCode,
-                map: { mappings: "" }
-              };
-            } else {
-              return result;
-            }
-          };
-        }
-      },
-      async handleHotUpdate({ file, server }) {
-        if (/\.(json5?|ya?ml)$/.test(file)) {
-          const module2 = server.moduleGraph.getModuleById(
-            asVirtualId(INTLIFY_BUNDLE_IMPORT_ID, meta.framework)
-          );
-          if (module2) {
-            server.moduleGraph.invalidateModule(module2);
-            return [module2];
-          }
-        }
-      }
-    },
-    webpack(compiler) {
-      webpackLike(compiler, "webpack", {
-        isProduction,
-        meta,
-        sourceMap,
-        getVueI18nAliasPath,
-        vueI18nAliasName,
-        ssrBuild,
-        runtimeOnly,
-        fullInstall,
-        filter
-      });
-    },
-    rspack(compiler) {
-      webpackLike(compiler, "rspack", {
-        isProduction,
-        meta,
-        sourceMap,
-        getVueI18nAliasPath,
-        vueI18nAliasName,
-        ssrBuild,
-        runtimeOnly,
-        fullInstall,
-        filter
-      });
-    },
-    resolveId(id, importer) {
-      debug$2("resolveId", id, importer);
-      if (id === INTLIFY_BUNDLE_IMPORT_ID) {
-        return asVirtualId(id, meta.framework);
-      }
-    },
-    loadInclude(id) {
-      return INTLIFY_BUNDLE_IMPORT_ID === getVirtualId(id, meta.framework);
-    },
-    async load(id) {
-      debug$2("load", id);
-      if (INTLIFY_BUNDLE_IMPORT_ID === getVirtualId(id, meta.framework) && include) {
-        let resourcePaths = [];
-        const includePaths = shared.isArray(include) ? include : [include];
-        for (const inc of includePaths) {
-          resourcePaths = [...resourcePaths, ...await fg__default(inc)];
-        }
-        resourcePaths = resourcePaths.filter(
-          (el, pos) => resourcePaths.indexOf(el) === pos
-        );
-        const code = await generateBundleResources(
-          resourcePaths,
-          isProduction,
-          {
-            forceStringify,
-            strictMessage,
-            escapeHtml
-          }
-        );
-        return {
-          code,
-          map: { mappings: "" }
-        };
-      }
-    },
-    transformInclude(id) {
-      debug$2("transformInclude", id);
-      if (meta.framework === "vite") {
-        return true;
-      } else {
-        const { filename } = parseVueRequest(id);
-        return filename.endsWith("vue") || filename.endsWith(INTLIFY_BUNDLE_IMPORT_ID) || /\.(json5?|ya?ml)$/.test(filename) && filter(filename);
-      }
-    },
-    async transform(code, id) {
-      const { filename, query } = parseVueRequest(id);
-      debug$2("transform", id, JSON.stringify(query), filename);
-      let langInfo = defaultSFCLang;
-      let inSourceMap;
-      if (!query.vue) {
-        if (/\.(json5?|ya?ml|[c|m]?js)$/.test(id) && filter(id)) {
-          langInfo = pathe.parse(filename).ext;
-          const generate = getGenerator(langInfo);
-          const parseOptions = getOptions(
-            filename,
-            isProduction,
-            query,
-            sourceMap,
-            {
-              inSourceMap,
-              isGlobal: globalSFCScope,
-              allowDynamic,
-              strictMessage,
-              escapeHtml,
-              jit: true,
-              onlyLocales,
-              forceStringify
-            }
-          );
-          debug$2("parseOptions", parseOptions);
-          const { code: generatedCode, map } = generate(code, parseOptions);
-          debug$2("generated code", generatedCode);
-          debug$2("sourcemap", map, sourceMap);
-          if (code === generatedCode)
-            return;
-          return {
-            code: generatedCode,
-            // prettier-ignore
-            map: { mappings: "" }
-          };
-        }
-      } else {
-        if (isCustomBlock(query)) {
-          if (shared.isString(query.lang)) {
-            langInfo = query.src ? query.lang === "i18n" ? defaultSFCLang : query.lang : query.lang;
-          } else if (defaultSFCLang) {
-            langInfo = defaultSFCLang;
-          }
-          debug$2("langInfo", langInfo);
-          const generate = /\.?json5?/.test(langInfo) ? bundleUtils.generateJSON : bundleUtils.generateYAML;
-          const parseOptions = getOptions(
-            filename,
-            isProduction,
-            query,
-            sourceMap,
-            {
-              inSourceMap,
-              isGlobal: globalSFCScope,
-              jit: true,
-              strictMessage,
-              escapeHtml,
-              onlyLocales,
-              forceStringify
-            }
-          );
-          debug$2("parseOptions", parseOptions);
-          let source = await getCode(
-            code,
-            filename,
-            sourceMap,
-            query,
-            getSfcParser(),
-            meta.framework
-          );
-          if (typeof transformI18nBlock === "function") {
-            const modifiedSource = transformI18nBlock(source);
-            if (modifiedSource && typeof modifiedSource === "string") {
-              source = modifiedSource;
-            } else {
-              warn("transformI18nBlock should return a string");
-            }
-          }
-          const { code: generatedCode, map } = generate(source, parseOptions);
-          debug$2("generated code", generatedCode);
-          debug$2("sourcemap", map, sourceMap);
-          if (code === generatedCode)
-            return;
-          return {
-            code: generatedCode,
-            // prettier-ignore
-            map: { mappings: "" }
-          };
-        }
-      }
-    }
-  };
-}
-function getGenerator(ext, defaultGen = bundleUtils.generateJSON) {
-  return /\.?json5?$/.test(ext) ? bundleUtils.generateJSON : /\.ya?ml$/.test(ext) ? bundleUtils.generateYAML : /\.([c|m]?js|[c|m]?ts)$/.test(ext) ? bundleUtils.generateJavaScript : defaultGen;
-}
-function webpackLike(compiler, framework, {
-  isProduction,
-  sourceMap,
-  meta,
-  getVueI18nAliasPath,
-  vueI18nAliasName,
-  ssrBuild,
-  runtimeOnly,
-  fullInstall,
-  filter
-}) {
-  isProduction = compiler.options.mode !== "development";
-  sourceMap = !!compiler.options.devtool;
-  debug$2(
-    `${framework}: isProduction = ${isProduction}, sourceMap = ${sourceMap}`
-  );
-  compiler.options.resolve = normalizeConfigResolveAlias(
-    compiler.options.resolve,
-    meta.framework
-  );
-  compiler.options.resolve.alias[vueI18nAliasName] = getVueI18nAliasPath({
-    ssr: ssrBuild,
-    runtimeOnly
-  });
-  debug$2(
-    `set ${vueI18nAliasName}: ${getVueI18nAliasPath({
-      ssr: ssrBuild,
-      runtimeOnly
-    })}`
-  );
-  const loader = framework === "webpack" ? loadWebpack : loadRspack;
-  loader().then((mod) => {
-    if (mod) {
-      compiler.options.plugins.push(
-        // @ts-expect-error type issue
-        new mod.DefinePlugin({
-          __VUE_I18N_FULL_INSTALL__: JSON.stringify(fullInstall),
-          __INTLIFY_PROD_DEVTOOLS__: "false"
-        })
-      );
-      debug$2(`set __VUE_I18N_FULL_INSTALL__ is '${fullInstall}'`);
-    } else {
-      debug$2(`ignore vue-i18n feature flags with ${framework}.DefinePlugin`);
-    }
-  });
-  if (compiler.options.module) {
-    compiler.options.module.rules.push({
-      test: /\.(json5?|ya?ml)$/,
-      type: "javascript/auto",
-      include(resource) {
-        return filter(resource);
-      }
-    });
-  }
-}
-function normalizeConfigResolveAlias(resolve, framework) {
-  if (resolve && resolve.alias) {
-    return resolve;
-  }
-  const webpackLike2 = framework === "webpack" || framework === "rspack";
-  if (!resolve) {
-    if (framework === "vite") {
-      return { alias: [] };
-    } else if (webpackLike2) {
-      return { alias: {} };
-    }
-  } else if (!resolve.alias) {
-    if (framework === "vite") {
-      resolve.alias = [];
-      return resolve;
-    } else if (webpackLike2) {
-      resolve.alias = {};
-      return resolve;
-    }
-  }
-}
-async function loadWebpack() {
-  try {
-    const mod = await import('webpack');
-    return mod.default || mod;
-  } catch (_e) {
-    warn(`webpack not found, please install webpack.`);
-  }
-  return null;
-}
-async function loadRspack() {
-  try {
-    const { rspack } = await import('@rspack/core');
-    return rspack;
-  } catch (_e) {
-    warn(`rspack not found, please install rspack.`);
-  }
-  return null;
-}
-async function generateBundleResources(resources, isProduction, {
-  forceStringify = false,
-  isGlobal = false,
-  onlyLocales = [],
-  strictMessage = true,
-  escapeHtml = false,
-  jit = true,
-  transformI18nBlock = void 0
-}) {
-  const codes = [];
-  for (const res of resources) {
-    debug$2(`${res} bundle loading ...`);
-    if (/\.(json5?|ya?ml)$/.test(res)) {
-      const { ext, name } = pathe.parse(res);
-      const source = await getRaw(res);
-      const generate = /json5?/.test(ext) ? bundleUtils.generateJSON : bundleUtils.generateYAML;
-      const parseOptions = getOptions(res, isProduction, {}, false, {
-        isGlobal,
-        jit,
-        onlyLocales,
-        strictMessage,
-        escapeHtml,
-        forceStringify,
-        transformI18nBlock
-      });
-      parseOptions.type = "bare";
-      const { code } = generate(source, parseOptions);
-      debug$2("generated code", code);
-      codes.push(`${JSON.stringify(name)}: ${code}`);
-    }
-  }
-  return `const isObject = (item) => item && typeof item === 'object' && !Array.isArray(item);
-
-const mergeDeep = (target, ...sources) => {
-  if (!sources.length) return target;
-  const source = sources.shift();
-
-  if (isObject(target) && isObject(source)) {
-    for (const key in source) {
-      if (isObject(source[key])) {
-        if (!target[key]) Object.assign(target, { [key]: {} });
-        mergeDeep(target[key], source[key]);
-      } else {
-        Object.assign(target, { [key]: source[key] });
-      }
-    }
-  }
-
-  return mergeDeep(target, ...sources);
-}
-
-export default mergeDeep({},
-  ${codes.map((code) => `{${code}}`).join(",\n")}
-);`;
-}
-async function getCode(source, filename, sourceMap, query, parser, framework = "vite") {
-  const { index, issuerPath } = query;
-  if (!shared.isNumber(index)) {
-    raiseError(`unexpected index: ${index}`);
-  }
-  if (framework === "webpack" || framework === "rspack") {
-    if (issuerPath) {
-      debug$2(`getCode (${framework}) ${index} via issuerPath`, issuerPath);
-      return await getRaw(filename);
-    } else {
-      const result = parser(await getRaw(filename), {
-        sourceMap,
-        filename
-      });
-      const block = result.descriptor.customBlocks[index];
-      if (block) {
-        const code = block.src ? await getRaw(block.src) : block.content;
-        debug$2(`getCode (${framework}) ${index} from SFC`, code);
-        return code;
-      } else {
-        return source;
-      }
-    }
-  } else {
-    return source;
-  }
-}
-function isCustomBlock(query) {
-  return !shared.isEmptyObject(query) && "vue" in query && (query["type"] === "custom" || // for vite (@vite-plugin-vue)
-  query["type"] === "i18n" || // for webpack (vue-loader)
-  query["blockType"] === "i18n");
-}
-function getOptions(filename, isProduction, query, sourceMap, {
-  inSourceMap = void 0,
-  forceStringify = false,
-  isGlobal = false,
-  onlyLocales = [],
-  allowDynamic = false,
-  strictMessage = true,
-  escapeHtml = false,
-  jit = true,
-  transformI18nBlock = null
-}) {
-  const mode = isProduction ? "production" : "development";
-  const baseOptions = {
-    filename,
-    sourceMap,
-    inSourceMap,
-    forceStringify,
-    allowDynamic,
-    strictMessage,
-    escapeHtml,
-    jit,
-    onlyLocales,
-    env: mode,
-    transformI18nBlock,
-    onWarn: (msg) => {
-      warn(`${filename} ${msg}`);
-    },
-    onError: (msg, extra) => {
-      const codeFrame = shared.generateCodeFrame(
-        extra?.source || extra?.location?.source || "",
-        extra?.location?.start.column,
-        extra?.location?.end.column
-      );
-      const errMssage = `${msg} (error code: ${extra?.code}) in ${filename}
-  target message: ${extra?.source}
-  target message path: ${extra?.path}
-
-  ${codeFrame}
-`;
-      error(errMssage);
-      throw new Error(errMssage);
-    }
-  };
-  if (isCustomBlock(query)) {
-    return shared.assign(baseOptions, {
-      type: "sfc",
-      locale: shared.isString(query.locale) ? query.locale : "",
-      isGlobal: isGlobal || !!query.global
-    });
-  } else {
-    return shared.assign(baseOptions, {
-      type: "plain",
-      isGlobal: false
-    });
-  }
-}
-function getVirtualId(id, framework = "vite") {
-  return framework === "vite" ? id.startsWith(VIRTUAL_PREFIX) ? id.slice(VIRTUAL_PREFIX.length) : "" : id;
-}
-function asVirtualId(id, framework = "vite") {
-  return framework === "vite" ? VIRTUAL_PREFIX + id : id;
-}
-async function getRaw(path) {
-  return node_fs.promises.readFile(path, { encoding: "utf-8" });
-}
-
-const debug$1 = createDebug__default(resolveNamespace("directive"));
+const debug$2 = createDebug__default(resolveNamespace("directive"));
 function directivePlugin({
   optimizeTranslationDirective,
   translationIdentifiers
@@ -766,7 +153,7 @@ function directivePlugin({
             optimizeTranslationDirective,
             translationIdentifiers
           );
-          debug$1(`vite:vue options['template']:`, vuePlugin.api.options);
+          debug$2(`vite:vue options['template']:`, vuePlugin.api.options);
         }
       },
       configResolved(config) {
@@ -808,11 +195,9 @@ function resolveVueOptions(vuePlugin, optimizeTranslationDirective, translationI
   const translationSignatureResolver = (context, baseResolver) => {
     const { filename } = context;
     const vuePluginOptions = getVuePluginOptions(vuePlugin);
-    const normalizedFilename = normalizePath(
-      path__default.relative(vuePluginOptions.root, filename)
-    );
+    const normalizedFilename = normalizePath(path__default.relative(vuePluginOptions.root, filename));
     const resolveIdentifier2 = translationIdentifiers.get(normalizedFilename);
-    debug$1("resolved vue-i18n Identifier", resolveIdentifier2);
+    debug$2("resolved vue-i18n Identifier", resolveIdentifier2);
     if (resolveIdentifier2 == null) {
       return void 0;
     }
@@ -830,7 +215,7 @@ function resolveVueOptions(vuePlugin, optimizeTranslationDirective, translationI
 }
 function analyzeIdentifiers(descriptor, { root }, translationIdentifiers) {
   const source = descriptor.scriptSetup?.content || descriptor.script?.content;
-  debug$1("getDescriptor content", source);
+  debug$2("getDescriptor content", source);
   if (!source) {
     return;
   }
@@ -848,13 +233,11 @@ function analyzeIdentifiers(descriptor, { root }, translationIdentifiers) {
   if (importLocalName == null) {
     return;
   }
-  debug$1("importLocalName", importLocalName);
+  debug$2("importLocalName", importLocalName);
   const resolvedIdentifier = getVueI18nIdentifier(scope, importLocalName);
   if (resolvedIdentifier) {
-    const normalizedFilename = normalizePath(
-      path__default.relative(root, descriptor.filename)
-    );
-    debug$1("set vue-i18n resolved identifier: ", resolvedIdentifier);
+    const normalizedFilename = normalizePath(path__default.relative(root, descriptor.filename));
+    debug$2("set vue-i18n resolved identifier: ", resolvedIdentifier);
     translationIdentifiers.set(normalizedFilename, resolvedIdentifier);
   }
 }
@@ -902,9 +285,9 @@ function getVueI18nIdentifier(scope, local) {
     return null;
   }
   const variableIdPairs = parseVariableId(id);
-  debug$1("variableIdPairs:", variableIdPairs);
+  debug$2("variableIdPairs:", variableIdPairs);
   const returnVariableIdPairs = parseReturnStatement(returnStatement);
-  debug$1("returnVariableIdPairs:", returnVariableIdPairs);
+  debug$2("returnVariableIdPairs:", returnVariableIdPairs);
   return resolveIdentifier(variableIdPairs, returnVariableIdPairs);
 }
 const EMPTY_NODE_RETURN = {
@@ -924,11 +307,9 @@ function getCallExpressionAndReturnStatement(scope, local) {
   }
   let returnStatement = null;
   if (callExpressionRef.from.type === "function" && callExpressionRef.from.block.type === typescriptEstree.AST_NODE_TYPES.FunctionExpression && callExpressionRef.from.block.parent.type === typescriptEstree.AST_NODE_TYPES.Property && callExpressionRef.from.block.parent.key.type === typescriptEstree.AST_NODE_TYPES.Identifier && callExpressionRef.from.block.parent.key.name === "setup") {
-    returnStatement = callExpressionRef.from.block.body.body.find(
-      (statement) => {
-        return statement.type === typescriptEstree.AST_NODE_TYPES.ReturnStatement;
-      }
-    );
+    returnStatement = callExpressionRef.from.block.body.body.find((statement) => {
+      return statement.type === typescriptEstree.AST_NODE_TYPES.ReturnStatement;
+    });
   }
   return {
     callExpression: callExpressionRef.identifier.parent,
@@ -997,9 +378,7 @@ function resolveIdentifier(localVariables, returnVariable) {
   } else {
     const variable = localVariables.find((pair) => pair.key === "t");
     if (variable && variable.value) {
-      const returnVar = returnVariable.find(
-        (pair) => pair.value === variable.value
-      );
+      const returnVar = returnVariable.find((pair) => pair.value === variable.value);
       if (returnVar && returnVar.key) {
         return { type: "identifier", key: returnVar.key };
       }
@@ -1007,9 +386,7 @@ function resolveIdentifier(localVariables, returnVariable) {
     const identifierOnly = localVariables.find((pair) => pair.value === null);
     if (identifierOnly && identifierOnly.key) {
       const targetKey = identifierOnly.key;
-      const returnVar = returnVariable.find(
-        (pair) => pair.value?.startsWith(targetKey)
-      );
+      const returnVar = returnVariable.find((pair) => pair.value?.startsWith(targetKey));
       if (returnVar && returnVar.key) {
         return { type: "object", key: returnVar.key, style: "setup-hook" };
       }
@@ -1018,6 +395,409 @@ function resolveIdentifier(localVariables, returnVariable) {
   }
 }
 
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+const getVueI18nAliasPath = (opts) => {
+  const filename = [
+    opts.module,
+    opts.runtimeOnly ? "runtime" : "",
+    !opts.ssr ? "esm-bundler" : "node",
+    "js"
+  ].filter(Boolean).join(".");
+  return `${opts.module}/dist/${filename}`;
+};
+function resolveOptions(options) {
+  const res = defu__default(options, {
+    ssr: false,
+    module: "vue-i18n",
+    escapeHtml: false,
+    onlyLocales: [],
+    fullInstall: true,
+    runtimeOnly: true,
+    strictMessage: true,
+    allowDynamic: false,
+    globalSFCScope: false,
+    forceStringify: false,
+    defaultSFCLang: "json",
+    dropMessageCompiler: false,
+    transformI18nBlock: void 0,
+    optimizeTranslationDirective: false
+  });
+  const include = res.include ? toArray(res.include).map((item) => path.normalize(item)) : void 0;
+  const _exclude = res.exclude ? toArray(res.exclude).map((item) => path.normalize(item)) : void 0;
+  const exclude = res.include ? _exclude : ["**/**"];
+  const onlyLocales = toArray(res.onlyLocales);
+  const fullInstall = res.module !== "vue-i18n" ? false : res.fullInstall;
+  const optimizeTranslationDirective = typeof res.optimizeTranslationDirective === "boolean" ? res.optimizeTranslationDirective : toArray(res.optimizeTranslationDirective);
+  const translationIdentifiers = /* @__PURE__ */ new Map();
+  const vueI18nAliasPath = getVueI18nAliasPath(res);
+  return {
+    ...res,
+    include,
+    exclude,
+    fullInstall,
+    onlyLocales,
+    vueI18nAliasPath,
+    translationIdentifiers,
+    optimizeTranslationDirective
+  };
+}
+
+const INTLIFY_BUNDLE_IMPORT_ID = "@intlify/unplugin-vue-i18n/messages";
+const VIRTUAL_PREFIX = "\0";
+const debug$1 = createDebug__default(resolveNamespace("resource"));
+function resourcePlugin(opts, meta) {
+  const _filter = pluginutils.createFilter(opts.include, opts.exclude);
+  const importedResources = /* @__PURE__ */ new Set();
+  const filter = (val) => _filter(val) || importedResources.has(val);
+  debug$1(`vue-i18n alias name: ${opts.module}`);
+  const ctx = {
+    prod: false,
+    sourceMap: false
+  };
+  let vuePlugin = null;
+  const getSfcParser = () => vuePlugin ? getVueCompiler(vuePlugin).parse : compilerSfc.parse;
+  const resourcePaths = /* @__PURE__ */ new Set();
+  for (const inc of opts.include || []) {
+    for (const resourcePath of fg__default.sync(inc, { ignore: opts.exclude })) {
+      resourcePaths.add(resourcePath);
+    }
+  }
+  function result(code) {
+    if (meta.framework === "vite") {
+      return { code, map: { mappings: "" } };
+    }
+    return { code };
+  }
+  function sharedWebpackLikePlugin(compiler) {
+    ctx.prod = compiler.options.mode !== "development";
+    ctx.sourceMap = !!compiler.options.devtool;
+    debug$1(`${meta.framework}: isProduction = ${ctx.prod}, sourceMap = ${ctx.sourceMap}`);
+    compiler.options.resolve.alias = {
+      ...compiler.options.resolve.alias,
+      [opts.module]: opts.vueI18nAliasPath
+    };
+    debug$1(`set ${opts.module}: ${opts.vueI18nAliasPath}`);
+    const loader = meta.framework === "webpack" ? loadWebpack : loadRspack;
+    loader().then((mod) => {
+      if (mod) {
+        compiler.options.plugins.push(
+          // @ts-expect-error -- FIXME: webpack type
+          new mod.DefinePlugin({
+            __VUE_I18N_FULL_INSTALL__: JSON.stringify(opts.fullInstall),
+            __INTLIFY_PROD_DEVTOOLS__: "false"
+          })
+        );
+        debug$1(`set __VUE_I18N_FULL_INSTALL__ is '${opts.fullInstall}'`);
+      } else {
+        debug$1(`ignore vue-i18n feature flags with ${meta.framework}.DefinePlugin`);
+      }
+    }).catch((_e) => {
+      warn(`${meta.framework} not found, please install ${meta.framework}.`);
+    });
+    compiler.options.module.rules.push({
+      test: /\.(json5?|ya?ml)$/,
+      type: "javascript/auto",
+      include: (resource) => filter(resource)
+    });
+  }
+  const supportedFileExtensionsRE = /\.(json5?|ya?ml|[c|m]?[j|t]s)$/;
+  return {
+    name: resolveNamespace("resource"),
+    /**
+     * NOTE:
+     * vite: early ('pre') transform for json and SFC's custom blocks
+     * because these are transformed into javascript code by `vite:json` plugin.
+     *
+     * webpack/rspack: late ('post') transform because we rely on vue-loader to generate the request queries.
+     */
+    enforce: meta.framework === "vite" ? "pre" : "post",
+    rspack: sharedWebpackLikePlugin,
+    webpack: sharedWebpackLikePlugin,
+    vite: {
+      config() {
+        const defineConfig = {
+          define: {
+            __VUE_I18N_FULL_INSTALL__: opts.fullInstall,
+            __INTLIFY_DROP_MESSAGE_COMPILER__: opts.dropMessageCompiler,
+            __VUE_I18N_PROD_DEVTOOLS__: false
+          }
+        };
+        debug$1("define Config:", defineConfig);
+        const aliasConfig = {
+          resolve: {
+            alias: {
+              [opts.module]: opts.vueI18nAliasPath
+            }
+          }
+        };
+        debug$1("alias Config:", aliasConfig);
+        return shared.assign(defineConfig, aliasConfig);
+      },
+      configResolved(config) {
+        vuePlugin = getVitePlugin(config, "vite:vue");
+        if (!checkVuePlugin(vuePlugin)) {
+          return;
+        }
+        ctx.prod = config.isProduction;
+        ctx.sourceMap = config.command === "build" ? !!config.build.sourcemap : false;
+        debug$1(`configResolved: isProduction = ${ctx.prod}, sourceMap = ${ctx.sourceMap}`);
+        const jsonPlugin = getVitePlugin(config, "vite:json");
+        if (jsonPlugin) {
+          const orgTransform = jsonPlugin.transform;
+          jsonPlugin.transform = async function(code, id) {
+            if (!/\.json$/.test(id) || filter(id)) {
+              return;
+            }
+            const { query } = parseVueRequest(id);
+            if (query.vue) {
+              return;
+            }
+            debug$1("org json plugin");
+            return orgTransform.apply(this, [code, id]);
+          };
+        }
+      }
+    },
+    resolveId(id, importer) {
+      debug$1("resolveId", id, importer);
+      if (id === INTLIFY_BUNDLE_IMPORT_ID) {
+        return asVirtualId(id, meta.framework);
+      }
+    },
+    loadInclude(id) {
+      return INTLIFY_BUNDLE_IMPORT_ID === getVirtualId(id, meta.framework);
+    },
+    load(id) {
+      debug$1("load", id);
+      if (INTLIFY_BUNDLE_IMPORT_ID === getVirtualId(id, meta.framework) && resourcePaths.size > 0) {
+        const code = generateBundleResources(resourcePaths);
+        for (const p of resourcePaths) {
+          this.addWatchFile(p);
+        }
+        return result(code);
+      }
+    },
+    transformInclude(id) {
+      debug$1("transformInclude", id);
+      if (meta.framework === "vite") {
+        return true;
+      }
+      const { filename, query } = parseVueRequest(id);
+      if (filename.endsWith("vue") || filename.endsWith(INTLIFY_BUNDLE_IMPORT_ID)) {
+        return true;
+      }
+      let isResourcePath = resourcePaths.has(id);
+      if (!isResourcePath && "issuerPath" in query) {
+        isResourcePath = resourcePaths.has(query.issuerPath);
+      }
+      return supportedFileExtensionsRE.test(filename) && filter(filename) && isResourcePath;
+    },
+    async transform(code, id) {
+      const { filename, query } = parseVueRequest(id);
+      debug$1("transform", id, JSON.stringify(query), filename);
+      let langInfo = opts.defaultSFCLang;
+      if (filter(id)) {
+        const imports = mlly.findStaticImports(code);
+        for (const p of imports) {
+          const res = path.resolve(path.dirname(id), p.specifier);
+          importedResources.add(res);
+        }
+      }
+      if (!query.vue && supportedFileExtensionsRE.test(id) && filter(id)) {
+        langInfo = path.parse(filename).ext;
+        const generate = getGenerator(langInfo);
+        const parseOptions = getOptions(filename, ctx, query, {
+          ...opts,
+          transformI18nBlock: void 0
+        });
+        debug$1("parseOptions", parseOptions);
+        try {
+          const { code: generatedCode, map } = generate(code, parseOptions);
+          debug$1("generated code", generatedCode);
+          debug$1("sourcemap", map, ctx.sourceMap);
+          if (code === generatedCode)
+            return;
+          return result(generatedCode);
+        } catch (err) {
+          if (err instanceof bundleUtils.DynamicResourceError) {
+            error(
+              `Unable to precompile or optimize \`${filename}\` - excluding from virtual bundle \`${INTLIFY_BUNDLE_IMPORT_ID}\`.
+`,
+              err
+            );
+            return `export default {}`;
+          } else {
+            throw err;
+          }
+        }
+      }
+      if (isCustomBlock(query)) {
+        langInfo = opts.defaultSFCLang;
+        if (query.lang && query.lang !== "i18n") {
+          langInfo = query.lang;
+        }
+        debug$1("langInfo", langInfo);
+        const parseOptions = getOptions(filename, ctx, query, {
+          ...opts,
+          allowDynamic: false,
+          transformI18nBlock: void 0
+        });
+        debug$1("parseOptions", parseOptions);
+        let source = getCode(code, filename, ctx.sourceMap, query, getSfcParser(), meta);
+        if (typeof opts.transformI18nBlock === "function") {
+          const modifiedSource = opts.transformI18nBlock(source);
+          if (modifiedSource && typeof modifiedSource === "string") {
+            source = modifiedSource;
+          } else {
+            warn("transformI18nBlock should return a string");
+          }
+        }
+        const generate = getGenerator(langInfo, bundleUtils.generateYAML);
+        const { code: generatedCode, map } = generate(source, parseOptions);
+        debug$1("generated code", generatedCode);
+        debug$1("sourcemap", map, ctx.sourceMap);
+        if (code !== generatedCode) {
+          return result(generatedCode);
+        }
+      }
+    }
+  };
+}
+function getGenerator(ext, fallback = bundleUtils.generateJSON) {
+  if (/\.?json5?$/.test(ext)) {
+    return bundleUtils.generateJSON;
+  }
+  if (/\.ya?ml$/.test(ext)) {
+    return bundleUtils.generateYAML;
+  }
+  if (/\.[c|m]?[j|t]s$/.test(ext)) {
+    return bundleUtils.generateJavaScript;
+  }
+  return fallback;
+}
+async function loadWebpack() {
+  const mod = await import('webpack');
+  return mod.default || mod;
+}
+async function loadRspack() {
+  const { rspack } = await import('@rspack/core');
+  return rspack;
+}
+function generateBundleResources(resources) {
+  const codes = [];
+  const imports = [];
+  for (const filename of resources) {
+    debug$1(`${filename} bundle loading ...`);
+    const { name } = path.parse(filename);
+    const varName = knitwork.genSafeVariableName(
+      [name, node_crypto.createHash("sha256").update(filename).digest("hex").substring(0, 8)].join("_")
+    );
+    imports.push({ statement: knitwork.genImport(filename, varName), varName });
+    codes.push(`${JSON.stringify(name)}: ${varName}`);
+  }
+  const importStatements = imports.map((x) => x.statement).join("\n");
+  return `
+${importStatements}
+
+const isObject = (item) => item && typeof item === 'object' && !Array.isArray(item);
+
+const mergeDeep = (target, ...sources) => {
+  if (!sources.length) return target;
+  const source = sources.shift();
+
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!target[key]) Object.assign(target, { [key]: {} });
+        mergeDeep(target[key], source[key]);
+      } else {
+        Object.assign(target, { [key]: source[key] });
+      }
+    }
+  }
+
+  return mergeDeep(target, ...sources);
+}
+
+export default mergeDeep({},
+  ${codes.map((code) => `{ ${code} }`).join(",\n  ")}
+);`;
+}
+function getCode(source, filename, sourceMap, query, parser, meta) {
+  if (query.index == null) {
+    raiseError(`unexpected index: ${query.index}`);
+  }
+  if (meta.framework === "vite") {
+    return source;
+  }
+  if (query.issuerPath) {
+    debug$1(`getCode (${meta.framework}) ${query.index} via issuerPath`, query.issuerPath);
+    return readFile(filename);
+  }
+  const result = parser(readFile(filename), { sourceMap, filename });
+  const block = result.descriptor.customBlocks[query.index];
+  if (block) {
+    const code = block.src ? readFile(block.src) : block.content;
+    debug$1(`getCode (${meta.framework}) ${query.index} from SFC`, code);
+    return code;
+  }
+  return source;
+}
+function isCustomBlock(query) {
+  return !shared.isEmptyObject(query) && "vue" in query && (query["type"] === "custom" || // for vite (@vite-plugin-vue)
+  query["type"] === "i18n" || // for webpack (vue-loader)
+  query["blockType"] === "i18n");
+}
+function getOptions(filename, ctx, query, opts) {
+  const baseOptions = {
+    ...opts,
+    filename,
+    jit: true,
+    // allow overriding ctx.sourceMap with opts
+    sourceMap: opts.sourceMap ?? ctx.sourceMap,
+    env: ctx.prod ? "production" : "development",
+    onWarn: (msg) => warn(`${filename} ${msg}`),
+    onError: (msg, extra) => {
+      const codeFrame = shared.generateCodeFrame(
+        extra?.source || extra?.location?.source || "",
+        extra?.location?.start.column,
+        extra?.location?.end.column
+      );
+      const errMessage = `${msg} (error code: ${extra?.code}) in ${filename}
+  target message: ${extra?.source}
+  target message path: ${extra?.path}
+
+  ${codeFrame}
+`;
+      error(errMessage);
+      throw new Error(errMessage);
+    }
+  };
+  if (isCustomBlock(query)) {
+    return shared.assign(baseOptions, {
+      type: "sfc",
+      locale: query.locale ?? "",
+      isGlobal: opts.globalSFCScope || !!query.global
+    });
+  }
+  return shared.assign(baseOptions, {
+    type: "plain",
+    isGlobal: false
+  });
+}
+function getVirtualId(id, framework = "vite") {
+  return framework === "vite" ? id.startsWith(VIRTUAL_PREFIX) ? id.slice(VIRTUAL_PREFIX.length) : "" : id;
+}
+function asVirtualId(id, framework = "vite") {
+  return framework === "vite" ? VIRTUAL_PREFIX + id : id;
+}
+function readFile(path) {
+  return fs__default.readFileSync(path, "utf-8");
+}
+
 const debug = createDebug__default(resolveNamespace("root"));
 const unpluginFactory = (options = {}, meta) => {
   debug("meta framework", meta.framework);