@dcloudio/uni-cli-shared 3.0.0-alpha-3021320211118002 → 3.0.0-alpha-3021320211122001

package/dist/vite/plugins/vitejs/plugins/h5Css.js

@@ -0,0 +1,922 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cssUrlRE = exports.cssPostPlugin = exports.cssPlugin = exports.removedPureCssFilesCache = exports.chunkToEmittedCssFileMap = exports.isDirectRequest = exports.isDirectCSSRequest = exports.isCSSRequest = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const utils_1 = require("../utils");
+const postcss_load_config_1 = __importDefault(require("postcss-load-config"));
+const pluginutils_1 = require("@rollup/pluginutils");
+const chalk_1 = __importDefault(require("chalk"));
+const constants_1 = require("../constants");
+const h5Asset_1 = require("./h5Asset");
+const magic_string_1 = __importDefault(require("magic-string"));
+const esbuild_1 = require("esbuild");
+const css_1 = require("./css");
+const cssLangs = `\\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\\?)`;
+const cssLangRE = new RegExp(cssLangs);
+const cssModuleRE = new RegExp(`\\.module${cssLangs}`);
+const directRequestRE = /(\?|&)direct\b/;
+const commonjsProxyRE = /\?commonjs-proxy/;
+const inlineRE = /(\?|&)inline\b/;
+const usedRE = /(\?|&)used\b/;
+const isCSSRequest = (request) => cssLangRE.test(request);
+exports.isCSSRequest = isCSSRequest;
+const isDirectCSSRequest = (request) => cssLangRE.test(request) && directRequestRE.test(request);
+exports.isDirectCSSRequest = isDirectCSSRequest;
+const isDirectRequest = (request) => directRequestRE.test(request);
+exports.isDirectRequest = isDirectRequest;
+const cssModulesCache = new WeakMap();
+exports.chunkToEmittedCssFileMap = new WeakMap();
+exports.removedPureCssFilesCache = new WeakMap();
+const postcssConfigCache = new WeakMap();
+/**
+ * Plugin applied before user plugins
+ */
+function cssPlugin(config) {
+    let server;
+    let moduleCache;
+    const resolveUrl = config.createResolver({
+        preferRelative: true,
+        tryIndex: false,
+        extensions: [],
+    });
+    const atImportResolvers = createCSSResolvers(config);
+    return {
+        name: 'vite:css',
+        configureServer(_server) {
+            server = _server;
+        },
+        buildStart() {
+            // Ensure a new cache for every build (i.e. rebuilding in watch mode)
+            moduleCache = new Map();
+            cssModulesCache.set(config, moduleCache);
+            exports.removedPureCssFilesCache.set(config, new Map());
+        },
+        async transform(raw, id) {
+            var _a, _b;
+            if (!(0, exports.isCSSRequest)(id) || commonjsProxyRE.test(id)) {
+                return;
+            }
+            const urlReplacer = async (url, importer) => {
+                if ((0, h5Asset_1.checkPublicFile)(url, config)) {
+                    return config.base + url.slice(1);
+                }
+                const resolved = await resolveUrl(url, importer);
+                if (resolved) {
+                    return (0, h5Asset_1.fileToUrl)(resolved, config, this);
+                }
+                return url;
+            };
+            const { code: css, modules, deps, } = await compileCSS(id, raw, config, urlReplacer, atImportResolvers, server);
+            if (modules) {
+                moduleCache.set(id, modules);
+            }
+            // track deps for build watch mode
+            if (config.command === 'build' && config.build.watch && deps) {
+                for (const file of deps) {
+                    this.addWatchFile(file);
+                }
+            }
+            // dev
+            if (server) {
+                // server only logic for handling CSS @import dependency hmr
+                const { moduleGraph } = server;
+                const thisModule = moduleGraph.getModuleById(id);
+                if (thisModule) {
+                    // CSS modules cannot self-accept since it exports values
+                    const isSelfAccepting = !modules && !inlineRE.test(id);
+                    if (deps) {
+                        // record deps in the module graph so edits to @import css can trigger
+                        // main import to hot update
+                        const depModules = new Set();
+                        for (const file of deps) {
+                            depModules.add((0, exports.isCSSRequest)(file)
+                                ? moduleGraph.createFileOnlyEntry(file)
+                                : await moduleGraph.ensureEntryFromUrl((await (0, h5Asset_1.fileToUrl)(file, config, this)).replace(((_b = (_a = config.server) === null || _a === void 0 ? void 0 : _a.origin) !== null && _b !== void 0 ? _b : '') + config.base, '/')));
+                        }
+                        moduleGraph.updateModuleInfo(thisModule, depModules, 
+                        // The root CSS proxy module is self-accepting and should not
+                        // have an explicit accept list
+                        new Set(), isSelfAccepting);
+                        for (const file of deps) {
+                            this.addWatchFile(file);
+                        }
+                    }
+                    else {
+                        thisModule.isSelfAccepting = isSelfAccepting;
+                    }
+                }
+            }
+            return {
+                code: css,
+                // TODO CSS source map
+                map: { mappings: '' },
+            };
+        },
+    };
+}
+exports.cssPlugin = cssPlugin;
+/**
+ * Plugin applied after user plugins
+ */
+function cssPostPlugin(config) {
+    // styles initialization in buildStart causes a styling loss in watch
+    const styles = new Map();
+    let pureCssChunks;
+    // when there are multiple rollup outputs and extracting CSS, only emit once,
+    // since output formats have no effect on the generated CSS.
+    let outputToExtractedCSSMap;
+    let hasEmitted = false;
+    return {
+        name: 'vite:css-post',
+        buildStart() {
+            // Ensure new caches for every build (i.e. rebuilding in watch mode)
+            pureCssChunks = new Set();
+            outputToExtractedCSSMap = new Map();
+            hasEmitted = false;
+        },
+        async transform(css, id, options) {
+            if (!(0, exports.isCSSRequest)(id) || commonjsProxyRE.test(id)) {
+                return;
+            }
+            const ssr = typeof options === 'boolean'
+                ? options
+                : (options && options.ssr) === true;
+            const inlined = inlineRE.test(id);
+            const modules = cssModulesCache.get(config).get(id);
+            const modulesCode = modules && (0, pluginutils_1.dataToEsm)(modules, { namedExports: true, preferConst: true });
+            if (config.command === 'serve') {
+                if ((0, exports.isDirectCSSRequest)(id)) {
+                    return css;
+                }
+                else {
+                    // server only
+                    if (ssr) {
+                        return modulesCode || `export default ${JSON.stringify(css)}`;
+                    }
+                    if (inlined) {
+                        return `export default ${JSON.stringify(css)}`;
+                    }
+                    return [
+                        `import { updateStyle, removeStyle } from ${JSON.stringify(path_1.default.posix.join(config.base, constants_1.CLIENT_PUBLIC_PATH))}`,
+                        `const id = ${JSON.stringify(id)}`,
+                        `const css = ${JSON.stringify(css)}`,
+                        `updateStyle(id, css)`,
+                        // css modules exports change on edit so it can't self accept
+                        `${modulesCode || `import.meta.hot.accept()\nexport default css`}`,
+                        `import.meta.hot.prune(() => removeStyle(id))`,
+                    ].join('\n');
+                }
+            }
+            // build CSS handling ----------------------------------------------------
+            // record css
+            if (!inlined) {
+                styles.set(id, css);
+            }
+            return {
+                code: modulesCode ||
+                    (usedRE.test(id)
+                        ? `export default ${JSON.stringify(inlined ? await minifyCSS(css, config) : css)}`
+                        : `export default ''`),
+                map: { mappings: '' },
+                // avoid the css module from being tree-shaken so that we can retrieve
+                // it in renderChunk()
+                moduleSideEffects: inlined ? false : 'no-treeshake',
+            };
+        },
+        async renderChunk(code, chunk, opts) {
+            let chunkCSS = '';
+            let isPureCssChunk = true;
+            const ids = Object.keys(chunk.modules);
+            for (const id of ids) {
+                if (!(0, exports.isCSSRequest)(id) ||
+                    cssModuleRE.test(id) ||
+                    commonjsProxyRE.test(id)) {
+                    isPureCssChunk = false;
+                }
+                if (styles.has(id)) {
+                    chunkCSS += styles.get(id);
+                }
+            }
+            if (!chunkCSS) {
+                return null;
+            }
+            // resolve asset URL placeholders to their built file URLs and perform
+            // minification if necessary
+            const processChunkCSS = async (css, { inlined, minify, }) => {
+                // replace asset url references with resolved url.
+                const isRelativeBase = config.base === '' || config.base.startsWith('.');
+                css = css.replace(h5Asset_1.assetUrlRE, (_, fileHash, postfix = '') => {
+                    const filename = (0, h5Asset_1.getAssetFilename)(fileHash, config) + postfix;
+                    (0, h5Asset_1.registerAssetToChunk)(chunk, filename);
+                    if (!isRelativeBase || inlined) {
+                        // absolute base or relative base but inlined (injected as style tag into
+                        // index.html) use the base as-is
+                        return config.base + filename;
+                    }
+                    else {
+                        // relative base + extracted CSS - asset file will be in the same dir
+                        return `./${path_1.default.posix.basename(filename)}`;
+                    }
+                });
+                // only external @imports should exist at this point - and they need to
+                // be hoisted to the top of the CSS chunk per spec (#1845)
+                if (css.includes('@import')) {
+                    css = await hoistAtImports(css);
+                }
+                if (minify && config.build.minify) {
+                    css = await minifyCSS(css, config);
+                }
+                return css;
+            };
+            if (config.build.cssCodeSplit) {
+                if (isPureCssChunk) {
+                    // this is a shared CSS-only chunk that is empty.
+                    pureCssChunks.add(chunk.fileName);
+                }
+                if (opts.format === 'es' || opts.format === 'cjs') {
+                    chunkCSS = await processChunkCSS(chunkCSS, {
+                        inlined: false,
+                        minify: true,
+                    });
+                    // emit corresponding css file
+                    const fileHandle = this.emitFile({
+                        name: chunk.name + '.css',
+                        type: 'asset',
+                        source: chunkCSS,
+                    });
+                    exports.chunkToEmittedCssFileMap.set(chunk, new Set([this.getFileName(fileHandle)]));
+                }
+                else if (!config.build.ssr) {
+                    // legacy build, inline css
+                    chunkCSS = await processChunkCSS(chunkCSS, {
+                        inlined: true,
+                        minify: true,
+                    });
+                    const style = `__vite_style__`;
+                    const injectCode = `var ${style} = document.createElement('style');` +
+                        `${style}.innerHTML = ${JSON.stringify(chunkCSS)};` +
+                        `document.head.appendChild(${style});`;
+                    if (config.build.sourcemap) {
+                        const s = new magic_string_1.default(code);
+                        s.prepend(injectCode);
+                        return {
+                            code: s.toString(),
+                            map: s.generateMap({ hires: true }),
+                        };
+                    }
+                    else {
+                        return { code: injectCode + code };
+                    }
+                }
+            }
+            else {
+                // non-split extracted CSS will be minified together
+                chunkCSS = await processChunkCSS(chunkCSS, {
+                    inlined: false,
+                    minify: false,
+                });
+                outputToExtractedCSSMap.set(opts, (outputToExtractedCSSMap.get(opts) || '') + chunkCSS);
+            }
+            return null;
+        },
+        async generateBundle(opts, bundle) {
+            // remove empty css chunks and their imports
+            if (pureCssChunks.size) {
+                const emptyChunkFiles = [...pureCssChunks]
+                    .map((file) => path_1.default.basename(file))
+                    .join('|')
+                    .replace(/\./g, '\\.');
+                const emptyChunkRE = new RegExp(opts.format === 'es'
+                    ? `\\bimport\\s*"[^"]*(?:${emptyChunkFiles})";\n?`
+                    : `\\brequire\\(\\s*"[^"]*(?:${emptyChunkFiles})"\\);\n?`, 'g');
+                for (const file in bundle) {
+                    const chunk = bundle[file];
+                    if (chunk.type === 'chunk') {
+                        // remove pure css chunk from other chunk's imports,
+                        // and also register the emitted CSS files under the importer
+                        // chunks instead.
+                        chunk.imports = chunk.imports.filter((file) => {
+                            if (pureCssChunks.has(file)) {
+                                const css = exports.chunkToEmittedCssFileMap.get(bundle[file]);
+                                if (css) {
+                                    let existing = exports.chunkToEmittedCssFileMap.get(chunk);
+                                    if (!existing) {
+                                        existing = new Set();
+                                    }
+                                    css.forEach((file) => existing.add(file));
+                                    exports.chunkToEmittedCssFileMap.set(chunk, existing);
+                                }
+                                return false;
+                            }
+                            return true;
+                        });
+                        chunk.code = chunk.code.replace(emptyChunkRE, 
+                        // remove css import while preserving source map location
+                        (m) => `/* empty css ${''.padEnd(m.length - 15)}*/`);
+                    }
+                }
+                const removedPureCssFiles = exports.removedPureCssFilesCache.get(config);
+                pureCssChunks.forEach((fileName) => {
+                    removedPureCssFiles.set(fileName, bundle[fileName]);
+                    delete bundle[fileName];
+                });
+            }
+            let extractedCss = outputToExtractedCSSMap.get(opts);
+            if (extractedCss && !hasEmitted) {
+                hasEmitted = true;
+                // minify css
+                if (config.build.minify) {
+                    extractedCss = await minifyCSS(extractedCss, config);
+                }
+                this.emitFile({
+                    name: 'style.css',
+                    type: 'asset',
+                    source: extractedCss,
+                });
+            }
+        },
+    };
+}
+exports.cssPostPlugin = cssPostPlugin;
+function createCSSResolvers(config) {
+    let cssResolve;
+    let sassResolve;
+    let lessResolve;
+    return {
+        get css() {
+            return (cssResolve ||
+                (cssResolve = config.createResolver({
+                    extensions: ['.css'],
+                    mainFields: ['style'],
+                    tryIndex: false,
+                    preferRelative: true,
+                })));
+        },
+        get sass() {
+            return (sassResolve ||
+                (sassResolve = config.createResolver({
+                    extensions: ['.scss', '.sass', '.css'],
+                    mainFields: ['sass', 'style'],
+                    tryIndex: true,
+                    tryPrefix: '_',
+                    preferRelative: true,
+                })));
+        },
+        get less() {
+            return (lessResolve ||
+                (lessResolve = config.createResolver({
+                    extensions: ['.less', '.css'],
+                    mainFields: ['less', 'style'],
+                    tryIndex: false,
+                    preferRelative: true,
+                })));
+        },
+    };
+}
+function getCssResolversKeys(resolvers) {
+    return Object.keys(resolvers);
+}
+async function compileCSS(id, code, config, urlReplacer, atImportResolvers, server) {
+    var _a;
+    const { modules: modulesOptions, preprocessorOptions } = config.css || {};
+    const isModule = modulesOptions !== false && cssModuleRE.test(id);
+    // although at serve time it can work without processing, we do need to
+    // crawl them in order to register watch dependencies.
+    const needInlineImport = code.includes('@import');
+    const hasUrl = exports.cssUrlRE.test(code) || cssImageSetRE.test(code);
+    const postcssConfig = await resolvePostcssConfig(config);
+    const lang = (_a = id.match(cssLangRE)) === null || _a === void 0 ? void 0 : _a[1];
+    // 1. plain css that needs no processing
+    if (lang === 'css' &&
+        !postcssConfig &&
+        !isModule &&
+        !needInlineImport &&
+        !hasUrl) {
+        return { code };
+    }
+    let map;
+    let modules;
+    const deps = new Set();
+    // 2. pre-processors: sass etc.
+    if (isPreProcessor(lang)) {
+        const preProcessor = preProcessors[lang];
+        let opts = (preprocessorOptions && preprocessorOptions[lang]) || {};
+        // support @import from node dependencies by default
+        switch (lang) {
+            case "scss" /* scss */:
+            case "sass" /* sass */:
+                opts = {
+                    includePaths: ['node_modules'],
+                    alias: config.resolve.alias,
+                    ...opts,
+                };
+                break;
+            case "less" /* less */:
+            case "styl" /* styl */:
+            case "stylus" /* stylus */:
+                opts = {
+                    paths: ['node_modules'],
+                    alias: config.resolve.alias,
+                    ...opts,
+                };
+        }
+        // important: set this for relative import resolving
+        opts.filename = (0, utils_1.cleanUrl)(id);
+        const preprocessResult = await preProcessor(code, config.root, opts, atImportResolvers);
+        if (preprocessResult.errors.length) {
+            throw preprocessResult.errors[0];
+        }
+        code = preprocessResult.code;
+        map = preprocessResult.map;
+        if (preprocessResult.deps) {
+            preprocessResult.deps.forEach((dep) => {
+                // sometimes sass registers the file itself as a dep
+                if ((0, utils_1.normalizePath)(dep) !== (0, utils_1.normalizePath)(opts.filename)) {
+                    deps.add(dep);
+                }
+            });
+        }
+    }
+    // 3. postcss
+    const postcssOptions = (postcssConfig && postcssConfig.options) || {};
+    const postcssPlugins = postcssConfig && postcssConfig.plugins ? postcssConfig.plugins.slice() : [];
+    if (needInlineImport) {
+        postcssPlugins.unshift((await Promise.resolve().then(() => __importStar(require('postcss-import')))).default({
+            async resolve(id, basedir) {
+                const resolved = await atImportResolvers.css(id, path_1.default.join(basedir, '*'));
+                if (resolved) {
+                    return path_1.default.resolve(resolved);
+                }
+                return id;
+            },
+        }));
+    }
+    postcssPlugins.push(UrlRewritePostcssPlugin({
+        replacer: urlReplacer,
+    }));
+    if (isModule) {
+        postcssPlugins.unshift((await Promise.resolve().then(() => __importStar(require('postcss-modules')))).default({
+            ...modulesOptions,
+            getJSON(cssFileName, _modules, outputFileName) {
+                modules = _modules;
+                if (modulesOptions && typeof modulesOptions.getJSON === 'function') {
+                    modulesOptions.getJSON(cssFileName, _modules, outputFileName);
+                }
+            },
+            async resolve(id) {
+                for (const key of getCssResolversKeys(atImportResolvers)) {
+                    const resolved = await atImportResolvers[key](id);
+                    if (resolved) {
+                        return path_1.default.resolve(resolved);
+                    }
+                }
+                return id;
+            },
+        }));
+    }
+    if (!postcssPlugins.length) {
+        return {
+            code,
+            map,
+        };
+    }
+    // postcss is an unbundled dep and should be lazy imported
+    const postcssResult = await (await Promise.resolve().then(() => __importStar(require('postcss'))))
+        .default(postcssPlugins)
+        .process(code, {
+        ...postcssOptions,
+        to: id,
+        from: id,
+        map: {
+            inline: false,
+            annotation: false,
+            prev: map,
+        },
+    });
+    // record CSS dependencies from @imports
+    for (const message of postcssResult.messages) {
+        if (message.type === 'dependency') {
+            deps.add(message.file);
+        }
+        else if (message.type === 'dir-dependency') {
+            // https://github.com/postcss/postcss/blob/main/docs/guidelines/plugin.md#3-dependencies
+            const { dir, glob: globPattern = '**' } = message;
+            const pattern = (0, utils_1.normalizePath)(path_1.default.resolve(path_1.default.dirname(id), dir)) + `/` + globPattern;
+            const files = fast_glob_1.default.sync(pattern, {
+                ignore: ['**/node_modules/**'],
+            });
+            for (let i = 0; i < files.length; i++) {
+                deps.add(files[i]);
+            }
+            if (server) {
+                // register glob importers so we can trigger updates on file add/remove
+                if (!(id in server._globImporters)) {
+                    ;
+                    server._globImporters[id] = {
+                        module: server.moduleGraph.getModuleById(id),
+                        importGlobs: [],
+                    };
+                }
+                ;
+                server._globImporters[id].importGlobs.push({
+                    base: config.root,
+                    pattern,
+                });
+            }
+        }
+        else if (message.type === 'warning') {
+            let msg = `[vite:css] ${message.text}`;
+            if (message.line && message.column) {
+                msg += `\n${(0, utils_1.generateCodeFrame)(code, {
+                    line: message.line,
+                    column: message.column,
+                })}`;
+            }
+            config.logger.warn(chalk_1.default.yellow(msg));
+        }
+    }
+    return {
+        ast: postcssResult,
+        code: postcssResult.css,
+        map: postcssResult.map,
+        modules,
+        deps,
+    };
+}
+async function resolvePostcssConfig(config) {
+    var _a;
+    let result = postcssConfigCache.get(config);
+    if (result !== undefined) {
+        return result;
+    }
+    // inline postcss config via vite config
+    const inlineOptions = (_a = config.css) === null || _a === void 0 ? void 0 : _a.postcss;
+    if ((0, utils_1.isObject)(inlineOptions)) {
+        const options = { ...inlineOptions };
+        delete options.plugins;
+        result = {
+            options,
+            plugins: inlineOptions.plugins || [],
+        };
+    }
+    else {
+        try {
+            const searchPath = typeof inlineOptions === 'string' ? inlineOptions : config.root;
+            // @ts-ignore
+            result = await (0, postcss_load_config_1.default)({}, searchPath);
+        }
+        catch (e) {
+            if (!/No PostCSS Config found/.test(e.message)) {
+                throw e;
+            }
+            result = null;
+        }
+    }
+    postcssConfigCache.set(config, result);
+    return result;
+}
+// https://drafts.csswg.org/css-syntax-3/#identifier-code-point
+exports.cssUrlRE = /(?<=^|[^\w\-\u0080-\uffff])url\(\s*('[^']+'|"[^"]+"|[^'")]+)\s*\)/;
+const cssImageSetRE = /image-set\(([^)]+)\)/;
+const UrlRewritePostcssPlugin = (opts) => {
+    if (!opts) {
+        throw new Error('base or replace is required');
+    }
+    return {
+        postcssPlugin: 'vite-url-rewrite',
+        Once(root) {
+            const promises = [];
+            root.walkDecls((declaration) => {
+                const isCssUrl = exports.cssUrlRE.test(declaration.value);
+                const isCssImageSet = cssImageSetRE.test(declaration.value);
+                if (isCssUrl || isCssImageSet) {
+                    const replacerForDeclaration = (rawUrl) => {
+                        var _a;
+                        const importer = (_a = declaration.source) === null || _a === void 0 ? void 0 : _a.input.file;
+                        return opts.replacer(rawUrl, importer);
+                    };
+                    const rewriterToUse = isCssUrl ? rewriteCssUrls : rewriteCssImageSet;
+                    promises.push(rewriterToUse(declaration.value, replacerForDeclaration).then((url) => {
+                        declaration.value = url;
+                    }));
+                }
+            });
+            if (promises.length) {
+                return Promise.all(promises);
+            }
+        },
+    };
+};
+UrlRewritePostcssPlugin.postcss = true;
+function rewriteCssUrls(css, replacer) {
+    return (0, utils_1.asyncReplace)(css, exports.cssUrlRE, async (match) => {
+        const [matched, rawUrl] = match;
+        return await doUrlReplace(rawUrl, matched, replacer);
+    });
+}
+function rewriteCssImageSet(css, replacer) {
+    return (0, utils_1.asyncReplace)(css, cssImageSetRE, async (match) => {
+        const [matched, rawUrl] = match;
+        const url = await (0, utils_1.processSrcSet)(rawUrl, ({ url }) => doUrlReplace(url, matched, replacer));
+        return `image-set(${url})`;
+    });
+}
+async function doUrlReplace(rawUrl, matched, replacer) {
+    let wrap = '';
+    const first = rawUrl[0];
+    if (first === `"` || first === `'`) {
+        wrap = first;
+        rawUrl = rawUrl.slice(1, -1);
+    }
+    if ((0, utils_1.isExternalUrl)(rawUrl) || (0, utils_1.isDataUrl)(rawUrl) || rawUrl.startsWith('#')) {
+        return matched;
+    }
+    return `url(${wrap}${await replacer(rawUrl)}${wrap})`;
+}
+async function minifyCSS(css, config) {
+    const { code, warnings } = await (0, esbuild_1.transform)(css, {
+        loader: 'css',
+        minify: true,
+        target: config.build.cssTarget || undefined,
+    });
+    if (warnings.length) {
+        const msgs = await (0, esbuild_1.formatMessages)(warnings, { kind: 'warning' });
+        config.logger.warn(chalk_1.default.yellow(`warnings when minifying css:\n${msgs.join('\n')}`));
+    }
+    return code;
+}
+// #1845
+// CSS @import can only appear at top of the file. We need to hoist all @import
+// to top when multiple files are concatenated.
+async function hoistAtImports(css) {
+    const postcss = await Promise.resolve().then(() => __importStar(require('postcss')));
+    return (await postcss.default([AtImportHoistPlugin]).process(css)).css;
+}
+const AtImportHoistPlugin = () => {
+    return {
+        postcssPlugin: 'vite-hoist-at-imports',
+        Once(root) {
+            const imports = [];
+            root.walkAtRules((rule) => {
+                if (rule.name === 'import') {
+                    // record in reverse so that can simply prepend to preserve order
+                    imports.unshift(rule);
+                }
+            });
+            imports.forEach((i) => root.prepend(i));
+        },
+    };
+};
+AtImportHoistPlugin.postcss = true;
+const loadedPreprocessors = {};
+function loadPreprocessor(lang, root) {
+    var _a, _b;
+    if (lang in loadedPreprocessors) {
+        return loadedPreprocessors[lang];
+    }
+    try {
+        // Search for the preprocessor in the root directory first, and fall back
+        // to the default require paths.
+        const fallbackPaths = ((_b = (_a = require.resolve).paths) === null || _b === void 0 ? void 0 : _b.call(_a, lang)) || [];
+        const resolved = require.resolve(lang, { paths: [root, ...fallbackPaths] });
+        return (loadedPreprocessors[lang] = require(resolved));
+    }
+    catch (e) {
+        throw new Error(`Preprocessor dependency "${lang}" not found. Did you install it?`);
+    }
+}
+// .scss/.sass processor
+const scss = async (source, root, options, resolvers) => {
+    const render = loadPreprocessor("sass" /* sass */, root).render;
+    const internalImporter = (url, importer, done) => {
+        resolvers.sass(url, importer).then((resolved) => {
+            if (resolved) {
+                rebaseUrls(resolved, options.filename, options.alias)
+                    .then((data) => done === null || done === void 0 ? void 0 : done(data))
+                    .catch((data) => done === null || done === void 0 ? void 0 : done(data));
+            }
+            else {
+                done === null || done === void 0 ? void 0 : done(null);
+            }
+        });
+    };
+    const importer = [internalImporter];
+    if (options.importer) {
+        Array.isArray(options.importer)
+            ? importer.push(...options.importer)
+            : importer.push(options.importer);
+    }
+    const finalOptions = {
+        ...options,
+        data: await getSource(source, options.filename, options.additionalData),
+        file: options.filename,
+        outFile: options.filename,
+        importer,
+    };
+    try {
+        const result = await new Promise((resolve, reject) => {
+            render(finalOptions, (err, res) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(res);
+                }
+            });
+        });
+        const deps = result.stats.includedFiles;
+        return {
+            code: result.css.toString(),
+            errors: [],
+            deps,
+        };
+    }
+    catch (e) {
+        // normalize SASS error
+        e.id = e.file;
+        e.frame = e.formatted;
+        return { code: '', errors: [e], deps: [] };
+    }
+};
+const sass = (source, root, options, aliasResolver) => scss(source, root, {
+    ...options,
+    indentedSyntax: true,
+}, aliasResolver);
+/**
+ * relative url() inside \@imported sass and less files must be rebased to use
+ * root file as base.
+ */
+async function rebaseUrls(file, rootFile, alias) {
+    file = path_1.default.resolve(file); // ensure os-specific flashes
+    // fixed by xxxxxx 条件编译
+    const contents = (0, css_1.preprocessCss)(fs_1.default.readFileSync(file, 'utf-8'));
+    // in the same dir, no need to rebase
+    const fileDir = path_1.default.dirname(file);
+    const rootDir = path_1.default.dirname(rootFile);
+    if (fileDir === rootDir) {
+        return { file, contents };
+    }
+    // no url()
+    if (!exports.cssUrlRE.test(contents)) {
+        return { file, contents };
+    }
+    const rebased = await rewriteCssUrls(contents, (url) => {
+        if (url.startsWith('/'))
+            return url;
+        // match alias, no need to rewrite
+        for (const { find } of alias) {
+            const matches = typeof find === 'string' ? url.startsWith(find) : find.test(url);
+            if (matches) {
+                return url;
+            }
+        }
+        const absolute = path_1.default.resolve(fileDir, url);
+        const relative = path_1.default.relative(rootDir, absolute);
+        return (0, utils_1.normalizePath)(relative);
+    });
+    return {
+        file,
+        contents: rebased,
+    };
+}
+// .less
+const less = async (source, root, options, resolvers) => {
+    const nodeLess = loadPreprocessor("less" /* less */, root);
+    const viteResolverPlugin = createViteLessPlugin(nodeLess, options.filename, options.alias, resolvers);
+    source = await getSource(source, options.filename, options.additionalData);
+    let result;
+    try {
+        result = await nodeLess.render(source, {
+            ...options,
+            plugins: [viteResolverPlugin, ...(options.plugins || [])],
+        });
+    }
+    catch (e) {
+        const error = e;
+        // normalize error info
+        const normalizedError = new Error(error.message || error.type);
+        normalizedError.loc = {
+            file: error.filename || options.filename,
+            line: error.line,
+            column: error.column,
+        };
+        return { code: '', errors: [normalizedError], deps: [] };
+    }
+    return {
+        code: result.css.toString(),
+        deps: result.imports,
+        errors: [],
+    };
+};
+/**
+ * Less manager, lazy initialized
+ */
+let ViteLessManager;
+function createViteLessPlugin(less, rootFile, alias, resolvers) {
+    if (!ViteLessManager) {
+        ViteLessManager = class ViteManager extends less.FileManager {
+            constructor(rootFile, resolvers, alias) {
+                super();
+                this.rootFile = rootFile;
+                this.resolvers = resolvers;
+                this.alias = alias;
+            }
+            supports() {
+                return true;
+            }
+            supportsSync() {
+                return false;
+            }
+            async loadFile(filename, dir, opts, env) {
+                const resolved = await this.resolvers.less(filename, path_1.default.join(dir, '*'));
+                if (resolved) {
+                    const result = await rebaseUrls(resolved, this.rootFile, this.alias);
+                    let contents;
+                    if (result && 'contents' in result) {
+                        contents = result.contents;
+                    }
+                    else {
+                        contents = fs_1.default.readFileSync(resolved, 'utf-8');
+                    }
+                    return {
+                        filename: path_1.default.resolve(resolved),
+                        contents,
+                    };
+                }
+                else {
+                    return super.loadFile(filename, dir, opts, env);
+                }
+            }
+        };
+    }
+    return {
+        install(_, pluginManager) {
+            pluginManager.addFileManager(new ViteLessManager(rootFile, resolvers, alias));
+        },
+        minVersion: [3, 0, 0],
+    };
+}
+// .styl
+const styl = async (source, root, options) => {
+    var _a;
+    const nodeStylus = loadPreprocessor("stylus" /* stylus */, root);
+    // Get source with preprocessor options.additionalData. Make sure a new line separator
+    // is added to avoid any render error, as added stylus content may not have semi-colon separators
+    source = await getSource(source, options.filename, options.additionalData, '\n');
+    // Get preprocessor options.imports dependencies as stylus
+    // does not return them with its builtin `.deps()` method
+    const importsDeps = ((_a = options.imports) !== null && _a !== void 0 ? _a : []).map((dep) => path_1.default.resolve(dep));
+    try {
+        const ref = nodeStylus(source, options);
+        // if (map) ref.set('sourcemap', { inline: false, comment: false })
+        const result = ref.render();
+        // Concat imports deps with computed deps
+        const deps = [...ref.deps(), ...importsDeps];
+        return { code: result, errors: [], deps };
+    }
+    catch (e) {
+        return { code: '', errors: [e], deps: [] };
+    }
+};
+function getSource(source, filename, additionalData, sep = '') {
+    if (!additionalData)
+        return source;
+    if (typeof additionalData === 'function') {
+        return additionalData(source, filename);
+    }
+    return additionalData + sep + source;
+}
+const preProcessors = Object.freeze({
+    ["less" /* less */]: less,
+    ["sass" /* sass */]: sass,
+    ["scss" /* scss */]: scss,
+    ["styl" /* styl */]: styl,
+    ["stylus" /* stylus */]: styl,
+});
+function isPreProcessor(lang) {
+    return lang && lang in preProcessors;
+}