@intlify/unplugin-vue-i18n 5.0.0-beta.1 → 5.0.0-beta.3

package/lib/index.cjs

@@ -3,64 +3,128 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const unplugin$1 = require('unplugin');
-const pathe = require('pathe');
 const createDebug = require('debug');
-const fg = require('fast-glob');
+const pc = require('picocolors');
+const path = require('node:path');
+const fs = require('node:fs');
+const module$1 = require('node:module');
+const pathe = require('pathe');
+const mlly = require('mlly');
 const shared = require('@intlify/shared');
+const fg = require('fast-glob');
 const pluginutils = require('@rollup/pluginutils');
 const bundleUtils = require('@intlify/bundle-utils');
-const compilerSfc = require('@vue/compiler-sfc');
-const fs = require('node:fs');
-const pc = require('picocolors');
-const module$1 = require('node:module');
-const path = require('node:path');
+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 eslintUitls = require('@eslint-community/eslint-utils');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const createDebug__default = /*#__PURE__*/_interopDefaultCompat(createDebug);
-const fg__default = /*#__PURE__*/_interopDefaultCompat(fg);
-const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 const pc__default = /*#__PURE__*/_interopDefaultCompat(pc);
-const module__default = /*#__PURE__*/_interopDefaultCompat(module$1);
 const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const module__default = /*#__PURE__*/_interopDefaultCompat(module$1);
+const fg__default = /*#__PURE__*/_interopDefaultCompat(fg);
+const eslintUitls__default = /*#__PURE__*/_interopDefaultCompat(eslintUitls);
 
-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)
-  );
-  ret.vue = params.has("vue");
-  ret.global = params.has("global");
-  ret.src = params.has("src");
-  ret.raw = params.has("raw");
-  if (params.has("type")) {
-    ret.type = params.get("type");
-  }
-  if (params.has("blockType")) {
-    ret.blockType = params.get("blockType");
+const PKG_NAME = "unplugin-vue-i18n";
+
+function warn(...args) {
+  console.warn(pc__default.yellow(pc__default.bold(`[${PKG_NAME}] `)), ...args);
+}
+function error(...args) {
+  console.error(pc__default.red(pc__default.bold(`[${PKG_NAME}] `)), ...args);
+}
+function raiseError(message) {
+  throw new Error(`[${PKG_NAME}] ${message}`);
+}
+
+function resolveNamespace(name) {
+  return `${PKG_NAME}:${name}`;
+}
+function getVitePlugin(config, name) {
+  return config.plugins.find((p) => p.name === name);
+}
+function checkVuePlugin(vuePlugin) {
+  if (vuePlugin == null || !vuePlugin.api) {
+    error(
+      "`@vitejs/plugin-vue` plugin is not found or invalid version. Please install `@vitejs/plugin-vue` v4.3.4 or later version."
+    );
+    return false;
   }
-  if (params.has("index")) {
-    ret.index = Number(params.get("index"));
+  return true;
+}
+const isWindows = typeof process !== "undefined" && process.platform === "win32";
+const windowsSlashRE = /\\/g;
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+function normalizePath(id) {
+  return path__default.posix.normalize(isWindows ? slash(id) : id);
+}
+
+const defaultFindOptions = {
+  startingFrom: ".",
+  rootPattern: /^node_modules$/,
+  reverse: false,
+  test: (filePath) => {
+    try {
+      if (fs.statSync(filePath).isFile()) {
+        return true;
+      }
+    } catch {
+    }
   }
-  if (params.has("locale")) {
-    ret.locale = params.get("locale");
+};
+function findFile(filename, _options = {}) {
+  const filenames = Array.isArray(filename) ? filename : [filename];
+  const options = { ...defaultFindOptions, ..._options };
+  const basePath = pathe.resolve(options.startingFrom);
+  const leadingSlash = basePath[0] === "/";
+  const segments = basePath.split("/").filter(Boolean);
+  if (leadingSlash) {
+    segments[0] = "/" + segments[0];
   }
-  if (langPart) {
-    const [, lang] = langPart.split(".");
-    ret.lang = lang;
-  } else if (params.has("lang")) {
-    ret.lang = params.get("lang");
+  let root = segments.findIndex((r) => r.match(options.rootPattern));
+  if (root === -1) {
+    root = 0;
   }
-  if (params.has("issuerPath")) {
-    ret.issuerPath = params.get("issuerPath");
+  if (options.reverse) {
+    for (let index = root + 1; index <= segments.length; index++) {
+      for (const filename2 of filenames) {
+        const filePath = pathe.join(...segments.slice(0, index), filename2);
+        if (options.test(filePath)) {
+          return filePath;
+        }
+      }
+    }
+  } else {
+    for (let index = segments.length; index > root; index--) {
+      for (const filename2 of filenames) {
+        const filePath = pathe.join(...segments.slice(0, index), filename2);
+        if (options.test(filePath)) {
+          return filePath;
+        }
+      }
+    }
   }
-  return {
-    filename,
-    query: ret
-  };
+  throw new Error(
+    `Cannot find matching ${filename} in ${options.startingFrom} or parent directories`
+  );
+}
+function findNearestFile(filename, _options = {}) {
+  return findFile(filename, _options);
+}
+function resolvePackageJSON(id = process.cwd(), options = {}) {
+  const resolvedPath = pathe.isAbsolute(id) ? id : mlly.resolvePathSync(id, options);
+  return findNearestFile("package.json", {
+    startingFrom: resolvedPath,
+    ...options
+  });
 }
 
 const _require = module__default.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
@@ -76,11 +140,11 @@ function checkInstallPackage(debug) {
 }
 function resolvePkgPath(id, debug) {
   try {
-    const resolvedPath = _require.resolve(id);
-    const pkgPath = path__default.dirname(resolvedPath);
-    const pkgJson = JSON.parse(
-      fs__default.readFileSync(path__default.join(pkgPath, "package.json"), "utf-8")
-    );
+    const modPath = _require.resolve(id);
+    debug("modPath:", modPath, id);
+    const pkgJsonPath = resolvePackageJSON(modPath);
+    debug("pkgJsonPath:", pkgJsonPath);
+    const pkgJson = JSON.parse(fs__default.readFileSync(pkgJsonPath, "utf-8"));
     const pkgName = pkgJson.name.startsWith("vue-i18n") ? "vue-i18n" : pkgJson.name.startsWith("petite-vue-i18n") ? "petite-vue-i18n" : "";
     return pkgJson ? { alias: id, pkg: pkgName } : null;
   } catch (e) {
@@ -88,34 +152,14 @@ function resolvePkgPath(id, debug) {
     return null;
   }
 }
-function warn(...args) {
-  console.warn(pc__default.yellow(pc__default.bold(`[unplugin-vue-i18n] `)), ...args);
-}
-function error(...args) {
-  console.error(pc__default.red(pc__default.bold(`[unplugin-vue-i18n] `)), ...args);
-}
-async function getRaw(path2) {
-  return fs.promises.readFile(path2, { encoding: "utf-8" });
-}
-function raiseError(message) {
-  throw new Error(`[unplugin-vue-i18n] ${message}`);
-}
 
-const INTLIFY_BUNDLE_IMPORT_ID = "@intlify/unplugin-vue-i18n/messages";
-const VIRTUAL_PREFIX = "\0";
-const debug = createDebug__default("unplugin-vue-i18n");
-const installedPkgInfo = checkInstallPackage(debug);
-const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
-  debug("plugin options:", options, meta.framework);
-  if (!["vite", "webpack"].includes(meta.framework)) {
-    raiseError(`This plugin is supported 'vite' and 'webpack' only`);
-  }
+function resolveOptions(options, installedPkgInfo) {
   let onlyLocales = [];
   if (options.onlyLocales) {
-    onlyLocales = Array.isArray(options.onlyLocales) ? options.onlyLocales : [options.onlyLocales];
+    onlyLocales = shared.isArray(options.onlyLocales) ? options.onlyLocales : [options.onlyLocales];
   }
   let include = options.include;
-  let exclude = null;
+  let exclude = void 0;
   if (include) {
     if (shared.isArray(include)) {
       include = include.map((item) => pathe.normalize(item));
@@ -125,35 +169,137 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
   } else {
     exclude = "**/**";
   }
-  const filter = pluginutils.createFilter(include, exclude);
   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;
-  debug("runtimeOnly", runtimeOnly);
   const dropMessageCompiler = !!options.dropMessageCompiler;
-  debug("dropMessageCompiler", dropMessageCompiler);
   const compositionOnly = installedPkgInfo.pkg === "vue-i18n" ? shared.isBoolean(options.compositionOnly) ? options.compositionOnly : true : true;
-  debug("compositionOnly", compositionOnly);
   const fullInstall = installedPkgInfo.pkg === "vue-i18n" ? shared.isBoolean(options.fullInstall) ? options.fullInstall : true : false;
-  debug("fullInstall", fullInstall);
   const ssrBuild = !!options.ssr;
-  debug("ssr", ssrBuild);
-  const getVueI18nAliasPath = ({ ssr = false, runtimeOnly: runtimeOnly2 = false }) => {
-    return `${installedPkgInfo.alias}/dist/${installedPkgInfo.pkg}${runtimeOnly2 ? ".runtime" : ""}.${!ssr ? "esm-bundler.js" : "node.mjs"}`;
-  };
   const allowDynamic = !!options.allowDynamic;
-  debug("allowDynamic", allowDynamic);
   const strictMessage = shared.isBoolean(options.strictMessage) ? options.strictMessage : true;
-  debug("strictMessage", strictMessage);
   const escapeHtml = !!options.escapeHtml;
-  debug("escapeHtml", escapeHtml);
+  const optimizeTranslationDirective = shared.isString(options.optimizeTranslationDirective) || shared.isArray(options.optimizeTranslationDirective) ? options.optimizeTranslationDirective : !!options.optimizeTranslationDirective;
+  const translationIdentifiers = /* @__PURE__ */ new Map();
+  return {
+    include,
+    exclude,
+    onlyLocales,
+    forceStringify,
+    defaultSFCLang,
+    globalSFCScope,
+    runtimeOnly,
+    dropMessageCompiler,
+    compositionOnly,
+    fullInstall,
+    ssrBuild,
+    allowDynamic,
+    strictMessage,
+    escapeHtml,
+    optimizeTranslationDirective,
+    translationIdentifiers
+  };
+}
+
+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)
+  );
+  ret.vue = params.has("vue");
+  ret.global = params.has("global");
+  ret.src = params.has("src");
+  ret.raw = params.has("raw");
+  if (params.has("type")) {
+    ret.type = params.get("type");
+  }
+  if (params.has("blockType")) {
+    ret.blockType = params.get("blockType");
+  }
+  if (params.has("index")) {
+    ret.index = Number(params.get("index"));
+  }
+  if (params.has("locale")) {
+    ret.locale = params.get("locale");
+  }
+  if (langPart) {
+    const [, lang] = langPart.split(".");
+    ret.lang = lang;
+  } else if (params.has("lang")) {
+    ret.lang = params.get("lang");
+  }
+  if (params.has("issuerPath")) {
+    ret.issuerPath = params.get("issuerPath");
+  }
+  return {
+    filename,
+    query: ret
+  };
+}
+
+function getVueCompiler(vuePlugin) {
+  return vuePlugin?.api?.options.compiler;
+}
+function getVuePluginOptions(vuePlugin) {
+  return {
+    isProduction: vuePlugin?.api?.options.isProduction,
+    root: vuePlugin?.api?.options.root,
+    template: vuePlugin?.api?.options.template,
+    compiler: vuePlugin?.api?.options.compiler
+  };
+}
+
+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,
+  forceStringify,
+  defaultSFCLang,
+  globalSFCScope,
+  runtimeOnly,
+  dropMessageCompiler,
+  compositionOnly,
+  fullInstall,
+  ssrBuild,
+  strictMessage,
+  allowDynamic,
+  escapeHtml
+}, meta, installedPkgInfo) {
+  const filter = pluginutils.createFilter(include, exclude);
+  const getVueI18nAliasPath = ({ ssr = false, runtimeOnly: runtimeOnly2 = false }) => {
+    return `${installedPkgInfo.alias}/dist/${installedPkgInfo.pkg}${runtimeOnly2 ? ".runtime" : ""}.${!ssr ? "esm-bundler.js" : "node.mjs"}`;
+  };
   let isProduction = false;
   let sourceMap = false;
   const vueI18nAliasName = installedPkgInfo.alias;
-  debug(`vue-i18n alias name: ${vueI18nAliasName}`);
+  debug$2(`vue-i18n alias name: ${vueI18nAliasName}`);
+  let vuePlugin = null;
+  const getSfcParser = () => {
+    return vuePlugin ? getVueCompiler(vuePlugin).parse : compilerSfc.parse;
+  };
   return {
-    name: "unplugin-vue-i18n",
+    name: resolveNamespace("resource"),
     /**
      * NOTE:
      *
@@ -173,7 +319,7 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
             __VUE_I18N_PROD_DEVTOOLS__: false
           }
         };
-        debug("define Config:", defineConfig);
+        debug$2("define Config:", defineConfig);
         const aliasConfig = {
           resolve: {
             alias: {
@@ -184,16 +330,20 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
             }
           }
         };
-        debug("alias Config:", aliasConfig);
+        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(
+        debug$2(
           `configResolved: isProduction = ${isProduction}, sourceMap = ${sourceMap}`
         );
-        const jsonPlugin = config.plugins.find((p) => p.name === "vite:json");
+        const jsonPlugin = getVitePlugin(config, "vite:json");
         if (jsonPlugin) {
           const orgTransform = jsonPlugin.transform;
           jsonPlugin.transform = async function(code, id) {
@@ -204,13 +354,11 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
             if (query.vue) {
               return;
             }
-            debug("org json plugin");
+            debug$2("org json plugin");
             return orgTransform.apply(this, [code, id]);
           };
         }
-        const esbuildPlugin = config.plugins.find(
-          (p) => p.name === "vite:esbuild"
-        );
+        const esbuildPlugin = getVitePlugin(config, "vite:esbuild");
         if (esbuildPlugin) {
           const orgTransform = esbuildPlugin.transform;
           esbuildPlugin.transform = async function(code, id) {
@@ -243,10 +391,10 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
                   forceStringify
                 }
               );
-              debug("parseOptions", parseOptions);
+              debug$2("parseOptions", parseOptions);
               const { code: generatedCode, map } = generate(_code, parseOptions);
-              debug("generated code", generatedCode);
-              debug("sourcemap", map, sourceMap);
+              debug$2("generated code", generatedCode);
+              debug$2("sourcemap", map, sourceMap);
               if (_code === generatedCode)
                 return;
               return {
@@ -274,7 +422,7 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
     webpack(compiler) {
       isProduction = compiler.options.mode !== "development";
       sourceMap = !!compiler.options.devtool;
-      debug(`webpack: isProduction = ${isProduction}, sourceMap = ${sourceMap}`);
+      debug$2(`webpack: isProduction = ${isProduction}, sourceMap = ${sourceMap}`);
       compiler.options.resolve = normalizeConfigResolveAlias(
         compiler.options.resolve,
         meta.framework
@@ -283,7 +431,7 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
         ssr: ssrBuild,
         runtimeOnly
       });
-      debug(
+      debug$2(
         `set ${vueI18nAliasName}: ${getVueI18nAliasPath({
           ssr: ssrBuild,
           runtimeOnly
@@ -298,10 +446,10 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
               __INTLIFY_PROD_DEVTOOLS__: "false"
             })
           );
-          debug(`set __VUE_I18N_LEGACY_API__ is '${compositionOnly}'`);
-          debug(`set __VUE_I18N_FULL_INSTALL__ is '${fullInstall}'`);
+          debug$2(`set __VUE_I18N_LEGACY_API__ is '${compositionOnly}'`);
+          debug$2(`set __VUE_I18N_FULL_INSTALL__ is '${fullInstall}'`);
         } else {
-          debug("ignore vue-i18n feature flags with webpack.DefinePlugin");
+          debug$2("ignore vue-i18n feature flags with webpack.DefinePlugin");
         }
       });
       if (compiler.options.module) {
@@ -315,15 +463,14 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
       }
     },
     resolveId(id, importer) {
-      debug("resolveId", id, importer);
+      debug$2("resolveId", id, importer);
       if (id === INTLIFY_BUNDLE_IMPORT_ID) {
         return asVirtualId(id, meta.framework);
       }
     },
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async load(id) {
-      debug("load", id);
-      const { query } = parseVueRequest(id);
+      debug$2("load", id);
       if (INTLIFY_BUNDLE_IMPORT_ID === getVirtualId(id, meta.framework) && include) {
         let resourcePaths = [];
         const includePaths = shared.isArray(include) ? include : [include];
@@ -335,7 +482,6 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
         );
         const code = await generateBundleResources(
           resourcePaths,
-          query,
           isProduction,
           {
             forceStringify,
@@ -350,7 +496,7 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
       }
     },
     transformInclude(id) {
-      debug("transformInclude", id);
+      debug$2("transformInclude", id);
       if (meta.framework === "vite") {
         return true;
       } else {
@@ -360,7 +506,7 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
     },
     async transform(code, id) {
       const { filename, query } = parseVueRequest(id);
-      debug("transform", id, JSON.stringify(query), filename);
+      debug$2("transform", id, JSON.stringify(query), filename);
       let langInfo = defaultSFCLang;
       let inSourceMap;
       if (!query.vue) {
@@ -383,10 +529,10 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
               forceStringify
             }
           );
-          debug("parseOptions", parseOptions);
+          debug$2("parseOptions", parseOptions);
           const { code: generatedCode, map } = generate(code, parseOptions);
-          debug("generated code", generatedCode);
-          debug("sourcemap", map, sourceMap);
+          debug$2("generated code", generatedCode);
+          debug$2("sourcemap", map, sourceMap);
           if (code === generatedCode)
             return;
           return {
@@ -402,7 +548,7 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
           } else if (defaultSFCLang) {
             langInfo = defaultSFCLang;
           }
-          debug("langInfo", langInfo);
+          debug$2("langInfo", langInfo);
           const generate = /\.?json5?/.test(langInfo) ? bundleUtils.generateJSON : bundleUtils.generateYAML;
           const parseOptions = getOptions(
             filename,
@@ -419,17 +565,18 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
               forceStringify
             }
           );
-          debug("parseOptions", parseOptions);
+          debug$2("parseOptions", parseOptions);
           const source = await getCode(
             code,
             filename,
             sourceMap,
             query,
+            getSfcParser(),
             meta.framework
           );
           const { code: generatedCode, map } = generate(source, parseOptions);
-          debug("generated code", generatedCode);
-          debug("sourcemap", map, sourceMap);
+          debug$2("generated code", generatedCode);
+          debug$2("sourcemap", map, sourceMap);
           if (code === generatedCode)
             return;
           return {
@@ -441,7 +588,7 @@ const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
       }
     }
   };
-});
+}
 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;
 }
@@ -474,7 +621,7 @@ async function loadWebpack() {
   }
   return webpack;
 }
-async function generateBundleResources(resources, query, isProduction, {
+async function generateBundleResources(resources, isProduction, {
   forceStringify = false,
   isGlobal = false,
   onlyLocales = [],
@@ -484,7 +631,7 @@ async function generateBundleResources(resources, query, isProduction, {
 }) {
   const codes = [];
   for (const res of resources) {
-    debug(`${res} bundle loading ...`);
+    debug$2(`${res} bundle loading ...`);
     if (/\.(json5?|ya?ml)$/.test(res)) {
       const { ext, name } = pathe.parse(res);
       const source = await getRaw(res);
@@ -499,7 +646,7 @@ async function generateBundleResources(resources, query, isProduction, {
       });
       parseOptions.type = "bare";
       const { code } = generate(source, parseOptions);
-      debug("generated code", code);
+      debug$2("generated code", code);
       codes.push(`${JSON.stringify(name)}: ${code}`);
     }
   }
@@ -527,24 +674,24 @@ export default mergeDeep({},
   ${codes.map((code) => `{${code}}`).join(",\n")}
 );`;
 }
-async function getCode(source, filename, sourceMap, query, framework = "vite") {
+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") {
     if (issuerPath) {
-      debug(`getCode (webpack) ${index} via issuerPath`, issuerPath);
+      debug$2(`getCode (webpack) ${index} via issuerPath`, issuerPath);
       return await getRaw(filename);
     } else {
-      const result = compilerSfc.parse(await getRaw(filename), {
+      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(`getCode (webpack) ${index} from SFC`, code);
+        debug$2(`getCode (webpack) ${index} from SFC`, code);
         return code;
       } else {
         return source;
@@ -619,6 +766,299 @@ function getVirtualId(id, framework = "vite") {
 function asVirtualId(id, framework = "vite") {
   return framework === "vite" ? VIRTUAL_PREFIX + id : id;
 }
+async function getRaw(path) {
+  return fs.promises.readFile(path, { encoding: "utf-8" });
+}
+
+const debug$1 = createDebug__default(resolveNamespace("directive"));
+function directivePlugin({
+  optimizeTranslationDirective,
+  translationIdentifiers
+}) {
+  let vuePlugin = null;
+  let vuePluginOptions = null;
+  return {
+    name: resolveNamespace("directive"),
+    enforce: "pre",
+    vite: {
+      config(config) {
+        vuePlugin = getVitePlugin(config, "vite:vue");
+        if (!checkVuePlugin(vuePlugin)) {
+          return;
+        }
+        if (optimizeTranslationDirective) {
+          vuePlugin.api.options = resolveVueOptions(
+            vuePlugin,
+            optimizeTranslationDirective,
+            translationIdentifiers
+          );
+          debug$1(`vite:vue options['template']:`, vuePlugin.api.options);
+        }
+      },
+      configResolved(config) {
+        vuePlugin = getVitePlugin(config, "vite:vue");
+        if (!checkVuePlugin(vuePlugin)) {
+          return;
+        }
+      }
+    },
+    async transform(code, id) {
+      const { filename } = parseVueRequest(id);
+      if (vuePluginOptions == null) {
+        vuePluginOptions = getVuePluginOptions(vuePlugin);
+      }
+      if (id.endsWith(".vue")) {
+        analyzeIdentifiers(
+          getDescriptor(filename, code, vuePluginOptions),
+          vuePluginOptions,
+          translationIdentifiers
+        );
+      }
+      return code;
+    }
+  };
+}
+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 = {});
+  const translationSignatureResolver = (context, baseResolver) => {
+    const { filename } = context;
+    const vuePluginOptions = getVuePluginOptions(vuePlugin);
+    const normalizedFilename = normalizePath(
+      path__default.relative(vuePluginOptions.root, filename)
+    );
+    const resolveIdentifier2 = translationIdentifiers.get(normalizedFilename);
+    debug$1("resolved vue-i18n Identifier", resolveIdentifier2);
+    if (resolveIdentifier2 == null) {
+      return void 0;
+    }
+    if (resolveIdentifier2.type === "identifier") {
+      return baseResolver(context, resolveIdentifier2.key);
+    } else {
+      const resolvedSignature = baseResolver(context, resolveIdentifier2.key);
+      return resolveIdentifier2?.style === "script-setup" ? `${resolvedSignature}.t` : resolvedSignature;
+    }
+  };
+  vueOptions.template.compilerOptions.directiveTransforms.t = vueI18nExtensions.transformVTDirective({
+    translationSignatures: shared.isBoolean(optimizeTranslationDirective) ? translationSignatureResolver : optimizeTranslationDirective
+  });
+  return vueOptions;
+}
+function analyzeIdentifiers(descriptor, { root }, translationIdentifiers) {
+  const source = descriptor.scriptSetup?.content || descriptor.script?.content;
+  debug$1("getDescriptor content", source);
+  if (!source) {
+    return;
+  }
+  const ast = typescriptEstree.parse(source, { range: true });
+  typescriptEstree.simpleTraverse(ast, {
+    enter(node, parent) {
+      if (parent) {
+        node.parent = parent;
+      }
+    }
+  });
+  const scopeManager$1 = scopeManager.analyze(ast, { sourceType: "module" });
+  const scope = getScope(scopeManager$1, ast);
+  const importLocalName = getImportLocalName(scope, "vue-i18n", "useI18n");
+  if (importLocalName == null) {
+    return;
+  }
+  debug$1("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);
+    translationIdentifiers.set(normalizedFilename, resolvedIdentifier);
+  }
+}
+function getScope(manager, node) {
+  const scope = manager.acquire(node, true);
+  if (scope) {
+    if (scope.type === "function-expression-name") {
+      return scope.childScopes[0];
+    }
+    return scope;
+  }
+  return manager.scopes[0];
+}
+function getImportLocalName(scope, source, imported) {
+  const importDecl = getImportDeclaration(scope, source);
+  if (importDecl) {
+    const specifierNode = importDecl.specifiers.find(
+      (specifierNode2) => isImportedIdentifierInImportClause(specifierNode2) && specifierNode2.imported.name === imported
+    );
+    return specifierNode ? specifierNode.local.name : null;
+  }
+  return null;
+}
+function getImportDeclaration(scope, source) {
+  const tracker = new eslintUitls__default.ReferenceTracker(scope);
+  const traceMap = {
+    [source]: {
+      [eslintUitls__default.ReferenceTracker.ESM]: true,
+      [eslintUitls__default.ReferenceTracker.READ]: true
+    }
+  };
+  const refs = Array.from(tracker.iterateEsmReferences(traceMap));
+  return refs.length ? refs[0].node : null;
+}
+function isImportedIdentifierInImportClause(node) {
+  return "imported" in node;
+}
+function getVueI18nIdentifier(scope, local) {
+  const { callExpression, returnStatement } = getCallExpressionAndReturnStatement(scope, local);
+  if (callExpression == null) {
+    return null;
+  }
+  const id = getVariableDeclarationIdFrom(callExpression);
+  if (id == null) {
+    return null;
+  }
+  const variableIdPairs = parseVariableId(id);
+  debug$1("variableIdPairs:", variableIdPairs);
+  const returnVariableIdPairs = parseReturnStatement(returnStatement);
+  debug$1("returnVariableIdPairs:", returnVariableIdPairs);
+  return resolveIdentifier(variableIdPairs, returnVariableIdPairs);
+}
+const EMPTY_NODE_RETURN = {
+  callExpression: null,
+  returnStatement: null
+};
+function getCallExpressionAndReturnStatement(scope, local) {
+  const variable = eslintUitls__default.findVariable(scope, local);
+  if (variable == null) {
+    return EMPTY_NODE_RETURN;
+  }
+  const callExpressionRef = variable.references.find((ref) => {
+    return ref.identifier.parent?.type === typescriptEstree.AST_NODE_TYPES.CallExpression;
+  });
+  if (callExpressionRef == null) {
+    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;
+      }
+    );
+  }
+  return {
+    callExpression: callExpressionRef.identifier.parent,
+    returnStatement
+  };
+}
+function getVariableDeclarationIdFrom(node) {
+  if (node.parent?.type !== typescriptEstree.AST_NODE_TYPES.VariableDeclarator) {
+    return null;
+  }
+  return node.parent.id;
+}
+function parseVariableId(node) {
+  if (node.type === typescriptEstree.AST_NODE_TYPES.Identifier) {
+    return [{ key: node.name, value: null }];
+  } else {
+    const props = node.properties.filter(
+      // ignore RestElement
+      (prop) => prop.type === typescriptEstree.AST_NODE_TYPES.Property
+    );
+    const pairs = [];
+    for (const prop of props) {
+      if (prop?.key.type === typescriptEstree.AST_NODE_TYPES.Identifier && prop?.value.type === typescriptEstree.AST_NODE_TYPES.Identifier) {
+        pairs.push({ key: prop.key.name, value: prop.value.name });
+      }
+    }
+    return pairs;
+  }
+}
+function parseReturnStatement(node) {
+  const pairs = [];
+  if (node == null || node.argument == null) {
+    return pairs;
+  }
+  if (node.argument.type === typescriptEstree.AST_NODE_TYPES.ObjectExpression) {
+    for (const prop of node.argument.properties) {
+      if (prop.type === typescriptEstree.AST_NODE_TYPES.Property) {
+        if (prop.key.type === typescriptEstree.AST_NODE_TYPES.Identifier && prop.value.type === typescriptEstree.AST_NODE_TYPES.Identifier) {
+          pairs.push({ key: prop.key.name, value: prop.value.name });
+        } else if (prop.key.type === typescriptEstree.AST_NODE_TYPES.Identifier && prop.value.type === typescriptEstree.AST_NODE_TYPES.MemberExpression && prop.value.object.type === typescriptEstree.AST_NODE_TYPES.Identifier && prop.value.property.type === typescriptEstree.AST_NODE_TYPES.Identifier) {
+          pairs.push({
+            key: prop.key.name,
+            value: `${prop.value.object.name}.${prop.value.property.name}`
+          });
+        }
+      }
+    }
+    return pairs;
+  } else if (node.argument.type === typescriptEstree.AST_NODE_TYPES.Identifier) {
+    return pairs;
+  } else {
+    return pairs;
+  }
+}
+function resolveIdentifier(localVariables, returnVariable) {
+  if (returnVariable.length === 0) {
+    const variable = localVariables.find((pair) => pair.key === "t");
+    if (variable && variable.value) {
+      return { type: "identifier", key: variable.value };
+    }
+    const identifierOnly = localVariables.find((pair) => pair.value === null);
+    if (identifierOnly && identifierOnly.key) {
+      return { type: "object", key: identifierOnly.key, style: "script-setup" };
+    }
+    return null;
+  } else {
+    const variable = localVariables.find((pair) => pair.key === "t");
+    if (variable && variable.value) {
+      const returnVar = returnVariable.find(
+        (pair) => pair.value === variable.value
+      );
+      if (returnVar && returnVar.key) {
+        return { type: "identifier", key: returnVar.key };
+      }
+    }
+    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)
+      );
+      if (returnVar && returnVar.key) {
+        return { type: "object", key: returnVar.key, style: "setup-hook" };
+      }
+    }
+    return null;
+  }
+}
+
+const debug = createDebug__default(resolveNamespace("root"));
+const installedPkgInfo = checkInstallPackage(debug);
+const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {
+  debug("meta framework", meta.framework);
+  if (!["vite", "webpack"].includes(meta.framework)) {
+    raiseError(`This plugin is supported 'vite' and 'webpack' only`);
+  }
+  debug("plugin options (resolving):", options);
+  const resolvedOptions = resolveOptions(options, installedPkgInfo);
+  debug("plugin options (resolved):", resolvedOptions);
+  const plugins = [resourcePlugin(resolvedOptions, meta, installedPkgInfo)];
+  if (resolvedOptions.optimizeTranslationDirective) {
+    if (meta.framework === "webpack") {
+      raiseError(
+        `The 'optimizeTranslationDirective' option still is not supported for webpack.
+We are waiting for your Pull Request \u{1F642}.`
+      );
+    }
+    plugins.push(directivePlugin(resolvedOptions));
+  }
+  return plugins;
+});
 
 exports.default = unplugin;
 exports.unplugin = unplugin;