@intlify/unplugin-vue-i18n 7.0.0-beta.2 → 11.0.0-beta.4

package/lib/index.cjs

@@ -2,36 +2,72 @@
 
 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 defu = require('defu');
-const pathe = require('pathe');
-const bundleUtils = require('@intlify/bundle-utils');
+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 fs = require('node:fs');
+const node_fs = require('node:fs');
+const path = require('node:path');
+const pathe = require('pathe');
 const compilerSfc = require('vue/compiler-sfc');
-const knitwork = require('knitwork');
-const mlly = require('mlly');
-const node_crypto = require('node:crypto');
+const pc = require('picocolors');
+const eslintUitls = require('@eslint-community/eslint-utils');
 const vueI18nExtensions = require('@intlify/vue-i18n-extensions');
 const scopeManager = require('@typescript-eslint/scope-manager');
 const typescriptEstree = require('@typescript-eslint/typescript-estree');
-const eslintUitls = require('@eslint-community/eslint-utils');
 
 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 defu__default = /*#__PURE__*/_interopDefaultCompat(defu);
 const fg__default = /*#__PURE__*/_interopDefaultCompat(fg);
-const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const pc__default = /*#__PURE__*/_interopDefaultCompat(pc);
 const eslintUitls__default = /*#__PURE__*/_interopDefaultCompat(eslintUitls);
 
+function resolveOptions(options) {
+  const moduleType = options.module || "vue-i18n";
+  let onlyLocales = [];
+  if (options.onlyLocales) {
+    onlyLocales = shared.isArray(options.onlyLocales) ? options.onlyLocales : [options.onlyLocales];
+  }
+  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 compositionOnly = moduleType === "vue-i18n" ? shared.isBoolean(options.compositionOnly) ? options.compositionOnly : true : true;
+  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: options.include,
+    exclude: options.exclude,
+    module: moduleType,
+    onlyLocales,
+    forceStringify,
+    defaultSFCLang,
+    globalSFCScope,
+    runtimeOnly,
+    dropMessageCompiler,
+    compositionOnly,
+    fullInstall,
+    ssrBuild,
+    allowDynamic,
+    strictMessage,
+    escapeHtml,
+    optimizeTranslationDirective,
+    translationIdentifiers,
+    transformI18nBlock
+  };
+}
+
 const PKG_NAME = "unplugin-vue-i18n";
 
 function warn(...args) {
@@ -68,63 +104,11 @@ function normalizePath(id) {
   return path__default.posix.normalize(isWindows ? slash(id) : id);
 }
 
-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) => pathe.normalize(item)) : void 0;
-  const _exclude = res.exclude ? toArray(res.exclude).map((item) => pathe.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
-  };
-}
-
 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");
@@ -185,85 +169,119 @@ function getDescriptor(filename, code, options) {
 
 const INTLIFY_BUNDLE_IMPORT_ID = "@intlify/unplugin-vue-i18n/messages";
 const VIRTUAL_PREFIX = "\0";
+const RE_INTLIFY_BUNDLE_IMPORT_ID = new RegExp(`^${INTLIFY_BUNDLE_IMPORT_ID}$`);
+const RE_VIRTUAL_PREFIXED_INTLIFY_BUNDLE_IMPORT_ID = new RegExp(
+  `^${VIRTUAL_PREFIX}${INTLIFY_BUNDLE_IMPORT_ID}$`
+);
+const RE_RESOURCE_FORMAT = /\.(json5?|ya?ml|[c|m]?[j|t]s)$/;
+const RE_SFC_I18N_CUSTOM_BLOCK = /\?vue&type=i18n/;
+const RE_SFC_I18N_WEBPACK_CUSTOM_BLOCK = /blockType=i18n/;
 const debug$2 = 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$2(`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 resourcePlugin({
+  onlyLocales,
+  include,
+  exclude,
+  module,
+  forceStringify,
+  defaultSFCLang,
+  globalSFCScope,
+  runtimeOnly,
+  dropMessageCompiler,
+  compositionOnly,
+  fullInstall,
+  ssrBuild,
+  strictMessage,
+  allowDynamic,
+  escapeHtml,
+  transformI18nBlock
+}, meta) {
+  let viteModule = null;
+  async function getViteModule() {
+    if (viteModule != null) {
+      return viteModule;
+    }
+    try {
+      viteModule = await import('vite');
+    } catch (e) {
+      error(`vite not found, please install vite.`, e.message);
+      throw e;
+    }
+    return viteModule;
+  }
+  function resolveIncludeExclude() {
+    const customBlockInclude = meta.framework === "vite" ? RE_SFC_I18N_CUSTOM_BLOCK : RE_SFC_I18N_WEBPACK_CUSTOM_BLOCK;
+    if (shared.isArray(include)) {
+      return [[...include, customBlockInclude], exclude];
+    } else if (shared.isString(include)) {
+      return [[include, customBlockInclude], exclude];
+    } else {
+      return [[RE_RESOURCE_FORMAT, customBlockInclude], exclude];
     }
   }
-  function result(code) {
-    if (meta.framework === "vite") {
-      return { code, map: { mappings: "" } };
+  function resolveIncludeExcludeForLegacy() {
+    const customBlockInclude = meta.framework === "vite" ? RE_SFC_I18N_CUSTOM_BLOCK : RE_SFC_I18N_WEBPACK_CUSTOM_BLOCK;
+    let _include = void 0;
+    let _exclude = void 0;
+    if (include) {
+      if (shared.isArray(include)) {
+        _include = [...include.map((item) => pathe.normalize(item)), customBlockInclude];
+      } else if (shared.isString(include)) {
+        _include = [pathe.normalize(include), customBlockInclude];
+      }
+    } else {
+      _exclude = "**/**";
     }
-    return { code };
+    return [_include, _exclude];
   }
-  function sharedWebpackLikePlugin(compiler) {
-    ctx.prod = compiler.options.mode !== "development";
-    ctx.sourceMap = !!compiler.options.devtool;
-    debug$2(
-      `${meta.framework}: isProduction = ${ctx.prod}, sourceMap = ${ctx.sourceMap}`
-    );
-    compiler.options.resolve.alias = {
-      ...compiler.options.resolve.alias,
-      [opts.module]: opts.vueI18nAliasPath
-    };
-    debug$2(`set ${opts.module}: ${opts.vueI18nAliasPath}`);
-    const loader = meta.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(opts.fullInstall),
-            __INTLIFY_PROD_DEVTOOLS__: "false"
-          })
-        );
-        debug$2(`set __VUE_I18N_FULL_INSTALL__ is '${opts.fullInstall}'`);
+  let _filter = null;
+  async function getFilter() {
+    if (_filter != null) {
+      return _filter;
+    }
+    if (meta.framework == "webpack") {
+      debug$2("Using filter for webpack");
+      _filter = pluginutils.createFilter(...resolveIncludeExclude());
+    } else {
+      const viteModule2 = await getViteModule();
+      if (viteModule2.rolldownVersion) {
+        debug$2("Using filter for rolldown-vite");
+        _filter = pluginutils.createFilter(...resolveIncludeExclude());
       } else {
-        debug$2(
-          `ignore vue-i18n feature flags with ${meta.framework}.DefinePlugin`
-        );
+        debug$2("Using filter for rollup-vite");
+        _filter = pluginutils.createFilter(...resolveIncludeExcludeForLegacy());
       }
-    }).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)
-    });
+    }
+    return _filter;
   }
-  const supportedFileExtensionsRE = /\.(json5?|ya?ml|[c|m]?[j|t]s)$/;
+  const getVueI18nAliasPath = ({ ssr = false, runtimeOnly: runtimeOnly2 = false }) => {
+    return `${module}/dist/${module}${runtimeOnly2 ? ".runtime" : ""}.${!ssr ? "esm-bundler.js" : "node.mjs"}`;
+  };
+  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:
-     * 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.
+     * 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",
-    rspack: sharedWebpackLikePlugin,
-    webpack: sharedWebpackLikePlugin,
     vite: {
       config() {
         const defineConfig = {
           define: {
-            __VUE_I18N_FULL_INSTALL__: opts.fullInstall,
-            __INTLIFY_DROP_MESSAGE_COMPILER__: opts.dropMessageCompiler,
+            __VUE_I18N_LEGACY_API__: !compositionOnly,
+            __VUE_I18N_FULL_INSTALL__: fullInstall,
+            __INTLIFY_DROP_MESSAGE_COMPILER__: dropMessageCompiler,
             __VUE_I18N_PROD_DEVTOOLS__: false
           }
         };
@@ -271,148 +289,227 @@ function resourcePlugin(opts, meta) {
         const aliasConfig = {
           resolve: {
             alias: {
-              [opts.module]: opts.vueI18nAliasPath
+              [vueI18nAliasName]: getVueI18nAliasPath({
+                ssr: ssrBuild,
+                runtimeOnly
+              })
             }
           }
         };
         debug$2("alias Config:", aliasConfig);
         return shared.assign(defineConfig, aliasConfig);
       },
-      configResolved(config) {
+      async 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$2(
-          `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;
+        isProduction = config.isProduction;
+        sourceMap = config.command === "build" ? !!config.build.sourcemap : false;
+        debug$2(`configResolved: isProduction = ${isProduction}, sourceMap = ${sourceMap}`);
+        const isRolldownVite = !!(await getViteModule()).rolldownVersion;
+        debug$2(`Using ${isRolldownVite ? "rolldown-vite" : "vite"} for the build`);
+        if (!isRolldownVite) {
+          const jsonPlugin = getVitePlugin(config, "vite:json");
+          if (jsonPlugin) {
+            const orgTransform = "handler" in jsonPlugin.transform ? jsonPlugin.transform.handler : jsonPlugin.transform;
+            async function overrideJson(code, id) {
+              const filter = await getFilter();
+              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 { query } = parseVueRequest(id);
-            if (query.vue) {
-              return;
+            jsonPlugin.transform = overrideJson;
+            if ("handler" in jsonPlugin.transform) {
+              jsonPlugin.transform.handler = overrideJson;
             }
-            debug$2("org json plugin");
-            return orgTransform.apply(this, [code, id]);
-          };
+          }
+        }
+      },
+      async handleHotUpdate({ file, server }) {
+        if (RE_RESOURCE_FORMAT.test(file)) {
+          const module2 = server.moduleGraph.getModuleById(
+            asVirtualId(INTLIFY_BUNDLE_IMPORT_ID, meta.framework)
+          );
+          if (module2) {
+            server.moduleGraph.invalidateModule(module2);
+            return [module2];
+          }
         }
       }
     },
-    resolveId(id, importer) {
-      debug$2("resolveId", id, importer);
-      if (id === INTLIFY_BUNDLE_IMPORT_ID) {
-        return asVirtualId(id, meta.framework);
+    webpack(compiler) {
+      isProduction = compiler.options.mode !== "development";
+      sourceMap = !!compiler.options.devtool;
+      debug$2(`webpack: 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
+        })}`
+      );
+      compiler.options.plugins.push(
+        new compiler.webpack.DefinePlugin({
+          __VUE_I18N_LEGACY_API__: JSON.stringify(compositionOnly),
+          __VUE_I18N_FULL_INSTALL__: JSON.stringify(fullInstall),
+          __INTLIFY_PROD_DEVTOOLS__: "false"
+        })
+      );
+      debug$2(`set __VUE_I18N_LEGACY_API__ is '${compositionOnly}'`);
+      debug$2(`set __VUE_I18N_FULL_INSTALL__ is '${fullInstall}'`);
+      const filter = pluginutils.createFilter(...resolveIncludeExclude());
+      if (compiler.options.module) {
+        compiler.options.module.rules.push({
+          test: RE_RESOURCE_FORMAT,
+          type: "javascript/auto",
+          include(resource) {
+            debug$2("webpack resource include", resource);
+            return filter(resource);
+          }
+        });
       }
     },
-    loadInclude(id) {
-      return INTLIFY_BUNDLE_IMPORT_ID === getVirtualId(id, meta.framework);
-    },
-    load(id) {
-      debug$2("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);
+    resolveId: {
+      filter: {
+        id: RE_INTLIFY_BUNDLE_IMPORT_ID
+      },
+      handler(id) {
+        return asVirtualId(id, meta.framework);
       }
     },
-    transformInclude(id) {
-      debug$2("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);
+    load: {
+      filter: {
+        id: RE_VIRTUAL_PREFIXED_INTLIFY_BUNDLE_IMPORT_ID
+      },
+      async handler(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 {
+            moduleType: "js",
+            code,
+            map: { mappings: "" }
+          };
+        }
       }
-      return supportedFileExtensionsRE.test(filename) && filter(filename) && isResourcePath;
     },
-    async transform(code, id) {
-      const { filename, query } = parseVueRequest(id);
-      debug$2("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 = pathe.resolve(pathe.dirname(id), p.specifier);
-          importedResources.add(res);
+    transform: {
+      async handler(code, id) {
+        const filter = await getFilter();
+        if (!filter(id)) {
+          return;
         }
-      }
-      if (!query.vue && supportedFileExtensionsRE.test(id) && filter(id)) {
-        langInfo = pathe.parse(filename).ext;
-        const generate = getGenerator(langInfo);
-        const parseOptions = getOptions(filename, ctx, query, {
-          ...opts,
-          transformI18nBlock: void 0
-        });
-        debug$2("parseOptions", parseOptions);
-        try {
-          const { code: generatedCode, map } = generate(code, parseOptions);
+        const { filename, query } = parseVueRequest(id);
+        debug$2("transform", id, JSON.stringify(query), filename);
+        let langInfo = defaultSFCLang;
+        let inSourceMap;
+        if (!query.vue) {
+          langInfo = path.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 } = await generate(code, parseOptions);
           debug$2("generated code", generatedCode);
-          debug$2("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
+          debug$2("sourcemap", map, sourceMap);
+          if (code === generatedCode) return;
+          return {
+            moduleType: "js",
+            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
+              }
             );
-            return `export default {}`;
-          } else {
-            throw err;
-          }
-        }
-      }
-      if (isCustomBlock(query)) {
-        langInfo = opts.defaultSFCLang;
-        if (query.lang && query.lang !== "i18n") {
-          langInfo = query.lang;
-        }
-        debug$2("langInfo", langInfo);
-        const parseOptions = getOptions(filename, ctx, query, {
-          ...opts,
-          allowDynamic: false,
-          transformI18nBlock: void 0
-        });
-        debug$2("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");
+            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 {
+              moduleType: "js",
+              code: generatedCode,
+              // prettier-ignore
+              map: { mappings: "" }
+            };
           }
         }
-        const generate = getGenerator(langInfo, bundleUtils.generateYAML);
-        const { code: generatedCode, map } = generate(source, parseOptions);
-        debug$2("generated code", generatedCode);
-        debug$2("sourcemap", map, ctx.sourceMap);
-        if (code !== generatedCode) {
-          return result(generatedCode);
-        }
       }
     }
   };
@@ -424,39 +521,66 @@ function getGenerator(ext, fallback = bundleUtils.generateJSON) {
   if (/\.ya?ml$/.test(ext)) {
     return bundleUtils.generateYAML;
   }
-  if (/\.[c|m]?[j|t]s$/.test(ext)) {
+  if (/\.[c|m]?js$/.test(ext)) {
     return bundleUtils.generateJavaScript;
   }
+  if (/\.[c|m]?ts$/.test(ext)) {
+    return bundleUtils.generateTypescript;
+  }
   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 normalizeConfigResolveAlias(resolve, framework) {
+  if (resolve && resolve.alias) {
+    return resolve;
+  }
+  if (!resolve) {
+    if (framework === "vite") {
+      return { alias: [] };
+    } else if (framework === "webpack") {
+      return { alias: {} };
+    }
+  } else if (!resolve.alias) {
+    if (framework === "vite") {
+      resolve.alias = [];
+      return resolve;
+    } else if (framework === "webpack") {
+      resolve.alias = {};
+      return resolve;
+    }
+  }
 }
-function generateBundleResources(resources) {
+async function generateBundleResources(resources, isProduction, {
+  forceStringify = false,
+  isGlobal = false,
+  onlyLocales = [],
+  strictMessage = true,
+  escapeHtml = false,
+  jit = true,
+  transformI18nBlock = void 0
+}) {
   const codes = [];
-  const imports = [];
-  for (const filename of resources) {
-    debug$2(`${filename} bundle loading ...`);
-    const { name } = pathe.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}`);
+  for (const res of resources) {
+    debug$2(`${res} bundle loading ...`);
+    if (/\.(json5?|ya?ml)$/.test(res)) {
+      const { ext, name } = path.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}`);
+    }
   }
-  const importStatements = imports.map((x) => x.statement).join("\n");
-  return `
-${importStatements}
-
-const isObject = (item) => item && typeof item === 'object' && !Array.isArray(item);
+  return `const isObject = (item) => item && typeof item === 'object' && !Array.isArray(item);
 
 const mergeDeep = (target, ...sources) => {
   if (!sources.length) return target;
@@ -477,73 +601,96 @@ const mergeDeep = (target, ...sources) => {
 }
 
 export default mergeDeep({},
-  ${codes.map((code) => `{ ${code} }`).join(",\n  ")}
+  ${codes.map((code) => `{${code}}`).join(",\n")}
 );`;
 }
-function getCode(source, filename, sourceMap, query, parser, meta) {
-  if (query.index == null) {
-    raiseError(`unexpected index: ${query.index}`);
+async function getCode(source, filename, sourceMap, query, parser, framework = "vite") {
+  const { index, issuerPath } = query;
+  if (!shared.isNumber(index)) {
+    raiseError(`unexpected index: ${index}`);
   }
-  if (meta.framework === "vite") {
+  if (framework === "webpack") {
+    if (issuerPath) {
+      debug$2(`getCode (webpack) ${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 (webpack) ${index} from SFC`, code);
+        return code;
+      } else {
+        return source;
+      }
+    }
+  } else {
     return source;
   }
-  if (query.issuerPath) {
-    debug$2(
-      `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$2(`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)
+  return !shared.isEmptyObject(query) && "vue" in query && (query["type"] === "custom" || // for webpack (vue-loader)
+  query["type"] === "i18n" || // for vite (@vite/plugin-vue)
   query["blockType"] === "i18n");
 }
-function getOptions(filename, ctx, query, opts) {
+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 = {
-    ...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}`),
+    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 errMessage = `${msg} (error code: ${extra?.code}) in ${filename}
+      const errMssage = `${msg} (error code: ${extra?.code}) in ${filename}
   target message: ${extra?.source}
   target message path: ${extra?.path}
 
   ${codeFrame}
 `;
-      error(errMessage);
-      throw new Error(errMessage);
+      error(errMssage);
+      throw new Error(errMssage);
     }
   };
   if (isCustomBlock(query)) {
     return shared.assign(baseOptions, {
       type: "sfc",
-      locale: query.locale ?? "",
-      isGlobal: opts.globalSFCScope || !!query.global
+      locale: shared.isString(query.locale) ? query.locale : "",
+      isGlobal: isGlobal || !!query.global
+    });
+  } else {
+    return shared.assign(baseOptions, {
+      type: "plain",
+      isGlobal: false
     });
   }
-  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;
@@ -551,8 +698,8 @@ function getVirtualId(id, framework = "vite") {
 function asVirtualId(id, framework = "vite") {
   return framework === "vite" ? VIRTUAL_PREFIX + id : id;
 }
-function readFile(path) {
-  return fs__default.readFileSync(path, "utf-8");
+async function getRaw(path) {
+  return node_fs.promises.readFile(path, { encoding: "utf-8" });
 }
 
 const debug$1 = createDebug__default(resolveNamespace("directive"));
@@ -612,17 +759,14 @@ function directivePlugin({
   };
 }
 function resolveVueOptions(vuePlugin, optimizeTranslationDirective, translationIdentifiers) {
-  var _a, _b;
   const vueOptions = vuePlugin.api.options;
-  vueOptions.template || (vueOptions.template = {});
-  (_a = vueOptions.template).compilerOptions || (_a.compilerOptions = {});
-  (_b = vueOptions.template.compilerOptions).directiveTransforms || (_b.directiveTransforms = {});
+  vueOptions.template ||= {};
+  vueOptions.template.compilerOptions ||= {};
+  vueOptions.template.compilerOptions.directiveTransforms ||= {};
   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);
     if (resolveIdentifier2 == null) {
@@ -663,9 +807,7 @@ function analyzeIdentifiers(descriptor, { root }, translationIdentifiers) {
   debug$1("importLocalName", importLocalName);
   const resolvedIdentifier = getVueI18nIdentifier(scope, importLocalName);
   if (resolvedIdentifier) {
-    const normalizedFilename = normalizePath(
-      path__default.relative(root, descriptor.filename)
-    );
+    const normalizedFilename = normalizePath(path__default.relative(root, descriptor.filename));
     debug$1("set vue-i18n resolved identifier: ", resolvedIdentifier);
     translationIdentifiers.set(normalizedFilename, resolvedIdentifier);
   }
@@ -735,14 +877,16 @@ function getCallExpressionAndReturnStatement(scope, local) {
     return EMPTY_NODE_RETURN;
   }
   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;
-      }
-    );
+  if (callExpressionRef.from.type === "function" && callExpressionRef.from.block.type === typescriptEstree.AST_NODE_TYPES.FunctionExpression && // @ts-expect-error -- FIXME: type error
+  callExpressionRef.from.block.parent.type === typescriptEstree.AST_NODE_TYPES.Property && // @ts-expect-error -- FIXME: type error
+  callExpressionRef.from.block.parent.key.type === typescriptEstree.AST_NODE_TYPES.Identifier && // @ts-expect-error -- FIXME: type error
+  callExpressionRef.from.block.parent.key.name === "setup") {
+    returnStatement = callExpressionRef.from.block.body.body.find((statement) => {
+      return statement.type === typescriptEstree.AST_NODE_TYPES.ReturnStatement;
+    });
   }
   return {
+    // @ts-expect-error -- FIXME: type error
     callExpression: callExpressionRef.identifier.parent,
     returnStatement
   };
@@ -809,9 +953,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 };
       }
@@ -819,9 +961,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" };
       }
@@ -833,17 +973,17 @@ function resolveIdentifier(localVariables, returnVariable) {
 const debug = createDebug__default(resolveNamespace("root"));
 const unpluginFactory = (options = {}, meta) => {
   debug("meta framework", meta.framework);
-  if (!["vite", "webpack", "rspack"].includes(meta.framework)) {
-    raiseError(`This plugin is supported 'vite', 'webpack' and 'rspack' only`);
+  if (!["vite", "webpack"].includes(meta.framework)) {
+    raiseError(`This plugin is supported 'vite' and 'webpack' only`);
   }
   debug("plugin options (resolving):", options);
   const resolvedOptions = resolveOptions(options);
   debug("plugin options (resolved):", resolvedOptions);
   const plugins = [resourcePlugin(resolvedOptions, meta)];
   if (resolvedOptions.optimizeTranslationDirective) {
-    if (meta.framework === "webpack" || meta.framework === "rspack") {
+    if (meta.framework === "webpack") {
       raiseError(
-        `The 'optimizeTranslationDirective' option still is not supported for ${meta.framework}.
+        `The 'optimizeTranslationDirective' option still is not supported for webpack.
 We are waiting for your Pull Request \u{1F642}.`
       );
     }