vite 2.9.0-beta.1 → 2.9.0-beta.10

package/dist/node/index.d.ts

@@ -10,6 +10,7 @@ import type { DuplexOptions } from 'stream';
 import { TransformOptions as EsbuildTransformOptions } from 'esbuild';
 import { EventEmitter } from 'events';
 import * as events from 'events';
+import type { ExistingRawSourceMap } from 'rollup';
 import type * as fs from 'fs';
 import type { GetManualChunk } from 'rollup';
 import * as http from 'http';
@@ -34,8 +35,8 @@ import type { RollupOutput } from 'rollup';
 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 { Server as Server_2 } from 'net';
+import type { Server as Server_3 } from 'https';
 import type { ServerOptions as ServerOptions_2 } from 'https';
 import type { ServerResponse } from 'http';
 import type { SourceDescription } from 'rollup';
@@ -47,6 +48,8 @@ import type { TransformResult as TransformResult_3 } from 'rollup';
 import type * as url from 'url';
 import type { URL as URL_2 } from 'url';
 import type { WatcherOptions } from 'rollup';
+import type { WebSocket as WebSocket_2 } from 'ws';
+import { WebSocketServer as WebSocketServer_2 } from 'ws';
 import type { ZlibOptions } from 'zlib';
 
 export declare interface Alias {
@@ -484,6 +487,19 @@ export declare interface CSSOptions {
     postcss?: string | (Postcss.ProcessOptions & {
         plugins?: Postcss.Plugin[];
     });
+    /**
+     * Enables css sourcemaps during dev
+     * @default false
+     * @experimental
+     */
+    devSourcemap?: boolean;
+}
+
+export declare interface CustomEventMap {
+    'vite:beforeUpdate': UpdatePayload
+    'vite:beforePrune': PrunePayload
+    'vite:beforeFullReload': FullReloadPayload
+    'vite:error': ErrorPayload
 }
 
 export declare interface CustomPayload {
@@ -516,15 +532,18 @@ export declare interface DepOptimizationMetadata {
      * Metadata for each already optimized dependency
      */
     optimized: Record<string, OptimizedDepInfo>;
+    /**
+     * Metadata for non-entry optimized chunks and dynamic imports
+     */
+    chunks: Record<string, OptimizedDepInfo>;
     /**
      * Metadata for each newly discovered dependency after processing
      */
     discovered: Record<string, OptimizedDepInfo>;
     /**
-     * During optimization, ids can still be resolved to their final location
-     * but the bundles may not yet be saved to disk
+     * OptimizedDepInfo list
      */
-    processing: Promise<DepOptimizationResult | undefined>;
+    depInfoList: OptimizedDepInfo[];
 }
 
 export declare interface DepOptimizationOptions {
@@ -579,18 +598,19 @@ export declare interface DepOptimizationOptions {
 }
 
 export declare interface DepOptimizationProcessing {
-    promise: Promise<DepOptimizationResult | undefined>;
-    resolve: (result?: DepOptimizationResult) => void;
+    promise: Promise<void>;
+    resolve: () => void;
 }
 
 export declare interface DepOptimizationResult {
+    metadata: DepOptimizationMetadata;
     /**
-     * After a re-optimization, the internal bundled chunks may change
-     * and a full page reload is required if that is the case
-     * If the files are stable, we can avoid the reload that is expensive
-     * for large applications
+     * When doing a re-run, if there are newly discovered dependendencies
+     * the page reload will be delayed until the next rerun so we need
+     * to be able to discard the result
      */
-    alteredFiles: boolean;
+    commit: () => void;
+    cancel: () => void;
 }
 
 export declare interface ErrorPayload {
@@ -652,6 +672,8 @@ export declare interface FileSystemServeOptions {
     deny?: string[];
 }
 
+export declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): ExistingRawSourceMap;
+
 export declare class FSWatcher extends EventEmitter implements fs.FSWatcher {
     options: WatchOptions
 
@@ -1015,6 +1037,9 @@ export declare type IndexHtmlTransformResult = string | HtmlTagDescriptor[] | {
     tags: HtmlTagDescriptor[];
 };
 
+export declare type InferCustomEventPayload<T extends string> =
+T extends keyof CustomEventMap ? CustomEventMap[T] : any
+
 export declare interface InlineConfig extends UserConfig {
     configFile?: string | false;
     envFile?: false;
@@ -1040,6 +1065,7 @@ export declare interface InternalResolveOptions extends ResolveOptions {
     isRequire?: boolean;
     isFromTsImporter?: boolean;
     tryEsmOnly?: boolean;
+    scan?: boolean;
 }
 
 export declare interface JsonOptions {
@@ -1171,8 +1197,9 @@ export declare class ModuleNode {
 export declare function normalizePath(id: string): string;
 
 export declare interface OptimizedDepInfo {
+    id: string;
     file: string;
-    src: string;
+    src?: string;
     needsInterop?: boolean;
     browserHash?: string;
     fileHash?: string;
@@ -1180,14 +1207,19 @@ export declare interface OptimizedDepInfo {
      * During optimization, ids can still be resolved to their final location
      * but the bundles may not yet be saved to disk
      */
-    processing: Promise<DepOptimizationResult | undefined>;
+    processing?: Promise<void>;
+}
+
+export declare interface OptimizedDeps {
+    metadata: DepOptimizationMetadata;
+    scanProcessing?: Promise<void>;
+    registerMissingImport: (id: string, resolved: string) => OptimizedDepInfo;
 }
 
 /**
  * Used by Vite CLI when running `vite optimize`
  */
-export declare function optimizeDeps(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean, newDeps?: Record<string, OptimizedDepInfo>, // missing imports encountered after server has started
-ssr?: boolean): Promise<DepOptimizationMetadata>;
+export declare function optimizeDeps(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
 
 /** Cache for package.json resolution and package.json contents */
 export declare type PackageCache = Map<string, PackageData>;
@@ -1310,6 +1342,7 @@ export declare interface Plugin extends Plugin_2 {
     resolveId?(this: PluginContext, source: string, importer: string | undefined, options: {
         custom?: CustomPluginOptions;
         ssr?: boolean;
+        /* Excluded from this release type: scan */
     }): Promise<ResolveIdResult> | ResolveIdResult;
     load?(this: PluginContext, id: string, options?: {
         ssr?: boolean;
@@ -1326,6 +1359,7 @@ export declare interface PluginContainer {
     resolveId(id: string, importer?: string, options?: {
         skip?: Set<Plugin>;
         ssr?: boolean;
+        /* Excluded from this release type: scan */
     }): Promise<PartialResolvedId | null>;
     transform(code: string, id: string, options?: {
         inMap?: SourceDescription['map'];
@@ -1368,7 +1402,7 @@ export declare interface PreviewServer {
 /**
  * @deprecated Use `server.printUrls()` instead
  */
-export declare function printHttpServerUrls(server: Server_3, config: ResolvedConfig): void;
+export declare function printHttpServerUrls(server: Server_2, config: ResolvedConfig): void;
 
 export declare interface ProxyOptions extends HttpProxy.ServerOptions {
     /**
@@ -1404,6 +1438,7 @@ export declare type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'alia
     cacheDir: string;
     command: 'build' | 'serve';
     mode: string;
+    isWorker: boolean;
     isProduction: boolean;
     env: Record<string, any>;
     resolve: ResolveOptions & {
@@ -2186,12 +2221,11 @@ 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: _optimizeDepsMetadata */
+    /* Excluded from this release type: _optimizedDeps */
     /* 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: _registerMissingImport */
     /* Excluded from this release type: _pendingRequests */
 }
 
@@ -2310,6 +2344,8 @@ export declare class WebSocket extends EventEmitter {
     binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments'
     readonly bufferedAmount: number
     readonly extensions: string
+    /** Indicates whether the websocket is paused */
+    readonly isPaused: boolean
     readonly protocol: string
     /** The current state of the connection */
     readonly readyState:
@@ -2328,11 +2364,12 @@ export declare class WebSocket extends EventEmitter {
     /** The connection is closed. */
     readonly CLOSED: 3
 
-    onopen: (event: WebSocket.Event) => void
-    onerror: (event: WebSocket.ErrorEvent) => void
-    onclose: (event: WebSocket.CloseEvent) => void
-    onmessage: (event: WebSocket.MessageEvent) => void
+    onopen: ((event: WebSocket.Event) => void) | null
+    onerror: ((event: WebSocket.ErrorEvent) => void) | null
+    onclose: ((event: WebSocket.CloseEvent) => void) | null
+    onmessage: ((event: WebSocket.MessageEvent) => void) | null
 
+    constructor(address: null)
     constructor(
     address: string | URL_2,
     options?: WebSocket.ClientOptions | ClientRequestArgs
@@ -2359,6 +2396,18 @@ export declare class WebSocket extends EventEmitter {
     ): void
     terminate(): void
 
+    /**
+     * Pause the websocket causing it to stop emitting events. Some events can still be
+     * emitted after this is called, until all buffered data is consumed. This method
+     * is a noop if the ready state is `CONNECTING` or `CLOSED`.
+     */
+    pause(): void
+    /**
+     * Make a paused socket resume emitting events. This method is a noop if the ready
+     * state is `CONNECTING` or `CLOSED`.
+     */
+    resume(): void
+
     // HTML5 WebSocket events
     addEventListener(
     method: 'message',
@@ -2595,6 +2644,7 @@ export declare namespace WebSocket {
     export interface ClientOptions extends SecureContextOptions {
         protocol?: string | undefined
         followRedirects?: boolean | undefined
+        generateMask?(mask: Buffer): void
         handshakeTimeout?: number | undefined
         maxRedirects?: number | undefined
         perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
@@ -2608,6 +2658,7 @@ export declare namespace WebSocket {
         checkServerIdentity?(servername: string, cert: CertMeta): boolean
         rejectUnauthorized?: boolean | undefined
         maxPayload?: number | undefined
+        skipUTF8Validation?: boolean | undefined
     }
 
     export interface PerMessageDeflateOptions {
@@ -2667,7 +2718,7 @@ export declare namespace WebSocket {
         host?: string | undefined
         port?: number | undefined
         backlog?: number | undefined
-        server?: Server | Server_2 | undefined
+        server?: Server | Server_3 | undefined
         verifyClient?:
         | VerifyClientCallbackAsync
         | VerifyClientCallbackSync
@@ -2682,6 +2733,7 @@ export declare namespace WebSocket {
         perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
         maxPayload?: number | undefined
         skipUTF8Validation?: boolean | undefined
+        WebSocket?: typeof WebSocket.WebSocket | undefined
     }
 
     export interface AddressInfo {
@@ -2691,10 +2743,10 @@ export declare namespace WebSocket {
     }
 
     // WebSocket Server
-    export class Server extends EventEmitter {
+    export class Server<T extends WebSocket = WebSocket> extends EventEmitter {
         options: ServerOptions
         path: string
-        clients: Set<WebSocket>
+        clients: Set<T>
 
         constructor(options?: ServerOptions, callback?: () => void)
 
@@ -2704,56 +2756,59 @@ export declare namespace WebSocket {
         request: IncomingMessage,
         socket: Duplex,
         upgradeHead: Buffer,
-        callback: (client: WebSocket, request: IncomingMessage) => void
+        callback: (client: T, request: IncomingMessage) => void
         ): void
         shouldHandle(request: IncomingMessage): boolean | Promise<boolean>
 
         // Events
         on(
         event: 'connection',
-        cb: (this: Server, socket: WebSocket, request: IncomingMessage) => void
+        cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
         ): this
-        on(event: 'error', cb: (this: Server, error: Error) => void): this
+        on(event: 'error', cb: (this: Server<T>, error: Error) => void): this
         on(
         event: 'headers',
-        cb: (this: Server, headers: string[], request: IncomingMessage) => void
+        cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
         ): this
-        on(event: 'close' | 'listening', cb: (this: Server) => void): this
+        on(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
         on(
         event: string | symbol,
-        listener: (this: Server, ...args: any[]) => void
+        listener: (this: Server<T>, ...args: any[]) => void
         ): this
 
         once(
         event: 'connection',
-        cb: (this: Server, socket: WebSocket, request: IncomingMessage) => void
+        cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
         ): this
-        once(event: 'error', cb: (this: Server, error: Error) => void): this
+        once(event: 'error', cb: (this: Server<T>, error: Error) => void): this
         once(
         event: 'headers',
-        cb: (this: Server, headers: string[], request: IncomingMessage) => void
+        cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
+        ): this
+        once(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
+        once(
+        event: string | symbol,
+        listener: (this: Server<T>, ...args: any[]) => void
         ): this
-        once(event: 'close' | 'listening', cb: (this: Server) => void): this
-        once(event: string | symbol, listener: (...args: any[]) => void): this
 
         off(
         event: 'connection',
-        cb: (this: Server, socket: WebSocket, request: IncomingMessage) => void
+        cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
         ): this
-        off(event: 'error', cb: (this: Server, error: Error) => void): this
+        off(event: 'error', cb: (this: Server<T>, error: Error) => void): this
         off(
         event: 'headers',
-        cb: (this: Server, headers: string[], request: IncomingMessage) => void
+        cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
         ): this
-        off(event: 'close' | 'listening', cb: (this: Server) => void): this
+        off(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
         off(
         event: string | symbol,
-        listener: (this: Server, ...args: any[]) => void
+        listener: (this: Server<T>, ...args: any[]) => void
         ): this
 
         addListener(
         event: 'connection',
-        cb: (client: WebSocket, request: IncomingMessage) => void
+        cb: (client: T, request: IncomingMessage) => void
         ): this
         addListener(event: 'error', cb: (err: Error) => void): this
         addListener(
@@ -2766,7 +2821,7 @@ export declare namespace WebSocket {
         listener: (...args: any[]) => void
         ): this
 
-        removeListener(event: 'connection', cb: (client: WebSocket) => void): this
+        removeListener(event: 'connection', cb: (client: T) => void): this
         removeListener(event: 'error', cb: (err: Error) => void): this
         removeListener(
         event: 'headers',
@@ -2780,9 +2835,9 @@ export declare namespace WebSocket {
     }
 
     const WebSocketServer: typeof Server
-    export type WebSocketServer = Server
+    export interface WebSocketServer extends Server {} // tslint:disable-line no-empty-interface
     const WebSocket: typeof WebSocketAlias
-    export type WebSocket = WebSocketAlias
+    export interface WebSocket extends WebSocketAlias {} // tslint:disable-line no-empty-interface
 
     // WebSocket stream
     export function createWebSocketStream(
@@ -2793,13 +2848,55 @@ export declare namespace WebSocket {
 
 export declare const WebSocketAlias: typeof WebSocket;
 
-export declare type WebSocketAlias = WebSocket
+export declare interface WebSocketAlias extends WebSocket {}
+
+export declare interface WebSocketClient {
+    /**
+     * Send event to the client
+     */
+    send(payload: HMRPayload): void;
+    /**
+     * Send custom event
+     */
+    send(event: string, payload?: CustomPayload['data']): void;
+    /**
+     * The raw WebSocket instance
+     * @advanced
+     */
+    socket: WebSocket_2;
+}
+
+export declare type WebSocketCustomListener<T> = (data: T, client: WebSocketClient) => void;
 
 export declare interface WebSocketServer {
-    on: WebSocket.Server['on'];
-    off: WebSocket.Server['off'];
+    /**
+     * Get all connected clients.
+     */
+    clients: Set<WebSocketClient>;
+    /**
+     * Boardcast events to all clients
+     */
     send(payload: HMRPayload): void;
+    /**
+     * Send custom event
+     */
+    send<T extends string>(event: T, payload?: InferCustomEventPayload<T>): void;
+    /**
+     * Disconnect all clients and terminate the server.
+     */
     close(): Promise<void>;
+    /**
+     * Handle custom event emitted by `import.meta.hot.send`
+     */
+    on: WebSocketServer_2['on'] & {
+        <T extends string>(event: T, listener: WebSocketCustomListener<InferCustomEventPayload<T>>): void;
+    };
+    /**
+     * Unregister event listener.
+     */
+    off: WebSocketServer_2['off'] & {
+        (event: string, listener: Function): void;
+    };
 }
 
 export { }

package/dist/node/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./chunks/dep-62435a6f.js');
+var index = require('./chunks/dep-7a52803b.js');
 require('fs');
 require('path');
 require('tty');
@@ -21,9 +21,9 @@ require('zlib');
 require('crypto');
 require('tls');
 require('assert');
+require('esbuild');
 require('buffer');
 require('querystring');
-require('esbuild');
 require('child_process');
 require('worker_threads');
 require('readline');
@@ -137,6 +137,7 @@ exports.build = index.build;
 exports.createLogger = index.createLogger;
 exports.createServer = index.createServer;
 exports.defineConfig = index.defineConfig;
+exports.formatPostcssSourceMap = index.formatPostcssSourceMap;
 exports.loadConfigFromFile = index.loadConfigFromFile;
 exports.loadEnv = index.loadEnv;
 exports.mergeConfig = index.mergeConfig;

package/dist/node/terser.js

@@ -10201,7 +10201,7 @@ function is_some_comments(comment) {
     // multiline comment
     return (
         (comment.type === "comment2" || comment.type === "comment1")
-        && /@preserve|@lic|@cc_on|^\**!/i.test(comment.value)
+        && /@preserve|@copyright|@lic|@cc_on|^\**!/i.test(comment.value)
     );
 }
 
@@ -10314,8 +10314,8 @@ function OutputStream(options) {
     var OUTPUT = new Rope();
     let printed_comments = new Set();
 
-    var to_utf8 = options.ascii_only ? function(str, identifier) {
-        if (options.ecma >= 2015 && !options.safari10) {
+    var to_utf8 = options.ascii_only ? function(str, identifier = false, regexp = false) {
+        if (options.ecma >= 2015 && !options.safari10 && !regexp) {
             str = str.replace(/[\ud800-\udbff][\udc00-\udfff]/g, function(ch) {
                 var code = get_full_char_code(ch, 0).toString(16);
                 return "\\u{" + code + "}";
@@ -11127,7 +11127,8 @@ function OutputStream(options) {
         var p = output.parent();
         if (this.args.length === 0
             && (p instanceof AST_PropAccess // (new Date).getTime(), (new Date)["getTime"]()
-                || p instanceof AST_Call && p.expression === this)) // (new foo)(bar)
+                || p instanceof AST_Call && p.expression === this
+                || p instanceof AST_PrefixedTemplateString && p.prefix === this)) // (new foo)(bar)
             return true;
     });
 
@@ -12242,7 +12243,7 @@ function OutputStream(options) {
         flags = flags ? sort_regexp_flags(flags) : "";
         source = source.replace(r_slash_script, slash_script_replace);
 
-        output.print(output.to_utf8(`/${source}/${flags}`));
+        output.print(output.to_utf8(`/${source}/${flags}`, false, true));
 
         const parent = output.parent();
         if (
@@ -12666,6 +12667,11 @@ const MASK_EXPORT_WANT_MANGLE = 1 << 1;
 
 let function_defs = null;
 let unmangleable_names = null;
+/**
+ * When defined, there is a function declaration somewhere that's inside of a block.
+ * See https://tc39.es/ecma262/multipage/additional-ecmascript-features-for-web-browsers.html#sec-block-level-function-declarations-web-legacy-compatibility-semantics
+*/
+let scopes_with_block_defuns = null;
 
 class SymbolDef {
     constructor(scope, orig, init) {
@@ -13216,6 +13222,15 @@ AST_Scope.DEFMETHOD("def_variable", function(symbol, init) {
 });
 
 function next_mangled(scope, options) {
+    let defun_scope;
+    if (
+        scopes_with_block_defuns
+        && (defun_scope = scope.get_defun_scope())
+        && scopes_with_block_defuns.has(defun_scope)
+    ) {
+        scope = defun_scope;
+    }
+
     var ext = scope.enclosed;
     var nth_identifier = options.nth_identifier;
     out: while (true) {
@@ -13350,6 +13365,13 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             lname = save_nesting;
             return true;        // don't descend again in TreeWalker
         }
+        if (
+            node instanceof AST_Defun
+            && !(tw.parent() instanceof AST_Scope)
+        ) {
+            scopes_with_block_defuns = scopes_with_block_defuns || new Set();
+            scopes_with_block_defuns.add(node.parent_scope.get_defun_scope());
+        }
         if (node instanceof AST_Scope) {
             node.variables.forEach(collect);
             return;
@@ -13398,6 +13420,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
 
     function_defs = null;
     unmangleable_names = null;
+    scopes_with_block_defuns = null;
 
     function collect(symbol) {
         if (symbol.export & MASK_EXPORT_DONT_MANGLE) {
@@ -30781,7 +30804,54 @@ function cache_to_json(cache) {
     };
 }
 
-async function minify(files, options) {
+function log_input(files, options, fs, debug_folder) {
+    if (!(fs && fs.writeFileSync && fs.mkdirSync)) {
+        return;
+    }
+
+    try {
+        fs.mkdirSync(debug_folder);
+    } catch (e) {
+        if (e.code !== "EEXIST") throw e;
+    }
+
+    const log_path = `${debug_folder}/terser-debug-${(Math.random() * 9999999) | 0}.log`;
+
+    options = options || {};
+
+    const options_str = JSON.stringify(options, (_key, thing) => {
+        if (typeof thing === "function") return "[Function " + thing.toString() + "]";
+        if (thing instanceof RegExp) return "[RegExp " + thing.toString() + "]";
+        return thing;
+    }, 4);
+
+    const files_str = (file) => {
+        if (typeof file === "object" && options.parse && options.parse.spidermonkey) {
+            return JSON.stringify(file, null, 2);
+        } else if (typeof file === "object") {
+            return Object.keys(file)
+                .map((key) => key + ": " + files_str(file[key]))
+                .join("\n\n");
+        } else if (typeof file === "string") {
+            return "```\n" + file + "\n```";
+        } else {
+            return file; // What do?
+        }
+    };
+
+    fs.writeFileSync(log_path, "Options: \n" + options_str + "\n\nInput files:\n\n" + files_str(files) + "\n");
+}
+
+async function minify(files, options, _fs_module) {
+    if (
+        _fs_module
+        && typeof process === "object"
+        && process.env
+        && typeof process.env.TERSER_DEBUG_DIR === "string"
+    ) {
+        log_input(files, options, _fs_module, process.env.TERSER_DEBUG_DIR);
+    }
+
     options = defaults(options, {
         compress: {},
         ecma: undefined,
@@ -30804,6 +30874,7 @@ async function minify(files, options) {
         warnings: false,
         wrap: false,
     }, true);
+
     var timings = options.timings && {
         start: Date.now()
     };
@@ -31205,7 +31276,7 @@ async function run_cli({ program, packageJson, fs, path }) {
 
         let result;
         try {
-            result = await minify(files, options);
+            result = await minify(files, options, fs);
         } catch (ex) {
             if (ex.name == "SyntaxError") {
                 print_error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
@@ -31268,14 +31339,18 @@ async function run_cli({ program, packageJson, fs, path }) {
             }, 2));
         } else if (program.output == "spidermonkey") {
             try {
-                const minified = await minify(result.code, {
-                    compress: false,
-                    mangle: false,
-                    format: {
-                        ast: true,
-                        code: false
-                    }
-                });
+                const minified = await minify(
+                    result.code,
+                    {
+                        compress: false,
+                        mangle: false,
+                        format: {
+                            ast: true,
+                            code: false
+                        }
+                    },
+                    fs
+                );
                 console.log(JSON.stringify(minified.ast.to_mozilla_ast(), null, 2));
             } catch (ex) {
                 fatal(ex);