vite 2.7.0-beta.8 → 2.7.2

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

@@ -0,0 +1,3 @@
+import { Plugin } from 'rollup';
+import { ResolvedConfig } from '../config';
+export declare function buildReporterPlugin(config: ResolvedConfig): Plugin;

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

@@ -0,0 +1,38 @@
+import { Plugin } from '../plugin';
+import { ViteDevServer, SSROptions } from '..';
+import { PartialResolvedId } from 'rollup';
+import { PackageCache, PackageData } from '../packages';
+export declare const browserExternalId = "__vite-browser-external";
+export interface ResolveOptions {
+    mainFields?: string[];
+    conditions?: string[];
+    extensions?: string[];
+    dedupe?: string[];
+    preserveSymlinks?: boolean;
+}
+export interface InternalResolveOptions extends ResolveOptions {
+    root: string;
+    isBuild: boolean;
+    isProduction: boolean;
+    ssrConfig?: SSROptions;
+    packageCache?: PackageCache;
+    /**
+     * src code mode also attempts the following:
+     * - resolving /xxx as URLs
+     * - resolving bare imports from optimized deps
+     */
+    asSrc?: boolean;
+    tryIndex?: boolean;
+    tryPrefix?: string;
+    skipPackageJson?: boolean;
+    preferRelative?: boolean;
+    preserveSymlinks?: boolean;
+    isRequire?: boolean;
+    isFromTsImporter?: boolean;
+    tryEsmOnly?: boolean;
+}
+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): string | undefined;
+export declare function resolvePackageEntry(id: string, { dir, data, setResolvedCache, getResolvedCache }: PackageData, targetWeb: boolean, options: InternalResolveOptions): string | undefined;

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

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { ResolvedConfig } from '..';
+import { Plugin } from '../plugin';
+/**
+ * This plugin hooks into Node's module resolution algorithm at runtime,
+ * so that SSR builds can benefit from `resolve.dedupe` like they do
+ * in development.
+ */
+export declare function ssrRequireHookPlugin(config: ResolvedConfig): Plugin | null;
+declare type NodeResolveFilename = (request: string, parent: NodeModule, isMain: boolean, options?: Record<string, any>) => string;
+export declare function hookNodeResolve(getResolver: (resolveFilename: NodeResolveFilename) => NodeResolveFilename): () => void;
+export {};

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

@@ -0,0 +1,3 @@
+import { Plugin } from '../plugin';
+import { ResolvedConfig } from '..';
+export declare function terserPlugin(config: ResolvedConfig): Plugin;

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

@@ -0,0 +1,3 @@
+import { ResolvedConfig } from '../config';
+import { Plugin } from '../plugin';
+export declare const wasmPlugin: (config: ResolvedConfig) => Plugin;

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

@@ -0,0 +1,3 @@
+import { ResolvedConfig } from '../config';
+import { Plugin } from '../plugin';
+export declare function webWorkerPlugin(config: ResolvedConfig): Plugin;

package/dist/node/preview.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import { Server } from 'http';
+import { InlineConfig, ResolvedConfig } from '.';
+import { ResolvedServerOptions } from './server';
+import { CommonServerOptions } from './http';
+export interface PreviewOptions extends CommonServerOptions {
+}
+export interface ResolvedPreviewOptions extends PreviewOptions {
+}
+export declare function resolvePreviewOptions(preview: PreviewOptions | undefined, server: ResolvedServerOptions): ResolvedPreviewOptions;
+export interface PreviewServer {
+    /**
+     * The resolved vite config object
+     */
+    config: ResolvedConfig;
+    /**
+     * native Node http server instance
+     */
+    httpServer: Server;
+    /**
+     * Print server urls
+     */
+    printUrls: () => void;
+}
+/**
+ * Starts the Vite server in preview mode, to simulate a production deployment
+ * @param config - the resolved Vite config
+ * @param serverOptions - what host and port to use
+ * @experimental
+ */
+export declare function preview(inlineConfig: InlineConfig): Promise<PreviewServer>;

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

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { ViteDevServer } from '..';
+import { ModuleNode } from './moduleGraph';
+import { Server } from 'http';
+export declare const debugHmr: (...args: any[]) => any;
+export interface HmrOptions {
+    protocol?: string;
+    host?: string;
+    port?: number;
+    clientPort?: number;
+    path?: string;
+    timeout?: number;
+    overlay?: boolean;
+    server?: Server;
+}
+export interface HmrContext {
+    file: string;
+    timestamp: number;
+    modules: Array<ModuleNode>;
+    read: () => string | Promise<string>;
+    server: ViteDevServer;
+}
+export declare function handleHMRUpdate(file: string, server: ViteDevServer): Promise<any>;
+export declare function handleFileAddUnlink(file: string, server: ViteDevServer, isUnlink?: boolean): Promise<void>;
+export declare function handlePrunedModules(mods: Set<ModuleNode>, { ws }: ViteDevServer): void;
+/**
+ * Lex import.meta.hot.accept() for accepted deps.
+ * Since hot.accept() can only accept string literals or array of string
+ * literals, we don't really need a heavy @babel/parse call on the entire source.
+ *
+ * @returns selfAccepts
+ */
+export declare function lexAcceptedHmrDeps(code: string, start: number, urls: Set<{
+    url: string;
+    start: number;
+    end: number;
+}>): boolean;

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

@@ -0,0 +1,214 @@
+/// <reference types="node" />
+import * as http from 'http';
+import { CommonServerOptions } from '../http';
+import { InlineConfig, ResolvedConfig } from '../config';
+import { PluginContainer } from './pluginContainer';
+import { FSWatcher, WatchOptions } from 'types/chokidar';
+import { WebSocketServer } from './ws';
+import { ModuleGraph, ModuleNode } from './moduleGraph';
+import { Connect } from 'types/connect';
+import { HmrOptions } from './hmr';
+import { TransformOptions, TransformResult } from './transformRequest';
+import { ESBuildTransformResult } from '../plugins/esbuild';
+import { TransformOptions as EsbuildTransformOptions } from 'esbuild';
+import { DepOptimizationMetadata } from '../optimizer';
+import { SourceMap } from 'rollup';
+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)
+     */
+    hmr?: HmrOptions | boolean;
+    /**
+     * chokidar watch options
+     * https://github.com/paulmillr/chokidar#api
+     */
+    watch?: WatchOptions;
+    /**
+     * Create Vite dev server to be used as a middleware in an existing server
+     */
+    middlewareMode?: boolean | 'html' | 'ssr';
+    /**
+     * Prepend this folder to http requests, for use when proxying vite as a subfolder
+     * Should start and end with the `/` character
+     */
+    base?: string;
+    /**
+     * Options for files served via '/\@fs/'.
+     */
+    fs?: FileSystemServeOptions;
+    /**
+     * Origin for the generated asset URLs.
+     */
+    origin?: string;
+}
+export interface ResolvedServerOptions extends ServerOptions {
+    fs: Required<FileSystemServeOptions>;
+}
+export interface FileSystemServeOptions {
+    /**
+     * Strictly restrict file accessing outside of allowing paths.
+     *
+     * Set to `false` to disable the warning
+     *
+     * @default true
+     */
+    strict?: boolean;
+    /**
+     * Restrict accessing files outside the allowed directories.
+     *
+     * Accepts absolute path or a path relative to project root.
+     * Will try to search up for workspace root by default.
+     */
+    allow?: string[];
+    /**
+     * Restrict accessing files that matches the patterns.
+     *
+     * This will have higher priority than `allow`.
+     * Glob patterns are supported.
+     *
+     * @default ['.env', '.env.*', '*.crt', '*.pem']
+     *
+     * @experimental
+     */
+    deny?: string[];
+}
+export declare type ServerHook = (server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>;
+export interface ViteDevServer {
+    /**
+     * The resolved vite config object
+     */
+    config: ResolvedConfig;
+    /**
+     * A connect app instance.
+     * - Can be used to attach custom middlewares to the dev server.
+     * - Can also be used as the handler function of a custom http server
+     *   or as a middleware in any connect-style Node.js frameworks
+     *
+     * https://github.com/senchalabs/connect#use-middleware
+     */
+    middlewares: Connect.Server;
+    /**
+     * @deprecated use `server.middlewares` instead
+     */
+    app: Connect.Server;
+    /**
+     * native Node http server instance
+     * will be null in middleware mode
+     */
+    httpServer: http.Server | null;
+    /**
+     * chokidar watcher instance
+     * https://github.com/paulmillr/chokidar#api
+     */
+    watcher: FSWatcher;
+    /**
+     * web socket server with `send(payload)` method
+     */
+    ws: WebSocketServer;
+    /**
+     * Rollup plugin container that can run plugin hooks on a given file
+     */
+    pluginContainer: PluginContainer;
+    /**
+     * Module graph that tracks the import relationships, url to file mapping
+     * and hmr state.
+     */
+    moduleGraph: ModuleGraph;
+    /**
+     * Programmatically resolve, load and transform a URL and get the result
+     * without going through the http request pipeline.
+     */
+    transformRequest(url: string, options?: TransformOptions): Promise<TransformResult | null>;
+    /**
+     * Apply vite built-in HTML transforms and any plugin HTML transforms.
+     */
+    transformIndexHtml(url: string, html: string, originalUrl?: string): Promise<string>;
+    /**
+     * Util for transforming a file with esbuild.
+     * Can be useful for certain plugins.
+     *
+     * @deprecated import `transformWithEsbuild` from `vite` instead
+     */
+    transformWithEsbuild(code: string, filename: string, options?: EsbuildTransformOptions, inMap?: object): Promise<ESBuildTransformResult>;
+    /**
+     * Transform module code into SSR format.
+     * @experimental
+     */
+    ssrTransform(code: string, inMap: SourceMap | null, url: string): Promise<TransformResult | null>;
+    /**
+     * Load a given URL as an instantiated module for SSR.
+     */
+    ssrLoadModule(url: string): Promise<Record<string, any>>;
+    /**
+     * Fix ssr error stacktrace
+     */
+    ssrFixStacktrace(e: Error): void;
+    /**
+     * Start the server.
+     */
+    listen(port?: number, isRestart?: boolean): Promise<ViteDevServer>;
+    /**
+     * Stop the server.
+     */
+    close(): Promise<void>;
+    /**
+     * Print server urls
+     */
+    printUrls(): void;
+    /**
+     * Restart the server.
+     *
+     * @param forceOptimize - force the optimizer to re-bundle, same as --force cli flag
+     */
+    restart(forceOptimize?: boolean): Promise<void>;
+    /**
+     * @internal
+     */
+    _optimizeDepsMetadata: DepOptimizationMetadata | null;
+    /**
+     * Deps that are externalized
+     * @internal
+     */
+    _ssrExternals: string[] | null;
+    /**
+     * @internal
+     */
+    _globImporters: Record<string, {
+        module: ModuleNode;
+        importGlobs: {
+            base: string;
+            pattern: string;
+        }[];
+    }>;
+    /**
+     * @internal
+     */
+    _restartPromise: Promise<void> | null;
+    /**
+     * @internal
+     */
+    _forceOptimizeOnRestart: boolean;
+    /**
+     * @internal
+     */
+    _isRunningOptimizer: boolean;
+    /**
+     * @internal
+     */
+    _registerMissingImport: ((id: string, resolved: string, ssr: boolean | undefined) => void) | null;
+    /**
+     * @internal
+     */
+    _pendingReload: Promise<void> | null;
+    /**
+     * @internal
+     */
+    _pendingRequests: Map<string, Promise<TransformResult | null>>;
+}
+export declare function createServer(inlineConfig?: InlineConfig): Promise<ViteDevServer>;
+export declare function resolveServerOptions(root: string, raw?: ServerOptions): ResolvedServerOptions;

package/dist/node/server/middlewares/base.d.ts

@@ -0,0 +1,3 @@
+import { ViteDevServer } from '..';
+import { Connect } from 'types/connect';
+export declare function baseMiddleware({ config }: ViteDevServer): Connect.NextHandleFunction;

package/dist/node/server/middlewares/error.d.ts

@@ -0,0 +1,8 @@
+import { RollupError } from 'rollup';
+import { ViteDevServer } from '../..';
+import { Connect } from 'types/connect';
+import { ErrorPayload } from 'types/hmrPayload';
+export declare function prepareError(err: Error | RollupError): ErrorPayload['err'];
+export declare function buildErrorMessage(err: RollupError, args?: string[], includeStack?: boolean): string;
+export declare function logError(server: ViteDevServer, err: RollupError): void;
+export declare function errorMiddleware(server: ViteDevServer, allowNext?: boolean): Connect.ErrorHandleFunction;

package/dist/node/server/middlewares/indexHtml.d.ts

@@ -0,0 +1,4 @@
+import { Connect } from 'types/connect';
+import { ViteDevServer } from '../..';
+export declare function createDevHtmlTransformFn(server: ViteDevServer): (url: string, html: string, originalUrl: string) => Promise<string>;
+export declare function indexHtmlMiddleware(server: ViteDevServer): Connect.NextHandleFunction;

package/dist/node/server/middlewares/proxy.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import * as http from 'http';
+import { Connect } from 'types/connect';
+import { HttpProxy } from 'types/http-proxy';
+import { ResolvedConfig } from '../..';
+export interface ProxyOptions extends HttpProxy.ServerOptions {
+    /**
+     * rewrite path
+     */
+    rewrite?: (path: string) => string;
+    /**
+     * configure the proxy server (e.g. listen to events)
+     */
+    configure?: (proxy: HttpProxy.Server, options: ProxyOptions) => void;
+    /**
+     * webpack-dev-server style bypass function
+     */
+    bypass?: (req: http.IncomingMessage, res: http.ServerResponse, options: ProxyOptions) => void | null | undefined | false | string;
+}
+export declare function proxyMiddleware(httpServer: http.Server | null, config: ResolvedConfig): Connect.NextHandleFunction;

package/dist/node/server/middlewares/spaFallback.d.ts

@@ -0,0 +1,2 @@
+import { Connect } from 'types/connect';
+export declare function spaFallbackMiddleware(root: string): Connect.NextHandleFunction;

package/dist/node/server/middlewares/static.d.ts

@@ -0,0 +1,6 @@
+import { Connect } from 'types/connect';
+import { ViteDevServer } from '../..';
+export declare function servePublicMiddleware(dir: string): Connect.NextHandleFunction;
+export declare function serveStaticMiddleware(dir: string, server: ViteDevServer): Connect.NextHandleFunction;
+export declare function serveRawFsMiddleware(server: ViteDevServer): Connect.NextHandleFunction;
+export declare function isFileServingAllowed(url: string, server: ViteDevServer): boolean;

package/dist/node/server/middlewares/time.d.ts

@@ -0,0 +1,2 @@
+import { Connect } from 'types/connect';
+export declare function timeMiddleware(root: string): Connect.NextHandleFunction;

package/dist/node/server/middlewares/transform.d.ts

@@ -0,0 +1,3 @@
+import { ViteDevServer } from '..';
+import { Connect } from 'types/connect';
+export declare function transformMiddleware(server: ViteDevServer): Connect.NextHandleFunction;

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

@@ -0,0 +1,53 @@
+import { ModuleInfo, PartialResolvedId } from 'rollup';
+import { TransformResult } from './transformRequest';
+export declare class ModuleNode {
+    /**
+     * Public served url path, starts with /
+     */
+    url: string;
+    /**
+     * Resolved file system path + query
+     */
+    id: string | null;
+    file: string | null;
+    type: 'js' | 'css';
+    info?: ModuleInfo;
+    meta?: Record<string, any>;
+    importers: Set<ModuleNode>;
+    importedModules: Set<ModuleNode>;
+    acceptedHmrDeps: Set<ModuleNode>;
+    isSelfAccepting: boolean;
+    transformResult: TransformResult | null;
+    ssrTransformResult: TransformResult | null;
+    ssrModule: Record<string, any> | null;
+    lastHMRTimestamp: number;
+    constructor(url: string);
+}
+export declare type ResolvedUrl = [
+    url: string,
+    resolvedId: string,
+    meta: object | null | undefined
+];
+export declare class ModuleGraph {
+    private resolveId;
+    urlToModuleMap: Map<string, ModuleNode>;
+    idToModuleMap: Map<string, ModuleNode>;
+    fileToModulesMap: Map<string, Set<ModuleNode>>;
+    safeModulesPath: Set<string>;
+    constructor(resolveId: (url: string) => Promise<PartialResolvedId | null>);
+    getModuleByUrl(rawUrl: string): Promise<ModuleNode | undefined>;
+    getModuleById(id: string): ModuleNode | undefined;
+    getModulesByFile(file: string): Set<ModuleNode> | undefined;
+    onFileChange(file: string): void;
+    invalidateModule(mod: ModuleNode, seen?: Set<ModuleNode>): void;
+    invalidateAll(): void;
+    /**
+     * Update the module graph based on a module's updated imports information
+     * If there are dependencies that no longer have any importers, they are
+     * returned as a Set.
+     */
+    updateModuleInfo(mod: ModuleNode, importedModules: Set<string | ModuleNode>, acceptedModules: Set<string | ModuleNode>, isSelfAccepting: boolean): Promise<Set<ModuleNode> | undefined>;
+    ensureEntryFromUrl(rawUrl: string): Promise<ModuleNode>;
+    createFileOnlyEntry(file: string): ModuleNode;
+    resolveUrl(url: string): Promise<ResolvedUrl>;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * The following is modified based on source found in
+ * https://github.com/facebook/create-react-app
+ *
+ * MIT Licensed
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * https://github.com/facebook/create-react-app/blob/master/LICENSE
+ *
+ */
+import { Logger } from '../logger';
+/**
+ * Reads the BROWSER environment variable and decides what to do with it.
+ * Returns true if it opened a browser or ran a node.js script, otherwise false.
+ */
+export declare function openBrowser(url: string, opt: string | true, logger: Logger): boolean;

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

@@ -0,0 +1,37 @@
+/**
+ * This file is refactored into TypeScript based on
+ * https://github.com/preactjs/wmr/blob/main/packages/wmr/src/lib/rollup-plugin-container.js
+ */
+import { Plugin } from '../plugin';
+import { InputOptions, OutputOptions, ModuleInfo, PartialResolvedId, LoadResult, SourceDescription } from 'rollup';
+import * as acorn from 'acorn';
+import { FSWatcher } from 'chokidar';
+import { ResolvedConfig } from '../config';
+import { ModuleGraph } from './moduleGraph';
+export interface PluginContainerOptions {
+    cwd?: string;
+    output?: OutputOptions;
+    modules?: Map<string, {
+        info: ModuleInfo;
+    }>;
+    writeFile?: (name: string, source: string | Uint8Array) => void;
+}
+export interface PluginContainer {
+    options: InputOptions;
+    getModuleInfo(id: string): ModuleInfo | null;
+    buildStart(options: InputOptions): Promise<void>;
+    resolveId(id: string, importer?: string, options?: {
+        skip?: Set<Plugin>;
+        ssr?: boolean;
+    }): Promise<PartialResolvedId | null>;
+    transform(code: string, id: string, options?: {
+        inMap?: SourceDescription['map'];
+        ssr?: boolean;
+    }): Promise<SourceDescription | null>;
+    load(id: string, options?: {
+        ssr?: boolean;
+    }): Promise<LoadResult | null>;
+    close(): Promise<void>;
+}
+export declare let parser: typeof acorn.Parser;
+export declare function createPluginContainer({ plugins, logger, root, build: { rollupOptions } }: ResolvedConfig, moduleGraph?: ModuleGraph, watcher?: FSWatcher): Promise<PluginContainer>;

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

@@ -0,0 +1,8 @@
+/**
+ * Search up for the nearest `package.json`
+ */
+export declare function searchForPackageRoot(current: string, root?: string): string;
+/**
+ * Search up for the nearest workspace root
+ */
+export declare function searchForWorkspaceRoot(current: string, root?: string): string;

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

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import { SourceMap } from 'rollup';
+export declare function send(req: IncomingMessage, res: ServerResponse, content: string | Buffer, type: string, etag?: string, cacheControl?: string, map?: SourceMap | null): void;

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

@@ -0,0 +1,8 @@
+import { Logger } from '../logger';
+interface SourceMapLike {
+    sources: string[];
+    sourcesContent?: (string | null)[];
+    sourceRoot?: string;
+}
+export declare function injectSourcesContent(map: SourceMapLike, file: string, logger: Logger): Promise<void>;
+export {};

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

@@ -0,0 +1,14 @@
+import { SourceMap } from 'rollup';
+import { ViteDevServer } from '..';
+export interface TransformResult {
+    code: string;
+    map: SourceMap | null;
+    etag?: string;
+    deps?: string[];
+    dynamicDeps?: string[];
+}
+export interface TransformOptions {
+    ssr?: boolean;
+    html?: boolean;
+}
+export declare function transformRequest(url: string, server: ViteDevServer, options?: TransformOptions): Promise<TransformResult | null>;

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

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { Server } from 'http';
+import { ServerOptions as HttpsServerOptions } from 'https';
+import { WebSocket as WebSocketTypes } from 'types/ws';
+import { HMRPayload } from 'types/hmrPayload';
+import { ResolvedConfig } from '..';
+export declare const HMR_HEADER = "vite-hmr";
+export interface WebSocketServer {
+    on: WebSocketTypes.Server['on'];
+    off: WebSocketTypes.Server['off'];
+    send(payload: HMRPayload): void;
+    close(): Promise<void>;
+}
+export declare function createWebSocketServer(server: Server | null, config: ResolvedConfig, httpsOptions?: HttpsServerOptions): WebSocketServer;

package/dist/node/ssr/ssrExternal.d.ts

@@ -0,0 +1,7 @@
+import { ResolvedConfig } from '..';
+/**
+ * Heuristics for determining whether a dependency should be externalized for
+ * server-side rendering.
+ */
+export declare function resolveSSRExternal(config: ResolvedConfig, knownImports: string[]): string[];
+export declare function shouldExternalizeForSSR(id: string, externals: string[]): boolean;

package/dist/node/ssr/ssrManifestPlugin.d.ts

@@ -0,0 +1,3 @@
+import { ResolvedConfig } from '..';
+import { Plugin } from '../plugin';
+export declare function ssrManifestPlugin(config: ResolvedConfig): Plugin;

package/dist/node/ssr/ssrModuleLoader.d.ts

@@ -0,0 +1,7 @@
+import { ViteDevServer } from '../server';
+interface SSRContext {
+    global: typeof globalThis;
+}
+declare type SSRModule = Record<string, any>;
+export declare function ssrLoadModule(url: string, server: ViteDevServer, context?: SSRContext, urlStack?: string[]): Promise<SSRModule>;
+export {};

package/dist/node/ssr/ssrStacktrace.d.ts

@@ -0,0 +1,3 @@
+import { ModuleGraph } from '../server/moduleGraph';
+export declare function ssrRewriteStacktrace(stack: string, moduleGraph: ModuleGraph): string;
+export declare function rebindErrorStacktrace(e: Error, stacktrace: string): void;

package/dist/node/ssr/ssrTransform.d.ts

@@ -0,0 +1,8 @@
+import { SourceMap } from 'rollup';
+import { TransformResult } from '../server/transformRequest';
+export declare const ssrModuleExportsKey = "__vite_ssr_exports__";
+export declare const ssrImportKey = "__vite_ssr_import__";
+export declare const ssrDynamicImportKey = "__vite_ssr_dynamic_import__";
+export declare const ssrExportAllKey = "__vite_ssr_exportAll__";
+export declare const ssrImportMetaKey = "__vite_ssr_import_meta__";
+export declare function ssrTransform(code: string, inMap: SourceMap | null, url: string): Promise<TransformResult | null>;