CPL
/
banboshi_V2
1
0
Çatalla 0
Kod Konular 0 Değişiklik İstekleri 0 Sürümler 1 Wiki Aktivite
版博士V2.0程序
25'ten fazla konu seçemezsiniz Konular bir harf veya rakamla başlamalı, kısa çizgiler ('-') içerebilir ve en fazla 35 karakter uzunluğunda olabilir.
61 İşleme
5 Dallar
6.2 GiB
 
 
 
 
Dal: TongWei
Dallar Biçim İmleri
${ item.name }
${ searchTerm } dalı oluştur
'TongWei'den
${ noResults }
banboshi_V2/HalftoneWeb/node_modules/@intlify/unplugin-vue-i18n/lib/index.mjs

660 satır
22 KiB
Ham Kalıcı Bağlantı Suçlama Geçmiş 

  1. import { createUnplugin } from 'unplugin';

  2. import { normalize, parse } from 'pathe';

  3. import createDebug from 'debug';

  4. import fg from 'fast-glob';

  5. import { isString, isArray, isBoolean, isObject, isNumber, isEmptyObject, assign, generateCodeFrame } from '@intlify/shared';

  6. import { createFilter } from '@rollup/pluginutils';

  7. import { checkInstallPackage, checkVueI18nBridgeInstallPackage, getVueI18nVersion, generateJSON, generateYAML, generateJavaScript } from '@intlify/bundle-utils';

  8. import { parse as parse$1 } from '@vue/compiler-sfc';

  9. import JSON5 from 'json5';

  10. import yaml from 'js-yaml';

  11. import { promises } from 'fs';

  12. import pc from 'picocolors';

  13. 

  14. function parseVueRequest(id) {

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

  16.   const params = new URLSearchParams(rawQuery);

  17.   const ret = {};

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

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

  20.   );

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

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

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

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

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

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

  27.   }

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

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

  30.   }

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

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

  33.   }

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

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

  36.   }

  37.   if (langPart) {

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

  39.     ret.lang = lang;

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

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

  42.   }

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

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

  45.   }

  46.   return {

  47.     filename,

  48.     query: ret

  49.   };

  50. }

  51. 

  52. function createBridgeCodeGenerator(source, query) {

  53.   return () => {

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

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

  56.     if (isString(query.locale)) {

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

  58.     }

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

  60.   };

  61. }

  62. function convert(source, lang) {

  63.   switch (lang) {

  64.     case "yaml":

  65.     case "yml":

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

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

  68.     case "json5":

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

  70.     default:

  71.       return source;

  72.   }

  73. }

  74. 

  75. function warn(...args) {

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

  77. }

  78. function error(...args) {

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

  80. }

  81. async function getRaw(path) {

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

  83. }

  84. function raiseError(message) {

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

  86. }

  87. 

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

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

  90. const VIRTUAL_PREFIX = "\0";

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

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

  93. const installedVueI18nBridge = checkVueI18nBridgeInstallPackage(debug);

  94. const vueI18nVersion = getVueI18nVersion(debug);

  95. const unplugin = createUnplugin((options = {}, meta) => {

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

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

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

  99.   }

  100.   let include = options.include;

  101.   let exclude = null;

  102.   if (include) {

  103.     if (isArray(include)) {

  104.       include = include.map((item) => normalize(item));

  105.     } else if (isString(include)) {

  106.       include = normalize(include);

  107.     }

  108.   } else {

  109.     exclude = "**/**";

  110.   }

  111.   const filter = createFilter(include, exclude);

  112.   const forceStringify = !!options.forceStringify;

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

  114.   const globalSFCScope = !!options.globalSFCScope;

  115.   const useClassComponent = !!options.useClassComponent;

  116.   const bridge = !!options.bridge;

  117.   debug("bridge", bridge);

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

  119.   debug("runtimeOnly", runtimeOnly);

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

  121.   debug("compositionOnly", compositionOnly);

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

  123.   debug("fullInstall", fullInstall);

  124.   const useVueI18nImportName = options.useVueI18nImportName;

  125.   if (useVueI18nImportName != null) {

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

  127.   }

  128.   debug("useVueI18nImportName", useVueI18nImportName);

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

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

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

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

  133.   debug("esm", esm);

  134.   const allowDynamic = !!options.allowDynamic;

  135.   debug("allowDynamic", allowDynamic);

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

  137.   debug("strictMessage", strictMessage);

  138.   const escapeHtml = !!options.escapeHtml;

  139.   debug("escapeHtml", escapeHtml);

  140.   let isProduction = false;

  141.   let sourceMap = false;

  142.   const vueI18nAliasName = getVueI18nAliasName();

  143.   return {

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

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

  146.     vite: {

  147.       config(config, { command }) {

  148.         config.resolve = normalizeConfigResolveAlias(

  149.           config.resolve,

  150.           meta.framework

  151.         );

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

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

  154.           if (isArray(config.resolve.alias)) {

  155.             config.resolve.alias.push({

  156.               find: vueI18nAliasName,

  157.               replacement: getVueI18nAliasPath(vueI18nAliasName)

  158.             });

  159.             if (installedVueI18nBridge) {

  160.               config.resolve.alias.push({

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

  162.                 replacement: getVueI18nBridgeAliasPath()

  163.               });

  164.             }

  165.           } else if (isObject(config.resolve.alias)) {

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

  167.             if (installedVueI18nBridge) {

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

  169.             }

  170.           }

  171.           debug(

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

  173.               vueI18nAliasName

  174.             )}`

  175.           );

  176.           if (installedVueI18nBridge) {

  177.             debug(

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

  179.             );

  180.           }

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

  182.           config.resolve = normalizeConfigResolveAlias(

  183.             config.resolve,

  184.             meta.framework

  185.           );

  186.           if (isArray(config.resolve.alias)) {

  187.             config.resolve.alias.push({

  188.               find: vueI18nAliasName,

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

  190.             });

  191.           } else {

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

  193.           }

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

  195.         }

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

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

  198.         debug(

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

  200.         );

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

  202.         debug(

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

  204.         );

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

  206.       },

  207.       configResolved(config) {

  208.         isProduction = config.isProduction;

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

  210.         debug(

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

  212.         );

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

  214.         if (jsonPlugin) {

  215.           const orgTransform = jsonPlugin.transform;

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

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

  218.               return;

  219.             }

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

  221.             if (query.vue) {

  222.               return;

  223.             }

  224.             debug("org json plugin");

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

  226.           };

  227.         }

  228.         const esbuildPlugin = config.plugins.find(

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

  230.         );

  231.         if (esbuildPlugin) {

  232.           const orgTransform = esbuildPlugin.transform;

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

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

  235.               code,

  236.               id

  237.             ]);

  238.             if (result == null) {

  239.               return result;

  240.             }

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

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

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

  244.               let langInfo = defaultSFCLang;

  245.               langInfo = parse(filename).ext;

  246.               const generate = getGenerator(langInfo);

  247.               const parseOptions = getOptions(

  248.                 filename,

  249.                 isProduction,

  250.                 query,

  251.                 sourceMap,

  252.                 {

  253.                   inSourceMap,

  254.                   isGlobal: globalSFCScope,

  255.                   useClassComponent,

  256.                   allowDynamic,

  257.                   strictMessage,

  258.                   escapeHtml,

  259.                   bridge,

  260.                   exportESM: esm,

  261.                   forceStringify

  262.                 }

  263.               );

  264.               debug("parseOptions", parseOptions);

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

  266.                 _code,

  267.                 parseOptions,

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

  269.               );

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

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

  272.               if (_code === generatedCode)

  273.                 return;

  274.               return {

  275.                 code: generatedCode,

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

  277.               };

  278.             } else {

  279.               return result;

  280.             }

  281.           };

  282.         }

  283.       },

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

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

  286.           const module = server.moduleGraph.getModuleById(

  287.             asVirtualId(INTLIFY_BUNDLE_IMPORT_ID, meta.framework)

  288.           );

  289.           if (module) {

  290.             server.moduleGraph.invalidateModule(module);

  291.             return [module];

  292.           }

  293.         }

  294.       }

  295.     },

  296.     webpack(compiler) {

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

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

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

  300.       compiler.options.resolve = normalizeConfigResolveAlias(

  301.         compiler.options.resolve,

  302.         meta.framework

  303.       );

  304.       if (isProduction && runtimeOnly) {

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

  306.         if (installedVueI18nBridge) {

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

  308.         }

  309.         debug(

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

  311.             vueI18nAliasName

  312.           )}`

  313.         );

  314.         if (installedVueI18nBridge) {

  315.           debug(

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

  317.           );

  318.         }

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

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

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

  322.       }

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

  324.         if (webpack) {

  325.           compiler.options.plugins.push(

  326.             new webpack.DefinePlugin({

  327.               __VUE_I18N_LEGACY_API__: JSON.stringify(compositionOnly),

  328.               __VUE_I18N_FULL_INSTALL__: JSON.stringify(fullInstall),

  329.               __INTLIFY_PROD_DEVTOOLS__: "false"

  330.             })

  331.           );

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

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

  334.         } else {

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

  336.         }

  337.       });

  338.       if (compiler.options.module) {

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

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

  341.           type: "javascript/auto",

  342.           include(resource) {

  343.             return filter(resource);

  344.           }

  345.         });

  346.       }

  347.     },

  348.     resolveId(id, importer) {

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

  350.       if (id === INTLIFY_BUNDLE_IMPORT_DEPRECTED_ID) {

  351.         warn(

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

  353.         );

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

  355.       }

  356.       if (id === INTLIFY_BUNDLE_IMPORT_ID) {

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

  358.       }

  359.     },

  360.     async load(id) {

  361.       debug("load", id);

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

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

  364.         getVirtualId(id, meta.framework)

  365.       ) && include) {

  366.         let resourcePaths = [];

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

  368.         for (const inc of includePaths) {

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

  370.         }

  371.         resourcePaths = resourcePaths.filter(

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

  373.         );

  374.         const code = await generateBundleResources(

  375.           resourcePaths,

  376.           query,

  377.           isProduction,

  378.           {

  379.             forceStringify,

  380.             bridge,

  381.             strictMessage,

  382.             escapeHtml,

  383.             exportESM: esm,

  384.             useClassComponent

  385.           }

  386.         );

  387.         return {

  388.           code,

  389.           map: { mappings: "" }

  390.         };

  391.       }

  392.     },

  393.     transformInclude(id) {

  394.       debug("transformInclude", id);

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

  396.         return true;

  397.       } else {

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

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

  400.       }

  401.     },

  402.     async transform(code, id) {

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

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

  405.       let langInfo = defaultSFCLang;

  406.       let inSourceMap;

  407.       if (!query.vue) {

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

  409.           langInfo = parse(filename).ext;

  410.           const generate = getGenerator(langInfo);

  411.           const parseOptions = getOptions(

  412.             filename,

  413.             isProduction,

  414.             query,

  415.             sourceMap,

  416.             {

  417.               inSourceMap,

  418.               isGlobal: globalSFCScope,

  419.               useClassComponent,

  420.               allowDynamic,

  421.               strictMessage,

  422.               escapeHtml,

  423.               bridge,

  424.               exportESM: esm,

  425.               forceStringify

  426.             }

  427.           );

  428.           debug("parseOptions", parseOptions);

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

  430.             code,

  431.             parseOptions,

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

  433.           );

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

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

  436.           if (code === generatedCode)

  437.             return;

  438.           return {

  439.             code: generatedCode,

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

  441.           };

  442.         }

  443.       } else {

  444.         if (isCustomBlock(query)) {

  445.           if (isString(query.lang)) {

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

  447.           } else if (defaultSFCLang) {

  448.             langInfo = defaultSFCLang;

  449.           }

  450.           debug("langInfo", langInfo);

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

  452.           const parseOptions = getOptions(

  453.             filename,

  454.             isProduction,

  455.             query,

  456.             sourceMap,

  457.             {

  458.               inSourceMap,

  459.               isGlobal: globalSFCScope,

  460.               useClassComponent,

  461.               bridge,

  462.               strictMessage,

  463.               escapeHtml,

  464.               exportESM: esm,

  465.               forceStringify

  466.             }

  467.           );

  468.           debug("parseOptions", parseOptions);

  469.           const source = await getCode(

  470.             code,

  471.             filename,

  472.             sourceMap,

  473.             query,

  474.             meta.framework

  475.           );

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

  477.             source,

  478.             parseOptions,

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

  480.           );

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

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

  483.           if (code === generatedCode)

  484.             return;

  485.           return {

  486.             code: generatedCode,

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

  488.           };

  489.         }

  490.       }

  491.     }

  492.   };

  493. });

  494. function getGenerator(ext, defaultGen = generateJSON) {

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

  496. }

  497. function normalizeConfigResolveAlias(resolve, framework) {

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

  499.     return resolve;

  500.   }

  501.   if (!resolve) {

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

  503.       return { alias: [] };

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

  505.       return { alias: {} };

  506.     }

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

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

  509.       resolve.alias = [];

  510.       return resolve;

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

  512.       resolve.alias = {};

  513.       return resolve;

  514.     }

  515.   }

  516. }

  517. async function loadWebpack() {

  518.   let webpack = null;

  519.   try {

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

  521.   } catch (e) {

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

  523.   }

  524.   return webpack;

  525. }

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

  527.   forceStringify = false,

  528.   isGlobal = false,

  529.   bridge = false,

  530.   exportESM = true,

  531.   strictMessage = true,

  532.   escapeHtml = false,

  533.   useClassComponent = false

  534. }) {

  535.   const codes = [];

  536.   for (const res of resources) {

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

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

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

  540.       const source = await getRaw(res);

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

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

  543.         isGlobal,

  544.         useClassComponent,

  545.         bridge,

  546.         exportESM,

  547.         strictMessage,

  548.         escapeHtml,

  549.         forceStringify

  550.       });

  551.       parseOptions.type = "bare";

  552.       const { code } = generate(

  553.         source,

  554.         parseOptions,

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

  556.       );

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

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

  559.     }

  560.   }

  561.   return `export default {

  562.   ${codes.join(`,

  563. `)}

  564. }`;

  565. }

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

  567.   const { index, issuerPath } = query;

  568.   if (!isNumber(index)) {

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

  570.   }

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

  572.     if (issuerPath) {

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

  574.       return await getRaw(filename);

  575.     } else {

  576.       const result = parse$1(await getRaw(filename), {

  577.         sourceMap,

  578.         filename

  579.       });

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

  581.       if (block) {

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

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

  584.         return code;

  585.       } else {

  586.         return source;

  587.       }

  588.     }

  589.   } else {

  590.     return source;

  591.   }

  592. }

  593. function isCustomBlock(query) {

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

  595. }

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

  597.   inSourceMap = void 0,

  598.   forceStringify = false,

  599.   isGlobal = false,

  600.   bridge = false,

  601.   exportESM = true,

  602.   useClassComponent = false,

  603.   allowDynamic = false,

  604.   strictMessage = true,

  605.   escapeHtml = false

  606. }) {

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

  608.   const baseOptions = {

  609.     filename,

  610.     sourceMap,

  611.     inSourceMap,

  612.     forceStringify,

  613.     useClassComponent,

  614.     allowDynamic,

  615.     strictMessage,

  616.     escapeHtml,

  617.     bridge,

  618.     exportESM,

  619.     env: mode,

  620.     onWarn: (msg) => {

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

  622.     },

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

  624.       const codeFrame = generateCodeFrame(

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

  626.         extra?.location?.start.column,

  627.         extra?.location?.end.column

  628.       );

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

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

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

  632. 

  633.   ${codeFrame}

  634. `;

  635.       error(errMssage);

  636.       throw new Error(errMssage);

  637.     }

  638.   };

  639.   if (isCustomBlock(query)) {

  640.     return assign(baseOptions, {

  641.       type: "sfc",

  642.       locale: isString(query.locale) ? query.locale : "",

  643.       isGlobal: isGlobal || !!query.global

  644.     });

  645.   } else {

  646.     return assign(baseOptions, {

  647.       type: "plain",

  648.       isGlobal: false

  649.     });

  650.   }

  651. }

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

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

  654. }

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

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

  657. }

  658. 

  659. export { unplugin as default, unplugin };