vite 5.1.0-beta.5 → 5.1.0-beta.6

package/dist/node/runtime.js

@@ -0,0 +1,1614 @@
+class HMRContext {
+    hmrClient;
+    ownerPath;
+    newListeners;
+    constructor(hmrClient, ownerPath) {
+        this.hmrClient = hmrClient;
+        this.ownerPath = ownerPath;
+        if (!hmrClient.dataMap.has(ownerPath)) {
+            hmrClient.dataMap.set(ownerPath, {});
+        }
+        // when a file is hot updated, a new context is created
+        // clear its stale callbacks
+        const mod = hmrClient.hotModulesMap.get(ownerPath);
+        if (mod) {
+            mod.callbacks = [];
+        }
+        // clear stale custom event listeners
+        const staleListeners = hmrClient.ctxToListenersMap.get(ownerPath);
+        if (staleListeners) {
+            for (const [event, staleFns] of staleListeners) {
+                const listeners = hmrClient.customListenersMap.get(event);
+                if (listeners) {
+                    hmrClient.customListenersMap.set(event, listeners.filter((l) => !staleFns.includes(l)));
+                }
+            }
+        }
+        this.newListeners = new Map();
+        hmrClient.ctxToListenersMap.set(ownerPath, this.newListeners);
+    }
+    get data() {
+        return this.hmrClient.dataMap.get(this.ownerPath);
+    }
+    accept(deps, callback) {
+        if (typeof deps === 'function' || !deps) {
+            // self-accept: hot.accept(() => {})
+            this.acceptDeps([this.ownerPath], ([mod]) => deps?.(mod));
+        }
+        else if (typeof deps === 'string') {
+            // explicit deps
+            this.acceptDeps([deps], ([mod]) => callback?.(mod));
+        }
+        else if (Array.isArray(deps)) {
+            this.acceptDeps(deps, callback);
+        }
+        else {
+            throw new Error(`invalid hot.accept() usage.`);
+        }
+    }
+    // export names (first arg) are irrelevant on the client side, they're
+    // extracted in the server for propagation
+    acceptExports(_, callback) {
+        this.acceptDeps([this.ownerPath], ([mod]) => callback?.(mod));
+    }
+    dispose(cb) {
+        this.hmrClient.disposeMap.set(this.ownerPath, cb);
+    }
+    prune(cb) {
+        this.hmrClient.pruneMap.set(this.ownerPath, cb);
+    }
+    // Kept for backward compatibility (#11036)
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    decline() { }
+    invalidate(message) {
+        this.hmrClient.notifyListeners('vite:invalidate', {
+            path: this.ownerPath,
+            message,
+        });
+        this.send('vite:invalidate', { path: this.ownerPath, message });
+        this.hmrClient.logger.debug(`[vite] invalidate ${this.ownerPath}${message ? `: ${message}` : ''}`);
+    }
+    on(event, cb) {
+        const addToMap = (map) => {
+            const existing = map.get(event) || [];
+            existing.push(cb);
+            map.set(event, existing);
+        };
+        addToMap(this.hmrClient.customListenersMap);
+        addToMap(this.newListeners);
+    }
+    off(event, cb) {
+        const removeFromMap = (map) => {
+            const existing = map.get(event);
+            if (existing === undefined) {
+                return;
+            }
+            const pruned = existing.filter((l) => l !== cb);
+            if (pruned.length === 0) {
+                map.delete(event);
+                return;
+            }
+            map.set(event, pruned);
+        };
+        removeFromMap(this.hmrClient.customListenersMap);
+        removeFromMap(this.newListeners);
+    }
+    send(event, data) {
+        this.hmrClient.messenger.send(JSON.stringify({ type: 'custom', event, data }));
+    }
+    acceptDeps(deps, callback = () => { }) {
+        const mod = this.hmrClient.hotModulesMap.get(this.ownerPath) || {
+            id: this.ownerPath,
+            callbacks: [],
+        };
+        mod.callbacks.push({
+            deps,
+            fn: callback,
+        });
+        this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
+    }
+}
+class HMRMessenger {
+    connection;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    queue = [];
+    send(message) {
+        this.queue.push(message);
+        this.flush();
+    }
+    flush() {
+        if (this.connection.isReady()) {
+            this.queue.forEach((msg) => this.connection.send(msg));
+            this.queue = [];
+        }
+    }
+}
+class HMRClient {
+    logger;
+    importUpdatedModule;
+    hotModulesMap = new Map();
+    disposeMap = new Map();
+    pruneMap = new Map();
+    dataMap = new Map();
+    customListenersMap = new Map();
+    ctxToListenersMap = new Map();
+    messenger;
+    constructor(logger, connection, 
+    // This allows implementing reloading via different methods depending on the environment
+    importUpdatedModule) {
+        this.logger = logger;
+        this.importUpdatedModule = importUpdatedModule;
+        this.messenger = new HMRMessenger(connection);
+    }
+    async notifyListeners(event, data) {
+        const cbs = this.customListenersMap.get(event);
+        if (cbs) {
+            await Promise.allSettled(cbs.map((cb) => cb(data)));
+        }
+    }
+    clear() {
+        this.hotModulesMap.clear();
+        this.disposeMap.clear();
+        this.pruneMap.clear();
+        this.dataMap.clear();
+        this.customListenersMap.clear();
+        this.ctxToListenersMap.clear();
+    }
+    // After an HMR update, some modules are no longer imported on the page
+    // but they may have left behind side effects that need to be cleaned up
+    // (.e.g style injections)
+    // TODO Trigger their dispose callbacks.
+    prunePaths(paths) {
+        paths.forEach((path) => {
+            const fn = this.pruneMap.get(path);
+            if (fn) {
+                fn(this.dataMap.get(path));
+            }
+        });
+    }
+    warnFailedUpdate(err, path) {
+        if (!err.message.includes('fetch')) {
+            this.logger.error(err);
+        }
+        this.logger.error(`[hmr] Failed to reload ${path}. ` +
+            `This could be due to syntax errors or importing non-existent ` +
+            `modules. (see errors above)`);
+    }
+    updateQueue = [];
+    pendingUpdateQueue = false;
+    /**
+     * buffer multiple hot updates triggered by the same src change
+     * so that they are invoked in the same order they were sent.
+     * (otherwise the order may be inconsistent because of the http request round trip)
+     */
+    async queueUpdate(payload) {
+        this.updateQueue.push(this.fetchUpdate(payload));
+        if (!this.pendingUpdateQueue) {
+            this.pendingUpdateQueue = true;
+            await Promise.resolve();
+            this.pendingUpdateQueue = false;
+            const loading = [...this.updateQueue];
+            this.updateQueue = [];
+            (await Promise.all(loading)).forEach((fn) => fn && fn());
+        }
+    }
+    async fetchUpdate(update) {
+        const { path, acceptedPath } = update;
+        const mod = this.hotModulesMap.get(path);
+        if (!mod) {
+            // In a code-splitting project,
+            // it is common that the hot-updating module is not loaded yet.
+            // https://github.com/vitejs/vite/issues/721
+            return;
+        }
+        let fetchedModule;
+        const isSelfUpdate = path === acceptedPath;
+        // determine the qualified callbacks before we re-import the modules
+        const qualifiedCallbacks = mod.callbacks.filter(({ deps }) => deps.includes(acceptedPath));
+        if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+            const disposer = this.disposeMap.get(acceptedPath);
+            if (disposer)
+                await disposer(this.dataMap.get(acceptedPath));
+            try {
+                fetchedModule = await this.importUpdatedModule(update);
+            }
+            catch (e) {
+                this.warnFailedUpdate(e, acceptedPath);
+            }
+        }
+        return () => {
+            for (const { deps, fn } of qualifiedCallbacks) {
+                fn(deps.map((dep) => (dep === acceptedPath ? fetchedModule : undefined)));
+            }
+            const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+            this.logger.debug(`[vite] hot updated: ${loggedPath}`);
+        };
+    }
+}
+
+const isWindows = typeof process !== 'undefined' && process.platform === 'win32';
+const decodeBase64 = typeof atob !== 'undefined'
+    ? atob
+    : (str) => Buffer.from(str, 'base64').toString('utf-8');
+// currently we copy this from '../../constants' - maybe we can inline it somewhow?
+const NULL_BYTE_PLACEHOLDER = `__x00__`;
+const VALID_ID_PREFIX = `/@id/`;
+function wrapId(id) {
+    return id.startsWith(VALID_ID_PREFIX)
+        ? id
+        : VALID_ID_PREFIX + id.replace('\0', NULL_BYTE_PLACEHOLDER);
+}
+function unwrapId(id) {
+    return id.startsWith(VALID_ID_PREFIX)
+        ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, '\0')
+        : id;
+}
+const windowsSlashRE = /\\/g;
+function slash(p) {
+    return p.replace(windowsSlashRE, '/');
+}
+const postfixRE = /[?#].*$/s;
+function cleanUrl(url) {
+    return url.replace(postfixRE, '');
+}
+function isPrimitive(value) {
+    return !value || (typeof value !== 'object' && typeof value !== 'function');
+}
+const CHAR_FORWARD_SLASH = 47;
+const CHAR_BACKWARD_SLASH = 92;
+const percentRegEx = /%/g;
+const backslashRegEx = /\\/g;
+const newlineRegEx = /\n/g;
+const carriageReturnRegEx = /\r/g;
+const tabRegEx = /\t/g;
+const questionRegex = /\?/g;
+const hashRegex = /#/g;
+function encodePathChars(filepath) {
+    if (filepath.indexOf('%') !== -1)
+        filepath = filepath.replace(percentRegEx, '%25');
+    // In posix, backslash is a valid character in paths:
+    if (!isWindows && filepath.indexOf('\\') !== -1)
+        filepath = filepath.replace(backslashRegEx, '%5C');
+    if (filepath.indexOf('\n') !== -1)
+        filepath = filepath.replace(newlineRegEx, '%0A');
+    if (filepath.indexOf('\r') !== -1)
+        filepath = filepath.replace(carriageReturnRegEx, '%0D');
+    if (filepath.indexOf('\t') !== -1)
+        filepath = filepath.replace(tabRegEx, '%09');
+    return filepath;
+}
+function posixPathToFileHref(posixPath) {
+    let resolved = posixResolve(posixPath);
+    // path.resolve strips trailing slashes so we must add them back
+    const filePathLast = posixPath.charCodeAt(posixPath.length - 1);
+    if ((filePathLast === CHAR_FORWARD_SLASH ||
+        (isWindows && filePathLast === CHAR_BACKWARD_SLASH)) &&
+        resolved[resolved.length - 1] !== '/')
+        resolved += '/';
+    // Call encodePathChars first to avoid encoding % again for ? and #.
+    resolved = encodePathChars(resolved);
+    // Question and hash character should be included in pathname.
+    // Therefore, encoding is required to eliminate parsing them in different states.
+    // This is done as an optimization to not creating a URL instance and
+    // later triggering pathname setter, which impacts performance
+    if (resolved.indexOf('?') !== -1)
+        resolved = resolved.replace(questionRegex, '%3F');
+    if (resolved.indexOf('#') !== -1)
+        resolved = resolved.replace(hashRegex, '%23');
+    return new URL(`file://${resolved}`).href;
+}
+function posixDirname(filepath) {
+    const normalizedPath = filepath.endsWith('/')
+        ? filepath.substring(0, filepath.length - 1)
+        : filepath;
+    return normalizedPath.substring(0, normalizedPath.lastIndexOf('/')) || '/';
+}
+function toWindowsPath(path) {
+    return path.replace(/\//g, '\\');
+}
+// inlined from pathe to support environments without access to node:path
+function cwd() {
+    if (typeof process !== 'undefined' && typeof process.cwd === 'function') {
+        return slash(process.cwd());
+    }
+    return '/';
+}
+function posixResolve(...segments) {
+    // Normalize windows arguments
+    segments = segments.map((argument) => slash(argument));
+    let resolvedPath = '';
+    let resolvedAbsolute = false;
+    for (let index = segments.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+        const path = index >= 0 ? segments[index] : cwd();
+        // Skip empty entries
+        if (!path || path.length === 0) {
+            continue;
+        }
+        resolvedPath = `${path}/${resolvedPath}`;
+        resolvedAbsolute = isAbsolute(path);
+    }
+    // At this point the path should be resolved to a full absolute path, but
+    // handle relative paths to be safe (might happen when process.cwd() fails)
+    // Normalize the path
+    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+        return `/${resolvedPath}`;
+    }
+    return resolvedPath.length > 0 ? resolvedPath : '.';
+}
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+function isAbsolute(p) {
+    return _IS_ABSOLUTE_RE.test(p);
+}
+// Resolves . and .. elements in a path with directory names
+function normalizeString(path, allowAboveRoot) {
+    let res = '';
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let char = null;
+    for (let index = 0; index <= path.length; ++index) {
+        if (index < path.length) {
+            char = path[index];
+        }
+        else if (char === '/') {
+            break;
+        }
+        else {
+            char = '/';
+        }
+        if (char === '/') {
+            if (lastSlash === index - 1 || dots === 1) ;
+            else if (dots === 2) {
+                if (res.length < 2 ||
+                    lastSegmentLength !== 2 ||
+                    res[res.length - 1] !== '.' ||
+                    res[res.length - 2] !== '.') {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.lastIndexOf('/');
+                        if (lastSlashIndex === -1) {
+                            res = '';
+                            lastSegmentLength = 0;
+                        }
+                        else {
+                            res = res.slice(0, lastSlashIndex);
+                            lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
+                        }
+                        lastSlash = index;
+                        dots = 0;
+                        continue;
+                    }
+                    else if (res.length > 0) {
+                        res = '';
+                        lastSegmentLength = 0;
+                        lastSlash = index;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    res += res.length > 0 ? '/..' : '..';
+                    lastSegmentLength = 2;
+                }
+            }
+            else {
+                if (res.length > 0) {
+                    res += `/${path.slice(lastSlash + 1, index)}`;
+                }
+                else {
+                    res = path.slice(lastSlash + 1, index);
+                }
+                lastSegmentLength = index - lastSlash - 1;
+            }
+            lastSlash = index;
+            dots = 0;
+        }
+        else if (char === '.' && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+
+class DecodedMap {
+    map;
+    _encoded;
+    _decoded;
+    _decodedMemo;
+    url;
+    version;
+    names = [];
+    resolvedSources;
+    constructor(map, from) {
+        this.map = map;
+        const { mappings, names, sources } = map;
+        this.version = map.version;
+        this.names = names || [];
+        this._encoded = mappings || '';
+        this._decodedMemo = memoizedState();
+        this.url = from;
+        this.resolvedSources = (sources || []).map((s) => posixResolve(s || '', from));
+    }
+}
+// This is a copy of all methods that we need for decoding a source map from "@jridgewell/trace-mapping"
+function indexOf(mappings, index) {
+    const idx = mappings.indexOf(';', index);
+    return idx === -1 ? mappings.length : idx;
+}
+const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const charToInt = new Uint8Array(128); // z is 122 in ASCII
+for (let i = 0; i < chars.length; i++) {
+    const c = chars.charCodeAt(i);
+    charToInt[c] = i;
+}
+function decodeInteger(mappings, pos, state, j) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = mappings.charCodeAt(pos++);
+        integer = charToInt[c];
+        value |= (integer & 31) << shift;
+        shift += 5;
+    } while (integer & 32);
+    const shouldNegate = value & 1;
+    value >>>= 1;
+    if (shouldNegate) {
+        value = -0x80000000 | -value;
+    }
+    state[j] += value;
+    return pos;
+}
+const comma = ','.charCodeAt(0);
+function hasMoreVlq(mappings, i, length) {
+    if (i >= length)
+        return false;
+    return mappings.charCodeAt(i) !== comma;
+}
+function decode(mappings) {
+    const state = new Int32Array(5);
+    const decoded = [];
+    let index = 0;
+    do {
+        const semi = indexOf(mappings, index);
+        const line = [];
+        let sorted = true;
+        let lastCol = 0;
+        state[0] = 0;
+        for (let i = index; i < semi; i++) {
+            let seg;
+            i = decodeInteger(mappings, i, state, 0); // genColumn
+            const col = state[0];
+            if (col < lastCol)
+                sorted = false;
+            lastCol = col;
+            if (hasMoreVlq(mappings, i, semi)) {
+                i = decodeInteger(mappings, i, state, 1); // sourcesIndex
+                i = decodeInteger(mappings, i, state, 2); // sourceLine
+                i = decodeInteger(mappings, i, state, 3); // sourceColumn
+                if (hasMoreVlq(mappings, i, semi)) {
+                    i = decodeInteger(mappings, i, state, 4); // namesIndex
+                    seg = [col, state[1], state[2], state[3], state[4]];
+                }
+                else {
+                    seg = [col, state[1], state[2], state[3]];
+                }
+            }
+            else {
+                seg = [col];
+            }
+            line.push(seg);
+        }
+        if (!sorted)
+            line.sort((a, b) => a[0] - b[0]);
+        decoded.push(line);
+        index = semi + 1;
+    } while (index <= mappings.length);
+    return decoded;
+}
+const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
+const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
+const COLUMN = 0;
+const SOURCES_INDEX = 1;
+const SOURCE_LINE = 2;
+const SOURCE_COLUMN = 3;
+const NAMES_INDEX = 4;
+function OMapping(source, line, column, name) {
+    return { source, line, column, name };
+}
+function decodedMappings(map) {
+    return map._decoded || (map._decoded = decode(map._encoded));
+}
+let found = false;
+function binarySearch(haystack, needle, low, high) {
+    while (low <= high) {
+        const mid = low + ((high - low) >> 1);
+        const cmp = haystack[mid][COLUMN] - needle;
+        if (cmp === 0) {
+            found = true;
+            return mid;
+        }
+        if (cmp < 0) {
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    found = false;
+    return low - 1;
+}
+function lowerBound(haystack, needle, index) {
+    for (let i = index - 1; i >= 0; index = i--) {
+        if (haystack[i][COLUMN] !== needle)
+            break;
+    }
+    return index;
+}
+function memoizedState() {
+    return {
+        lastKey: -1,
+        lastNeedle: -1,
+        lastIndex: -1,
+    };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+    const { lastKey, lastNeedle, lastIndex } = state;
+    let low = 0;
+    let high = haystack.length - 1;
+    if (key === lastKey) {
+        if (needle === lastNeedle) {
+            found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+            return lastIndex;
+        }
+        if (needle >= lastNeedle) {
+            // lastIndex may be -1 if the previous needle was not found.
+            low = lastIndex === -1 ? 0 : lastIndex;
+        }
+        else {
+            high = lastIndex;
+        }
+    }
+    state.lastKey = key;
+    state.lastNeedle = needle;
+    return (state.lastIndex = binarySearch(haystack, needle, low, high));
+}
+function traceSegmentInternal(segments, memo, line, column) {
+    let index = memoizedBinarySearch(segments, column, memo, line);
+    if (found) {
+        index = lowerBound(segments, column, index);
+    }
+    if (index === -1 || index === segments.length)
+        return -1;
+    return index;
+}
+function getOriginalPosition(map, { line, column }) {
+    line--;
+    if (line < 0)
+        throw new Error(LINE_GTR_ZERO);
+    if (column < 0)
+        throw new Error(COL_GTR_EQ_ZERO);
+    map._decodedMemo ??= memoizedState();
+    const decoded = decodedMappings(map);
+    // It's common for parent source maps to have pointers to lines that have no
+    // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+    if (line >= decoded.length)
+        return null;
+    const segments = decoded[line];
+    const index = traceSegmentInternal(segments, map._decodedMemo, line, column);
+    if (index === -1)
+        return null;
+    const segment = segments[index];
+    if (segment.length === 1)
+        return null;
+    const { names, resolvedSources } = map;
+    return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+
+let SOURCEMAPPING_URL = 'sourceMa';
+SOURCEMAPPING_URL += 'ppingURL';
+const VITE_RUNTIME_SOURCEMAPPING_URL = `${SOURCEMAPPING_URL}=data:application/json;charset=utf-8`;
+const VITE_RUNTIME_SOURCEMAPPING_REGEXP = new RegExp(`//# ${VITE_RUNTIME_SOURCEMAPPING_URL};base64,(.+)`);
+class ModuleCacheMap extends Map {
+    root;
+    constructor(root, entries) {
+        super(entries);
+        this.root = withTrailingSlash(root);
+    }
+    normalize(fsPath) {
+        return normalizeModuleId(fsPath, this.root);
+    }
+    /**
+     * Assign partial data to the map
+     */
+    update(fsPath, mod) {
+        fsPath = this.normalize(fsPath);
+        if (!super.has(fsPath))
+            this.setByModuleId(fsPath, mod);
+        else
+            Object.assign(super.get(fsPath), mod);
+        return this;
+    }
+    setByModuleId(modulePath, mod) {
+        return super.set(modulePath, mod);
+    }
+    set(fsPath, mod) {
+        return this.setByModuleId(this.normalize(fsPath), mod);
+    }
+    getByModuleId(modulePath) {
+        if (!super.has(modulePath))
+            this.setByModuleId(modulePath, {});
+        const mod = super.get(modulePath);
+        if (!mod.imports) {
+            Object.assign(mod, {
+                imports: new Set(),
+                importers: new Set(),
+            });
+        }
+        return mod;
+    }
+    get(fsPath) {
+        return this.getByModuleId(this.normalize(fsPath));
+    }
+    deleteByModuleId(modulePath) {
+        return super.delete(modulePath);
+    }
+    delete(fsPath) {
+        return this.deleteByModuleId(this.normalize(fsPath));
+    }
+    /**
+     * Invalidate modules that dependent on the given modules, up to the main entry
+     */
+    invalidateDepTree(ids, invalidated = new Set()) {
+        for (const _id of ids) {
+            const id = this.normalize(_id);
+            if (invalidated.has(id))
+                continue;
+            invalidated.add(id);
+            const mod = super.get(id);
+            if (mod?.importers)
+                this.invalidateDepTree(mod.importers, invalidated);
+            super.delete(id);
+        }
+        return invalidated;
+    }
+    /**
+     * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+     */
+    invalidateSubDepTree(ids, invalidated = new Set()) {
+        for (const _id of ids) {
+            const id = this.normalize(_id);
+            if (invalidated.has(id))
+                continue;
+            invalidated.add(id);
+            const subIds = Array.from(super.entries())
+                .filter(([, mod]) => mod.importers?.has(id))
+                .map(([key]) => key);
+            subIds.length && this.invalidateSubDepTree(subIds, invalidated);
+            super.delete(id);
+        }
+        return invalidated;
+    }
+    getSourceMap(moduleId) {
+        const mod = this.get(moduleId);
+        if (mod.map)
+            return mod.map;
+        if (!mod.meta || !('code' in mod.meta))
+            return null;
+        const mapString = mod.meta.code.match(VITE_RUNTIME_SOURCEMAPPING_REGEXP)?.[1];
+        if (!mapString)
+            return null;
+        const baseFile = mod.meta.file || moduleId.split('?')[0];
+        mod.map = new DecodedMap(JSON.parse(decodeBase64(mapString)), baseFile);
+        return mod.map;
+    }
+}
+function withTrailingSlash(path) {
+    if (path[path.length - 1] !== '/') {
+        return `${path}/`;
+    }
+    return path;
+}
+// unique id that is not available as "$bare_import" like "test"
+const prefixedBuiltins = new Set(['node:test']);
+// transform file url to id
+// virtual:custom -> virtual:custom
+// \0custom -> \0custom
+// /root/id -> /id
+// /root/id.js -> /id.js
+// C:/root/id.js -> /id.js
+// C:\root\id.js -> /id.js
+function normalizeModuleId(file, root) {
+    if (prefixedBuiltins.has(file))
+        return file;
+    // unix style, but Windows path still starts with the drive letter to check the root
+    let unixFile = file
+        .replace(/\\/g, '/')
+        .replace(/^\/@fs\//, isWindows ? '' : '/')
+        .replace(/^node:/, '')
+        .replace(/^\/+/, '/');
+    if (unixFile.startsWith(root)) {
+        // keep slash
+        unixFile = unixFile.slice(root.length - 1);
+    }
+    // if it's not in the root, keep it as a path, not a URL
+    return unixFile.replace(/^file:\//, '/');
+}
+
+// they are exported from ssrTransform plugin, but we can't import from there for performance reasons
+const ssrModuleExportsKey = `__vite_ssr_exports__`;
+const ssrImportKey = `__vite_ssr_import__`;
+const ssrDynamicImportKey = `__vite_ssr_dynamic_import__`;
+const ssrExportAllKey = `__vite_ssr_exportAll__`;
+const ssrImportMetaKey = `__vite_ssr_import_meta__`;
+
+const noop = () => { };
+const silentConsole = {
+    debug: noop,
+    error: noop,
+};
+
+// updates to HMR should go one after another. It is possible to trigger another update during the invalidation for example.
+function createHMRHandler(runtime) {
+    const queue = new Queue();
+    return (payload) => queue.enqueue(() => handleHMRPayload(runtime, payload));
+}
+async function handleHMRPayload(runtime, payload) {
+    const hmrClient = runtime.hmrClient;
+    if (!hmrClient || runtime.isDestroyed())
+        return;
+    switch (payload.type) {
+        case 'connected':
+            hmrClient.logger.debug(`[vite] connected.`);
+            hmrClient.messenger.flush();
+            break;
+        case 'update':
+            await hmrClient.notifyListeners('vite:beforeUpdate', payload);
+            await Promise.all(payload.updates.map(async (update) => {
+                if (update.type === 'js-update') {
+                    // runtime always caches modules by their full path without /@id/ prefix
+                    update.acceptedPath = unwrapId(update.acceptedPath);
+                    update.path = unwrapId(update.path);
+                    return hmrClient.queueUpdate(update);
+                }
+                hmrClient.logger.error('[vite] css hmr is not supported in runtime mode.');
+            }));
+            await hmrClient.notifyListeners('vite:afterUpdate', payload);
+            break;
+        case 'custom': {
+            await hmrClient.notifyListeners(payload.event, payload.data);
+            break;
+        }
+        case 'full-reload':
+            hmrClient.logger.debug(`[vite] program reload`);
+            await hmrClient.notifyListeners('vite:beforeFullReload', payload);
+            Array.from(runtime.moduleCache.keys()).forEach((id) => {
+                if (!id.includes('node_modules')) {
+                    runtime.moduleCache.deleteByModuleId(id);
+                }
+            });
+            for (const id of runtime.entrypoints) {
+                await runtime.executeUrl(id);
+            }
+            break;
+        case 'prune':
+            await hmrClient.notifyListeners('vite:beforePrune', payload);
+            hmrClient.prunePaths(payload.paths);
+            break;
+        case 'error': {
+            await hmrClient.notifyListeners('vite:error', payload);
+            const err = payload.err;
+            hmrClient.logger.error(`[vite] Internal Server Error\n${err.message}\n${err.stack}`);
+            break;
+        }
+        default: {
+            const check = payload;
+            return check;
+        }
+    }
+}
+class Queue {
+    queue = [];
+    pending = false;
+    enqueue(promise) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                promise,
+                resolve,
+                reject,
+            });
+            this.dequeue();
+        });
+    }
+    dequeue() {
+        if (this.pending) {
+            return false;
+        }
+        const item = this.queue.shift();
+        if (!item) {
+            return false;
+        }
+        this.pending = true;
+        item
+            .promise()
+            .then(item.resolve)
+            .catch(item.reject)
+            .finally(() => {
+            this.pending = false;
+            this.dequeue();
+        });
+        return true;
+    }
+}
+
+const sourceMapCache = {};
+const fileContentsCache = {};
+const moduleGraphs = new Set();
+const retrieveFileHandlers = new Set();
+const retrieveSourceMapHandlers = new Set();
+const createExecHandlers = (handlers) => {
+    return ((...args) => {
+        for (const handler of handlers) {
+            const result = handler(...args);
+            if (result)
+                return result;
+        }
+        return null;
+    });
+};
+const retrieveFileFromHandlers = createExecHandlers(retrieveFileHandlers);
+const retrievSourceMapFromHandlers = createExecHandlers(retrieveSourceMapHandlers);
+let overriden = false;
+const originalPrepare = Error.prepareStackTrace;
+function resetInterceptor(runtime, options) {
+    moduleGraphs.delete(runtime.moduleCache);
+    if (options.retrieveFile)
+        retrieveFileHandlers.delete(options.retrieveFile);
+    if (options.retrieveSourceMap)
+        retrieveSourceMapHandlers.delete(options.retrieveSourceMap);
+    if (moduleGraphs.size === 0) {
+        Error.prepareStackTrace = originalPrepare;
+        overriden = false;
+    }
+}
+function interceptStackTrace(runtime, options = {}) {
+    if (!overriden) {
+        Error.prepareStackTrace = prepareStackTrace;
+        overriden = true;
+    }
+    moduleGraphs.add(runtime.moduleCache);
+    if (options.retrieveFile)
+        retrieveFileHandlers.add(options.retrieveFile);
+    if (options.retrieveSourceMap)
+        retrieveSourceMapHandlers.add(options.retrieveSourceMap);
+    return () => resetInterceptor(runtime, options);
+}
+// Support URLs relative to a directory, but be careful about a protocol prefix
+function supportRelativeURL(file, url) {
+    if (!file)
+        return url;
+    const dir = posixDirname(file.replace(/\\/g, '/'));
+    const match = /^\w+:\/\/[^/]*/.exec(dir);
+    let protocol = match ? match[0] : '';
+    const startPath = dir.slice(protocol.length);
+    if (protocol && /^\/\w:/.test(startPath)) {
+        // handle file:///C:/ paths
+        protocol += '/';
+        return (protocol +
+            posixResolve(dir.slice(protocol.length), url).replace(/\\/g, '/'));
+    }
+    return protocol + posixResolve(dir.slice(protocol.length), url);
+}
+function getRuntimeSourceMap(position) {
+    for (const moduleCache of moduleGraphs) {
+        const sourceMap = moduleCache.getSourceMap(position.source);
+        if (sourceMap) {
+            return {
+                url: position.source,
+                map: sourceMap,
+                vite: true,
+            };
+        }
+    }
+    return null;
+}
+function retrieveFile(path) {
+    if (path in fileContentsCache)
+        return fileContentsCache[path];
+    const content = retrieveFileFromHandlers(path);
+    if (typeof content === 'string') {
+        fileContentsCache[path] = content;
+        return content;
+    }
+    return null;
+}
+function retrieveSourceMapURL(source) {
+    // Get the URL of the source map
+    const fileData = retrieveFile(source);
+    if (!fileData)
+        return null;
+    const re = /\/\/[@#]\s*sourceMappingURL=([^\s'"]+)\s*$|\/\*[@#]\s*sourceMappingURL=[^\s*'"]+\s*\*\/\s*$/gm;
+    // Keep executing the search to find the *last* sourceMappingURL to avoid
+    // picking up sourceMappingURLs from comments, strings, etc.
+    let lastMatch, match;
+    while ((match = re.exec(fileData)))
+        lastMatch = match;
+    if (!lastMatch)
+        return null;
+    return lastMatch[1];
+}
+const reSourceMap = /^data:application\/json[^,]+base64,/;
+function retrieveSourceMap(source) {
+    const urlAndMap = retrievSourceMapFromHandlers(source);
+    if (urlAndMap)
+        return urlAndMap;
+    let sourceMappingURL = retrieveSourceMapURL(source);
+    if (!sourceMappingURL)
+        return null;
+    // Read the contents of the source map
+    let sourceMapData;
+    if (reSourceMap.test(sourceMappingURL)) {
+        // Support source map URL as a data url
+        const rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(',') + 1);
+        sourceMapData = Buffer.from(rawData, 'base64').toString();
+        sourceMappingURL = source;
+    }
+    else {
+        // Support source map URLs relative to the source URL
+        sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
+        sourceMapData = retrieveFile(sourceMappingURL);
+    }
+    if (!sourceMapData)
+        return null;
+    return {
+        url: sourceMappingURL,
+        map: sourceMapData,
+    };
+}
+function mapSourcePosition(position) {
+    if (!position.source)
+        return position;
+    let sourceMap = getRuntimeSourceMap(position);
+    if (!sourceMap)
+        sourceMap = sourceMapCache[position.source];
+    if (!sourceMap) {
+        // Call the (overrideable) retrieveSourceMap function to get the source map.
+        const urlAndMap = retrieveSourceMap(position.source);
+        if (urlAndMap && urlAndMap.map) {
+            const url = urlAndMap.url;
+            sourceMap = sourceMapCache[position.source] = {
+                url,
+                map: new DecodedMap(typeof urlAndMap.map === 'string'
+                    ? JSON.parse(urlAndMap.map)
+                    : urlAndMap.map, url),
+            };
+            const contents = sourceMap.map?.map.sourcesContent;
+            // Load all sources stored inline with the source map into the file cache
+            // to pretend like they are already loaded. They may not exist on disk.
+            if (sourceMap.map && contents) {
+                sourceMap.map.resolvedSources.forEach((source, i) => {
+                    const content = contents[i];
+                    if (content && source && url) {
+                        const contentUrl = supportRelativeURL(url, source);
+                        fileContentsCache[contentUrl] = content;
+                    }
+                });
+            }
+        }
+        else {
+            sourceMap = sourceMapCache[position.source] = {
+                url: null,
+                map: null,
+            };
+        }
+    }
+    // Resolve the source URL relative to the URL of the source map
+    if (sourceMap && sourceMap.map && sourceMap.url) {
+        const originalPosition = getOriginalPosition(sourceMap.map, position);
+        // Only return the original position if a matching line was found. If no
+        // matching line is found then we return position instead, which will cause
+        // the stack trace to print the path and line for the compiled file. It is
+        // better to give a precise location in the compiled file than a vague
+        // location in the original file.
+        if (originalPosition && originalPosition.source != null) {
+            originalPosition.source = supportRelativeURL(sourceMap.url, originalPosition.source);
+            if (sourceMap.vite) {
+                // @ts-expect-error vite is not defined
+                originalPosition._vite = true;
+            }
+            return originalPosition;
+        }
+    }
+    return position;
+}
+// Parses code generated by FormatEvalOrigin(), a function inside V8:
+// https://code.google.com/p/v8/source/browse/trunk/src/messages.js
+function mapEvalOrigin(origin) {
+    // Most eval() calls are in this format
+    let match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
+    if (match) {
+        const position = mapSourcePosition({
+            name: null,
+            source: match[2],
+            line: +match[3],
+            column: +match[4] - 1,
+        });
+        return `eval at ${match[1]} (${position.source}:${position.line}:${position.column + 1})`;
+    }
+    // Parse nested eval() calls using recursion
+    match = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
+    if (match)
+        return `eval at ${match[1]} (${mapEvalOrigin(match[2])})`;
+    // Make sure we still return useful information if we didn't find anything
+    return origin;
+}
+// This is copied almost verbatim from the V8 source code at
+// https://code.google.com/p/v8/source/browse/trunk/src/messages.js. The
+// implementation of wrapCallSite() used to just forward to the actual source
+// code of CallSite.prototype.toString but unfortunately a new release of V8
+// did something to the prototype chain and broke the shim. The only fix I
+// could find was copy/paste.
+function CallSiteToString() {
+    let fileName;
+    let fileLocation = '';
+    if (this.isNative()) {
+        fileLocation = 'native';
+    }
+    else {
+        fileName = this.getScriptNameOrSourceURL();
+        if (!fileName && this.isEval()) {
+            fileLocation = this.getEvalOrigin();
+            fileLocation += ', '; // Expecting source position to follow.
+        }
+        if (fileName) {
+            fileLocation += fileName;
+        }
+        else {
+            // Source code does not originate from a file and is not native, but we
+            // can still get the source position inside the source string, e.g. in
+            // an eval string.
+            fileLocation += '<anonymous>';
+        }
+        const lineNumber = this.getLineNumber();
+        if (lineNumber != null) {
+            fileLocation += `:${lineNumber}`;
+            const columnNumber = this.getColumnNumber();
+            if (columnNumber)
+                fileLocation += `:${columnNumber}`;
+        }
+    }
+    let line = '';
+    const functionName = this.getFunctionName();
+    let addSuffix = true;
+    const isConstructor = this.isConstructor();
+    const isMethodCall = !(this.isToplevel() || isConstructor);
+    if (isMethodCall) {
+        let typeName = this.getTypeName();
+        // Fixes shim to be backward compatable with Node v0 to v4
+        if (typeName === '[object Object]')
+            typeName = 'null';
+        const methodName = this.getMethodName();
+        if (functionName) {
+            if (typeName && functionName.indexOf(typeName) !== 0)
+                line += `${typeName}.`;
+            line += functionName;
+            if (methodName &&
+                functionName.indexOf(`.${methodName}`) !==
+                    functionName.length - methodName.length - 1)
+                line += ` [as ${methodName}]`;
+        }
+        else {
+            line += `${typeName}.${methodName || '<anonymous>'}`;
+        }
+    }
+    else if (isConstructor) {
+        line += `new ${functionName || '<anonymous>'}`;
+    }
+    else if (functionName) {
+        line += functionName;
+    }
+    else {
+        line += fileLocation;
+        addSuffix = false;
+    }
+    if (addSuffix)
+        line += ` (${fileLocation})`;
+    return line;
+}
+function cloneCallSite(frame) {
+    const object = {};
+    Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach((name) => {
+        const key = name;
+        // @ts-expect-error difficult to type
+        object[key] = /^(?:is|get)/.test(name)
+            ? function () {
+                return frame[key].call(frame);
+            }
+            : frame[key];
+    });
+    object.toString = CallSiteToString;
+    return object;
+}
+function wrapCallSite(frame, state) {
+    // provides interface backward compatibility
+    if (state === undefined)
+        state = { nextPosition: null, curPosition: null };
+    if (frame.isNative()) {
+        state.curPosition = null;
+        return frame;
+    }
+    // Most call sites will return the source file from getFileName(), but code
+    // passed to eval() ending in "//# sourceURL=..." will return the source file
+    // from getScriptNameOrSourceURL() instead
+    const source = frame.getFileName() || frame.getScriptNameOrSourceURL();
+    if (source) {
+        const line = frame.getLineNumber();
+        let column = frame.getColumnNumber() - 1;
+        // Fix position in Node where some (internal) code is prepended.
+        // See https://github.com/evanw/node-source-map-support/issues/36
+        // Header removed in node at ^10.16 || >=11.11.0
+        // v11 is not an LTS candidate, we can just test the one version with it.
+        // Test node versions for: 10.16-19, 10.20+, 12-19, 20-99, 100+, or 11.11
+        const headerLength = 62;
+        if (line === 1 && column > headerLength && !frame.isEval())
+            column -= headerLength;
+        const position = mapSourcePosition({
+            name: null,
+            source,
+            line,
+            column,
+        });
+        state.curPosition = position;
+        frame = cloneCallSite(frame);
+        const originalFunctionName = frame.getFunctionName;
+        frame.getFunctionName = function () {
+            const name = (() => {
+                if (state.nextPosition == null)
+                    return originalFunctionName();
+                return state.nextPosition.name || originalFunctionName();
+            })();
+            return name === 'eval' && '_vite' in position ? null : name;
+        };
+        frame.getFileName = function () {
+            return position.source ?? undefined;
+        };
+        frame.getLineNumber = function () {
+            return position.line;
+        };
+        frame.getColumnNumber = function () {
+            return position.column + 1;
+        };
+        frame.getScriptNameOrSourceURL = function () {
+            return position.source;
+        };
+        return frame;
+    }
+    // Code called using eval() needs special handling
+    let origin = frame.isEval() && frame.getEvalOrigin();
+    if (origin) {
+        origin = mapEvalOrigin(origin);
+        frame = cloneCallSite(frame);
+        frame.getEvalOrigin = function () {
+            return origin || undefined;
+        };
+        return frame;
+    }
+    // If we get here then we were unable to change the source position
+    return frame;
+}
+function prepareStackTrace(error, stack) {
+    const name = error.name || 'Error';
+    const message = error.message || '';
+    const errorString = `${name}: ${message}`;
+    const state = { nextPosition: null, curPosition: null };
+    const processedStack = [];
+    for (let i = stack.length - 1; i >= 0; i--) {
+        processedStack.push(`\n    at ${wrapCallSite(stack[i], state)}`);
+        state.nextPosition = state.curPosition;
+    }
+    state.curPosition = state.nextPosition = null;
+    return errorString + processedStack.reverse().join('');
+}
+
+function enableSourceMapSupport(runtime) {
+    if (runtime.options.sourcemapInterceptor === 'node') {
+        if (typeof process === 'undefined') {
+            throw new TypeError(`Cannot use "sourcemapInterceptor: 'node'" because global "process" variable is not available.`);
+        }
+        if (typeof process.setSourceMapsEnabled !== 'function') {
+            throw new TypeError(`Cannot use "sourcemapInterceptor: 'node'" because "process.setSourceMapsEnabled" function is not available. Please use Node >= 16.6.0.`);
+        }
+        const isEnabledAlready = process.sourceMapsEnabled ?? false;
+        process.setSourceMapsEnabled(true);
+        return () => !isEnabledAlready && process.setSourceMapsEnabled(false);
+    }
+    return interceptStackTrace(runtime, typeof runtime.options.sourcemapInterceptor === 'object'
+        ? runtime.options.sourcemapInterceptor
+        : undefined);
+}
+
+class ViteRuntime {
+    options;
+    runner;
+    debug;
+    /**
+     * Holds the cache of modules
+     * Keys of the map are ids
+     */
+    moduleCache;
+    hmrClient;
+    entrypoints = new Set();
+    idToUrlMap = new Map();
+    fileToIdMap = new Map();
+    envProxy = new Proxy({}, {
+        get(_, p) {
+            throw new Error(`[vite-runtime] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`);
+        },
+    });
+    _destroyed = false;
+    _resetSourceMapSupport;
+    constructor(options, runner, debug) {
+        this.options = options;
+        this.runner = runner;
+        this.debug = debug;
+        this.moduleCache = options.moduleCache ?? new ModuleCacheMap(options.root);
+        if (typeof options.hmr === 'object') {
+            this.hmrClient = new HMRClient(options.hmr.logger === false
+                ? silentConsole
+                : options.hmr.logger || console, options.hmr.connection, ({ acceptedPath, ssrInvalidates }) => {
+                this.moduleCache.delete(acceptedPath);
+                if (ssrInvalidates) {
+                    this.invalidateFiles(ssrInvalidates);
+                }
+                return this.executeUrl(acceptedPath);
+            });
+            options.hmr.connection.onUpdate(createHMRHandler(this));
+        }
+        if (options.sourcemapInterceptor !== false) {
+            this._resetSourceMapSupport = enableSourceMapSupport(this);
+        }
+    }
+    /**
+     * URL to execute. Accepts file path, server path or id relative to the root.
+     */
+    async executeUrl(url) {
+        url = this.normalizeEntryUrl(url);
+        const fetchedModule = await this.cachedModule(url);
+        return await this.cachedRequest(url, fetchedModule);
+    }
+    /**
+     * Entrypoint URL to execute. Accepts file path, server path or id relative to the root.
+     * In the case of a full reload triggered by HMR, this is the module that will be reloaded.
+     * If this method is called multiple times, all entrypoints will be reloaded one at a time.
+     */
+    async executeEntrypoint(url) {
+        url = this.normalizeEntryUrl(url);
+        const fetchedModule = await this.cachedModule(url);
+        return await this.cachedRequest(url, fetchedModule, [], {
+            entrypoint: true,
+        });
+    }
+    /**
+     * Clear all caches including HMR listeners.
+     */
+    clearCache() {
+        this.moduleCache.clear();
+        this.idToUrlMap.clear();
+        this.entrypoints.clear();
+        this.hmrClient?.clear();
+    }
+    /**
+     * Clears all caches, removes all HMR listeners, and resets source map support.
+     * This method doesn't stop the HMR connection.
+     */
+    async destroy() {
+        this._resetSourceMapSupport?.();
+        this.clearCache();
+        this.hmrClient = undefined;
+        this._destroyed = true;
+    }
+    /**
+     * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
+     */
+    isDestroyed() {
+        return this._destroyed;
+    }
+    invalidateFiles(files) {
+        files.forEach((file) => {
+            const ids = this.fileToIdMap.get(file);
+            if (ids) {
+                ids.forEach((id) => this.moduleCache.deleteByModuleId(id));
+            }
+        });
+    }
+    // we don't use moduleCache.normalize because this URL doesn't have to follow the same rules
+    // this URL is something that user passes down manually, and is later resolved by fetchModule
+    // moduleCache.normalize is used on resolved "file" property
+    normalizeEntryUrl(url) {
+        // expect fetchModule to resolve relative module correctly
+        if (url[0] === '.') {
+            return url;
+        }
+        // file:///C:/root/id.js -> C:/root/id.js
+        if (url.startsWith('file://')) {
+            // 8 is the length of "file:///"
+            url = url.slice(isWindows ? 8 : 7);
+        }
+        url = url.replace(/\\/g, '/');
+        const _root = this.options.root;
+        const root = _root[_root.length - 1] === '/' ? _root : `${_root}/`;
+        // strip root from the URL because fetchModule prefers a public served url path
+        // packages/vite/src/node/server/moduleGraph.ts:17
+        if (url.startsWith(root)) {
+            // /root/id.js -> /id.js
+            // C:/root/id.js -> /id.js
+            // 1 is to keep the leading slash
+            return url.slice(root.length - 1);
+        }
+        // if it's a server url (starts with a slash), keep it, otherwise assume a virtual module
+        // /id.js -> /id.js
+        // virtual:custom -> /@id/virtual:custom
+        return url[0] === '/' ? url : wrapId(url);
+    }
+    processImport(exports, fetchResult, metadata) {
+        if (!('externalize' in fetchResult)) {
+            return exports;
+        }
+        const { id, type } = fetchResult;
+        if (type !== 'module' && type !== 'commonjs')
+            return exports;
+        analyzeImportedModDifference(exports, id, type, metadata);
+        return proxyGuardOnlyEsm(exports, id, metadata);
+    }
+    async cachedRequest(id, fetchedModule, callstack = [], metadata) {
+        const moduleId = fetchedModule.id;
+        if (metadata?.entrypoint) {
+            this.entrypoints.add(moduleId);
+        }
+        const mod = this.moduleCache.getByModuleId(moduleId);
+        const { imports, importers } = mod;
+        const importee = callstack[callstack.length - 1];
+        if (importee)
+            importers.add(importee);
+        // check circular dependency
+        if (callstack.includes(moduleId) ||
+            Array.from(imports.values()).some((i) => importers.has(i))) {
+            if (mod.exports)
+                return this.processImport(mod.exports, fetchedModule, metadata);
+        }
+        const getStack = () => `stack:\n${[...callstack, moduleId]
+            .reverse()
+            .map((p) => `  - ${p}`)
+            .join('\n')}`;
+        let debugTimer;
+        if (this.debug)
+            debugTimer = setTimeout(() => this.debug(`[vite-runtime] module ${moduleId} takes over 2s to load.\n${getStack()}`), 2000);
+        try {
+            // cached module
+            if (mod.promise)
+                return this.processImport(await mod.promise, fetchedModule, metadata);
+            const promise = this.directRequest(id, fetchedModule, callstack);
+            mod.promise = promise;
+            mod.evaluated = false;
+            return this.processImport(await promise, fetchedModule, metadata);
+        }
+        finally {
+            mod.evaluated = true;
+            if (debugTimer)
+                clearTimeout(debugTimer);
+        }
+    }
+    async cachedModule(id, importer) {
+        if (this._destroyed) {
+            throw new Error(`[vite] Vite runtime has been destroyed.`);
+        }
+        const normalized = this.idToUrlMap.get(id);
+        if (normalized) {
+            const mod = this.moduleCache.getByModuleId(normalized);
+            if (mod.meta) {
+                return mod.meta;
+            }
+        }
+        this.debug?.('[vite-runtime] fetching', id);
+        // fast return for established externalized patterns
+        const fetchedModule = id.startsWith('data:')
+            ? { externalize: id, type: 'builtin' }
+            : await this.options.fetchModule(id, importer);
+        // base moduleId on "file" and not on id
+        // if `import(variable)` is called it's possible that it doesn't have an extension for example
+        // if we used id for that, it's possible to have a duplicated module
+        const idQuery = id.split('?')[1];
+        const query = idQuery ? `?${idQuery}` : '';
+        const file = 'file' in fetchedModule ? fetchedModule.file : undefined;
+        const fullFile = file ? `${file}${query}` : id;
+        const moduleId = this.moduleCache.normalize(fullFile);
+        const mod = this.moduleCache.getByModuleId(moduleId);
+        fetchedModule.id = moduleId;
+        mod.meta = fetchedModule;
+        if (file) {
+            const fileModules = this.fileToIdMap.get(file) || [];
+            fileModules.push(moduleId);
+            this.fileToIdMap.set(file, fileModules);
+        }
+        this.idToUrlMap.set(id, moduleId);
+        this.idToUrlMap.set(unwrapId(id), moduleId);
+        return fetchedModule;
+    }
+    // override is allowed, consider this a public API
+    async directRequest(id, fetchResult, _callstack) {
+        const moduleId = fetchResult.id;
+        const callstack = [..._callstack, moduleId];
+        const mod = this.moduleCache.getByModuleId(moduleId);
+        const request = async (dep, metadata) => {
+            const fetchedModule = await this.cachedModule(dep, moduleId);
+            const depMod = this.moduleCache.getByModuleId(fetchedModule.id);
+            depMod.importers.add(moduleId);
+            mod.imports.add(fetchedModule.id);
+            return this.cachedRequest(dep, fetchedModule, callstack, metadata);
+        };
+        const dynamicRequest = async (dep) => {
+            // it's possible to provide an object with toString() method inside import()
+            dep = String(dep);
+            if (dep[0] === '.') {
+                dep = posixResolve(posixDirname(id), dep);
+            }
+            return request(dep, { isDynamicImport: true });
+        };
+        if ('externalize' in fetchResult) {
+            const { externalize } = fetchResult;
+            this.debug?.('[vite-runtime] externalizing', externalize);
+            const exports = await this.runner.runExternalModule(externalize);
+            mod.exports = exports;
+            return exports;
+        }
+        const { code, file } = fetchResult;
+        if (code == null) {
+            const importer = callstack[callstack.length - 2];
+            throw new Error(`[vite-runtime] Failed to load "${id}"${importer ? ` imported from ${importer}` : ''}`);
+        }
+        const modulePath = cleanUrl(file || moduleId);
+        // disambiguate the `<UNIT>:/` on windows: see nodejs/node#31710
+        const href = posixPathToFileHref(modulePath);
+        const filename = modulePath;
+        const dirname = posixDirname(modulePath);
+        const meta = {
+            filename: isWindows ? toWindowsPath(filename) : filename,
+            dirname: isWindows ? toWindowsPath(dirname) : dirname,
+            url: href,
+            env: this.envProxy,
+            resolve(id, parent) {
+                throw new Error('[vite-runtime] "import.meta.resolve" is not supported.');
+            },
+            // should be replaced during transformation
+            glob() {
+                throw new Error('[vite-runtime] "import.meta.glob" is not supported.');
+            },
+        };
+        const exports = Object.create(null);
+        Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module',
+            enumerable: false,
+            configurable: false,
+        });
+        mod.exports = exports;
+        let hotContext;
+        if (this.hmrClient) {
+            Object.defineProperty(meta, 'hot', {
+                enumerable: true,
+                get: () => {
+                    if (!this.hmrClient) {
+                        throw new Error(`[vite-runtime] HMR client was destroyed.`);
+                    }
+                    this.debug?.('[vite-runtime] creating hmr context for', moduleId);
+                    hotContext ||= new HMRContext(this.hmrClient, moduleId);
+                    return hotContext;
+                },
+                set: (value) => {
+                    hotContext = value;
+                },
+            });
+        }
+        const context = {
+            [ssrImportKey]: request,
+            [ssrDynamicImportKey]: dynamicRequest,
+            [ssrModuleExportsKey]: exports,
+            [ssrExportAllKey]: (obj) => exportAll(exports, obj),
+            [ssrImportMetaKey]: meta,
+        };
+        this.debug?.('[vite-runtime] executing', href);
+        await this.runner.runViteModule(context, code, id);
+        return exports;
+    }
+}
+function exportAll(exports, sourceModule) {
+    // when a module exports itself it causes
+    // call stack error
+    if (exports === sourceModule)
+        return;
+    if (isPrimitive(sourceModule) ||
+        Array.isArray(sourceModule) ||
+        sourceModule instanceof Promise)
+        return;
+    for (const key in sourceModule) {
+        if (key !== 'default' && key !== '__esModule') {
+            try {
+                Object.defineProperty(exports, key, {
+                    enumerable: true,
+                    configurable: true,
+                    get: () => sourceModule[key],
+                });
+            }
+            catch (_err) { }
+        }
+    }
+}
+/**
+ * Vite converts `import { } from 'foo'` to `const _ = __vite_ssr_import__('foo')`.
+ * Top-level imports and dynamic imports work slightly differently in Node.js.
+ * This function normalizes the differences so it matches prod behaviour.
+ */
+function analyzeImportedModDifference(mod, rawId, moduleType, metadata) {
+    // No normalization needed if the user already dynamic imports this module
+    if (metadata?.isDynamicImport)
+        return;
+    // If file path is ESM, everything should be fine
+    if (moduleType === 'module')
+        return;
+    // For non-ESM, named imports is done via static analysis with cjs-module-lexer in Node.js.
+    // If the user named imports a specifier that can't be analyzed, error.
+    if (metadata?.importedNames?.length) {
+        const missingBindings = metadata.importedNames.filter((s) => !(s in mod));
+        if (missingBindings.length) {
+            const lastBinding = missingBindings[missingBindings.length - 1];
+            // Copied from Node.js
+            throw new SyntaxError(`\
+[vite] Named export '${lastBinding}' not found. The requested module '${rawId}' is a CommonJS module, which may not support all module.exports as named exports.
+CommonJS modules can always be imported via the default export, for example using:
+
+import pkg from '${rawId}';
+const {${missingBindings.join(', ')}} = pkg;
+`);
+        }
+    }
+}
+/**
+ * Guard invalid named exports only, similar to how Node.js errors for top-level imports.
+ * But since we transform as dynamic imports, we need to emulate the error manually.
+ */
+function proxyGuardOnlyEsm(mod, rawId, metadata) {
+    // If the module doesn't import anything explicitly, e.g. `import 'foo'` or
+    // `import * as foo from 'foo'`, we can skip the proxy guard.
+    if (!metadata?.importedNames?.length)
+        return mod;
+    return new Proxy(mod, {
+        get(mod, prop) {
+            if (prop !== 'then' && !(prop in mod)) {
+                throw new SyntaxError(`[vite] The requested module '${rawId}' does not provide an export named '${prop.toString()}'`);
+            }
+            return mod[prop];
+        },
+    });
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const AsyncFunction = async function () { }.constructor;
+class ESModulesRunner {
+    async runViteModule(context, code) {
+        // use AsyncFunction instead of vm module to support broader array of environments out of the box
+        const initModule = new AsyncFunction(ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey, 
+        // source map should already be inlined by Vite
+        '"use strict";' + code);
+        await initModule(context[ssrModuleExportsKey], context[ssrImportMetaKey], context[ssrImportKey], context[ssrDynamicImportKey], context[ssrExportAllKey]);
+        Object.freeze(context[ssrModuleExportsKey]);
+    }
+    runExternalModule(filepath) {
+        return import(filepath);
+    }
+}
+
+export { ESModulesRunner, ModuleCacheMap, ViteRuntime, ssrDynamicImportKey, ssrExportAllKey, ssrImportKey, ssrImportMetaKey, ssrModuleExportsKey };