@dcloudio/uni-cli-shared 0.0.1-nvue3.3030820220125001

package/dist/vite/plugins/inject.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniViteInjectPlugin = void 0;
+const path_1 = require("path");
+const debug_1 = __importDefault(require("debug"));
+const pluginutils_1 = require("@rollup/pluginutils");
+const estree_walker_1 = require("estree-walker");
+const shared_1 = require("@vue/shared");
+const magic_string_1 = __importDefault(require("magic-string"));
+const utils_1 = require("../utils");
+const debugInject = (0, debug_1.default)('uni:inject');
+const debugInjectTry = (0, debug_1.default)('uni:inject-try');
+function uniViteInjectPlugin(name, options) {
+    if (!options)
+        throw new Error('Missing options');
+    const filter = (0, pluginutils_1.createFilter)(options.include, options.exclude);
+    const modules = (0, shared_1.extend)({}, options);
+    delete modules.include;
+    delete modules.exclude;
+    delete modules.sourceMap;
+    delete modules.callback;
+    const reassignments = new Set();
+    const modulesMap = new Map();
+    const namespaceModulesMap = new Map();
+    Object.keys(modules).forEach((name) => {
+        if (name.endsWith('.')) {
+            namespaceModulesMap.set(name, modules[name]);
+        }
+        modulesMap.set(name, modules[name]);
+    });
+    const hasNamespace = namespaceModulesMap.size > 0;
+    // Fix paths on Windows
+    if (path_1.sep !== '/') {
+        normalizeModulesMap(modulesMap);
+        normalizeModulesMap(namespaceModulesMap);
+    }
+    const firstpass = new RegExp(`(?:${Array.from(modulesMap.keys()).map(escape).join('|')})`, 'g');
+    const sourceMap = options.sourceMap !== false;
+    const callback = options.callback;
+    return {
+        name,
+        // 确保在 commonjs 之后，否则会混合 es6 module 与 cjs 的代码，导致 commonjs 失效
+        enforce: 'post',
+        transform(code, id) {
+            if (!filter(id))
+                return null;
+            if (!(0, utils_1.isJsFile)(id))
+                return null;
+            debugInjectTry(id);
+            if (code.search(firstpass) === -1)
+                return null;
+            if (path_1.sep !== '/')
+                id = id.split(path_1.sep).join('/');
+            let ast = null;
+            try {
+                ast = this.parse(code);
+            }
+            catch (err) {
+                this.warn({
+                    code: 'PARSE_ERROR',
+                    message: `plugin-inject: failed to parse ${id}. Consider restricting the plugin to particular files via options.include`,
+                });
+            }
+            if (!ast) {
+                return null;
+            }
+            const imports = new Set();
+            ast.body.forEach((node) => {
+                if (node.type === 'ImportDeclaration') {
+                    node.specifiers.forEach((specifier) => {
+                        imports.add(specifier.local.name);
+                    });
+                }
+            });
+            // analyse scopes
+            let scope = (0, pluginutils_1.attachScopes)(ast, 'scope');
+            const magicString = new magic_string_1.default(code);
+            const newImports = new Map();
+            function handleReference(node, name, keypath, parent) {
+                let mod = modulesMap.get(keypath);
+                if (!mod && hasNamespace) {
+                    const mods = keypath.split('.');
+                    if (mods.length === 2) {
+                        mod = namespaceModulesMap.get(mods[0] + '.');
+                        if (mod) {
+                            if (Array.isArray(mod)) {
+                                const testFn = mod[1];
+                                if (testFn(mods[1])) {
+                                    mod = [mod[0], mods[1]];
+                                }
+                                else {
+                                    mod = undefined;
+                                }
+                            }
+                            else {
+                                mod = [mod, mods[1]];
+                            }
+                        }
+                    }
+                }
+                if (mod && !imports.has(name) && !scope.contains(name)) {
+                    if (typeof mod === 'string')
+                        mod = [mod, 'default'];
+                    if (mod[0] === id)
+                        return false;
+                    const hash = `${keypath}:${mod[0]}:${mod[1]}`;
+                    // 当 API 被覆盖定义后，不再摇树
+                    if (reassignments.has(hash)) {
+                        return false;
+                    }
+                    if (parent &&
+                        (0, utils_1.isAssignmentExpression)(parent) &&
+                        parent.left === node) {
+                        reassignments.add(hash);
+                        return false;
+                    }
+                    const importLocalName = name === keypath ? name : (0, pluginutils_1.makeLegalIdentifier)(`$inject_${keypath}`);
+                    if (!newImports.has(hash)) {
+                        if (mod[1] === '*') {
+                            newImports.set(hash, `import * as ${importLocalName} from '${mod[0]}';`);
+                        }
+                        else {
+                            newImports.set(hash, `import { ${mod[1]} as ${importLocalName} } from '${mod[0]}';`);
+                            callback && callback(newImports, mod);
+                        }
+                    }
+                    if (name !== keypath) {
+                        magicString.overwrite(node.start, node.end, importLocalName, {
+                            storeName: true,
+                        });
+                    }
+                    return true;
+                }
+                return false;
+            }
+            (0, estree_walker_1.walk)(ast, {
+                enter(node, parent) {
+                    if (sourceMap) {
+                        magicString.addSourcemapLocation(node.start);
+                        magicString.addSourcemapLocation(node.end);
+                    }
+                    if (node.scope) {
+                        scope = node.scope;
+                    }
+                    if ((0, utils_1.isProperty)(node) && node.shorthand) {
+                        const { name } = node.key;
+                        handleReference(node, name, name);
+                        this.skip();
+                        return;
+                    }
+                    if ((0, utils_1.isReference)(node, parent)) {
+                        const { name, keypath } = flatten(node);
+                        const handled = handleReference(node, name, keypath, parent);
+                        if (handled) {
+                            this.skip();
+                        }
+                    }
+                },
+                leave(node) {
+                    if (node.scope) {
+                        scope = scope.parent;
+                    }
+                },
+            });
+            debugInject(id, newImports.size);
+            if (newImports.size === 0) {
+                return {
+                    code,
+                    // 不能返回 ast ，否则会导致代码不能被再次修改
+                    // 比如 App.vue 中，console.log('uniCloud') 触发了 inject 检测，检测完，发现不需要
+                    // 此时返回 ast，会导致 import { setupApp } from '@dcloudio/uni-h5' 不会被编译
+                    // ast
+                    map: sourceMap ? magicString.generateMap({ hires: true }) : null,
+                };
+            }
+            const importBlock = Array.from(newImports.values()).join('\n\n');
+            magicString.prepend(`${importBlock}\n\n`);
+            return {
+                code: magicString.toString(),
+                map: sourceMap ? magicString.generateMap({ hires: true }) : null,
+            };
+        },
+    };
+}
+exports.uniViteInjectPlugin = uniViteInjectPlugin;
+const escape = (str) => str.replace(/[-[\]/{}()*+?.\\^$|]/g, '\\$&');
+const flatten = (startNode) => {
+    const parts = [];
+    let node = startNode;
+    while ((0, utils_1.isMemberExpression)(node)) {
+        parts.unshift(node.property.name);
+        node = node.object;
+    }
+    const { name } = node;
+    parts.unshift(name);
+    return { name, keypath: parts.join('.') };
+};
+function normalizeModulesMap(modulesMap) {
+    modulesMap.forEach((mod, key) => {
+        modulesMap.set(key, Array.isArray(mod)
+            ? [mod[0].split(path_1.sep).join('/'), mod[1]]
+            : mod.split(path_1.sep).join('/'));
+    });
+}

package/dist/vite/plugins/jsonJs.d.ts

@@ -0,0 +1,3 @@
+import { CreateUniViteFilterPlugin } from '../utils/plugin';
+export declare const defineUniPagesJsonPlugin: (createVitePlugin: CreateUniViteFilterPlugin) => import("vite").Plugin;
+export declare const defineUniManifestJsonPlugin: (createVitePlugin: CreateUniViteFilterPlugin) => import("vite").Plugin;

package/dist/vite/plugins/jsonJs.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineUniManifestJsonPlugin = exports.defineUniPagesJsonPlugin = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("../../utils");
+exports.defineUniPagesJsonPlugin = createDefineJsonJsPlugin('pages.json');
+exports.defineUniManifestJsonPlugin = createDefineJsonJsPlugin('manifest.json');
+function createDefineJsonJsPlugin(name) {
+    const JSON_JS = name + '.js';
+    return function (createVitePlugin) {
+        const opts = {
+            resolvedConfig: {},
+            filter(id) {
+                return id.endsWith(JSON_JS);
+            },
+        };
+        const plugin = createVitePlugin(opts);
+        const origLoad = plugin.load;
+        const origResolveId = plugin.resolveId;
+        const origConfigResolved = plugin.configResolved;
+        let jsonPath = '';
+        plugin.resolveId = function (id, importer, options) {
+            const res = origResolveId && origResolveId.call(this, id, importer, options);
+            if (res) {
+                return res;
+            }
+            if (id.endsWith(JSON_JS)) {
+                return jsonPath + '.js';
+            }
+        };
+        plugin.configResolved = function (config) {
+            opts.resolvedConfig = config;
+            jsonPath = (0, utils_1.normalizePath)(path_1.default.join(process.env.UNI_INPUT_DIR, name));
+            return origConfigResolved && origConfigResolved(config);
+        };
+        plugin.load = function (id, ssr) {
+            const res = origLoad && origLoad.call(this, id, ssr);
+            if (res) {
+                return res;
+            }
+            if (!opts.filter(id)) {
+                return;
+            }
+            return fs_1.default.readFileSync(jsonPath, 'utf8');
+        };
+        return plugin;
+    };
+}

package/dist/vite/plugins/mainJs.d.ts

@@ -0,0 +1,2 @@
+import { CreateUniViteFilterPlugin } from '../utils/plugin';
+export declare function defineUniMainJsPlugin(createUniMainJsPlugin: CreateUniViteFilterPlugin): import("vite").Plugin;

package/dist/vite/plugins/mainJs.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineUniMainJsPlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("../../utils");
+function defineUniMainJsPlugin(createUniMainJsPlugin) {
+    const opts = {
+        resolvedConfig: {},
+        filter(id) {
+            return id === mainJsPath || id === mainTsPath;
+        },
+    };
+    const plugin = createUniMainJsPlugin(opts);
+    const origConfigResolved = plugin.configResolved;
+    let mainJsPath = '';
+    let mainTsPath = '';
+    plugin.configResolved = function (config) {
+        opts.resolvedConfig = config;
+        const mainPath = (0, utils_1.normalizePath)(path_1.default.resolve(process.env.UNI_INPUT_DIR, 'main'));
+        mainJsPath = mainPath + '.js';
+        mainTsPath = mainPath + '.ts';
+        return origConfigResolved && origConfigResolved(config);
+    };
+    return plugin;
+}
+exports.defineUniMainJsPlugin = defineUniMainJsPlugin;

package/dist/vite/plugins/vitejs/config.d.ts

@@ -0,0 +1 @@
+export type { ResolvedConfig } from 'vite';

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vite/plugins/vitejs/constants.d.ts

@@ -0,0 +1,8 @@
+/**
+ * https://github.com/vitejs/vite/blob/main/packages/vite/src/node/constants.ts
+ */
+/**
+ * Prefix for resolved fs paths, since windows paths may not be valid as URLs.
+ */
+export declare const FS_PREFIX = "/@fs/";
+export declare const CLIENT_PUBLIC_PATH = "/@vite/client";

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIENT_PUBLIC_PATH = exports.FS_PREFIX = void 0;
+/**
+ * https://github.com/vitejs/vite/blob/main/packages/vite/src/node/constants.ts
+ */
+/**
+ * Prefix for resolved fs paths, since windows paths may not be valid as URLs.
+ */
+exports.FS_PREFIX = `/@fs/`;
+exports.CLIENT_PUBLIC_PATH = `/@vite/client`;

package/dist/vite/plugins/vitejs/index.d.ts

@@ -0,0 +1 @@
+export type { ResolveFn, ViteDevServer } from 'vite';

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vite/plugins/vitejs/plugin.d.ts

@@ -0,0 +1 @@
+export type { Plugin } from 'vite';

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vite/plugins/vitejs/plugins/asset.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import type { OutputOptions, PluginContext, RenderedChunk } from 'rollup';
+import { Plugin } from '../plugin';
+import { ResolvedConfig } from '../config';
+export declare const assetUrlRE: RegExp;
+export declare const chunkToEmittedAssetsMap: WeakMap<RenderedChunk, Set<string>>;
+/**
+ * Also supports loading plain strings with import text from './foo.txt?raw'
+ */
+export declare function assetPlugin(config: ResolvedConfig): Plugin;
+export declare function registerAssetToChunk(chunk: RenderedChunk, file: string): void;
+export declare function checkPublicFile(url: string, { publicDir }: ResolvedConfig): string | undefined;
+export declare function fileToUrl(id: string, config: ResolvedConfig, ctx: PluginContext, canInline?: boolean): string;
+export declare function getAssetFilename(hash: string, config: ResolvedConfig): string | undefined;
+/**
+ * converts the source filepath of the asset to the output filename based on the assetFileNames option. \
+ * this function imitates the behavior of rollup.js. \
+ * https://rollupjs.org/guide/en/#outputassetfilenames
+ *
+ * @example
+ * ```ts
+ * const content = Buffer.from('text');
+ * const fileName = assetFileNamesToFileName(
+ *   'assets/[name].[hash][extname]',
+ *   '/path/to/file.txt',
+ *   getAssetHash(content),
+ *   content
+ * )
+ * // fileName: 'assets/file.982d9e3e.txt'
+ * ```
+ *
+ * @param assetFileNames filename pattern. e.g. `'assets/[name].[hash][extname]'`
+ * @param file filepath of the asset
+ * @param contentHash hash of the asset. used for `'[hash]'` placeholder
+ * @param content content of the asset. passed to `assetFileNames` if `assetFileNames` is a function
+ * @returns output filename
+ */
+export declare function assetFileNamesToFileName(assetFileNames: Exclude<OutputOptions['assetFileNames'], undefined>, file: string, contentHash: string, content: string | Buffer): string;
+export declare function getAssetHash(content: Buffer): string;
+export declare function urlToBuiltUrl(url: string, importer: string, config: ResolvedConfig, pluginContext: PluginContext): string;

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

@@ -0,0 +1,270 @@
+"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.urlToBuiltUrl = exports.getAssetHash = exports.assetFileNamesToFileName = exports.getAssetFilename = exports.fileToUrl = exports.checkPublicFile = exports.registerAssetToChunk = exports.assetPlugin = exports.chunkToEmittedAssetsMap = exports.assetUrlRE = void 0;
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const lite_1 = __importDefault(require("mime/lite"));
+const fs_1 = __importStar(require("fs"));
+const magic_string_1 = __importDefault(require("magic-string"));
+const crypto_1 = require("crypto");
+const utils_1 = require("../utils");
+const utils_2 = require("../../../../vite/utils/utils");
+exports.assetUrlRE = /__VITE_ASSET__([a-z\d]{8})__(?:\$_(.*?)__)?/g;
+// urls in JS must be quoted as strings, so when replacing them we need
+// a different regex
+const assetUrlQuotedRE = /"__VITE_ASSET__([a-z\d]{8})__(?:\$_(.*?)__)?"/g;
+const rawRE = /(\?|&)raw(?:&|$)/;
+const urlRE = /(\?|&)url(?:&|$)/;
+exports.chunkToEmittedAssetsMap = new WeakMap();
+const assetCache = new WeakMap();
+const assetHashToFilenameMap = new WeakMap();
+// save hashes of the files that has been emitted in build watch
+const emittedHashMap = new WeakMap();
+/**
+ * Also supports loading plain strings with import text from './foo.txt?raw'
+ */
+function assetPlugin(config) {
+    // assetHashToFilenameMap initialization in buildStart causes getAssetFilename to return undefined
+    assetHashToFilenameMap.set(config, new Map());
+    return {
+        name: 'vite:asset',
+        buildStart() {
+            assetCache.set(config, new Map());
+            emittedHashMap.set(config, new Set());
+        },
+        resolveId(id) {
+            if (!config.assetsInclude((0, utils_1.cleanUrl)(id))) {
+                return;
+            }
+            // imports to absolute urls pointing to files in /public
+            // will fail to resolve in the main resolver. handle them here.
+            const publicFile = checkPublicFile(id, config);
+            if (publicFile) {
+                return id;
+            }
+        },
+        async load(id) {
+            if (id.startsWith('\0')) {
+                // Rollup convention, this id should be handled by the
+                // plugin that marked it with \0
+                return;
+            }
+            // raw requests, read from disk
+            if (rawRE.test(id)) {
+                const file = checkPublicFile(id, config) || (0, utils_1.cleanUrl)(id);
+                // raw query, read file and return as string
+                return `export default ${JSON.stringify(await fs_1.promises.readFile(file, 'utf-8'))}`;
+            }
+            if (!config.assetsInclude((0, utils_1.cleanUrl)(id)) && !urlRE.test(id)) {
+                return;
+            }
+            id = id.replace(urlRE, '$1').replace(/[\?&]$/, '');
+            const url = await fileToUrl(id, config, this);
+            return `export default ${JSON.stringify(url)}`;
+        },
+        renderChunk(code, chunk) {
+            let match;
+            let s;
+            while ((match = assetUrlQuotedRE.exec(code))) {
+                s = s || (s = new magic_string_1.default(code));
+                const [full, hash, postfix = ''] = match;
+                // some internal plugins may still need to emit chunks (e.g. worker) so
+                // fallback to this.getFileName for that.
+                const file = getAssetFilename(hash, config) || this.getFileName(hash);
+                registerAssetToChunk(chunk, file);
+                const outputFilepath = config.base + file + postfix;
+                s.overwrite(match.index, match.index + full.length, JSON.stringify(outputFilepath));
+            }
+            if (s) {
+                return {
+                    code: s.toString(),
+                    map: (0, utils_2.withSourcemap)(config) ? s.generateMap({ hires: true }) : null,
+                };
+            }
+            else {
+                return null;
+            }
+        },
+    };
+}
+exports.assetPlugin = assetPlugin;
+function registerAssetToChunk(chunk, file) {
+    let emitted = exports.chunkToEmittedAssetsMap.get(chunk);
+    if (!emitted) {
+        emitted = new Set();
+        exports.chunkToEmittedAssetsMap.set(chunk, emitted);
+    }
+    emitted.add((0, utils_1.cleanUrl)(file));
+}
+exports.registerAssetToChunk = registerAssetToChunk;
+function checkPublicFile(url, { publicDir }) {
+    // note if the file is in /public, the resolver would have returned it
+    // as-is so it's not going to be a fully resolved path.
+    if (!publicDir || !url.startsWith('/')) {
+        return;
+    }
+    const publicFile = path_1.default.join(publicDir, (0, utils_1.cleanUrl)(url));
+    if (fs_1.default.existsSync(publicFile)) {
+        return publicFile;
+    }
+    else {
+        return;
+    }
+}
+exports.checkPublicFile = checkPublicFile;
+function fileToUrl(id, config, ctx, canInline = false) {
+    return fileToBuiltUrl(id, config, ctx, false, canInline);
+}
+exports.fileToUrl = fileToUrl;
+function getAssetFilename(hash, config) {
+    var _a;
+    return (_a = assetHashToFilenameMap.get(config)) === null || _a === void 0 ? void 0 : _a.get(hash);
+}
+exports.getAssetFilename = getAssetFilename;
+/**
+ * converts the source filepath of the asset to the output filename based on the assetFileNames option. \
+ * this function imitates the behavior of rollup.js. \
+ * https://rollupjs.org/guide/en/#outputassetfilenames
+ *
+ * @example
+ * ```ts
+ * const content = Buffer.from('text');
+ * const fileName = assetFileNamesToFileName(
+ *   'assets/[name].[hash][extname]',
+ *   '/path/to/file.txt',
+ *   getAssetHash(content),
+ *   content
+ * )
+ * // fileName: 'assets/file.982d9e3e.txt'
+ * ```
+ *
+ * @param assetFileNames filename pattern. e.g. `'assets/[name].[hash][extname]'`
+ * @param file filepath of the asset
+ * @param contentHash hash of the asset. used for `'[hash]'` placeholder
+ * @param content content of the asset. passed to `assetFileNames` if `assetFileNames` is a function
+ * @returns output filename
+ */
+function assetFileNamesToFileName(assetFileNames, file, contentHash, content) {
+    const basename = path_1.default.basename(file);
+    // placeholders for `assetFileNames`
+    // `hash` is slightly different from the rollup's one
+    const extname = path_1.default.extname(basename);
+    const ext = extname.substring(1);
+    const name = basename.slice(0, -extname.length);
+    const hash = contentHash;
+    if (typeof assetFileNames === 'function') {
+        assetFileNames = assetFileNames({
+            name: file,
+            source: content,
+            type: 'asset',
+        });
+        if (typeof assetFileNames !== 'string') {
+            throw new TypeError('assetFileNames must return a string');
+        }
+    }
+    else if (typeof assetFileNames !== 'string') {
+        throw new TypeError('assetFileNames must be a string or a function');
+    }
+    const fileName = assetFileNames.replace(/\[\w+\]/g, (placeholder) => {
+        switch (placeholder) {
+            case '[ext]':
+                return ext;
+            case '[extname]':
+                return extname;
+            case '[hash]':
+                return hash;
+            case '[name]':
+                return name;
+        }
+        throw new Error(`invalid placeholder ${placeholder} in assetFileNames "${assetFileNames}"`);
+    });
+    return fileName;
+}
+exports.assetFileNamesToFileName = assetFileNamesToFileName;
+/**
+ * Register an asset to be emitted as part of the bundle (if necessary)
+ * and returns the resolved public URL
+ */
+function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false, canInline = false) {
+    if (!skipPublicCheck && checkPublicFile(id, config)) {
+        return config.base + id.slice(1);
+    }
+    const cache = assetCache.get(config);
+    const cached = cache.get(id);
+    if (cached) {
+        return cached;
+    }
+    const file = (0, utils_1.cleanUrl)(id);
+    const content = fs_1.default.readFileSync(file);
+    let url;
+    if (canInline && content.length < Number(config.build.assetsInlineLimit)) {
+        // base64 inlined as a string
+        url = `data:${lite_1.default.getType(file)};base64,${content.toString('base64')}`;
+    }
+    else {
+        const map = assetHashToFilenameMap.get(config);
+        const contentHash = getAssetHash(content);
+        const { search, hash } = (0, url_1.parse)(id);
+        const postfix = (search || '') + (hash || '');
+        const inputDir = (0, utils_1.normalizePath)(process.env.UNI_INPUT_DIR);
+        let fileName = file.startsWith(inputDir)
+            ? path_1.default.posix.relative(inputDir, file)
+            : assetFileNamesToFileName(path_1.default.posix.join(config.build.assetsDir, '[name].[hash][extname]'), file, contentHash, content);
+        if (!map.has(contentHash)) {
+            map.set(contentHash, fileName);
+        }
+        if (!fileName.includes('/static/')) {
+            const emittedSet = emittedHashMap.get(config);
+            if (!emittedSet.has(contentHash)) {
+                pluginContext.emitFile({
+                    name: fileName,
+                    fileName,
+                    type: 'asset',
+                    source: content,
+                });
+                emittedSet.add(contentHash);
+            }
+        }
+        url = `__VITE_ASSET__${contentHash}__${postfix ? `$_${postfix}__` : ``}`;
+    }
+    cache.set(id, url);
+    return url;
+}
+function getAssetHash(content) {
+    return (0, crypto_1.createHash)('sha256').update(content).digest('hex').slice(0, 8);
+}
+exports.getAssetHash = getAssetHash;
+function urlToBuiltUrl(url, importer, config, pluginContext) {
+    if (checkPublicFile(url, config)) {
+        return config.base + url.slice(1);
+    }
+    const file = url.startsWith('/')
+        ? path_1.default.join(config.root, url)
+        : path_1.default.join(path_1.default.dirname(importer), url);
+    return fileToBuiltUrl(file, config, pluginContext, 
+    // skip public check since we just did it above
+    true);
+}
+exports.urlToBuiltUrl = urlToBuiltUrl;