vite 5.1.0-beta.5 → 5.1.0-beta.7

package/dist/node/chunks/{dep-Y86Adl1p.js → dep-G1t0FnMB.js}

@@ -32,10 +32,10 @@ import assert$1 from 'node:assert';
 import v8 from 'node:v8';
 import { Worker as Worker$1 } from 'node:worker_threads';
 import { Buffer as Buffer$1 } from 'node:buffer';
+import { EventEmitter as EventEmitter$4 } from 'node:events';
 import { parseAst, parseAstAsync } from 'rollup/parseAst';
 import * as qs from 'querystring';
 import readline from 'node:readline';
-import { EventEmitter as EventEmitter$4 } from 'node:events';
 import require$$0$b from 'zlib';
 import require$$0$c from 'buffer';
 import require$$1$1 from 'https';
@@ -32002,8 +32002,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-JW1Wr5se.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-AgYU8wIQ.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-ma2Y1b9q.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-go6jvlFO.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 const preprocessorWorkerControllerCache = new WeakMap();
 let alwaysFakeWorkerWorkerControllerCache;
@@ -46850,9 +46850,11 @@ const cachedFsUtilsMap = new WeakMap();
 function getFsUtils(config) {
     let fsUtils = cachedFsUtilsMap.get(config);
     if (!fsUtils) {
-        if (config.command !== 'serve' || !config.server.fs.cachedChecks) {
-            // cached fsUtils is only used in the dev server for now, and only when the watcher isn't configured
-            // we can support custom ignored patterns later
+        if (config.command !== 'serve' ||
+            config.server.fs.cachedChecks === false ||
+            config.server.watch?.ignored) {
+            // cached fsUtils is only used in the dev server for now
+            // it is enabled by default only when there aren't custom watcher ignored patterns configured
             fsUtils = commonFsUtils;
         }
         else if (!config.resolve.preserveSymlinks &&
@@ -46931,11 +46933,11 @@ function createCachedFsUtils(config) {
                     return;
                 }
                 if (nextDirentCache.type === 'directory_maybe_symlink') {
-                    dirPath ??= pathUntilPart(root, parts, i);
+                    dirPath ??= pathUntilPart(root, parts, i + 1);
                     const isSymlink = fs$l
                         .lstatSync(dirPath, { throwIfNoEntry: false })
                         ?.isSymbolicLink();
-                    direntCache.type = isSymlink ? 'symlink' : 'directory';
+                    nextDirentCache.type = isSymlink ? 'symlink' : 'directory';
                 }
                 direntCache = nextDirentCache;
             }
@@ -50935,15 +50937,16 @@ function orderedDependencies(deps) {
     return Object.fromEntries(depsList);
 }
 function globEntries(pattern, config) {
+    const rootPattern = glob.convertPathToPattern(config.root);
     return glob(pattern, {
         cwd: config.root,
         ignore: [
-            '**/node_modules/**',
-            `**/${config.build.outDir}/**`,
+            `${rootPattern}/**/node_modules/**`,
+            `${rootPattern}/**/${config.build.outDir}/**`,
             // if there aren't explicit entries, also ignore other common folders
             ...(config.optimizeDeps.entries
                 ? []
-                : [`**/__tests__/**`, `**/coverage/**`]),
+                : [`${rootPattern}/**/__tests__/**`, `${rootPattern}/**/coverage/**`]),
         ],
         absolute: true,
         suppressErrors: true, // suppress EACCES errors
@@ -53371,12 +53374,37 @@ function transformRequest(url, server, options = {}) {
 async function doTransform(url, server, options, timestamp) {
     url = removeTimestampQuery(url);
     const { config, pluginContainer } = server;
-    const prettyUrl = debugCache$1 ? prettifyUrl(url, config.root) : '';
     const ssr = !!options.ssr;
     if (ssr && isDepsOptimizerEnabled(config, true)) {
         await initDevSsrDepsOptimizer(config, server);
     }
-    const module = await server.moduleGraph.getModuleByUrl(url, ssr);
+    let module = await server.moduleGraph.getModuleByUrl(url, ssr);
+    if (module) {
+        // try use cache from url
+        const cached = await getCachedTransformResult(url, module, server, ssr, timestamp);
+        if (cached)
+            return cached;
+    }
+    const resolved = module
+        ? undefined
+        : (await pluginContainer.resolveId(url, undefined, { ssr })) ?? undefined;
+    // resolve
+    const id = module?.id ?? resolved?.id ?? url;
+    module ??= server.moduleGraph.getModuleById(id);
+    if (module) {
+        // if a different url maps to an existing loaded id,  make sure we relate this url to the id
+        await server.moduleGraph._ensureEntryFromUrl(url, ssr, undefined, resolved);
+        // try use cache from id
+        const cached = await getCachedTransformResult(url, module, server, ssr, timestamp);
+        if (cached)
+            return cached;
+    }
+    const result = loadAndTransform(id, url, server, options, timestamp, module, resolved);
+    getDepsOptimizer(config, ssr)?.delayDepsOptimizerUntil(id, () => result);
+    return result;
+}
+async function getCachedTransformResult(url, module, server, ssr, timestamp) {
+    const prettyUrl = debugCache$1 ? prettifyUrl(url, server.config.root) : '';
     // tries to handle soft invalidation of the module if available,
     // returns a boolean true is successful, or false if no handling is needed
     const softInvalidatedTransformResult = module &&
@@ -53391,14 +53419,6 @@ async function doTransform(url, server, options, timestamp) {
         debugCache$1?.(`[memory] ${prettyUrl}`);
         return cached;
     }
-    const resolved = module
-        ? undefined
-        : (await pluginContainer.resolveId(url, undefined, { ssr })) ?? undefined;
-    // resolve
-    const id = module?.id ?? resolved?.id ?? url;
-    const result = loadAndTransform(id, url, server, options, timestamp, module, resolved);
-    getDepsOptimizer(config, ssr)?.delayDepsOptimizerUntil(id, () => result);
-    return result;
 }
 async function loadAndTransform(id, url, server, options, timestamp, mod, resolved) {
     const { config, pluginContainer, moduleGraph } = server;
@@ -54456,12 +54476,12 @@ function ssrFixStacktrace(e, moduleGraph) {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-function
-const AsyncFunction = async function () { }.constructor;
-let fnDeclarationLineCount = 0;
+const AsyncFunction$1 = async function () { }.constructor;
+let fnDeclarationLineCount$1 = 0;
 {
     const body = '/*code*/';
-    const source = new AsyncFunction('a', 'b', body).toString();
-    fnDeclarationLineCount =
+    const source = new AsyncFunction$1('a', 'b', body).toString();
+    fnDeclarationLineCount$1 =
         source.slice(0, source.indexOf(body)).split('\n').length - 1;
 }
 const pendingModules = new Map();
@@ -54591,13 +54611,13 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
         const moduleSourceMap = Object.assign({}, result.map, {
             // currently we need to offset the line
             // https://github.com/nodejs/node/issues/43047#issuecomment-1180632750
-            mappings: ';'.repeat(fnDeclarationLineCount) + result.map.mappings,
+            mappings: ';'.repeat(fnDeclarationLineCount$1) + result.map.mappings,
         });
         sourceMapSuffix =
             '\n//# sourceMappingURL=' + genSourceMapUrl(moduleSourceMap);
     }
     try {
-        const initModule = new AsyncFunction(`global`, ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey, '"use strict";' +
+        const initModule = new AsyncFunction$1(`global`, ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey, '"use strict";' +
             result.code +
             `\n//# sourceURL=${mod.id}${sourceMapSuffix}`);
         await initModule(context.global, ssrModule, ssrImportMeta, ssrImport, ssrDynamicImport, ssrExportAll);
@@ -56027,6 +56047,12 @@ class NoopWatcher extends EventEmitter$4 {
     getWatched() {
         return {};
     }
+    ref() {
+        return this;
+    }
+    unref() {
+        return this;
+    }
     async close() {
         // noop
     }
@@ -56035,6 +56061,105 @@ function createNoopWatcher(options) {
     return new NoopWatcher(options);
 }
 
+/**
+ * Fetch module information for Vite runtime.
+ * @experimental
+ */
+async function fetchModule(server, url, importer, options = {}) {
+    // builtins should always be externalized
+    if (url.startsWith('data:') || isBuiltin(url)) {
+        return { externalize: url, type: 'builtin' };
+    }
+    if (isExternalUrl(url)) {
+        return { externalize: url, type: 'network' };
+    }
+    if (url[0] !== '.' && url[0] !== '/') {
+        const { isProduction, resolve: { dedupe, preserveSymlinks }, root, ssr, } = server.config;
+        const overrideConditions = ssr.resolve?.externalConditions || [];
+        const resolveOptions = {
+            mainFields: ['main'],
+            conditions: [],
+            overrideConditions: [...overrideConditions, 'production', 'development'],
+            extensions: ['.js', '.cjs', '.json'],
+            dedupe,
+            preserveSymlinks,
+            isBuild: false,
+            isProduction,
+            root,
+            ssrConfig: ssr,
+            legacyProxySsrExternalModules: server.config.legacy?.proxySsrExternalModules,
+            packageCache: server.config.packageCache,
+        };
+        const resolved = tryNodeResolve(url, importer, { ...resolveOptions, tryEsmOnly: true }, false, undefined, true);
+        if (!resolved) {
+            const err = new Error(`Cannot find module '${url}' imported from '${importer}'`);
+            err.code = 'ERR_MODULE_NOT_FOUND';
+            throw err;
+        }
+        const file = pathToFileURL(resolved.id).toString();
+        const type = isFilePathESM(file, server.config.packageCache)
+            ? 'module'
+            : 'commonjs';
+        return { externalize: file, type };
+    }
+    url = unwrapId(url);
+    let result = await server.transformRequest(url, { ssr: true });
+    if (!result) {
+        throw new Error(`[vite] transform failed for module '${url}'${importer ? ` imported from '${importer}'` : ''}.`);
+    }
+    // module entry should be created by transformRequest
+    const mod = await server.moduleGraph.getModuleByUrl(url, true);
+    if (!mod) {
+        throw new Error(`[vite] cannot find module '${url}' ${importer ? ` imported from '${importer}'` : ''}.`);
+    }
+    if (options.inlineSourceMap !== false) {
+        result = inlineSourceMap(mod, result, options.processSourceMap);
+    }
+    // remove shebang
+    if (result.code[0] === '#')
+        result.code = result.code.replace(/^#!.*/, (s) => ' '.repeat(s.length));
+    return { code: result.code, file: mod.file };
+}
+let SOURCEMAPPING_URL = 'sourceMa';
+SOURCEMAPPING_URL += 'ppingURL';
+const VITE_RUNTIME_SOURCEMAPPING_SOURCE = '//# sourceMappingSource=vite-runtime';
+const VITE_RUNTIME_SOURCEMAPPING_URL = `${SOURCEMAPPING_URL}=data:application/json;charset=utf-8`;
+function inlineSourceMap(mod, result, processSourceMap) {
+    const map = result.map;
+    let code = result.code;
+    if (!map ||
+        !('version' in map) ||
+        code.includes(VITE_RUNTIME_SOURCEMAPPING_SOURCE))
+        return result;
+    // to reduce the payload size, we only inline vite node source map, because it's also the only one we use
+    const OTHER_SOURCE_MAP_REGEXP = new RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json[^,]+base64,([A-Za-z0-9+/=]+)$`, 'gm');
+    while (OTHER_SOURCE_MAP_REGEXP.test(code))
+        code = code.replace(OTHER_SOURCE_MAP_REGEXP, '');
+    const sourceMap = Buffer.from(JSON.stringify(processSourceMap?.(map) || map), 'utf-8').toString('base64');
+    result.code = `${code.trimEnd()}\n//# sourceURL=${mod.id}\n${VITE_RUNTIME_SOURCEMAPPING_SOURCE}\n//# ${VITE_RUNTIME_SOURCEMAPPING_URL};base64,${sourceMap}\n`;
+    return result;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const AsyncFunction = async function () { }.constructor;
+const fnDeclarationLineCount = (() => {
+    const body = '/*code*/';
+    const source = new AsyncFunction('a', 'b', body).toString();
+    return source.slice(0, source.indexOf(body)).split('\n').length - 1;
+})();
+function ssrFetchModule(server, id, importer) {
+    return fetchModule(server, id, importer, {
+        processSourceMap(map) {
+            // this assumes that "new AsyncFunction" is used to create the module
+            return Object.assign({}, map, {
+                // currently we need to offset the line
+                // https://github.com/nodejs/node/issues/43047#issuecomment-1180632750
+                mappings: ';'.repeat(fnDeclarationLineCount) + map.mappings,
+            });
+        },
+    });
+}
+
 var bufferUtil$1 = {exports: {}};
 
 var constants = {
@@ -64027,7 +64152,9 @@ async function _createServer(inlineConfig = {}, options) {
         ? null
         : await resolveHttpServer(serverConfig, middlewares, httpsOptions);
     const ws = createWebSocketServer(httpServer, config, httpsOptions);
-    const hot = createHMRBroadcaster().addChannel(ws);
+    const hot = createHMRBroadcaster()
+        .addChannel(ws)
+        .addChannel(createServerHMRChannel());
     if (typeof config.server.hmr === 'object' && config.server.hmr.channels) {
         config.server.hmr.channels.forEach((channel) => hot.addChannel(channel));
     }
@@ -64086,6 +64213,9 @@ async function _createServer(inlineConfig = {}, options) {
         async ssrLoadModule(url, opts) {
             return ssrLoadModule(url, server, undefined, undefined, opts?.fixStacktrace);
         },
+        async ssrFetchModule(url, importer) {
+            return ssrFetchModule(server, url, importer);
+        },
         ssrFixStacktrace(e) {
             ssrFixStacktrace(e, moduleGraph);
         },
@@ -64493,7 +64623,7 @@ function resolveServerOptions(root, raw, logger) {
         strict: server.fs?.strict ?? true,
         allow: allowDirs,
         deny,
-        cachedChecks: server.fs?.cachedChecks ?? true,
+        cachedChecks: server.fs?.cachedChecks,
     };
     if (server.origin?.endsWith('/')) {
         server.origin = server.origin.slice(0, -1);
@@ -64687,6 +64817,9 @@ function updateModules(file, modules, timestamp, { config, hot, moduleGraph }, a
                 ? isExplicitImportRequired(acceptedVia.url)
                 : false,
             isWithinCircularImport,
+            // browser modules are invalidated by changing ?t= query,
+            // but in ssr we control the module system, so we can directly remove them form cache
+            ssrInvalidates: getSSRInvalidatedImporters(acceptedVia),
         })));
     }
     if (needFullReload) {
@@ -64710,6 +64843,24 @@ function updateModules(file, modules, timestamp, { config, hot, moduleGraph }, a
         updates,
     });
 }
+function populateSSRImporters(module, timestamp, seen) {
+    module.ssrImportedModules.forEach((importer) => {
+        if (seen.has(importer)) {
+            return;
+        }
+        if (importer.lastHMRTimestamp === timestamp ||
+            importer.lastInvalidationTimestamp === timestamp) {
+            seen.add(importer);
+            populateSSRImporters(importer, timestamp, seen);
+        }
+    });
+    return seen;
+}
+function getSSRInvalidatedImporters(module) {
+    return [
+        ...populateSSRImporters(module, module.lastHMRTimestamp, new Set()),
+    ].map((m) => m.file);
+}
 async function handleFileAddUnlink(file, server, isUnlink) {
     const modules = [...(server.moduleGraph.getModulesByFile(file) || [])];
     if (isUnlink) {
@@ -65094,6 +65245,44 @@ function createHMRBroadcaster() {
     };
     return broadcaster;
 }
+function createServerHMRChannel() {
+    const innerEmitter = new EventEmitter$4();
+    const outsideEmitter = new EventEmitter$4();
+    return {
+        name: 'ssr',
+        send(...args) {
+            let payload;
+            if (typeof args[0] === 'string') {
+                payload = {
+                    type: 'custom',
+                    event: args[0],
+                    data: args[1],
+                };
+            }
+            else {
+                payload = args[0];
+            }
+            outsideEmitter.emit('send', payload);
+        },
+        off(event, listener) {
+            innerEmitter.off(event, listener);
+        },
+        on: ((event, listener) => {
+            innerEmitter.on(event, listener);
+        }),
+        close() {
+            innerEmitter.removeAllListeners();
+            outsideEmitter.removeAllListeners();
+        },
+        listen() {
+            innerEmitter.emit('connection');
+        },
+        api: {
+            innerEmitter,
+            outsideEmitter,
+        },
+    };
+}
 
 const debug$1 = createDebugger('vite:import-analysis');
 const clientDir = normalizePath$3(CLIENT_DIR);
@@ -65101,18 +65290,11 @@ const skipRE = /\.(?:map|json)(?:$|\?)/;
 const canSkipImportAnalysis = (id) => skipRE.test(id) || isDirectCSSRequest(id);
 const optimizedDepChunkRE = /\/chunk-[A-Z\d]{8}\.js/;
 const optimizedDepDynamicRE = /-[A-Z\d]{8}\.js/;
-const hasImportInQueryParamsRE = /[?&]import=?\b/;
 const hasViteIgnoreRE = /\/\*\s*@vite-ignore\s*\*\//;
 const urlIsStringRE = /^(?:'.*'|".*"|`.*`)$/;
 const templateLiteralRE = /^\s*`(.*)`\s*$/;
 function isExplicitImportRequired(url) {
-    return !isJSRequest(cleanUrl(url)) && !isCSSRequest(url);
-}
-function markExplicitImport(url) {
-    if (isExplicitImportRequired(url)) {
-        return injectQuery(url, 'import');
-    }
-    return url;
+    return !isJSRequest(url) && !isCSSRequest(url);
 }
 function extractImportedBindings(id, source, importSpec, importedBindings) {
     let bindings = importedBindings.get(id);
@@ -65329,15 +65511,16 @@ function importAnalysisPlugin(config) {
                 // make the URL browser-valid if not SSR
                 if (!ssr) {
                     // mark non-js/css imports with `?import`
-                    url = markExplicitImport(url);
-                    // If the url isn't a request for a pre-bundled common chunk,
-                    // for relative js/css imports, or self-module virtual imports
-                    // (e.g. vue blocks), inherit importer's version query
-                    // do not do this for unknown type imports, otherwise the appended
-                    // query can break 3rd party plugin's extension checks.
-                    if ((isRelative || isSelfImport) &&
-                        !hasImportInQueryParamsRE.test(url) &&
+                    if (isExplicitImportRequired(url)) {
+                        url = injectQuery(url, 'import');
+                    }
+                    else if ((isRelative || isSelfImport) &&
                         !DEP_VERSION_RE.test(url)) {
+                        // If the url isn't a request for a pre-bundled common chunk,
+                        // for relative js/css imports, or self-module virtual imports
+                        // (e.g. vue blocks), inherit importer's version query
+                        // do not do this for unknown type imports, otherwise the appended
+                        // query can break 3rd party plugin's extension checks.
                         const versionMatch = importer.match(DEP_VERSION_RE);
                         if (versionMatch) {
                             url = injectQuery(url, versionMatch[1]);
@@ -67273,6 +67456,24 @@ const promisifiedRealpath = promisify$4(fs$l.realpath);
 function defineConfig(config) {
     return config;
 }
+/**
+ * Check and warn if `path` includes characters that don't work well in Vite,
+ * such as `#` and `?`.
+ */
+function checkBadCharactersInPath(path, logger) {
+    const badChars = [];
+    if (path.includes('#')) {
+        badChars.push('#');
+    }
+    if (path.includes('?')) {
+        badChars.push('?');
+    }
+    if (badChars.length > 0) {
+        const charString = badChars.map((c) => `"${c}"`).join(' and ');
+        const inflectedChars = badChars.length > 1 ? 'characters' : 'character';
+        logger.warn(colors$1.yellow(`The project root contains the ${charString} ${inflectedChars} (${colors$1.cyan(path)}), which may not work when running Vite. Consider renaming the directory to remove the characters.`));
+    }
+}
 async function resolveConfig(inlineConfig, command, defaultMode = 'development', defaultNodeEnv = 'development', isPreview = false) {
     let config = inlineConfig;
     let configFileDependencies = [];
@@ -67329,9 +67530,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
     });
     // resolve root
     const resolvedRoot = normalizePath$3(config.root ? path$o.resolve(config.root) : process.cwd());
-    if (resolvedRoot.includes('#')) {
-        logger.warn(colors$1.yellow(`The project root contains the "#" character (${colors$1.cyan(resolvedRoot)}), which may not work when running Vite. Consider renaming the directory to remove the "#".`));
-    }
+    checkBadCharactersInPath(resolvedRoot, logger);
     const clientAlias = [
         {
             find: /^\/?@vite\/env/,
@@ -67890,7 +68089,7 @@ function optimizeDepsDisabledBackwardCompatibility(resolved, optimizeDeps, optim
                 resolved.build.commonjsOptions.include = undefined;
             }
             resolved.logger.warn(colors$1.yellow(`(!) Experimental ${optimizeDepsPath}optimizeDeps.disabled and deps pre-bundling during build were removed in Vite 5.1.
-    To disable the deps optimizer, set ${optimizeDepsPath}optimizeDeps.noDiscovery to true and ${optimizeDepsPath}optimizeDeps.include as undefined or empty. 
+    To disable the deps optimizer, set ${optimizeDepsPath}optimizeDeps.noDiscovery to true and ${optimizeDepsPath}optimizeDeps.include as undefined or empty.
     Please remove ${optimizeDepsPath}optimizeDeps.disabled from your config.
     ${commonjsPluginDisabled
                 ? 'Empty config.build.commonjsOptions.include will be ignored to support CJS during build. This config should also be removed.'
@@ -67907,4 +68106,4 @@ function optimizeDepsDisabledBackwardCompatibility(resolved, optimizeDeps, optim
     }
 }
 
-export { getDefaultExportFromCjs as A, commonjsGlobal as B, index$1 as C, index as D, build$1 as E, preview$1 as F, arraify as a, build as b, createServer as c, defineConfig as d, preprocessCSS as e, formatPostcssSourceMap as f, buildErrorMessage as g, mergeAlias as h, isInNodeModules$1 as i, createFilter as j, rollupVersion as k, loadConfigFromFile as l, mergeConfig as m, normalizePath$3 as n, optimizeDeps as o, preview as p, send as q, resolveConfig as r, sortUserPlugins as s, transformWithEsbuild as t, createLogger as u, searchForWorkspaceRoot as v, isFileServingAllowed as w, loadEnv as x, resolveEnvPrefix as y, colors$1 as z };
+export { resolveEnvPrefix as A, getDefaultExportFromCjs as B, commonjsGlobal as C, index$1 as D, index as E, build$1 as F, preview$1 as G, createLogger as a, arraify as b, colors$1 as c, defineConfig as d, createServer as e, build as f, formatPostcssSourceMap as g, preprocessCSS as h, isInNodeModules$1 as i, buildErrorMessage as j, fetchModule as k, loadConfigFromFile as l, mergeConfig as m, normalizePath$3 as n, optimizeDeps as o, preview as p, mergeAlias as q, resolveConfig as r, sortUserPlugins as s, transformWithEsbuild as t, createFilter as u, rollupVersion as v, send as w, searchForWorkspaceRoot as x, isFileServingAllowed as y, loadEnv as z };

package/dist/node/chunks/{dep-AgYU8wIQ.js → dep-go6jvlFO.js}

@@ -1,4 +1,4 @@
-import { B as commonjsGlobal, A as getDefaultExportFromCjs } from './dep-Y86Adl1p.js';
+import { C as commonjsGlobal, B as getDefaultExportFromCjs } from './dep-G1t0FnMB.js';
 import require$$0__default from 'fs';
 import require$$0 from 'postcss';
 import require$$0$1 from 'path';

package/dist/node/chunks/{dep-JW1Wr5se.js → dep-ma2Y1b9q.js}

@@ -1,4 +1,4 @@
-import { A as getDefaultExportFromCjs } from './dep-Y86Adl1p.js';
+import { B as getDefaultExportFromCjs } from './dep-G1t0FnMB.js';
 import require$$0 from 'path';
 import require$$0__default from 'fs';
 import { l as lib } from './dep-8a-6Quh6.js';

package/dist/node/cli.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { performance } from 'node:perf_hooks';
 import { EventEmitter } from 'events';
-import { z as colors, u as createLogger, r as resolveConfig } from './chunks/dep-Y86Adl1p.js';
+import { c as colors, a as createLogger, r as resolveConfig } from './chunks/dep-G1t0FnMB.js';
 import { VERSION } from './constants.js';
 import 'node:fs/promises';
 import 'node:url';
@@ -32,10 +32,10 @@ import 'node:assert';
 import 'node:v8';
 import 'node:worker_threads';
 import 'node:buffer';
+import 'node:events';
 import 'rollup/parseAst';
 import 'querystring';
 import 'node:readline';
-import 'node:events';
 import 'zlib';
 import 'buffer';
 import 'https';
@@ -757,7 +757,7 @@ cli
     filterDuplicateOptions(options);
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await import('./chunks/dep-Y86Adl1p.js').then(function (n) { return n.D; });
+    const { createServer } = await import('./chunks/dep-G1t0FnMB.js').then(function (n) { return n.E; });
     try {
         const server = await createServer({
             root,
@@ -837,7 +837,7 @@ cli
     .option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { build } = await import('./chunks/dep-Y86Adl1p.js').then(function (n) { return n.E; });
+    const { build } = await import('./chunks/dep-G1t0FnMB.js').then(function (n) { return n.F; });
     const buildOptions = cleanOptions(options);
     try {
         await build({
@@ -865,7 +865,7 @@ cli
     .option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { optimizeDeps } = await import('./chunks/dep-Y86Adl1p.js').then(function (n) { return n.C; });
+    const { optimizeDeps } = await import('./chunks/dep-G1t0FnMB.js').then(function (n) { return n.D; });
     try {
         const config = await resolveConfig({
             root,
@@ -891,7 +891,7 @@ cli
     .option('--outDir <dir>', `[string] output directory (default: dist)`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { preview } = await import('./chunks/dep-Y86Adl1p.js').then(function (n) { return n.F; });
+    const { preview } = await import('./chunks/dep-G1t0FnMB.js').then(function (n) { return n.G; });
     try {
         const server = await preview({
             root,