vite 2.9.12 → 3.0.0-alpha.10

package/dist/node/index.d.ts

@@ -24,7 +24,7 @@ import type { OutgoingHttpHeaders } from 'http';
 import type { OutputBundle } from 'rollup';
 import type { OutputChunk } from 'rollup';
 import type { PartialResolvedId } from 'rollup';
-import type { Plugin as Plugin_2 } from 'rollup';
+import type { Plugin as Plugin_3 } from 'rollup';
 import type { PluginContext } from 'rollup';
 import type { PluginHooks } from 'rollup';
 import type * as PostCSS from 'postcss';
@@ -36,15 +36,14 @@ import type { RollupWatcher } from 'rollup';
 import type { SecureContextOptions } from 'tls';
 import type { Server } from 'http';
 import type { Server as Server_2 } from 'https';
-import type { Server as Server_3 } from 'net';
 import type { ServerOptions as ServerOptions_2 } from 'https';
 import type { ServerResponse } from 'http';
 import type { SourceDescription } from 'rollup';
 import type { SourceMap } from 'rollup';
 import type * as stream from 'stream';
 import type { TransformPluginContext } from 'rollup';
-import type { TransformResult as TransformResult_2 } from 'esbuild';
-import type { TransformResult as TransformResult_3 } from 'rollup';
+import type { TransformResult as TransformResult_2 } from 'rollup';
+import type { TransformResult as TransformResult_3 } from 'esbuild';
 import type * as url from 'url';
 import type { URL as URL_2 } from 'url';
 import type { WatcherOptions } from 'rollup';
@@ -95,11 +94,6 @@ export declare interface AwaitWriteFinishOptions {
 export declare function build(inlineConfig?: InlineConfig): Promise<RollupOutput | RollupOutput[] | RollupWatcher>;
 
 export declare interface BuildOptions {
-    /**
-     * Base public path when served in production.
-     * @deprecated `base` is now a root-level config option.
-     */
-    base?: string;
     /**
      * Compatibility transform target. The transform is performed with esbuild
      * and the lowest supported target is es2015/es6. Note this only handles
@@ -123,13 +117,6 @@ export declare interface BuildOptions {
      * @default true
      */
     polyfillModulePreload?: boolean;
-    /**
-     * whether to inject dynamic import polyfill.
-     * Note: does not apply to library mode.
-     * @default false
-     * @deprecated use plugin-legacy for browsers that don't support dynamic import
-     */
-    polyfillDynamicImport?: boolean;
     /**
      * Directory relative from `root` where build output will be placed. If the
      * directory exists, it will be removed before the build.
@@ -183,10 +170,6 @@ export declare interface BuildOptions {
      * https://terser.org/docs/api-reference#minify-options
      */
     terserOptions?: Terser.MinifyOptions;
-    /**
-     * @deprecated Vite now uses esbuild for CSS minification.
-     */
-    cleanCssOptions?: any;
     /**
      * Will be merged with internal rollup options.
      * https://rollupjs.org/guide/en/#big-list-of-options
@@ -251,12 +234,6 @@ export declare interface BuildOptions {
      * Can slightly improve build speed.
      */
     reportCompressedSize?: boolean;
-    /**
-     * Set to false to disable brotli compressed size reporting for build.
-     * Can slightly improve build speed.
-     * @deprecated use `build.reportCompressedSize` instead.
-     */
-    brotliSize?: boolean;
     /**
      * Adjust chunk size warning limit (in kbs).
      * @default 500
@@ -556,6 +533,13 @@ export declare interface DepOptimizationOptions {
      * vite project root. This will overwrite default entries inference.
      */
     entries?: string | string[];
+    /**
+     * Enable esbuild based scan phase, to get back to the optimized deps discovery
+     * strategy used in Vite v2
+     * @default false
+     * @experimental
+     */
+    devScan?: boolean;
     /**
      * Force optimize listed dependencies (must be resolvable import paths,
      * cannot be globs).
@@ -566,6 +550,12 @@ export declare 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
      *
@@ -574,15 +564,10 @@ export declare interface DepOptimizationOptions {
      *
      * - `external` is also omitted, use Vite's `optimizeDeps.exclude` option
      * - `plugins` are merged with Vite's dep plugin
-     * - `keepNames` takes precedence over the deprecated `optimizeDeps.keepNames`
      *
      * https://esbuild.github.io/api
      */
     esbuildOptions?: Omit<BuildOptions_2, 'bundle' | 'entryPoints' | 'external' | 'write' | 'watch' | 'outdir' | 'outfile' | 'outbase' | 'outExtension' | 'metafile'>;
-    /**
-     * @deprecated use `esbuildOptions.keepNames`
-     */
-    keepNames?: boolean;
     /**
      * List of file extensions that can be optimized. A corresponding esbuild
      * plugin must exist to handle the specific extension.
@@ -594,11 +579,13 @@ export declare 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 declare interface DepOptimizationProcessing {
@@ -617,6 +604,20 @@ export declare interface DepOptimizationResult {
     cancel: () => void;
 }
 
+export declare 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;
+    delayDepsOptimizerUntil: (id: string, done: () => Promise<any>) => void;
+    registerWorkersSource: (id: string) => void;
+    resetRegisteredIds: () => void;
+    options: DepOptimizationOptions;
+}
+
 export declare interface ErrorPayload {
     type: 'error'
     err: {
@@ -643,10 +644,28 @@ export declare interface ESBuildOptions extends EsbuildTransformOptions {
 
 export { EsbuildTransformOptions }
 
-export declare type ESBuildTransformResult = Omit<TransformResult_2, 'map'> & {
+export declare type ESBuildTransformResult = Omit<TransformResult_3, 'map'> & {
     map: SourceMap;
 };
 
+export declare interface ExperimentalOptions {
+    /**
+     * Append fake `&lang.(ext)` when queries are specified, to preseve the file extension for following plugins to process.
+     *
+     * @experimental
+     * @default false
+     */
+    importGlobRestoreExtension?: boolean;
+}
+
+export declare type ExportsData = {
+    hasImports: boolean;
+    exports: readonly string[];
+    facade: boolean;
+    hasReExports?: boolean;
+    jsxLoader?: boolean;
+};
+
 export declare interface FileSystemServeOptions {
     /**
      * Strictly restrict file accessing outside of allowing paths.
@@ -670,13 +689,11 @@ export declare interface FileSystemServeOptions {
      * Glob patterns are supported.
      *
      * @default ['.env', '.env.*', '*.crt', '*.pem']
-     *
-     * @experimental
      */
     deny?: string[];
 }
 
-export declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): ExistingRawSourceMap;
+export declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;
 
 export declare class FSWatcher extends EventEmitter implements fs.FSWatcher {
     options: WatchOptions
@@ -1014,6 +1031,86 @@ export declare namespace HttpProxy {
     }
 }
 
+export declare interface ImportGlobEagerFunction {
+    /**
+     * 1. No generic provided, infer the type from `as`
+     */
+    <
+    As extends string,
+    T = As extends keyof KnownAsTypeMap ? KnownAsTypeMap[As] : unknown
+    >(
+    glob: string | string[],
+    options?: Omit<ImportGlobOptions<boolean, As>, 'eager'>
+    ): Record<string, T>
+    /**
+     * 2. Module generic provided
+     */
+    <M>(
+    glob: string | string[],
+    options?: Omit<ImportGlobOptions<boolean, string>, 'eager'>
+    ): Record<string, M>
+}
+
+export declare interface ImportGlobFunction {
+    /**
+     * 1. No generic provided, infer the type from `eager` and `as`
+     */
+    <
+    Eager extends boolean,
+    As extends string,
+    T = As extends keyof KnownAsTypeMap ? KnownAsTypeMap[As] : unknown
+    >(
+    glob: string | string[],
+    options?: ImportGlobOptions<Eager, As>
+    ): (Eager extends true ? true : false) extends true
+    ? Record<string, T>
+    : Record<string, () => Promise<T>>
+    /**
+     * 2. Module generic provided, infer the type from `eager: false`
+     */
+    <M>(
+    glob: string | string[],
+    options?: ImportGlobOptions<false, string>
+    ): Record<string, () => Promise<M>>
+    /**
+     * 3. Module generic provided, infer the type from `eager: true`
+     */
+    <M>(
+    glob: string | string[],
+    options: ImportGlobOptions<true, string>
+    ): Record<string, M>
+}
+
+export declare interface ImportGlobOptions<
+Eager extends boolean,
+AsType extends string
+> {
+    /**
+     * Import type for the import url.
+     */
+    as?: AsType
+    /**
+     * Import as static or dynamic
+     *
+     * @default false
+     */
+    eager?: Eager
+    /**
+     * Import only the specific named export. Set to `default` to import the default export.
+     */
+    import?: string
+    /**
+     * Custom queries
+     */
+    query?: string | Record<string, string | number | boolean>
+    /**
+     * Search files also inside `node_modules/` and hidden directories (e.g. `.git/`). This might have impact on performance.
+     *
+     * @default false
+     */
+    exhaustive?: boolean
+}
+
 export declare type IndexHtmlTransform = IndexHtmlTransformHook | {
     enforce?: 'pre' | 'post';
     transform: IndexHtmlTransformHook;
@@ -1070,8 +1167,12 @@ export declare interface InternalResolveOptions extends ResolveOptions {
     isFromTsImporter?: boolean;
     tryEsmOnly?: boolean;
     scan?: boolean;
+    getDepsOptimizer?: () => DepsOptimizer | undefined;
+    shouldExternalize?: (id: string) => boolean | undefined;
 }
 
+export declare function isDepsOptimizerEnabled(config: ResolvedConfig): boolean;
+
 export declare interface JsonOptions {
     /**
      * Generate a named export for every property of the JSON object
@@ -1086,12 +1187,34 @@ export declare interface JsonOptions {
     stringify?: boolean;
 }
 
+export declare interface KnownAsTypeMap {
+    raw: string
+    url: string
+    worker: Worker
+}
+
 export declare type LibraryFormats = 'es' | 'cjs' | 'umd' | 'iife';
 
 export declare interface LibraryOptions {
+    /**
+     * Path of library entry
+     */
     entry: string;
+    /**
+     * The name of the exposed global variable. Required when the `formats` option includes
+     * `umd` or `iife`
+     */
     name?: string;
+    /**
+     * Output bundle formats
+     * @default ['es', 'umd']
+     */
     formats?: LibraryFormats[];
+    /**
+     * The name of the package file output. The default file name is the name option
+     * of the project package.json. It can also be defined as a function taking the
+     * format as an argument.
+     */
     fileName?: string | ((format: ModuleFormat) => string);
 }
 
@@ -1147,6 +1270,8 @@ export declare interface ManifestChunk {
 
 export declare type Matcher = AnymatchPattern | AnymatchPattern[]
 
+export declare function mergeAlias(a?: AliasOptions, b?: AliasOptions): AliasOptions | undefined;
+
 export declare function mergeConfig(defaults: Record<string, any>, overrides: Record<string, any>, isRoot?: boolean): Record<string, any>;
 
 export declare class ModuleGraph {
@@ -1213,12 +1338,11 @@ export declare interface OptimizedDepInfo {
      * but the bundles may not yet be saved to disk
      */
     processing?: Promise<void>;
-}
-
-export declare interface OptimizedDeps {
-    metadata: DepOptimizationMetadata;
-    scanProcessing?: Promise<void>;
-    registerMissingImport: (id: string, resolved: string) => OptimizedDepInfo;
+    /**
+     * 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>;
 }
 
 /**
@@ -1238,6 +1362,8 @@ export declare interface PackageData {
     getResolvedCache: (key: string, targetWeb: boolean) => string | undefined;
     data: {
         [field: string]: any;
+        name: string;
+        type: string;
         version: string;
         main: string;
         module: string;
@@ -1268,7 +1394,7 @@ export declare interface PackageData {
  * If a plugin should be applied only for server or build, a function format
  * config file can be used to conditional determine the plugins to use.
  */
-export declare interface Plugin extends Plugin_2 {
+declare interface Plugin_2 extends Plugin_3 {
     /**
      * Enforce plugin invocation tier similar to webpack loaders.
      *
@@ -1363,15 +1489,16 @@ export declare interface Plugin extends Plugin_2 {
     }): Promise<LoadResult> | LoadResult;
     transform?(this: TransformPluginContext, code: string, id: string, options?: {
         ssr?: boolean;
-    }): Promise<TransformResult_3> | TransformResult_3;
+    }): Promise<TransformResult_2> | TransformResult_2;
 }
+export { Plugin_2 as Plugin }
 
 export declare interface PluginContainer {
     options: InputOptions;
     getModuleInfo(id: string): ModuleInfo | null;
     buildStart(options: InputOptions): Promise<void>;
     resolveId(id: string, importer?: string, options?: {
-        skip?: Set<Plugin>;
+        skip?: Set<Plugin_2>;
         ssr?: boolean;
         /* Excluded from this release type: scan */
     }): Promise<PartialResolvedId | null>;
@@ -1385,13 +1512,12 @@ export declare interface PluginContainer {
     close(): Promise<void>;
 }
 
-export declare type PluginOption = Plugin | false | null | undefined | PluginOption[];
+export declare type PluginOption = Plugin_2 | false | null | undefined | PluginOption[];
 
 /**
  * Starts the Vite server in preview mode, to simulate a production deployment
- * @experimental
  */
-export declare function preview(inlineConfig: InlineConfig): Promise<PreviewServer>;
+export declare function preview(inlineConfig?: InlineConfig): Promise<PreviewServer>;
 
 export declare interface PreviewOptions extends CommonServerOptions {
 }
@@ -1404,7 +1530,7 @@ export declare interface PreviewServer {
     /**
      * native Node http server instance
      */
-    httpServer: Server;
+    httpServer: http.Server;
     /**
      * Print server urls
      */
@@ -1416,11 +1542,6 @@ export declare type PreviewServerHook = (server: {
     httpServer: http.Server;
 }) => (() => void) | void | Promise<(() => void) | void>;
 
-/**
- * @deprecated Use `server.printUrls()` instead
- */
-export declare function printHttpServerUrls(server: Server_3, config: ResolvedConfig): void;
-
 export declare interface ProxyOptions extends HttpProxy.ServerOptions {
     /**
      * rewrite path
@@ -1443,9 +1564,9 @@ export declare interface PrunePayload {
 
 export declare function resolveConfig(inlineConfig: InlineConfig, command: 'build' | 'serve', defaultMode?: string): Promise<ResolvedConfig>;
 
-export declare type ResolvedBuildOptions = Required<Omit<BuildOptions, 'base' | 'cleanCssOptions' | 'polyfillDynamicImport' | 'brotliSize'>>;
+export declare type ResolvedBuildOptions = Required<BuildOptions>;
 
-export declare type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'alias' | 'dedupe' | 'assetsInclude' | 'optimizeDeps' | 'worker'> & {
+export declare type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'assetsInclude' | 'optimizeDeps' | 'worker'> & {
     configFile: string | undefined;
     configFileDependencies: string[];
     inlineConfig: InlineConfig;
@@ -1456,21 +1577,24 @@ export declare type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'alia
     command: 'build' | 'serve';
     mode: string;
     isWorker: boolean;
+    /* Excluded from this release type: mainConfig */
     isProduction: boolean;
     env: Record<string, any>;
     resolve: ResolveOptions & {
         alias: Alias[];
     };
-    plugins: readonly Plugin[];
+    plugins: readonly Plugin_2[];
     server: ResolvedServerOptions;
     build: ResolvedBuildOptions;
     preview: ResolvedPreviewOptions;
+    ssr: ResolvedSSROptions | undefined;
     assetsInclude: (file: string) => boolean;
     logger: Logger;
     createResolver: (options?: Partial<InternalResolveOptions>) => ResolveFn;
-    optimizeDeps: Omit<DepOptimizationOptions, 'keepNames'>;
+    optimizeDeps: DepOptimizationOptions;
     /* Excluded from this release type: packageCache */
     worker: ResolveWorkerOptions;
+    spa: boolean;
 }>;
 
 export declare interface ResolvedPreviewOptions extends PreviewOptions {
@@ -1480,6 +1604,11 @@ export declare interface ResolvedServerOptions extends ServerOptions {
     fs: Required<FileSystemServeOptions>;
 }
 
+export declare interface ResolvedSSROptions extends SSROptions {
+    target: SSRTarget;
+    format: SSRFormat;
+}
+
 export declare type ResolvedUrl = [
 url: string,
 resolvedId: string,
@@ -1511,7 +1640,7 @@ export declare interface ResolverObject {
 
 export declare interface ResolveWorkerOptions {
     format: 'es' | 'iife';
-    plugins: Plugin[];
+    plugins: Plugin_2[];
     rollupOptions: RollupOptions;
 }
 
@@ -1733,10 +1862,6 @@ export declare interface SendOptions {
 export declare type ServerHook = (server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>;
 
 export declare interface ServerOptions extends CommonServerOptions {
-    /**
-     * Force dep pre-optimization regardless of whether deps have changed.
-     */
-    force?: boolean;
     /**
      * Configure HMR-specific options (port, host, path & protocol)
      */
@@ -1767,14 +1892,12 @@ export declare interface ServerOptions extends CommonServerOptions {
     origin?: string;
     /**
      * Pre-transform known direct imports
-     *
-     * @experimental this option is experimental and might be changed in the future
      * @default true
      */
     preTransformRequests?: boolean;
 }
 
-export declare function sortUserPlugins(plugins: (Plugin | Plugin[])[] | undefined): [Plugin[], Plugin[], Plugin[]];
+export declare function sortUserPlugins(plugins: (Plugin_2 | Plugin_2[])[] | undefined): [Plugin_2[], Plugin_2[], Plugin_2[]];
 
 export declare function splitVendorChunk(options?: {
     cache?: SplitVendorChunkCache;
@@ -1786,7 +1909,9 @@ export declare class SplitVendorChunkCache {
     reset(): void;
 }
 
-export declare function splitVendorChunkPlugin(): Plugin;
+export declare function splitVendorChunkPlugin(): Plugin_2;
+
+export declare type SSRFormat = 'esm' | 'cjs';
 
 export declare interface SSROptions {
     external?: string[];
@@ -1797,6 +1922,14 @@ export declare interface SSROptions {
      * Default: 'node'
      */
     target?: SSRTarget;
+    /**
+     * Define the format for the ssr build. Since Vite v3 the SSR build generates ESM by default.
+     * `'cjs'` can be selected to generate a CJS build, but it isn't recommended. This option is
+     * left marked as experimental to give users more time to update to ESM. CJS builds requires
+     * complex externalization heuristics that aren't present in the ESM format.
+     * @experimental
+     */
+    format?: SSRFormat;
 }
 
 export declare type SSRTarget = 'node' | 'webworker';
@@ -1952,8 +2085,6 @@ export declare namespace Terser {
         module?: boolean
         nameCache?: object
         format?: FormatOptions
-        /** @deprecated use format instead */
-        output?: FormatOptions
         parse?: ParseOptions
         safari10?: boolean
         sourceMap?: boolean | SourceMapOptions
@@ -2082,11 +2213,27 @@ export declare interface UserConfig {
      * Preview specific options, e.g. host, port, https...
      */
     preview?: PreviewOptions;
+    /**
+     * Force dep pre-optimization regardless of whether deps have changed.
+     * @experimental
+     */
+    force?: boolean;
     /**
      * Dep optimization options
      */
     optimizeDeps?: DepOptimizationOptions;
-    /* Excluded from this release type: ssr */
+    /**
+     * SSR specific options
+     */
+    ssr?: SSROptions;
+    /**
+     * Experimental features
+     *
+     * Features under this field are addressed to be changed that might NOT follow semver.
+     * Please be careful and always pin Vite's version when using them.
+     * @experimental
+     */
+    experimental?: ExperimentalOptions;
     /**
      * Log level.
      * Default: 'info'
@@ -2111,17 +2258,6 @@ export declare interface UserConfig {
      * @default 'VITE_'
      */
     envPrefix?: string | string[];
-    /**
-     * Import aliases
-     * @deprecated use `resolve.alias` instead
-     */
-    alias?: AliasOptions;
-    /**
-     * Force Vite to always resolve listed dependencies to the same copy (from
-     * project root).
-     * @deprecated use `resolve.dedupe` instead
-     */
-    dedupe?: string[];
     /**
      * Worker bundle options
      */
@@ -2140,12 +2276,20 @@ export declare interface UserConfig {
          */
         rollupOptions?: Omit<RollupOptions, 'plugins' | 'input' | 'onwarn' | 'preserveEntrySignatures'>;
     };
+    /**
+     * Whether your application is a Single Page Application (SPA). Set to `false`
+     * for other kinds of apps like MPAs.
+     * @default true
+     */
+    spa?: boolean;
 }
 
 export declare type UserConfigExport = UserConfig | Promise<UserConfig> | UserConfigFn;
 
 export declare type UserConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>;
 
+export declare const version: string;
+
 export declare interface ViteDevServer {
     /**
      * The resolved vite config object
@@ -2160,10 +2304,6 @@ export declare interface ViteDevServer {
      * 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
@@ -2196,16 +2336,8 @@ export declare interface ViteDevServer {
      * 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>;
     /**
@@ -2240,9 +2372,8 @@ export declare interface ViteDevServer {
      * @param forceOptimize - force the optimizer to re-bundle, same as --force cli flag
      */
     restart(forceOptimize?: boolean): Promise<void>;
-    /* Excluded from this release type: _optimizedDeps */
+    /* Excluded from this release type: _importGlobMap */
     /* Excluded from this release type: _ssrExternals */
-    /* Excluded from this release type: _globImporters */
     /* Excluded from this release type: _restartPromise */
     /* Excluded from this release type: _forceOptimizeOnRestart */
     /* Excluded from this release type: _pendingRequests */
@@ -2284,8 +2415,10 @@ export declare interface WatchOptions {
     cwd?: string
 
     /**
-     *  If set to true then the strings passed to .watch() and .add() are treated as literal path
-     *  names, even if they look like globs. Default: false.
+     * If set to true then the strings passed to .watch() and .add() are treated as literal path
+     * names, even if they look like globs.
+     *
+     * @default false
      */
     disableGlobbing?: boolean
 
@@ -2350,7 +2483,7 @@ export declare interface WatchOptions {
     awaitWriteFinish?: AwaitWriteFinishOptions | boolean
 }
 
-export declare class WebSocket extends EventEmitter {
+declare class WebSocket_2 extends EventEmitter {
     /** The connection is not yet open. */
     static readonly CONNECTING: 0
     /** The connection is open and ready to communicate. */
@@ -2368,10 +2501,10 @@ export declare class WebSocket extends EventEmitter {
     readonly protocol: string
     /** The current state of the connection */
     readonly readyState:
-    | typeof WebSocket.CONNECTING
-    | typeof WebSocket.OPEN
-    | typeof WebSocket.CLOSING
-    | typeof WebSocket.CLOSED
+    | typeof WebSocket_2.CONNECTING
+    | typeof WebSocket_2.OPEN
+    | typeof WebSocket_2.CLOSING
+    | typeof WebSocket_2.CLOSED
     readonly url: string
 
     /** The connection is not yet open. */
@@ -2383,20 +2516,20 @@ export declare class WebSocket extends EventEmitter {
     /** The connection is closed. */
     readonly CLOSED: 3
 
-    onopen: ((event: WebSocket.Event) => void) | null
-    onerror: ((event: WebSocket.ErrorEvent) => void) | null
-    onclose: ((event: WebSocket.CloseEvent) => void) | null
-    onmessage: ((event: WebSocket.MessageEvent) => void) | null
+    onopen: ((event: WebSocket_2.Event) => void) | null
+    onerror: ((event: WebSocket_2.ErrorEvent) => void) | null
+    onclose: ((event: WebSocket_2.CloseEvent) => void) | null
+    onmessage: ((event: WebSocket_2.MessageEvent) => void) | null
 
     constructor(address: null)
     constructor(
     address: string | URL_2,
-    options?: WebSocket.ClientOptions | ClientRequestArgs
+    options?: WebSocket_2.ClientOptions | ClientRequestArgs
     )
     constructor(
     address: string | URL_2,
     protocols?: string | string[],
-    options?: WebSocket.ClientOptions | ClientRequestArgs
+    options?: WebSocket_2.ClientOptions | ClientRequestArgs
     )
 
     close(code?: number, data?: string | Buffer): void
@@ -2430,146 +2563,146 @@ export declare class WebSocket extends EventEmitter {
     // HTML5 WebSocket events
     addEventListener(
     method: 'message',
-    cb: (event: WebSocket.MessageEvent) => void,
-    options?: WebSocket.EventListenerOptions
+    cb: (event: WebSocket_2.MessageEvent) => void,
+    options?: WebSocket_2.EventListenerOptions
     ): void
     addEventListener(
     method: 'close',
-    cb: (event: WebSocket.CloseEvent) => void,
-    options?: WebSocket.EventListenerOptions
+    cb: (event: WebSocket_2.CloseEvent) => void,
+    options?: WebSocket_2.EventListenerOptions
     ): void
     addEventListener(
     method: 'error',
-    cb: (event: WebSocket.ErrorEvent) => void,
-    options?: WebSocket.EventListenerOptions
+    cb: (event: WebSocket_2.ErrorEvent) => void,
+    options?: WebSocket_2.EventListenerOptions
     ): void
     addEventListener(
     method: 'open',
-    cb: (event: WebSocket.Event) => void,
-    options?: WebSocket.EventListenerOptions
+    cb: (event: WebSocket_2.Event) => void,
+    options?: WebSocket_2.EventListenerOptions
     ): void
 
     removeEventListener(
     method: 'message',
-    cb: (event: WebSocket.MessageEvent) => void
+    cb: (event: WebSocket_2.MessageEvent) => void
     ): void
     removeEventListener(
     method: 'close',
-    cb: (event: WebSocket.CloseEvent) => void
+    cb: (event: WebSocket_2.CloseEvent) => void
     ): void
     removeEventListener(
     method: 'error',
-    cb: (event: WebSocket.ErrorEvent) => void
+    cb: (event: WebSocket_2.ErrorEvent) => void
     ): void
     removeEventListener(
     method: 'open',
-    cb: (event: WebSocket.Event) => void
+    cb: (event: WebSocket_2.Event) => void
     ): void
 
     // Events
     on(
     event: 'close',
-    listener: (this: WebSocket, code: number, reason: Buffer) => void
+    listener: (this: WebSocket_2, code: number, reason: Buffer) => void
     ): this
-    on(event: 'error', listener: (this: WebSocket, err: Error) => void): this
+    on(event: 'error', listener: (this: WebSocket_2, err: Error) => void): this
     on(
     event: 'upgrade',
-    listener: (this: WebSocket, request: IncomingMessage) => void
+    listener: (this: WebSocket_2, request: IncomingMessage) => void
     ): this
     on(
     event: 'message',
     listener: (
-    this: WebSocket,
-    data: WebSocket.RawData,
+    this: WebSocket_2,
+    data: WebSocket_2.RawData,
     isBinary: boolean
     ) => void
     ): this
-    on(event: 'open', listener: (this: WebSocket) => void): this
+    on(event: 'open', listener: (this: WebSocket_2) => void): this
     on(
     event: 'ping' | 'pong',
-    listener: (this: WebSocket, data: Buffer) => void
+    listener: (this: WebSocket_2, data: Buffer) => void
     ): this
     on(
     event: 'unexpected-response',
     listener: (
-    this: WebSocket,
+    this: WebSocket_2,
     request: ClientRequest,
     response: IncomingMessage
     ) => void
     ): this
     on(
     event: string | symbol,
-    listener: (this: WebSocket, ...args: any[]) => void
+    listener: (this: WebSocket_2, ...args: any[]) => void
     ): this
 
     once(
     event: 'close',
-    listener: (this: WebSocket, code: number, reason: Buffer) => void
+    listener: (this: WebSocket_2, code: number, reason: Buffer) => void
     ): this
-    once(event: 'error', listener: (this: WebSocket, err: Error) => void): this
+    once(event: 'error', listener: (this: WebSocket_2, err: Error) => void): this
     once(
     event: 'upgrade',
-    listener: (this: WebSocket, request: IncomingMessage) => void
+    listener: (this: WebSocket_2, request: IncomingMessage) => void
     ): this
     once(
     event: 'message',
     listener: (
-    this: WebSocket,
-    data: WebSocket.RawData,
+    this: WebSocket_2,
+    data: WebSocket_2.RawData,
     isBinary: boolean
     ) => void
     ): this
-    once(event: 'open', listener: (this: WebSocket) => void): this
+    once(event: 'open', listener: (this: WebSocket_2) => void): this
     once(
     event: 'ping' | 'pong',
-    listener: (this: WebSocket, data: Buffer) => void
+    listener: (this: WebSocket_2, data: Buffer) => void
     ): this
     once(
     event: 'unexpected-response',
     listener: (
-    this: WebSocket,
+    this: WebSocket_2,
     request: ClientRequest,
     response: IncomingMessage
     ) => void
     ): this
     once(
     event: string | symbol,
-    listener: (this: WebSocket, ...args: any[]) => void
+    listener: (this: WebSocket_2, ...args: any[]) => void
     ): this
 
     off(
     event: 'close',
-    listener: (this: WebSocket, code: number, reason: Buffer) => void
+    listener: (this: WebSocket_2, code: number, reason: Buffer) => void
     ): this
-    off(event: 'error', listener: (this: WebSocket, err: Error) => void): this
+    off(event: 'error', listener: (this: WebSocket_2, err: Error) => void): this
     off(
     event: 'upgrade',
-    listener: (this: WebSocket, request: IncomingMessage) => void
+    listener: (this: WebSocket_2, request: IncomingMessage) => void
     ): this
     off(
     event: 'message',
     listener: (
-    this: WebSocket,
-    data: WebSocket.RawData,
+    this: WebSocket_2,
+    data: WebSocket_2.RawData,
     isBinary: boolean
     ) => void
     ): this
-    off(event: 'open', listener: (this: WebSocket) => void): this
+    off(event: 'open', listener: (this: WebSocket_2) => void): this
     off(
     event: 'ping' | 'pong',
-    listener: (this: WebSocket, data: Buffer) => void
+    listener: (this: WebSocket_2, data: Buffer) => void
     ): this
     off(
     event: 'unexpected-response',
     listener: (
-    this: WebSocket,
+    this: WebSocket_2,
     request: ClientRequest,
     response: IncomingMessage
     ) => void
     ): this
     off(
     event: string | symbol,
-    listener: (this: WebSocket, ...args: any[]) => void
+    listener: (this: WebSocket_2, ...args: any[]) => void
     ): this
 
     addListener(
@@ -2583,7 +2716,7 @@ export declare class WebSocket extends EventEmitter {
     ): this
     addListener(
     event: 'message',
-    listener: (data: WebSocket.RawData, isBinary: boolean) => void
+    listener: (data: WebSocket_2.RawData, isBinary: boolean) => void
     ): this
     addListener(event: 'open', listener: () => void): this
     addListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this
@@ -2604,7 +2737,7 @@ export declare class WebSocket extends EventEmitter {
     ): this
     removeListener(
     event: 'message',
-    listener: (data: WebSocket.RawData, isBinary: boolean) => void
+    listener: (data: WebSocket_2.RawData, isBinary: boolean) => void
     ): this
     removeListener(event: 'open', listener: () => void): this
     removeListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this
@@ -2618,28 +2751,28 @@ export declare class WebSocket extends EventEmitter {
     ): this
 }
 
-export declare namespace WebSocket {
+declare namespace WebSocket_2 {
     /**
      * Data represents the raw message payload received over the WebSocket.
      */
-    export type RawData = Buffer | ArrayBuffer | Buffer[]
+    type RawData = Buffer | ArrayBuffer | Buffer[]
 
     /**
      * Data represents the message payload received over the WebSocket.
      */
-    export type Data = string | Buffer | ArrayBuffer | Buffer[]
+    type Data = string | Buffer | ArrayBuffer | Buffer[]
 
     /**
      * CertMeta represents the accepted types for certificate & key data.
      */
-    export type CertMeta = string | string[] | Buffer | Buffer[]
+    type CertMeta = string | string[] | Buffer | Buffer[]
 
     /**
      * VerifyClientCallbackSync is a synchronous callback used to inspect the
      * incoming message. The return value (boolean) of the function determines
      * whether or not to accept the handshake.
      */
-    export type VerifyClientCallbackSync = (info: {
+    type VerifyClientCallbackSync = (info: {
         origin: string
         secure: boolean
         req: IncomingMessage
@@ -2650,7 +2783,7 @@ export declare namespace WebSocket {
      * incoming message. The return value (boolean) of the function determines
      * whether or not to accept the handshake.
      */
-    export type VerifyClientCallbackAsync = (
+    type VerifyClientCallbackAsync = (
     info: { origin: string; secure: boolean; req: IncomingMessage },
     callback: (
     res: boolean,
@@ -2660,7 +2793,7 @@ export declare namespace WebSocket {
     ) => void
     ) => void
 
-    export interface ClientOptions extends SecureContextOptions {
+    interface ClientOptions extends SecureContextOptions {
         protocol?: string | undefined
         followRedirects?: boolean | undefined
         generateMask?(mask: Buffer): void
@@ -2680,7 +2813,7 @@ export declare namespace WebSocket {
         skipUTF8Validation?: boolean | undefined
     }
 
-    export interface PerMessageDeflateOptions {
+    interface PerMessageDeflateOptions {
         serverNoContextTakeover?: boolean | undefined
         clientNoContextTakeover?: boolean | undefined
         serverMaxWindowBits?: number | undefined
@@ -2703,19 +2836,19 @@ export declare namespace WebSocket {
         concurrencyLimit?: number | undefined
     }
 
-    export interface Event {
+    interface Event {
         type: string
         target: WebSocket
     }
 
-    export interface ErrorEvent {
+    interface ErrorEvent {
         error: any
         message: string
         type: string
         target: WebSocket
     }
 
-    export interface CloseEvent {
+    interface CloseEvent {
         wasClean: boolean
         code: number
         reason: string
@@ -2723,17 +2856,17 @@ export declare namespace WebSocket {
         target: WebSocket
     }
 
-    export interface MessageEvent {
+    interface MessageEvent {
         data: Data
         type: string
         target: WebSocket
     }
 
-    export interface EventListenerOptions {
+    interface EventListenerOptions {
         once?: boolean | undefined
     }
 
-    export interface ServerOptions {
+    interface ServerOptions {
         host?: string | undefined
         port?: number | undefined
         backlog?: number | undefined
@@ -2755,14 +2888,14 @@ export declare namespace WebSocket {
         WebSocket?: typeof WebSocket.WebSocket | undefined
     }
 
-    export interface AddressInfo {
+    interface AddressInfo {
         address: string
         family: string
         port: number
     }
 
     // WebSocket Server
-    export class Server<T extends WebSocket = WebSocket> extends EventEmitter {
+    class Server<T extends WebSocket = WebSocket> extends EventEmitter {
         options: ServerOptions
         path: string
         clients: Set<T>
@@ -2854,20 +2987,21 @@ export declare namespace WebSocket {
     }
 
     const WebSocketServer: typeof Server
-    export interface WebSocketServer extends Server {} // tslint:disable-line no-empty-interface
+    interface WebSocketServer extends Server {} // tslint:disable-line no-empty-interface
     const WebSocket: typeof WebSocketAlias
-    export interface WebSocket extends WebSocketAlias {} // tslint:disable-line no-empty-interface
+    interface WebSocket extends WebSocketAlias {} // tslint:disable-line no-empty-interface
 
     // WebSocket stream
-    export function createWebSocketStream(
+    function createWebSocketStream(
     websocket: WebSocket,
     options?: DuplexOptions
     ): Duplex
 }
+export { WebSocket_2 as WebSocket }
 
-export declare const WebSocketAlias: typeof WebSocket;
+export declare const WebSocketAlias: typeof WebSocket_2;
 
-export declare interface WebSocketAlias extends WebSocket {}
+export declare interface WebSocketAlias extends WebSocket_2 {}
 
 export declare interface WebSocketClient {
     /**
@@ -2882,7 +3016,7 @@ export declare interface WebSocketClient {
      * The raw WebSocket instance
      * @advanced
      */
-    socket: WebSocket;
+    socket: WebSocket_2;
 }
 
 export declare type WebSocketCustomListener<T> = (data: T, client: WebSocketClient) => void;
@@ -2907,13 +3041,13 @@ export declare interface WebSocketServer {
     /**
      * Handle custom event emitted by `import.meta.hot.send`
      */
-    on: WebSocket.Server['on'] & {
+    on: WebSocket_2.Server['on'] & {
         <T extends string>(event: T, listener: WebSocketCustomListener<InferCustomEventPayload<T>>): void;
     };
     /**
      * Unregister event listener.
      */
-    off: WebSocket.Server['off'] & {
+    off: WebSocket_2.Server['off'] & {
         (event: string, listener: Function): void;
     };
 }