vite 3.0.0-alpha.2 → 3.0.0-alpha.5

package/dist/node/optimizer/index.d.ts

@@ -1,14 +1,21 @@
 import type { BuildOptions as EsbuildBuildOptions } from 'esbuild';
 import { parse } from 'es-module-lexer';
 import type { ResolvedConfig } from '../config';
+export { initDepsOptimizer, getDepsOptimizer } from './optimizer';
 export declare const debuggerViteDeps: (...args: any[]) => any;
 export declare type ExportsData = ReturnType<typeof parse> & {
     hasReExports?: true;
+    jsxLoader?: true;
 };
-export interface OptimizedDeps {
+export interface DepsOptimizer {
     metadata: DepOptimizationMetadata;
     scanProcessing?: Promise<void>;
     registerMissingImport: (id: string, resolved: string) => OptimizedDepInfo;
+    run: () => void;
+    isOptimizedDepFile: (id: string) => boolean;
+    isOptimizedDepUrl: (url: string) => boolean;
+    getOptimizedDepId: (depInfo: OptimizedDepInfo) => string;
+    options: DepOptimizationOptions;
 }
 export interface DepOptimizationOptions {
     /**
@@ -32,6 +39,12 @@ export interface DepOptimizationOptions {
      * cannot be globs).
      */
     exclude?: string[];
+    /**
+     * Force ESM interop when importing for these dependencies. Some legacy
+     * packages advertise themselves as ESM but use `require` internally
+     * @experimental
+     */
+    needsInterop?: string[];
     /**
      * Options to pass to esbuild during the dep scanning and optimization
      *
@@ -55,11 +68,13 @@ export interface DepOptimizationOptions {
      */
     extensions?: string[];
     /**
-     * Disables dependencies optimizations
+     * Disables dependencies optimizations, true disables the optimizer during
+     * build and dev. Pass 'build' or 'dev' to only disable the optimizer in
+     * one of the modes. Deps optimization is enabled by default in both
      * @default false
      * @experimental
      */
-    disabled?: boolean;
+    disabled?: boolean | 'build' | 'dev';
 }
 export interface DepOptimizationResult {
     metadata: DepOptimizationMetadata;
@@ -87,6 +102,11 @@ export interface OptimizedDepInfo {
      * but the bundles may not yet be saved to disk
      */
     processing?: Promise<void>;
+    /**
+     * ExportData cache, discovered deps will parse the src entry to get exports
+     * data used both to define if interop is needed and when pre-bundling
+     */
+    exportsData?: Promise<ExportsData>;
 }
 export interface DepOptimizationMetadata {
     /**
@@ -121,7 +141,7 @@ export interface DepOptimizationMetadata {
  * Used by Vite CLI when running `vite optimize`
  */
 export declare function optimizeDeps(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
-export declare function createOptimizedDepsMetadata(config: ResolvedConfig, timestamp?: string): DepOptimizationMetadata;
+export declare function initDepsOptimizerMetadata(config: ResolvedConfig, timestamp?: string): DepOptimizationMetadata;
 export declare function addOptimizedDepInfo(metadata: DepOptimizationMetadata, type: 'optimized' | 'discovered' | 'chunks', depInfo: OptimizedDepInfo): OptimizedDepInfo;
 /**
  * Creates the initial dep optimization metadata, loading it from the deps cache
@@ -133,12 +153,18 @@ export declare function loadCachedDepOptimizationMetadata(config: ResolvedConfig
  * find deps to pre-bundle and include user hard-coded dependencies
  */
 export declare function discoverProjectDependencies(config: ResolvedConfig, timestamp?: string): Promise<Record<string, OptimizedDepInfo>>;
+/**
+ * Create the initial discovered deps list. At build time we only
+ * have the manually included deps. During dev, a scan phase is
+ * performed and knownDeps is the list of discovered deps
+ */
+export declare function initialProjectDependencies(config: ResolvedConfig, timestamp?: string, knownDeps?: Record<string, string>): Promise<Record<string, OptimizedDepInfo>>;
 export declare function depsLogString(qualifiedIds: string[]): string;
 /**
  * Internally, Vite uses this function to prepare a optimizeDeps run. When Vite starts, we can get
  * the metadata and start the server without waiting for the optimizeDeps processing to be completed
  */
-export declare function runOptimizeDeps(config: ResolvedConfig, depsInfo: Record<string, OptimizedDepInfo>): Promise<DepOptimizationResult>;
+export declare function runOptimizeDeps(resolvedConfig: ResolvedConfig, depsInfo: Record<string, OptimizedDepInfo>): Promise<DepOptimizationResult>;
 export declare function findKnownImports(config: ResolvedConfig): Promise<string[]>;
 export declare function newDepOptimizationProcessing(): DepOptimizationProcessing;
 export declare function depsFromOptimizedDepInfo(depsInfo: Record<string, OptimizedDepInfo>): {
@@ -148,7 +174,8 @@ export declare function getOptimizedDepPath(id: string, config: ResolvedConfig):
 export declare function getDepsCacheDir(config: ResolvedConfig): string;
 export declare function isOptimizedDepFile(id: string, config: ResolvedConfig): boolean;
 export declare function createIsOptimizedDepUrl(config: ResolvedConfig): (url: string) => boolean;
+export declare function extractExportsData(filePath: string, config: ResolvedConfig): Promise<ExportsData>;
 export declare function getDepHash(config: ResolvedConfig): string;
 export declare function optimizedDepInfoFromId(metadata: DepOptimizationMetadata, id: string): OptimizedDepInfo | undefined;
 export declare function optimizedDepInfoFromFile(metadata: DepOptimizationMetadata, file: string): OptimizedDepInfo | undefined;
-export declare function optimizedDepNeedsInterop(metadata: DepOptimizationMetadata, file: string): Promise<boolean | undefined>;
+export declare function optimizedDepNeedsInterop(metadata: DepOptimizationMetadata, file: string, config: ResolvedConfig): Promise<boolean | undefined>;

package/dist/node/optimizer/optimizer.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedConfig, ViteDevServer } from '..';
+import type { DepsOptimizer } from '.';
+export declare function getDepsOptimizer(config: ResolvedConfig): DepsOptimizer | undefined;
+export declare function initDepsOptimizer(config: ResolvedConfig, server?: ViteDevServer): Promise<DepsOptimizer>;

package/dist/node/plugin.d.ts

@@ -1,4 +1,5 @@
 import type { CustomPluginOptions, LoadResult, PluginContext, ResolveIdResult, Plugin as RollupPlugin, TransformPluginContext, TransformResult } from 'rollup';
+export type { PluginContext } from 'rollup';
 import type { UserConfig } from './config';
 import type { ServerHook } from './server';
 import type { IndexHtmlTransform } from './plugins/html';

package/dist/node/plugins/optimizedDeps.d.ts

@@ -1,4 +1,7 @@
+import type { ResolvedConfig } from '..';
 import type { Plugin } from '../plugin';
 export declare const ERR_OPTIMIZE_DEPS_PROCESSING_ERROR = "ERR_OPTIMIZE_DEPS_PROCESSING_ERROR";
 export declare const ERR_OUTDATED_OPTIMIZED_DEP = "ERR_OUTDATED_OPTIMIZED_DEP";
-export declare function optimizedDepsPlugin(): Plugin;
+export declare function registerWorkersSource(config: ResolvedConfig, id: string): void;
+export declare function optimizedDepsPlugin(config: ResolvedConfig): Plugin;
+export declare function optimizedDepsBuildPlugin(config: ResolvedConfig): Plugin;

package/dist/node/plugins/preAlias.d.ts

@@ -1,5 +1,6 @@
+import type { ResolvedConfig } from '..';
 import type { Plugin } from '../plugin';
 /**
  * A plugin to avoid an aliased AND optimized dep from being aliased in src
  */
-export declare function preAliasPlugin(): Plugin;
+export declare function preAliasPlugin(config: ResolvedConfig): Plugin;

package/dist/node/plugins/resolve.d.ts

@@ -1,6 +1,7 @@
 import type { PartialResolvedId } from 'rollup';
 import type { Plugin } from '../plugin';
-import type { SSROptions, ViteDevServer } from '..';
+import type { DepsOptimizer } from '../optimizer';
+import type { SSROptions } from '..';
 import type { PackageCache, PackageData } from '../packages';
 export declare const browserExternalId = "__vite-browser-external";
 export interface ResolveOptions {
@@ -31,9 +32,10 @@ export interface InternalResolveOptions extends ResolveOptions {
     isFromTsImporter?: boolean;
     tryEsmOnly?: boolean;
     scan?: boolean;
+    getDepsOptimizer?: () => DepsOptimizer | undefined;
 }
 export declare function resolvePlugin(baseOptions: InternalResolveOptions): Plugin;
 export declare const idToPkgMap: Map<string, PackageData>;
-export declare function tryNodeResolve(id: string, importer: string | null | undefined, options: InternalResolveOptions, targetWeb: boolean, server?: ViteDevServer, ssr?: boolean): PartialResolvedId | undefined;
-export declare function tryOptimizedResolve(id: string, server: ViteDevServer, importer?: string): Promise<string | undefined>;
+export declare function tryNodeResolve(id: string, importer: string | null | undefined, options: InternalResolveOptions, targetWeb: boolean, depsOptimizer?: DepsOptimizer, ssr?: boolean): PartialResolvedId | undefined;
+export declare function tryOptimizedResolve(depsOptimizer: DepsOptimizer, id: string, importer?: string): Promise<string | undefined>;
 export declare function resolvePackageEntry(id: string, { dir, data, setResolvedCache, getResolvedCache }: PackageData, targetWeb: boolean, options: InternalResolveOptions): string | undefined;

package/dist/node/publicUtils.d.ts

@@ -8,3 +8,4 @@ export { normalizePath, mergeConfig, mergeAlias } from './utils';
 export { send } from './server/send';
 export { createLogger } from './logger';
 export { searchForWorkspaceRoot } from './server/searchRoot';
+export { loadEnv, resolveEnvPrefix } from './env';

package/dist/node/server/index.d.ts

@@ -5,7 +5,6 @@ import type { Connect } from 'types/connect';
 import type { SourceMap } from 'rollup';
 import type { CommonServerOptions } from '../http';
 import type { InlineConfig, ResolvedConfig } from '../config';
-import type { OptimizedDeps } from '../optimizer';
 import type { Logger } from '../logger';
 import type { PluginContainer } from './pluginContainer';
 import type { WebSocketServer } from './ws';
@@ -14,10 +13,6 @@ import type { HmrOptions } from './hmr';
 import type { TransformOptions, TransformResult } from './transformRequest';
 export { searchForWorkspaceRoot } from './searchRoot';
 export interface ServerOptions extends CommonServerOptions {
-    /**
-     * Force dep pre-optimization regardless of whether deps have changed.
-     */
-    force?: boolean;
     /**
      * Configure HMR-specific options (port, host, path & protocol)
      */
@@ -164,10 +159,6 @@ export interface ViteDevServer {
      * @param forceOptimize - force the optimizer to re-bundle, same as --force cli flag
      */
     restart(forceOptimize?: boolean): Promise<void>;
-    /**
-     * @internal
-     */
-    _optimizedDeps: OptimizedDeps | null;
     /**
      * @internal
      */

package/dist/node/utils.d.ts

@@ -102,8 +102,7 @@ export declare function isFileReadable(filename: string): boolean;
  */
 export declare function emptyDir(dir: string, skip?: string[]): void;
 export declare function copyDir(srcDir: string, destDir: string): void;
-export declare function removeDirSync(dir: string): void;
-export declare const removeDir: typeof removeDirSync;
+export declare const removeDir: (dir: string) => void;
 export declare const renameDir: ((arg1: string, arg2: string) => Promise<void>) | typeof fs.renameSync;
 export declare function ensureWatchedFile(watcher: FSWatcher, file: string | null, root: string): void;
 interface ImageCandidate {

package/dist/node-cjs/publicUtils.cjs

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var fs = require('fs');
-var os = require('os');
-var path = require('path');
+var fs$1 = require('fs');
+var os$1 = require('os');
+var path$1 = require('path');
 var require$$1 = require('util');
 var module$1 = require('module');
 var require$$0 = require('tty');
@@ -14,9 +14,9 @@ var readline = require('readline');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
 
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$1);
+var os__default = /*#__PURE__*/_interopDefaultLegacy(os$1);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path$1);
 var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
 var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
 var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
@@ -136,17 +136,6 @@ for (let i = 0; i < chars.length; i++) {
     charToInt[c] = i;
 }
 
-Object.freeze({
-    source: null,
-    line: null,
-    column: null,
-    name: null,
-});
-Object.freeze({
-    line: null,
-    column: null,
-});
-
 var picocolors = {exports: {}};
 
 let tty = require$$0__default;
@@ -243,7 +232,7 @@ var ms = function(val, options) {
   options = options || {};
   var type = typeof val;
   if (type === 'string' && val.length > 0) {
-    return parse(val);
+    return parse$1(val);
   } else if (type === 'number' && isFinite(val)) {
     return options.long ? fmtLong(val) : fmtShort(val);
   }
@@ -261,7 +250,7 @@ var ms = function(val, options) {
  * @api private
  */
 
-function parse(str) {
+function parse$1(str) {
   str = String(str);
   if (str.length > 100) {
     return;
@@ -1204,9 +1193,9 @@ if (typeof process === 'undefined' || process.type === 'renderer' || process.bro
 
 var debug = src.exports;
 
-const VITE_PACKAGE_DIR = path.resolve(url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))), '../../..');
-const CLIENT_ENTRY = path.resolve(VITE_PACKAGE_DIR, 'dist/client/client.mjs');
-path.resolve(VITE_PACKAGE_DIR, 'dist/client/env.mjs');
+const VITE_PACKAGE_DIR = path$1.resolve(url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))), '../../..');
+const CLIENT_ENTRY = path$1.resolve(VITE_PACKAGE_DIR, 'dist/client/client.mjs');
+path$1.resolve(VITE_PACKAGE_DIR, 'dist/client/env.mjs');
 path__default.dirname(CLIENT_ENTRY);
 
 function slash(p) {
@@ -1253,6 +1242,19 @@ function normalizePath(id) {
 function isObject(value) {
     return Object.prototype.toString.call(value) === '[object Object]';
 }
+function lookupFile(dir, formats, options) {
+    for (const format of formats) {
+        const fullPath = path__default.join(dir, format);
+        if (fs__default.existsSync(fullPath) && fs__default.statSync(fullPath).isFile()) {
+            return options?.pathOnly ? fullPath : fs__default.readFileSync(fullPath, 'utf-8');
+        }
+    }
+    const parentDir = path__default.dirname(dir);
+    if (parentDir !== dir &&
+        (!options?.rootDir || parentDir.startsWith(options?.rootDir))) {
+        return lookupFile(parentDir, formats, options);
+    }
+}
 /**
  * Use instead of fs.existsSync(filename)
  * #2051 if we don't have read permission on a directory, existsSync() still
@@ -1268,15 +1270,11 @@ function isFileReadable(filename) {
         return false;
     }
 }
-function removeDirSync(dir) {
-    if (fs__default.existsSync(dir)) {
-        const rmSync = fs__default.rmSync ?? fs__default.rmdirSync; // TODO: Remove after support for Node 12 is dropped
-        rmSync(dir, { recursive: true });
-    }
-}
 isWindows
     ? require$$1.promisify(gracefulRemoveDir)
-    : removeDirSync;
+    : function removeDirSync(dir) {
+        fs__default.rmSync(dir, { recursive: true, force: true });
+    };
 isWindows ? require$$1.promisify(gracefulRename) : fs__default.renameSync;
 function arraify(target) {
     return Array.isArray(target) ? target : [target];
@@ -1329,17 +1327,16 @@ function gracefulRename(from, to, cb) {
 }
 const GRACEFUL_REMOVE_DIR_TIMEOUT = 5000;
 function gracefulRemoveDir(dir, cb) {
-    const rmdir = fs__default.rm ?? fs__default.rmdir; // TODO: Remove after support for Node 12 is dropped
     const start = Date.now();
     let backoff = 0;
-    rmdir(dir, { recursive: true }, function CB(er) {
+    fs__default.rm(dir, { recursive: true }, function CB(er) {
         if (er) {
             if ((er.code === 'ENOTEMPTY' ||
                 er.code === 'EACCES' ||
                 er.code === 'EPERM') &&
                 Date.now() - start < GRACEFUL_REMOVE_DIR_TIMEOUT) {
                 setTimeout(function () {
-                    rmdir(dir, { recursive: true }, CB);
+                    fs__default.rm(dir, { recursive: true }, CB);
                 }, backoff);
                 if (backoff < 100)
                     backoff += 10;
@@ -1737,19 +1734,19 @@ const ROOT_FILES = [
 // npm: https://docs.npmjs.com/cli/v7/using-npm/workspaces#installing-workspaces
 // yarn: https://classic.yarnpkg.com/en/docs/workspaces/#toc-how-to-use-it
 function hasWorkspacePackageJSON(root) {
-    const path$1 = path.join(root, 'package.json');
-    if (!isFileReadable(path$1)) {
+    const path = path$1.join(root, 'package.json');
+    if (!isFileReadable(path)) {
         return false;
     }
-    const content = JSON.parse(fs__default.readFileSync(path$1, 'utf-8')) || {};
+    const content = JSON.parse(fs__default.readFileSync(path, 'utf-8')) || {};
     return !!content.workspaces;
 }
 function hasRootFile(root) {
-    return ROOT_FILES.some((file) => fs__default.existsSync(path.join(root, file)));
+    return ROOT_FILES.some((file) => fs__default.existsSync(path$1.join(root, file)));
 }
 function hasPackageJSON(root) {
-    const path$1 = path.join(root, 'package.json');
-    return fs__default.existsSync(path$1);
+    const path = path$1.join(root, 'package.json');
+    return fs__default.existsSync(path);
 }
 /**
  * Search up for the nearest `package.json`
@@ -1757,7 +1754,7 @@ function hasPackageJSON(root) {
 function searchForPackageRoot(current, root = current) {
     if (hasPackageJSON(current))
         return current;
-    const dir = path.dirname(current);
+    const dir = path$1.dirname(current);
     // reach the fs root
     if (!dir || dir === current)
         return root;
@@ -1771,17 +1768,268 @@ function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
         return current;
     if (hasWorkspacePackageJSON(current))
         return current;
-    const dir = path.dirname(current);
+    const dir = path$1.dirname(current);
     // reach the fs root
     if (!dir || dir === current)
         return root;
     return searchForWorkspaceRoot(dir, root);
 }
 
+var main$1 = {exports: {}};
+
+const fs = fs__default;
+const path = path__default;
+const os = os__default;
+
+function log (message) {
+  console.log(`[dotenv][DEBUG] ${message}`);
+}
+
+const NEWLINE = '\n';
+const RE_INI_KEY_VAL = /^\s*([\w.-]+)\s*=\s*("[^"]*"|'[^']*'|.*?)(\s+#.*)?$/;
+const RE_NEWLINES = /\\n/g;
+const NEWLINES_MATCH = /\r\n|\n|\r/;
+
+// Parses src into an Object
+function parse (src, options) {
+  const debug = Boolean(options && options.debug);
+  const multiline = Boolean(options && options.multiline);
+  const obj = {};
+
+  // convert Buffers before splitting into lines and processing
+  const lines = src.toString().split(NEWLINES_MATCH);
+
+  for (let idx = 0; idx < lines.length; idx++) {
+    let line = lines[idx];
+
+    // matching "KEY' and 'VAL' in 'KEY=VAL'
+    const keyValueArr = line.match(RE_INI_KEY_VAL);
+    // matched?
+    if (keyValueArr != null) {
+      const key = keyValueArr[1];
+      // default undefined or missing values to empty string
+      let val = (keyValueArr[2] || '');
+      let end = val.length - 1;
+      const isDoubleQuoted = val[0] === '"' && val[end] === '"';
+      const isSingleQuoted = val[0] === "'" && val[end] === "'";
+
+      const isMultilineDoubleQuoted = val[0] === '"' && val[end] !== '"';
+      const isMultilineSingleQuoted = val[0] === "'" && val[end] !== "'";
+
+      // if parsing line breaks and the value starts with a quote
+      if (multiline && (isMultilineDoubleQuoted || isMultilineSingleQuoted)) {
+        const quoteChar = isMultilineDoubleQuoted ? '"' : "'";
+
+        val = val.substring(1);
+
+        while (idx++ < lines.length - 1) {
+          line = lines[idx];
+          end = line.length - 1;
+          if (line[end] === quoteChar) {
+            val += NEWLINE + line.substring(0, end);
+            break
+          }
+          val += NEWLINE + line;
+        }
+      // if single or double quoted, remove quotes
+      } else if (isSingleQuoted || isDoubleQuoted) {
+        val = val.substring(1, end);
+
+        // if double quoted, expand newlines
+        if (isDoubleQuoted) {
+          val = val.replace(RE_NEWLINES, NEWLINE);
+        }
+      } else {
+        // remove surrounding whitespace
+        val = val.trim();
+      }
+
+      obj[key] = val;
+    } else if (debug) {
+      const trimmedLine = line.trim();
+
+      // ignore empty and commented lines
+      if (trimmedLine.length && trimmedLine[0] !== '#') {
+        log(`Failed to match key and value when parsing line ${idx + 1}: ${line}`);
+      }
+    }
+  }
+
+  return obj
+}
+
+function resolveHome (envPath) {
+  return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath
+}
+
+// Populates process.env from .env file
+function config (options) {
+  let dotenvPath = path.resolve(process.cwd(), '.env');
+  let encoding = 'utf8';
+  const debug = Boolean(options && options.debug);
+  const override = Boolean(options && options.override);
+  const multiline = Boolean(options && options.multiline);
+
+  if (options) {
+    if (options.path != null) {
+      dotenvPath = resolveHome(options.path);
+    }
+    if (options.encoding != null) {
+      encoding = options.encoding;
+    }
+  }
+
+  try {
+    // specifying an encoding returns a string instead of a buffer
+    const parsed = DotenvModule.parse(fs.readFileSync(dotenvPath, { encoding }), { debug, multiline });
+
+    Object.keys(parsed).forEach(function (key) {
+      if (!Object.prototype.hasOwnProperty.call(process.env, key)) {
+        process.env[key] = parsed[key];
+      } else {
+        if (override === true) {
+          process.env[key] = parsed[key];
+        }
+
+        if (debug) {
+          if (override === true) {
+            log(`"${key}" is already defined in \`process.env\` and WAS overwritten`);
+          } else {
+            log(`"${key}" is already defined in \`process.env\` and was NOT overwritten`);
+          }
+        }
+      }
+    });
+
+    return { parsed }
+  } catch (e) {
+    if (debug) {
+      log(`Failed to load ${dotenvPath} ${e.message}`);
+    }
+
+    return { error: e }
+  }
+}
+
+const DotenvModule = {
+  config,
+  parse
+};
+
+main$1.exports.config = DotenvModule.config;
+main$1.exports.parse = DotenvModule.parse;
+main$1.exports = DotenvModule;
+
+var dotenv = main$1.exports;
+
+var dotenvExpand = function (config) {
+  // if ignoring process.env, use a blank object
+  var environment = config.ignoreProcessEnv ? {} : process.env;
+
+  var interpolate = function (envValue) {
+    var matches = envValue.match(/(.?\${?(?:[a-zA-Z0-9_]+)?}?)/g) || [];
+
+    return matches.reduce(function (newEnv, match) {
+      var parts = /(.?)\${?([a-zA-Z0-9_]+)?}?/g.exec(match);
+      var prefix = parts[1];
+
+      var value, replacePart;
+
+      if (prefix === '\\') {
+        replacePart = parts[0];
+        value = replacePart.replace('\\$', '$');
+      } else {
+        var key = parts[2];
+        replacePart = parts[0].substring(prefix.length);
+        // process.env value 'wins' over .env file's value
+        value = environment.hasOwnProperty(key) ? environment[key] : (config.parsed[key] || '');
+
+        // Resolve recursive interpolations
+        value = interpolate(value);
+      }
+
+      return newEnv.replace(replacePart, value)
+    }, envValue)
+  };
+
+  for (var configKey in config.parsed) {
+    var value = environment.hasOwnProperty(configKey) ? environment[configKey] : config.parsed[configKey];
+
+    config.parsed[configKey] = interpolate(value);
+  }
+
+  for (var processKey in config.parsed) {
+    environment[processKey] = config.parsed[processKey];
+  }
+
+  return config
+};
+
+var main = dotenvExpand;
+
+function loadEnv(mode, envDir, prefixes = 'VITE_') {
+    if (mode === 'local') {
+        throw new Error(`"local" cannot be used as a mode name because it conflicts with ` +
+            `the .local postfix for .env files.`);
+    }
+    prefixes = arraify(prefixes);
+    const env = {};
+    const envFiles = [
+        /** mode local file */ `.env.${mode}.local`,
+        /** mode file */ `.env.${mode}`,
+        /** local file */ `.env.local`,
+        /** default file */ `.env`
+    ];
+    // check if there are actual env variables starting with VITE_*
+    // these are typically provided inline and should be prioritized
+    for (const key in process.env) {
+        if (prefixes.some((prefix) => key.startsWith(prefix)) &&
+            env[key] === undefined) {
+            env[key] = process.env[key];
+        }
+    }
+    for (const file of envFiles) {
+        const path = lookupFile(envDir, [file], { pathOnly: true, rootDir: envDir });
+        if (path) {
+            const parsed = dotenv.parse(fs__default.readFileSync(path), {
+                debug: process.env.DEBUG?.includes('vite:dotenv') || undefined
+            });
+            // let environment variables use each other
+            main({
+                parsed,
+                // prevent process.env mutation
+                ignoreProcessEnv: true
+            });
+            // only keys that start with prefix are exposed to client
+            for (const [key, value] of Object.entries(parsed)) {
+                if (prefixes.some((prefix) => key.startsWith(prefix)) &&
+                    env[key] === undefined) {
+                    env[key] = value;
+                }
+                else if (key === 'NODE_ENV' &&
+                    process.env.VITE_USER_NODE_ENV === undefined) {
+                    // NODE_ENV override in .env file
+                    process.env.VITE_USER_NODE_ENV = value;
+                }
+            }
+        }
+    }
+    return env;
+}
+function resolveEnvPrefix({ envPrefix = 'VITE_' }) {
+    envPrefix = arraify(envPrefix);
+    if (envPrefix.some((prefix) => prefix === '')) {
+        throw new Error(`envPrefix option contains value '', which could lead unexpected exposure of sensitive information.`);
+    }
+    return envPrefix;
+}
+
 exports.createLogger = createLogger;
+exports.loadEnv = loadEnv;
 exports.mergeAlias = mergeAlias;
 exports.mergeConfig = mergeConfig;
 exports.normalizePath = normalizePath;
+exports.resolveEnvPrefix = resolveEnvPrefix;
 exports.searchForWorkspaceRoot = searchForWorkspaceRoot;
 exports.send = send;
 exports.splitVendorChunk = splitVendorChunk;