CPL
/
banboshi_V2
1
0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Релизы 1 Вики Активность
版博士V2.0程序
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
61 коммит
5 Ветки
6.2 GiB
 
 
 
 
Дерево: d271ad1b21
Ветки Теги
${ item.name }
Создать ветку ${ searchTerm }
из 'd271ad1b21'
${ noResults }
banboshi_V2/HalftoneWeb/node_modules/@intlify/unplugin-vue-i18n/lib/index.cjs

665 строки
22 KiB
Исходник Вина История 

  1. 'use strict';

  2. 

  3. Object.defineProperty(exports, '__esModule', { value: true });

  4. 

  5. const unplugin$1 = require('unplugin');

  6. const pathe = require('pathe');

  7. const createDebug = require('debug');

  8. const fg = require('fast-glob');

  9. const shared = require('@intlify/shared');

  10. const pluginutils = require('@rollup/pluginutils');

  11. const bundleUtils = require('@intlify/bundle-utils');

  12. const compilerSfc = require('@vue/compiler-sfc');

  13. const JSON5 = require('json5');

  14. const yaml = require('js-yaml');

  15. const fs = require('fs');

  16. const pc = require('picocolors');

  17. 

  18. function parseVueRequest(id) {

  19.   const [filename, rawQuery] = id.split(`?`, 2);

  20.   const params = new URLSearchParams(rawQuery);

  21.   const ret = {};

  22.   const langPart = Object.keys(Object.fromEntries(params)).find(

  23.     (key) => /lang\./i.test(key)

  24.   );

  25.   ret.vue = params.has("vue");

  26.   ret.global = params.has("global");

  27.   ret.src = params.has("src");

  28.   ret.raw = params.has("raw");

  29.   if (params.has("type")) {

  30.     ret.type = params.get("type");

  31.   }

  32.   if (params.has("blockType")) {

  33.     ret.blockType = params.get("blockType");

  34.   }

  35.   if (params.has("index")) {

  36.     ret.index = Number(params.get("index"));

  37.   }

  38.   if (params.has("locale")) {

  39.     ret.locale = params.get("locale");

  40.   }

  41.   if (langPart) {

  42.     const [, lang] = langPart.split(".");

  43.     ret.lang = lang;

  44.   } else if (params.has("lang")) {

  45.     ret.lang = params.get("lang");

  46.   }

  47.   if (params.has("issuerPath")) {

  48.     ret.issuerPath = params.get("issuerPath");

  49.   }

  50.   return {

  51.     filename,

  52.     query: ret

  53.   };

  54. }

  55. 

  56. function createBridgeCodeGenerator(source, query) {

  57.   return () => {

  58.     const data = convert(source, query.lang);

  59.     let value = JSON.parse(data);

  60.     if (shared.isString(query.locale)) {

  61.       value = Object.assign({}, { [query.locale]: value });

  62.     }

  63.     return JSON.stringify(value).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029").replace(/\\/g, "\\\\").replace(/\u0027/g, "\\u0027");

  64.   };

  65. }

  66. function convert(source, lang) {

  67.   switch (lang) {

  68.     case "yaml":

  69.     case "yml":

  70.       const data = yaml.load(source);

  71.       return JSON.stringify(data, void 0, "	");

  72.     case "json5":

  73.       return JSON.stringify(JSON5.parse(source));

  74.     default:

  75.       return source;

  76.   }

  77. }

  78. 

  79. function warn(...args) {

  80.   console.warn(pc.yellow(pc.bold(`[unplugin-vue-i18n] `)), ...args);

  81. }

  82. function error(...args) {

  83.   console.error(pc.red(pc.bold(`[unplugin-vue-i18n] `)), ...args);

  84. }

  85. async function getRaw(path) {

  86.   return fs.promises.readFile(path, { encoding: "utf-8" });

  87. }

  88. function raiseError(message) {

  89.   throw new Error(`[unplugin-vue-i18n] ${message}`);

  90. }

  91. 

  92. const INTLIFY_BUNDLE_IMPORT_ID = "@intlify/unplugin-vue-i18n/messages";

  93. const INTLIFY_BUNDLE_IMPORT_DEPRECTED_ID = "@intlify/vite-plugin-vue-i18n/messages";

  94. const VIRTUAL_PREFIX = "\0";

  95. const debug = createDebug("unplugin-vue-i18n");

  96. const installedPkg = bundleUtils.checkInstallPackage("@intlify/unplugin-vue-i18n", debug);

  97. const installedVueI18nBridge = bundleUtils.checkVueI18nBridgeInstallPackage(debug);

  98. const vueI18nVersion = bundleUtils.getVueI18nVersion(debug);

  99. const unplugin = unplugin$1.createUnplugin((options = {}, meta) => {

  100.   debug("plugin options:", options, meta.framework);

  101.   if (!["vite", "webpack"].includes(meta.framework)) {

  102.     raiseError(`This plugin is supported 'vite' and 'webpack' only`);

  103.   }

  104.   let include = options.include;

  105.   let exclude = null;

  106.   if (include) {

  107.     if (shared.isArray(include)) {

  108.       include = include.map((item) => pathe.normalize(item));

  109.     } else if (shared.isString(include)) {

  110.       include = pathe.normalize(include);

  111.     }

  112.   } else {

  113.     exclude = "**/**";

  114.   }

  115.   const filter = pluginutils.createFilter(include, exclude);

  116.   const forceStringify = !!options.forceStringify;

  117.   const defaultSFCLang = shared.isString(options.defaultSFCLang) ? options.defaultSFCLang : "json";

  118.   const globalSFCScope = !!options.globalSFCScope;

  119.   const useClassComponent = !!options.useClassComponent;

  120.   const bridge = !!options.bridge;

  121.   debug("bridge", bridge);

  122.   const runtimeOnly = shared.isBoolean(options.runtimeOnly) ? options.runtimeOnly : true;

  123.   debug("runtimeOnly", runtimeOnly);

  124.   const compositionOnly = installedPkg === "vue-i18n" ? shared.isBoolean(options.compositionOnly) ? options.compositionOnly : true : true;

  125.   debug("compositionOnly", compositionOnly);

  126.   const fullInstall = installedPkg === "vue-i18n" ? shared.isBoolean(options.fullInstall) ? options.fullInstall : true : false;

  127.   debug("fullInstall", fullInstall);

  128.   const useVueI18nImportName = options.useVueI18nImportName;

  129.   if (useVueI18nImportName != null) {

  130.     warn(`'useVueI18nImportName' option is experimental`);

  131.   }

  132.   debug("useVueI18nImportName", useVueI18nImportName);

  133.   const getVueI18nAliasName = () => vueI18nVersion === "9" || vueI18nVersion === "8" ? "vue-i18n" : vueI18nVersion === "unknown" && installedPkg === "petite-vue-i18n" && shared.isBoolean(useVueI18nImportName) && useVueI18nImportName ? "vue-i18n" : installedPkg;

  134.   const getVueI18nBridgeAliasPath = () => `vue-i18n-bridge/dist/vue-i18n-bridge.runtime.esm-bundler.js`;

  135.   const getVueI18nAliasPath = (aliasName) => vueI18nVersion === "8" ? `${aliasName}/dist/${aliasName}.esm.js` : `${aliasName}/dist/${installedPkg}.runtime.esm-bundler.js`;

  136.   const esm = shared.isBoolean(options.esm) ? options.esm : true;

  137.   debug("esm", esm);

  138.   const allowDynamic = !!options.allowDynamic;

  139.   debug("allowDynamic", allowDynamic);

  140.   const strictMessage = shared.isBoolean(options.strictMessage) ? options.strictMessage : true;

  141.   debug("strictMessage", strictMessage);

  142.   const escapeHtml = !!options.escapeHtml;

  143.   debug("escapeHtml", escapeHtml);

  144.   let isProduction = false;

  145.   let sourceMap = false;

  146.   const vueI18nAliasName = getVueI18nAliasName();

  147.   return {

  148.     name: "unplugin-vue-i18n",

  149.     enforce: meta.framework === "vite" ? "pre" : "post",

  150.     vite: {

  151.       config(config, { command }) {

  152.         config.resolve = normalizeConfigResolveAlias(

  153.           config.resolve,

  154.           meta.framework

  155.         );

  156.         if (command === "build" && runtimeOnly) {

  157.           debug(`vue-i18n alias name: ${vueI18nAliasName}`);

  158.           if (shared.isArray(config.resolve.alias)) {

  159.             config.resolve.alias.push({

  160.               find: vueI18nAliasName,

  161.               replacement: getVueI18nAliasPath(vueI18nAliasName)

  162.             });

  163.             if (installedVueI18nBridge) {

  164.               config.resolve.alias.push({

  165.                 find: "vue-i18n-bridge",

  166.                 replacement: getVueI18nBridgeAliasPath()

  167.               });

  168.             }

  169.           } else if (shared.isObject(config.resolve.alias)) {

  170.             config.resolve.alias[vueI18nAliasName] = getVueI18nAliasPath(vueI18nAliasName);

  171.             if (installedVueI18nBridge) {

  172.               config.resolve.alias["vue-i18n-bridge"] = getVueI18nBridgeAliasPath();

  173.             }

  174.           }

  175.           debug(

  176.             `set ${vueI18nAliasName} runtime only: ${getVueI18nAliasPath(

  177.               vueI18nAliasName

  178.             )}`

  179.           );

  180.           if (installedVueI18nBridge) {

  181.             debug(

  182.               `set vue-i18n-bridge runtime only: ${getVueI18nBridgeAliasPath()}`

  183.             );

  184.           }

  185.         } else if (command === "serve" && installedPkg === "petite-vue-i18n" && useVueI18nImportName) {

  186.           config.resolve = normalizeConfigResolveAlias(

  187.             config.resolve,

  188.             meta.framework

  189.           );

  190.           if (shared.isArray(config.resolve.alias)) {

  191.             config.resolve.alias.push({

  192.               find: vueI18nAliasName,

  193.               replacement: `petite-vue-i18n/dist/petite-vue-i18n.esm-bundler.js`

  194.             });

  195.           } else {

  196.             config.resolve.alias[vueI18nAliasName] = `petite-vue-i18n/dist/petite-vue-i18n.esm-bundler.js`;

  197.           }

  198.           debug(`petite-vue-i18n alias name: ${vueI18nAliasName}`);

  199.         }

  200.         config.define = config.define || {};

  201.         config.define["__VUE_I18N_LEGACY_API__"] = !compositionOnly;

  202.         debug(

  203.           `set __VUE_I18N_LEGACY_API__ is '${config.define["__VUE_I18N_LEGACY_API__"]}'`

  204.         );

  205.         config.define["__VUE_I18N_FULL_INSTALL__"] = fullInstall;

  206.         debug(

  207.           `set __VUE_I18N_FULL_INSTALL__ is '${config.define["__VUE_I18N_FULL_INSTALL__"]}'`

  208.         );

  209.         config.define["__VUE_I18N_PROD_DEVTOOLS__"] = false;

  210.       },

  211.       configResolved(config) {

  212.         isProduction = config.isProduction;

  213.         sourceMap = config.command === "build" ? !!config.build.sourcemap : false;

  214.         debug(

  215.           `configResolved: isProduction = ${isProduction}, sourceMap = ${sourceMap}`

  216.         );

  217.         const jsonPlugin = config.plugins.find((p) => p.name === "vite:json");

  218.         if (jsonPlugin) {

  219.           const orgTransform = jsonPlugin.transform;

  220.           jsonPlugin.transform = async function(code, id) {

  221.             if (!/\.json$/.test(id) || filter(id)) {

  222.               return;

  223.             }

  224.             const { query } = parseVueRequest(id);

  225.             if (query.vue) {

  226.               return;

  227.             }

  228.             debug("org json plugin");

  229.             return orgTransform.apply(this, [code, id]);

  230.           };

  231.         }

  232.         const esbuildPlugin = config.plugins.find(

  233.           (p) => p.name === "vite:esbuild"

  234.         );

  235.         if (esbuildPlugin) {

  236.           const orgTransform = esbuildPlugin.transform;

  237.           esbuildPlugin.transform = async function(code, id) {

  238.             const result = await orgTransform.apply(this, [

  239.               code,

  240.               id

  241.             ]);

  242.             if (result == null) {

  243.               return result;

  244.             }

  245.             const { filename, query } = parseVueRequest(id);

  246.             if (!query.vue && filter(id) && /\.[c|m]?ts$/.test(id)) {

  247.               const [_code, inSourceMap] = shared.isString(result) ? [result, void 0] : [result.code, result.map];

  248.               let langInfo = defaultSFCLang;

  249.               langInfo = pathe.parse(filename).ext;

  250.               const generate = getGenerator(langInfo);

  251.               const parseOptions = getOptions(

  252.                 filename,

  253.                 isProduction,

  254.                 query,

  255.                 sourceMap,

  256.                 {

  257.                   inSourceMap,

  258.                   isGlobal: globalSFCScope,

  259.                   useClassComponent,

  260.                   allowDynamic,

  261.                   strictMessage,

  262.                   escapeHtml,

  263.                   bridge,

  264.                   exportESM: esm,

  265.                   forceStringify

  266.                 }

  267.               );

  268.               debug("parseOptions", parseOptions);

  269.               const { code: generatedCode, map } = generate(

  270.                 _code,

  271.                 parseOptions,

  272.                 bridge ? createBridgeCodeGenerator(_code, query) : void 0

  273.               );

  274.               debug("generated code", generatedCode);

  275.               debug("sourcemap", map, sourceMap);

  276.               if (_code === generatedCode)

  277.                 return;

  278.               return {

  279.                 code: generatedCode,

  280.                 map: sourceMap ? map : { mappings: "" }

  281.               };

  282.             } else {

  283.               return result;

  284.             }

  285.           };

  286.         }

  287.       },

  288.       async handleHotUpdate({ file, server }) {

  289.         if (/\.(json5?|ya?ml)$/.test(file)) {

  290.           const module = server.moduleGraph.getModuleById(

  291.             asVirtualId(INTLIFY_BUNDLE_IMPORT_ID, meta.framework)

  292.           );

  293.           if (module) {

  294.             server.moduleGraph.invalidateModule(module);

  295.             return [module];

  296.           }

  297.         }

  298.       }

  299.     },

  300.     webpack(compiler) {

  301.       isProduction = compiler.options.mode !== "development";

  302.       sourceMap = !!compiler.options.devtool;

  303.       debug(`webpack: isProduction = ${isProduction}, sourceMap = ${sourceMap}`);

  304.       compiler.options.resolve = normalizeConfigResolveAlias(

  305.         compiler.options.resolve,

  306.         meta.framework

  307.       );

  308.       if (isProduction && runtimeOnly) {

  309.         compiler.options.resolve.alias[vueI18nAliasName] = getVueI18nAliasPath(vueI18nAliasName);

  310.         if (installedVueI18nBridge) {

  311.           compiler.options.resolve.alias["vue-i18n-bridge"] = getVueI18nBridgeAliasPath();

  312.         }

  313.         debug(

  314.           `set ${vueI18nAliasName} runtime only: ${getVueI18nAliasPath(

  315.             vueI18nAliasName

  316.           )}`

  317.         );

  318.         if (installedVueI18nBridge) {

  319.           debug(

  320.             `set vue-i18n-bridge runtime only: ${getVueI18nBridgeAliasPath()}`

  321.           );

  322.         }

  323.       } else if (!isProduction && installedPkg === "petite-vue-i18n" && useVueI18nImportName) {

  324.         compiler.options.resolve.alias[vueI18nAliasName] = `petite-vue-i18n/dist/petite-vue-i18n.esm-bundler.js`;

  325.         debug(`petite-vue-i18n alias name: ${vueI18nAliasName}`);

  326.       }

  327.       loadWebpack().then((webpack) => {

  328.         if (webpack) {

  329.           compiler.options.plugins.push(

  330.             new webpack.DefinePlugin({

  331.               __VUE_I18N_LEGACY_API__: JSON.stringify(compositionOnly),

  332.               __VUE_I18N_FULL_INSTALL__: JSON.stringify(fullInstall),

  333.               __INTLIFY_PROD_DEVTOOLS__: "false"

  334.             })

  335.           );

  336.           debug(`set __VUE_I18N_LEGACY_API__ is '${compositionOnly}'`);

  337.           debug(`set __VUE_I18N_FULL_INSTALL__ is '${fullInstall}'`);

  338.         } else {

  339.           debug("ignore vue-i18n feature flags with webpack.DefinePlugin");

  340.         }

  341.       });

  342.       if (compiler.options.module) {

  343.         compiler.options.module.rules.push({

  344.           test: /\.(json5?|ya?ml)$/,

  345.           type: "javascript/auto",

  346.           include(resource) {

  347.             return filter(resource);

  348.           }

  349.         });

  350.       }

  351.     },

  352.     resolveId(id, importer) {

  353.       debug("resolveId", id, importer);

  354.       if (id === INTLIFY_BUNDLE_IMPORT_DEPRECTED_ID) {

  355.         warn(

  356.           `deprected '${INTLIFY_BUNDLE_IMPORT_DEPRECTED_ID}', you should switch to '${INTLIFY_BUNDLE_IMPORT_ID}'`

  357.         );

  358.         return asVirtualId(id, meta.framework);

  359.       }

  360.       if (id === INTLIFY_BUNDLE_IMPORT_ID) {

  361.         return asVirtualId(id, meta.framework);

  362.       }

  363.     },

  364.     async load(id) {

  365.       debug("load", id);

  366.       const { query } = parseVueRequest(id);

  367.       if ([INTLIFY_BUNDLE_IMPORT_DEPRECTED_ID, INTLIFY_BUNDLE_IMPORT_ID].includes(

  368.         getVirtualId(id, meta.framework)

  369.       ) && include) {

  370.         let resourcePaths = [];

  371.         const includePaths = shared.isArray(include) ? include : [include];

  372.         for (const inc of includePaths) {

  373.           resourcePaths = [...resourcePaths, ...await fg(inc)];

  374.         }

  375.         resourcePaths = resourcePaths.filter(

  376.           (el, pos) => resourcePaths.indexOf(el) === pos

  377.         );

  378.         const code = await generateBundleResources(

  379.           resourcePaths,

  380.           query,

  381.           isProduction,

  382.           {

  383.             forceStringify,

  384.             bridge,

  385.             strictMessage,

  386.             escapeHtml,

  387.             exportESM: esm,

  388.             useClassComponent

  389.           }

  390.         );

  391.         return {

  392.           code,

  393.           map: { mappings: "" }

  394.         };

  395.       }

  396.     },

  397.     transformInclude(id) {

  398.       debug("transformInclude", id);

  399.       if (meta.framework === "vite") {

  400.         return true;

  401.       } else {

  402.         const { filename } = parseVueRequest(id);

  403.         return filename.endsWith("vue") || filename.endsWith(INTLIFY_BUNDLE_IMPORT_ID) || filename.endsWith(INTLIFY_BUNDLE_IMPORT_DEPRECTED_ID) || /\.(json5?|ya?ml)$/.test(filename) && filter(filename);

  404.       }

  405.     },

  406.     async transform(code, id) {

  407.       const { filename, query } = parseVueRequest(id);

  408.       debug("transform", id, JSON.stringify(query), filename);

  409.       let langInfo = defaultSFCLang;

  410.       let inSourceMap;

  411.       if (!query.vue) {

  412.         if (/\.(json5?|ya?ml|[c|m]?js)$/.test(id) && filter(id)) {

  413.           langInfo = pathe.parse(filename).ext;

  414.           const generate = getGenerator(langInfo);

  415.           const parseOptions = getOptions(

  416.             filename,

  417.             isProduction,

  418.             query,

  419.             sourceMap,

  420.             {

  421.               inSourceMap,

  422.               isGlobal: globalSFCScope,

  423.               useClassComponent,

  424.               allowDynamic,

  425.               strictMessage,

  426.               escapeHtml,

  427.               bridge,

  428.               exportESM: esm,

  429.               forceStringify

  430.             }

  431.           );

  432.           debug("parseOptions", parseOptions);

  433.           const { code: generatedCode, map } = generate(

  434.             code,

  435.             parseOptions,

  436.             bridge ? createBridgeCodeGenerator(code, query) : void 0

  437.           );

  438.           debug("generated code", generatedCode);

  439.           debug("sourcemap", map, sourceMap);

  440.           if (code === generatedCode)

  441.             return;

  442.           return {

  443.             code: generatedCode,

  444.             map: sourceMap ? map : { mappings: "" }

  445.           };

  446.         }

  447.       } else {

  448.         if (isCustomBlock(query)) {

  449.           if (shared.isString(query.lang)) {

  450.             langInfo = query.src ? query.lang === "i18n" ? "json" : query.lang : query.lang;

  451.           } else if (defaultSFCLang) {

  452.             langInfo = defaultSFCLang;

  453.           }

  454.           debug("langInfo", langInfo);

  455.           const generate = /\.?json5?/.test(langInfo) ? bundleUtils.generateJSON : bundleUtils.generateYAML;

  456.           const parseOptions = getOptions(

  457.             filename,

  458.             isProduction,

  459.             query,

  460.             sourceMap,

  461.             {

  462.               inSourceMap,

  463.               isGlobal: globalSFCScope,

  464.               useClassComponent,

  465.               bridge,

  466.               strictMessage,

  467.               escapeHtml,

  468.               exportESM: esm,

  469.               forceStringify

  470.             }

  471.           );

  472.           debug("parseOptions", parseOptions);

  473.           const source = await getCode(

  474.             code,

  475.             filename,

  476.             sourceMap,

  477.             query,

  478.             meta.framework

  479.           );

  480.           const { code: generatedCode, map } = generate(

  481.             source,

  482.             parseOptions,

  483.             bridge ? createBridgeCodeGenerator(source, query) : void 0

  484.           );

  485.           debug("generated code", generatedCode);

  486.           debug("sourcemap", map, sourceMap);

  487.           if (code === generatedCode)

  488.             return;

  489.           return {

  490.             code: generatedCode,

  491.             map: sourceMap ? map : { mappings: "" }

  492.           };

  493.         }

  494.       }

  495.     }

  496.   };

  497. });

  498. function getGenerator(ext, defaultGen = bundleUtils.generateJSON) {

  499.   return /\.?json5?$/.test(ext) ? bundleUtils.generateJSON : /\.ya?ml$/.test(ext) ? bundleUtils.generateYAML : /\.([c|m]?js|[c|m]?ts)$/.test(ext) ? bundleUtils.generateJavaScript : defaultGen;

  500. }

  501. function normalizeConfigResolveAlias(resolve, framework) {

  502.   if (resolve && resolve.alias) {

  503.     return resolve;

  504.   }

  505.   if (!resolve) {

  506.     if (framework === "vite") {

  507.       return { alias: [] };

  508.     } else if (framework === "webpack") {

  509.       return { alias: {} };

  510.     }

  511.   } else if (!resolve.alias) {

  512.     if (framework === "vite") {

  513.       resolve.alias = [];

  514.       return resolve;

  515.     } else if (framework === "webpack") {

  516.       resolve.alias = {};

  517.       return resolve;

  518.     }

  519.   }

  520. }

  521. async function loadWebpack() {

  522.   let webpack = null;

  523.   try {

  524.     webpack = await import('webpack').then((m) => m.default || m);

  525.   } catch (e) {

  526.     warn(`webpack not found, please install webpack.`);

  527.   }

  528.   return webpack;

  529. }

  530. async function generateBundleResources(resources, query, isProduction, {

  531.   forceStringify = false,

  532.   isGlobal = false,

  533.   bridge = false,

  534.   exportESM = true,

  535.   strictMessage = true,

  536.   escapeHtml = false,

  537.   useClassComponent = false

  538. }) {

  539.   const codes = [];

  540.   for (const res of resources) {

  541.     debug(`${res} bundle loading ...`);

  542.     if (/\.(json5?|ya?ml)$/.test(res)) {

  543.       const { ext, name } = pathe.parse(res);

  544.       const source = await getRaw(res);

  545.       const generate = /json5?/.test(ext) ? bundleUtils.generateJSON : bundleUtils.generateYAML;

  546.       const parseOptions = getOptions(res, isProduction, {}, false, {

  547.         isGlobal,

  548.         useClassComponent,

  549.         bridge,

  550.         exportESM,

  551.         strictMessage,

  552.         escapeHtml,

  553.         forceStringify

  554.       });

  555.       parseOptions.type = "bare";

  556.       const { code } = generate(

  557.         source,

  558.         parseOptions,

  559.         bridge ? createBridgeCodeGenerator(source, query) : void 0

  560.       );

  561.       debug("generated code", code);

  562.       codes.push(`${JSON.stringify(name)}: ${code}`);

  563.     }

  564.   }

  565.   return `export default {

  566.   ${codes.join(`,

  567. `)}

  568. }`;

  569. }

  570. async function getCode(source, filename, sourceMap, query, framework = "vite") {

  571.   const { index, issuerPath } = query;

  572.   if (!shared.isNumber(index)) {

  573.     raiseError(`unexpected index: ${index}`);

  574.   }

  575.   if (framework === "webpack") {

  576.     if (issuerPath) {

  577.       debug(`getCode (webpack) ${index} via issuerPath`, issuerPath);

  578.       return await getRaw(filename);

  579.     } else {

  580.       const result = compilerSfc.parse(await getRaw(filename), {

  581.         sourceMap,

  582.         filename

  583.       });

  584.       const block = result.descriptor.customBlocks[index];

  585.       if (block) {

  586.         const code = block.src ? await getRaw(block.src) : block.content;

  587.         debug(`getCode (webpack) ${index} from SFC`, code);

  588.         return code;

  589.       } else {

  590.         return source;

  591.       }

  592.     }

  593.   } else {

  594.     return source;

  595.   }

  596. }

  597. function isCustomBlock(query) {

  598.   return !shared.isEmptyObject(query) && "vue" in query && (query["type"] === "custom" || query["type"] === "i18n" || query["blockType"] === "i18n");

  599. }

  600. function getOptions(filename, isProduction, query, sourceMap, {

  601.   inSourceMap = void 0,

  602.   forceStringify = false,

  603.   isGlobal = false,

  604.   bridge = false,

  605.   exportESM = true,

  606.   useClassComponent = false,

  607.   allowDynamic = false,

  608.   strictMessage = true,

  609.   escapeHtml = false

  610. }) {

  611.   const mode = isProduction ? "production" : "development";

  612.   const baseOptions = {

  613.     filename,

  614.     sourceMap,

  615.     inSourceMap,

  616.     forceStringify,

  617.     useClassComponent,

  618.     allowDynamic,

  619.     strictMessage,

  620.     escapeHtml,

  621.     bridge,

  622.     exportESM,

  623.     env: mode,

  624.     onWarn: (msg) => {

  625.       warn(`${filename} ${msg}`);

  626.     },

  627.     onError: (msg, extra) => {

  628.       const codeFrame = shared.generateCodeFrame(

  629.         extra?.source || extra?.location?.source || "",

  630.         extra?.location?.start.column,

  631.         extra?.location?.end.column

  632.       );

  633.       const errMssage = `${msg} (error code: ${extra?.code}) in ${filename}

  634.   target message: ${extra?.source}

  635.   target message path: ${extra?.path}

  636. 

  637.   ${codeFrame}

  638. `;

  639.       error(errMssage);

  640.       throw new Error(errMssage);

  641.     }

  642.   };

  643.   if (isCustomBlock(query)) {

  644.     return shared.assign(baseOptions, {

  645.       type: "sfc",

  646.       locale: shared.isString(query.locale) ? query.locale : "",

  647.       isGlobal: isGlobal || !!query.global

  648.     });

  649.   } else {

  650.     return shared.assign(baseOptions, {

  651.       type: "plain",

  652.       isGlobal: false

  653.     });

  654.   }

  655. }

  656. function getVirtualId(id, framework = "vite") {

  657.   return framework === "vite" ? id.startsWith(VIRTUAL_PREFIX) ? id.slice(VIRTUAL_PREFIX.length) : "" : id;

  658. }

  659. function asVirtualId(id, framework = "vite") {

  660.   return framework === "vite" ? VIRTUAL_PREFIX + id : id;

  661. }

  662. 

  663. exports.default = unplugin;

  664. exports.unplugin = unplugin;