rollup 3.21.0 → 3.21.2

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.0
-	Sun, 23 Apr 2023 19:43:51 GMT - commit b79b73cd8bb98c10ab7eedae154bb5c1e03ced7d
+	Rollup.js v3.21.2
+	Sun, 30 Apr 2023 05:31:29 GMT - commit f138dcee19367f17f2e66f940fb8d612471f7ddf
 
 	https://github.com/rollup/rollup
 
@@ -16,8 +16,6 @@ const process$2 = require('node:process');
 const index = require('./index.js');
 const cli = require('../bin/rollup');
 const rollup = require('./rollup.js');
-const require$$0 = require('assert');
-const require$$0$1 = require('events');
 const loadConfigFile_js = require('./loadConfigFile.js');
 const node_child_process = require('node:child_process');
 const watchProxy = require('./watch-proxy.js');
@@ -27,6 +25,7 @@ require('stream');
 require('path');
 require('os');
 require('./fsevents-importer.js');
+require('events');
 require('node:path');
 require('tty');
 require('node:perf_hooks');
@@ -72,89 +71,47 @@ function dateTime(options = {}) {
 		.replace(/\..+/, end);
 }
 
-var signalExitExports = {};
-var signalExit = {
-  get exports(){ return signalExitExports; },
-  set exports(v){ signalExitExports = v; },
-};
-
-var signalsExports = {};
-var signals$1 = {
-  get exports(){ return signalsExports; },
-  set exports(v){ signalsExports = v; },
-};
-
-var hasRequiredSignals;
-
-function requireSignals () {
-	if (hasRequiredSignals) return signalsExports;
-	hasRequiredSignals = 1;
-	(function (module) {
-		// This is not the set of all possible signals.
-		//
-		// It IS, however, the set of all signals that trigger
-		// an exit on either Linux or BSD systems.  Linux is a
-		// superset of the signal names supported on BSD, and
-		// the unknown signals just fail to register, so we can
-		// catch that easily enough.
-		//
-		// Don't bother with SIGKILL.  It's uncatchable, which
-		// means that we can't fire any callbacks anyway.
-		//
-		// If a user does happen to register a handler on a non-
-		// fatal signal like SIGWINCH or something, and then
-		// exit, it'll end up firing `process.emit('exit')`, so
-		// the handler will be fired anyway.
-		//
-		// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
-		// artificially, inherently leave the process in a
-		// state from which it is not safe to try and enter JS
-		// listeners.
-		module.exports = [
-		  'SIGABRT',
-		  'SIGALRM',
-		  'SIGHUP',
-		  'SIGINT',
-		  'SIGTERM'
-		];
-
-		if (process.platform !== 'win32') {
-		  module.exports.push(
-		    'SIGVTALRM',
-		    'SIGXCPU',
-		    'SIGXFSZ',
-		    'SIGUSR2',
-		    'SIGTRAP',
-		    'SIGSYS',
-		    'SIGQUIT',
-		    'SIGIOT'
-		    // should detect profiler and enable/disable accordingly.
-		    // see #21
-		    // 'SIGPROF'
-		  );
-		}
-
-		if (process.platform === 'linux') {
-		  module.exports.push(
-		    'SIGIO',
-		    'SIGPOLL',
-		    'SIGPWR',
-		    'SIGSTKFLT',
-		    'SIGUNUSED'
-		  );
-		}
-} (signals$1));
-	return signalsExports;
+/**
+ * This is not the set of all possible signals.
+ *
+ * It IS, however, the set of all signals that trigger
+ * an exit on either Linux or BSD systems.  Linux is a
+ * superset of the signal names supported on BSD, and
+ * the unknown signals just fail to register, so we can
+ * catch that easily enough.
+ *
+ * Windows signals are a different set, since there are
+ * signals that terminate Windows processes, but don't
+ * terminate (or don't even exist) on Posix systems.
+ *
+ * Don't bother with SIGKILL.  It's uncatchable, which
+ * means that we can't fire any callbacks anyway.
+ *
+ * If a user does happen to register a handler on a non-
+ * fatal signal like SIGWINCH or something, and then
+ * exit, it'll end up firing `process.emit('exit')`, so
+ * the handler will be fired anyway.
+ *
+ * SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+ * artificially, inherently leave the process in a
+ * state from which it is not safe to try and enter JS
+ * listeners.
+ */
+const signals = [];
+signals.push('SIGHUP', 'SIGINT', 'SIGTERM');
+if (process.platform !== 'win32') {
+    signals.push('SIGALRM', 'SIGABRT', 'SIGVTALRM', 'SIGXCPU', 'SIGXFSZ', 'SIGUSR2', 'SIGTRAP', 'SIGSYS', 'SIGQUIT', 'SIGIOT'
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+    );
+}
+if (process.platform === 'linux') {
+    signals.push('SIGIO', 'SIGPOLL', 'SIGPWR', 'SIGSTKFLT');
 }
 
 // Note: since nyc uses this module to output coverage, any lines
-// that are in the direct sync flow of nyc's outputCoverage are
-// ignored, since we can never get coverage for them.
-// grab a reference to node's real process object right away
-var process$1 = rollup.commonjsGlobal.process;
-
-const processOk = function (process) {
-  return process &&
+const processOk = (process) => !!process &&
     typeof process === 'object' &&
     typeof process.removeListener === 'function' &&
     typeof process.emit === 'function' &&
@@ -162,193 +119,260 @@ const processOk = function (process) {
     typeof process.listeners === 'function' &&
     typeof process.kill === 'function' &&
     typeof process.pid === 'number' &&
-    typeof process.on === 'function'
-};
-
-// some kind of non-node environment, just no-op
-/* istanbul ignore if */
-if (!processOk(process$1)) {
-  signalExit.exports = function () {
-    return function () {}
-  };
-} else {
-  var assert = require$$0;
-  var signals = requireSignals();
-  var isWin = /^win/i.test(process$1.platform);
-
-  var EE = require$$0$1;
-  /* istanbul ignore if */
-  if (typeof EE !== 'function') {
-    EE = EE.EventEmitter;
-  }
-
-  var emitter;
-  if (process$1.__signal_exit_emitter__) {
-    emitter = process$1.__signal_exit_emitter__;
-  } else {
-    emitter = process$1.__signal_exit_emitter__ = new EE();
-    emitter.count = 0;
-    emitter.emitted = {};
-  }
-
-  // Because this emitter is a global, we have to check to see if a
-  // previous version of this library failed to enable infinite listeners.
-  // I know what you're about to say.  But literally everything about
-  // signal-exit is a compromise with evil.  Get used to it.
-  if (!emitter.infinite) {
-    emitter.setMaxListeners(Infinity);
-    emitter.infinite = true;
-  }
-
-  signalExit.exports = function (cb, opts) {
-    /* istanbul ignore if */
-    if (!processOk(rollup.commonjsGlobal.process)) {
-      return function () {}
+    typeof process.on === 'function';
+const kExitEmitter = Symbol.for('signal-exit emitter');
+const global = globalThis;
+const ObjectDefineProperty = Object.defineProperty.bind(Object);
+// teeny tiny ee
+class Emitter {
+    emitted = {
+        afterExit: false,
+        exit: false,
+    };
+    listeners = {
+        afterExit: [],
+        exit: [],
+    };
+    count = 0;
+    id = Math.random();
+    constructor() {
+        if (global[kExitEmitter]) {
+            console.error('reusing global emitter');
+            return global[kExitEmitter];
+        }
+        ObjectDefineProperty(global, kExitEmitter, {
+            value: this,
+            writable: false,
+            enumerable: false,
+            configurable: false,
+        });
     }
-    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
-
-    if (loaded === false) {
-      load();
+    on(ev, fn) {
+        this.listeners[ev].push(fn);
     }
-
-    var ev = 'exit';
-    if (opts && opts.alwaysLast) {
-      ev = 'afterexit';
+    removeListener(ev, fn) {
+        const list = this.listeners[ev];
+        const i = list.indexOf(fn);
+        /* c8 ignore start */
+        if (i === -1) {
+            return;
+        }
+        /* c8 ignore stop */
+        if (i === 0 && list.length === 1) {
+            list.length = 0;
+        }
+        else {
+            list.splice(i, 1);
+        }
     }
-
-    var remove = function () {
-      emitter.removeListener(ev, cb);
-      if (emitter.listeners('exit').length === 0 &&
-          emitter.listeners('afterexit').length === 0) {
-        unload();
-      }
+    emit(ev, code, signal) {
+        if (this.emitted[ev]) {
+            return;
+        }
+        this.emitted[ev] = true;
+        for (const fn of this.listeners[ev]) {
+            fn(code, signal);
+        }
+    }
+}
+class SignalExitBase {
+}
+const signalExitWrap = (handler) => {
+    return {
+        onExit(cb, opts) {
+            return handler.onExit(cb, opts);
+        },
+        load() {
+            return handler.load();
+        },
+        unload() {
+            return handler.unload();
+        },
     };
-    emitter.on(ev, cb);
-
-    return remove
-  };
-
-  var unload = function unload () {
-    if (!loaded || !processOk(rollup.commonjsGlobal.process)) {
-      return
+};
+class SignalExitFallback extends SignalExitBase {
+    onExit() {
+        return () => { };
     }
-    loaded = false;
-
-    signals.forEach(function (sig) {
-      try {
-        process$1.removeListener(sig, sigListeners[sig]);
-      } catch (er) {}
-    });
-    process$1.emit = originalProcessEmit;
-    process$1.reallyExit = originalProcessReallyExit;
-    emitter.count -= 1;
-  };
-  signalExitExports.unload = unload;
-
-  var emit = function emit (event, code, signal) {
-    /* istanbul ignore if */
-    if (emitter.emitted[event]) {
-      return
+    load() { }
+    unload() { }
+}
+class SignalExit extends SignalExitBase {
+    // "SIGHUP" throws an `ENOSYS` error on Windows,
+    // so use a supported signal instead
+    /* c8 ignore start */
+    #hupSig = process$1.platform === 'win32' ? 'SIGINT' : 'SIGHUP';
+    /* c8 ignore stop */
+    #emitter = new Emitter();
+    #process;
+    #originalProcessEmit;
+    #originalProcessReallyExit;
+    #sigListeners = {};
+    #loaded = false;
+    constructor(process) {
+        super();
+        this.#process = process;
+        // { <signal>: <listener fn>, ... }
+        this.#sigListeners = {};
+        for (const sig of signals) {
+            this.#sigListeners[sig] = () => {
+                // If there are no other listeners, an exit is coming!
+                // Simplest way: remove us and then re-send the signal.
+                // We know that this will kill the process, so we can
+                // safely emit now.
+                const listeners = this.#process.listeners(sig);
+                let { count } = this.#emitter;
+                // This is a workaround for the fact that signal-exit v3 and signal
+                // exit v4 are not aware of each other, and each will attempt to let
+                // the other handle it, so neither of them do. To correct this, we
+                // detect if we're the only handler *except* for previous versions
+                // of signal-exit.
+                /* c8 ignore start */
+                //@ts-ignore
+                if (typeof process.__signal_exit_emitter__ === 'object')
+                    count++;
+                /* c8 ignore stop */
+                if (listeners.length === count) {
+                    this.unload();
+                    this.#emitter.emit('exit', null, sig);
+                    this.#emitter.emit('afterExit', null, sig);
+                    /* c8 ignore start */
+                    process.kill(process.pid, sig === 'SIGHUP' ? this.#hupSig : sig);
+                    /* c8 ignore stop */
+                }
+            };
+        }
+        this.#originalProcessReallyExit = process.reallyExit;
+        this.#originalProcessEmit = process.emit;
     }
-    emitter.emitted[event] = true;
-    emitter.emit(event, code, signal);
-  };
-
-  // { <signal>: <listener fn>, ... }
-  var sigListeners = {};
-  signals.forEach(function (sig) {
-    sigListeners[sig] = function listener () {
-      /* istanbul ignore if */
-      if (!processOk(rollup.commonjsGlobal.process)) {
-        return
-      }
-      // If there are no other listeners, an exit is coming!
-      // Simplest way: remove us and then re-send the signal.
-      // We know that this will kill the process, so we can
-      // safely emit now.
-      var listeners = process$1.listeners(sig);
-      if (listeners.length === emitter.count) {
-        unload();
-        emit('exit', null, sig);
-        /* istanbul ignore next */
-        emit('afterexit', null, sig);
-        /* istanbul ignore next */
-        if (isWin && sig === 'SIGHUP') {
-          // "SIGHUP" throws an `ENOSYS` error on Windows,
-          // so use a supported signal instead
-          sig = 'SIGINT';
+    onExit(cb, opts) {
+        /* c8 ignore start */
+        if (!processOk(this.#process)) {
+            return () => { };
         }
-        /* istanbul ignore next */
-        process$1.kill(process$1.pid, sig);
-      }
-    };
-  });
-
-  signalExitExports.signals = function () {
-    return signals
-  };
-
-  var loaded = false;
-
-  var load = function load () {
-    if (loaded || !processOk(rollup.commonjsGlobal.process)) {
-      return
+        /* c8 ignore stop */
+        if (this.#loaded === false) {
+            this.load();
+        }
+        const ev = opts?.alwaysLast ? 'afterExit' : 'exit';
+        this.#emitter.on(ev, cb);
+        return () => {
+            this.#emitter.removeListener(ev, cb);
+            if (this.#emitter.listeners['exit'].length === 0 &&
+                this.#emitter.listeners['afterExit'].length === 0) {
+                this.unload();
+            }
+        };
     }
-    loaded = true;
-
-    // This is the number of onSignalExit's that are in play.
-    // It's important so that we can count the correct number of
-    // listeners on signals, and don't wait for the other one to
-    // handle it instead of us.
-    emitter.count += 1;
-
-    signals = signals.filter(function (sig) {
-      try {
-        process$1.on(sig, sigListeners[sig]);
-        return true
-      } catch (er) {
-        return false
-      }
-    });
-
-    process$1.emit = processEmit;
-    process$1.reallyExit = processReallyExit;
-  };
-  signalExitExports.load = load;
-
-  var originalProcessReallyExit = process$1.reallyExit;
-  var processReallyExit = function processReallyExit (code) {
-    /* istanbul ignore if */
-    if (!processOk(rollup.commonjsGlobal.process)) {
-      return
+    load() {
+        if (this.#loaded) {
+            return;
+        }
+        this.#loaded = true;
+        // This is the number of onSignalExit's that are in play.
+        // It's important so that we can count the correct number of
+        // listeners on signals, and don't wait for the other one to
+        // handle it instead of us.
+        this.#emitter.count += 1;
+        for (const sig of signals) {
+            try {
+                const fn = this.#sigListeners[sig];
+                if (fn)
+                    this.#process.on(sig, fn);
+            }
+            catch (_) { }
+        }
+        this.#process.emit = (ev, ...a) => {
+            return this.#processEmit(ev, ...a);
+        };
+        this.#process.reallyExit = (code) => {
+            return this.#processReallyExit(code);
+        };
     }
-    process$1.exitCode = code || /* istanbul ignore next */ 0;
-    emit('exit', process$1.exitCode, null);
-    /* istanbul ignore next */
-    emit('afterexit', process$1.exitCode, null);
-    /* istanbul ignore next */
-    originalProcessReallyExit.call(process$1, process$1.exitCode);
-  };
-
-  var originalProcessEmit = process$1.emit;
-  var processEmit = function processEmit (ev, arg) {
-    if (ev === 'exit' && processOk(rollup.commonjsGlobal.process)) {
-      /* istanbul ignore else */
-      if (arg !== undefined) {
-        process$1.exitCode = arg;
-      }
-      var ret = originalProcessEmit.apply(this, arguments);
-      /* istanbul ignore next */
-      emit('exit', process$1.exitCode, null);
-      /* istanbul ignore next */
-      emit('afterexit', process$1.exitCode, null);
-      /* istanbul ignore next */
-      return ret
-    } else {
-      return originalProcessEmit.apply(this, arguments)
+    unload() {
+        if (!this.#loaded) {
+            return;
+        }
+        this.#loaded = false;
+        signals.forEach(sig => {
+            const listener = this.#sigListeners[sig];
+            /* c8 ignore start */
+            if (!listener) {
+                throw new Error('Listener not defined for signal: ' + sig);
+            }
+            /* c8 ignore stop */
+            try {
+                this.#process.removeListener(sig, listener);
+                /* c8 ignore start */
+            }
+            catch (_) { }
+            /* c8 ignore stop */
+        });
+        this.#process.emit = this.#originalProcessEmit;
+        this.#process.reallyExit = this.#originalProcessReallyExit;
+        this.#emitter.count -= 1;
+    }
+    #processReallyExit(code) {
+        /* c8 ignore start */
+        if (!processOk(this.#process)) {
+            return 0;
+        }
+        this.#process.exitCode = code || 0;
+        /* c8 ignore stop */
+        this.#emitter.emit('exit', this.#process.exitCode, null);
+        this.#emitter.emit('afterExit', this.#process.exitCode, null);
+        return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+    }
+    #processEmit(ev, ...args) {
+        const og = this.#originalProcessEmit;
+        if (ev === 'exit' && processOk(this.#process)) {
+            if (typeof args[0] === 'number') {
+                this.#process.exitCode = args[0];
+                /* c8 ignore start */
+            }
+            /* c8 ignore start */
+            const ret = og.call(this.#process, ev, ...args);
+            /* c8 ignore start */
+            this.#emitter.emit('exit', this.#process.exitCode, null);
+            this.#emitter.emit('afterExit', this.#process.exitCode, null);
+            /* c8 ignore stop */
+            return ret;
+        }
+        else {
+            return og.call(this.#process, ev, ...args);
+        }
     }
-  };
 }
+const process$1 = globalThis.process;
+// wrap so that we call the method on the actual handler, without
+// exporting it directly.
+const { 
+/**
+ * Called when the process is exiting, whether via signal, explicit
+ * exit, or running out of stuff to do.
+ *
+ * If the global process object is not suitable for instrumentation,
+ * then this will be a no-op.
+ *
+ * Returns a function that may be used to unload signal-exit.
+ */
+onExit, 
+/**
+ * Load the listeners.  Likely you never need to call this, unless
+ * doing a rather deep integration with signal-exit functionality.
+ * Mostly exposed for the benefit of testing.
+ *
+ * @internal
+ */
+load, 
+/**
+ * Unload the listeners.  Likely you never need to call this, unless
+ * doing a rather deep integration with signal-exit functionality.
+ * Mostly exposed for the benefit of testing.
+ *
+ * @internal
+ */
+unload, } = signalExitWrap(processOk(process$1) ? new SignalExit(process$1) : new SignalExitFallback());
 
 const CLEAR_SCREEN = '\u001Bc';
 function getResetScreen(configs, allowClearScreen) {
@@ -406,7 +430,7 @@ async function watch(command) {
     let resetScreen;
     const configFile = command.config ? await cli.getConfigPath(command.config) : null;
     const runWatchHook = createWatchHooks(command);
-    signalExitExports(close);
+    onExit(close);
     process$2.on('uncaughtException', close);
     if (!process$2.stdin.isTTY) {
         process$2.stdin.on('end', close);

package/dist/shared/watch-proxy.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.0
-	Sun, 23 Apr 2023 19:43:51 GMT - commit b79b73cd8bb98c10ab7eedae154bb5c1e03ced7d
+	Rollup.js v3.21.2
+	Sun, 30 Apr 2023 05:31:29 GMT - commit f138dcee19367f17f2e66f940fb8d612471f7ddf
 
 	https://github.com/rollup/rollup
 

package/dist/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.21.0
-	Sun, 23 Apr 2023 19:43:51 GMT - commit b79b73cd8bb98c10ab7eedae154bb5c1e03ced7d
+	Rollup.js v3.21.2
+	Sun, 30 Apr 2023 05:31:29 GMT - commit f138dcee19367f17f2e66f940fb8d612471f7ddf
 
 	https://github.com/rollup/rollup