@bytecodealliance/jco 0.4.1 → 0.5.0

package/api.mjs

@@ -2782,60 +2782,48 @@ module.exports.q = codes;
 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 // a duplex stream is just a stream that is both readable and writable.
 // Since JS doesn't have multiple prototypal inheritance, this class
 // prototypally inherits from Readable, and then parasitically from
 // Writable.
 
-/*<replacement>*/
 
+
+/*<replacement>*/
 var objectKeys = Object.keys || function (obj) {
   var keys = [];
-
-  for (var key in obj) {
-    keys.push(key);
-  }
-
+  for (var key in obj) keys.push(key);
   return keys;
 };
 /*</replacement>*/
 
-
 module.exports = Duplex;
-
 var Readable = __nccwpck_require__(1433);
-
 var Writable = __nccwpck_require__(6993);
-
 __nccwpck_require__(4124)(Duplex, Readable);
-
 {
   // Allow the keys array to be GC'ed.
   var keys = objectKeys(Writable.prototype);
-
   for (var v = 0; v < keys.length; v++) {
     var method = keys[v];
     if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
   }
 }
-
 function Duplex(options) {
   if (!(this instanceof Duplex)) return new Duplex(options);
   Readable.call(this, options);
   Writable.call(this, options);
   this.allowHalfOpen = true;
-
   if (options) {
     if (options.readable === false) this.readable = false;
     if (options.writable === false) this.writable = false;
-
     if (options.allowHalfOpen === false) {
       this.allowHalfOpen = false;
       this.once('end', onend);
     }
   }
 }
-
 Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
   // making it explicit this property is not enumerable
   // because otherwise some prototype manipulation in
@@ -2862,20 +2850,20 @@ Object.defineProperty(Duplex.prototype, 'writableLength', {
   get: function get() {
     return this._writableState.length;
   }
-}); // the no-half-open enforcer
+});
 
+// the no-half-open enforcer
 function onend() {
   // If the writable side ended, then we're ok.
-  if (this._writableState.ended) return; // no more data can be written.
-  // But allow more writes to happen in this tick.
+  if (this._writableState.ended) return;
 
+  // no more data can be written.
+  // But allow more writes to happen in this tick.
   process.nextTick(onEndNT, this);
 }
-
 function onEndNT(self) {
   self.end();
 }
-
 Object.defineProperty(Duplex.prototype, 'destroyed', {
   // making it explicit this property is not enumerable
   // because otherwise some prototype manipulation in
@@ -2885,7 +2873,6 @@ Object.defineProperty(Duplex.prototype, 'destroyed', {
     if (this._readableState === undefined || this._writableState === undefined) {
       return false;
     }
-
     return this._readableState.destroyed && this._writableState.destroyed;
   },
   set: function set(value) {
@@ -2893,10 +2880,10 @@ Object.defineProperty(Duplex.prototype, 'destroyed', {
     // has not been initialized yet
     if (this._readableState === undefined || this._writableState === undefined) {
       return;
-    } // backward compatibility, the user is explicitly
-    // managing destroyed
-
+    }
 
+    // backward compatibility, the user is explicitly
+    // managing destroyed
     this._readableState.destroyed = value;
     this._writableState.destroyed = value;
   }
@@ -2927,22 +2914,20 @@ Object.defineProperty(Duplex.prototype, 'destroyed', {
 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 // a passthrough stream.
 // basically just the most minimal sort of Transform stream.
 // Every written chunk gets output as-is.
 
 
-module.exports = PassThrough;
 
+module.exports = PassThrough;
 var Transform = __nccwpck_require__(4415);
-
 __nccwpck_require__(4124)(PassThrough, Transform);
-
 function PassThrough(options) {
   if (!(this instanceof PassThrough)) return new PassThrough(options);
   Transform.call(this, options);
 }
-
 PassThrough.prototype._transform = function (chunk, encoding, cb) {
   cb(null, chunk);
 };
@@ -2974,47 +2959,38 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) {
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 
+
 module.exports = Readable;
-/*<replacement>*/
 
+/*<replacement>*/
 var Duplex;
 /*</replacement>*/
 
 Readable.ReadableState = ReadableState;
-/*<replacement>*/
 
+/*<replacement>*/
 var EE = (__nccwpck_require__(2361).EventEmitter);
-
 var EElistenerCount = function EElistenerCount(emitter, type) {
   return emitter.listeners(type).length;
 };
 /*</replacement>*/
 
 /*<replacement>*/
-
-
 var Stream = __nccwpck_require__(2387);
 /*</replacement>*/
 
-
 var Buffer = (__nccwpck_require__(4300).Buffer);
-
-var OurUint8Array = global.Uint8Array || function () {};
-
+var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {};
 function _uint8ArrayToBuffer(chunk) {
   return Buffer.from(chunk);
 }
-
 function _isUint8Array(obj) {
   return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
 }
-/*<replacement>*/
-
 
+/*<replacement>*/
 var debugUtil = __nccwpck_require__(3837);
-
 var debug;
-
 if (debugUtil && debugUtil.debuglog) {
   debug = debugUtil.debuglog('stream');
 } else {
@@ -3022,60 +2998,57 @@ if (debugUtil && debugUtil.debuglog) {
 }
 /*</replacement>*/
 
-
 var BufferList = __nccwpck_require__(2746);
-
 var destroyImpl = __nccwpck_require__(7049);
-
 var _require = __nccwpck_require__(9948),
-    getHighWaterMark = _require.getHighWaterMark;
-
+  getHighWaterMark = _require.getHighWaterMark;
 var _require$codes = (__nccwpck_require__(7214)/* .codes */ .q),
-    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
-    ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,
-    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
-    ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance.
-
+  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
+  ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,
+  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
+  ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
 
+// Lazy loaded to improve the startup performance.
 var StringDecoder;
 var createReadableStreamAsyncIterator;
 var from;
-
 __nccwpck_require__(4124)(Readable, Stream);
-
 var errorOrDestroy = destroyImpl.errorOrDestroy;
 var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
-
 function prependListener(emitter, event, fn) {
   // Sadly this is not cacheable as some libraries bundle their own
   // event emitter implementation with them.
-  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any
+  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);
+
+  // This is a hack to make sure that our error handler is attached before any
   // userland ones.  NEVER DO THIS. This is here only because this code needs
   // to continue to work with older versions of Node.js that do not include
   // the prependListener() method. The goal is to eventually remove this hack.
-
   if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
 }
-
 function ReadableState(options, stream, isDuplex) {
   Duplex = Duplex || __nccwpck_require__(1359);
-  options = options || {}; // Duplex streams are both readable and writable, but share
+  options = options || {};
+
+  // Duplex streams are both readable and writable, but share
   // the same options object.
   // However, some cases require setting options to different
   // values for the readable and the writable sides of the duplex stream.
   // These options can be provided separately as readableXXX and writableXXX.
+  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex;
 
-  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to
+  // object stream flag. Used to make read(n) ignore n and to
   // make all the buffer merging and length checks go away
-
   this.objectMode = !!options.objectMode;
-  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer
+  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
+
+  // the point at which it stops calling _read() to fill the buffer
   // Note: 0 is a valid value, means "don't call _read preemptively ever"
+  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex);
 
-  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the
+  // A linked list is used to store data chunks instead of an array because the
   // linked list can remove elements from the beginning faster than
   // array.shift()
-
   this.buffer = new BufferList();
   this.length = 0;
   this.pipes = null;
@@ -3083,61 +3056,66 @@ function ReadableState(options, stream, isDuplex) {
   this.flowing = null;
   this.ended = false;
   this.endEmitted = false;
-  this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted
+  this.reading = false;
+
+  // a flag to be able to tell if the event 'readable'/'data' is emitted
   // immediately, or on a later tick.  We set this to true at first, because
   // any actions that shouldn't happen until "later" should generally also
   // not happen before the first read call.
+  this.sync = true;
 
-  this.sync = true; // whenever we return null, then we set a flag to say
+  // whenever we return null, then we set a flag to say
   // that we're awaiting a 'readable' event emission.
-
   this.needReadable = false;
   this.emittedReadable = false;
   this.readableListening = false;
   this.resumeScheduled = false;
-  this.paused = true; // Should close be emitted on destroy. Defaults to true.
+  this.paused = true;
+
+  // Should close be emitted on destroy. Defaults to true.
+  this.emitClose = options.emitClose !== false;
 
-  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')
+  // Should .destroy() be called after 'end' (and potentially 'finish')
+  this.autoDestroy = !!options.autoDestroy;
 
-  this.autoDestroy = !!options.autoDestroy; // has it been destroyed
+  // has it been destroyed
+  this.destroyed = false;
 
-  this.destroyed = false; // Crypto is kind of old and crusty.  Historically, its default string
+  // Crypto is kind of old and crusty.  Historically, its default string
   // encoding is 'binary' so we have to make this configurable.
   // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = options.defaultEncoding || 'utf8';
 
-  this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s
-
-  this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled
+  // the number of writers that are awaiting a drain event in .pipe()s
+  this.awaitDrain = 0;
 
+  // if true, a maybeReadMore has been scheduled
   this.readingMore = false;
   this.decoder = null;
   this.encoding = null;
-
   if (options.encoding) {
     if (!StringDecoder) StringDecoder = (__nccwpck_require__(4841)/* .StringDecoder */ .s);
     this.decoder = new StringDecoder(options.encoding);
     this.encoding = options.encoding;
   }
 }
-
 function Readable(options) {
   Duplex = Duplex || __nccwpck_require__(1359);
-  if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside
-  // the ReadableState constructor, at least with V8 6.5
+  if (!(this instanceof Readable)) return new Readable(options);
 
+  // Checking for a Stream.Duplex instance is faster here instead of inside
+  // the ReadableState constructor, at least with V8 6.5
   var isDuplex = this instanceof Duplex;
-  this._readableState = new ReadableState(options, this, isDuplex); // legacy
+  this._readableState = new ReadableState(options, this, isDuplex);
 
+  // legacy
   this.readable = true;
-
   if (options) {
     if (typeof options.read === 'function') this._read = options.read;
     if (typeof options.destroy === 'function') this._destroy = options.destroy;
   }
-
   Stream.call(this);
 }
-
 Object.defineProperty(Readable.prototype, 'destroyed', {
   // making it explicit this property is not enumerable
   // because otherwise some prototype manipulation in
@@ -3147,7 +3125,6 @@ Object.defineProperty(Readable.prototype, 'destroyed', {
     if (this._readableState === undefined) {
       return false;
     }
-
     return this._readableState.destroyed;
   },
   set: function set(value) {
@@ -3155,69 +3132,60 @@ Object.defineProperty(Readable.prototype, 'destroyed', {
     // has not been initialized yet
     if (!this._readableState) {
       return;
-    } // backward compatibility, the user is explicitly
-    // managing destroyed
-
+    }
 
+    // backward compatibility, the user is explicitly
+    // managing destroyed
     this._readableState.destroyed = value;
   }
 });
 Readable.prototype.destroy = destroyImpl.destroy;
 Readable.prototype._undestroy = destroyImpl.undestroy;
-
 Readable.prototype._destroy = function (err, cb) {
   cb(err);
-}; // Manually shove something into the read() buffer.
+};
+
+// Manually shove something into the read() buffer.
 // This returns true if the highWaterMark has not been hit yet,
 // similar to how Writable.write() returns true if you should
 // write() some more.
-
-
 Readable.prototype.push = function (chunk, encoding) {
   var state = this._readableState;
   var skipChunkCheck;
-
   if (!state.objectMode) {
     if (typeof chunk === 'string') {
       encoding = encoding || state.defaultEncoding;
-
       if (encoding !== state.encoding) {
         chunk = Buffer.from(chunk, encoding);
         encoding = '';
       }
-
       skipChunkCheck = true;
     }
   } else {
     skipChunkCheck = true;
   }
-
   return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
-}; // Unshift should *always* be something directly out of read()
-
+};
 
+// Unshift should *always* be something directly out of read()
 Readable.prototype.unshift = function (chunk) {
   return readableAddChunk(this, chunk, null, true, false);
 };
-
 function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
   debug('readableAddChunk', chunk);
   var state = stream._readableState;
-
   if (chunk === null) {
     state.reading = false;
     onEofChunk(stream, state);
   } else {
     var er;
     if (!skipChunkCheck) er = chunkInvalid(state, chunk);
-
     if (er) {
       errorOrDestroy(stream, er);
     } else if (state.objectMode || chunk && chunk.length > 0) {
       if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
         chunk = _uint8ArrayToBuffer(chunk);
       }
-
       if (addToFront) {
         if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);
       } else if (state.ended) {
@@ -3226,7 +3194,6 @@ function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
         return false;
       } else {
         state.reading = false;
-
         if (state.decoder && !encoding) {
           chunk = state.decoder.write(chunk);
           if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
@@ -3238,14 +3205,13 @@ function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
       state.reading = false;
       maybeReadMore(stream, state);
     }
-  } // We can push more data if we are below the highWaterMark.
+  }
+
+  // We can push more data if we are below the highWaterMark.
   // Also, if we have no data yet, we can stand some more bytes.
   // This is to work around cases where hwm=0, such as the repl.
-
-
   return !state.ended && (state.length < state.highWaterMark || state.length === 0);
 }
-
 function addChunk(stream, state, chunk, addToFront) {
   if (state.flowing && state.length === 0 && !state.sync) {
     state.awaitDrain = 0;
@@ -3256,50 +3222,42 @@ function addChunk(stream, state, chunk, addToFront) {
     if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
     if (state.needReadable) emitReadable(stream);
   }
-
   maybeReadMore(stream, state);
 }
-
 function chunkInvalid(state, chunk) {
   var er;
-
   if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
     er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
   }
-
   return er;
 }
-
 Readable.prototype.isPaused = function () {
   return this._readableState.flowing === false;
-}; // backwards compatibility.
-
+};
 
+// backwards compatibility.
 Readable.prototype.setEncoding = function (enc) {
   if (!StringDecoder) StringDecoder = (__nccwpck_require__(4841)/* .StringDecoder */ .s);
   var decoder = new StringDecoder(enc);
-  this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8
-
-  this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:
+  this._readableState.decoder = decoder;
+  // If setEncoding(null), decoder.encoding equals utf8
+  this._readableState.encoding = this._readableState.decoder.encoding;
 
+  // Iterate over current buffer to convert already stored Buffers:
   var p = this._readableState.buffer.head;
   var content = '';
-
   while (p !== null) {
     content += decoder.write(p.data);
     p = p.next;
   }
-
   this._readableState.buffer.clear();
-
   if (content !== '') this._readableState.buffer.push(content);
   this._readableState.length = content.length;
   return this;
-}; // Don't raise the hwm > 1GB
-
+};
 
+// Don't raise the hwm > 1GB
 var MAX_HWM = 0x40000000;
-
 function computeNewHighWaterMark(n) {
   if (n >= MAX_HWM) {
     // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.
@@ -3315,55 +3273,54 @@ function computeNewHighWaterMark(n) {
     n |= n >>> 16;
     n++;
   }
-
   return n;
-} // This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-
+}
 
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
 function howMuchToRead(n, state) {
   if (n <= 0 || state.length === 0 && state.ended) return 0;
   if (state.objectMode) return 1;
-
   if (n !== n) {
     // Only flow one buffer at a time
     if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
-  } // If we're asking for more than the current hwm, then raise the hwm.
-
-
+  }
+  // If we're asking for more than the current hwm, then raise the hwm.
   if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
-  if (n <= state.length) return n; // Don't have enough
-
+  if (n <= state.length) return n;
+  // Don't have enough
   if (!state.ended) {
     state.needReadable = true;
     return 0;
   }
-
   return state.length;
-} // you can override either this method, or the async _read(n) below.
-
+}
 
+// you can override either this method, or the async _read(n) below.
 Readable.prototype.read = function (n) {
   debug('read', n);
   n = parseInt(n, 10);
   var state = this._readableState;
   var nOrig = n;
-  if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we
+  if (n !== 0) state.emittedReadable = false;
+
+  // if we're doing read(0) to trigger a readable event, but we
   // already have a bunch of data in the buffer, then just trigger
   // the 'readable' event and move on.
-
   if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
     debug('read: emitReadable', state.length, state.ended);
     if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
     return null;
   }
+  n = howMuchToRead(n, state);
 
-  n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.
-
+  // if we've ended, and we're now clear, then finish it up.
   if (n === 0 && state.ended) {
     if (state.length === 0) endReadable(this);
     return null;
-  } // All the actual chunk generation logic needs to be
+  }
+
+  // All the actual chunk generation logic needs to be
   // *below* the call to _read.  The reason is that in certain
   // synthetic stream cases, such as passthrough streams, _read
   // may be a completely synchronous operation which may change
@@ -3384,40 +3341,37 @@ Readable.prototype.read = function (n) {
   // 'readable' etc.
   //
   // 3. Actually pull the requested chunks out of the buffer and return.
-  // if we need a readable event, then we need to do some reading.
-
 
+  // if we need a readable event, then we need to do some reading.
   var doRead = state.needReadable;
-  debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some
+  debug('need readable', doRead);
 
+  // if we currently have less than the highWaterMark, then also read some
   if (state.length === 0 || state.length - n < state.highWaterMark) {
     doRead = true;
     debug('length less than watermark', doRead);
-  } // however, if we've ended, then there's no point, and if we're already
-  // reading, then it's unnecessary.
-
+  }
 
+  // however, if we've ended, then there's no point, and if we're already
+  // reading, then it's unnecessary.
   if (state.ended || state.reading) {
     doRead = false;
     debug('reading or ended', doRead);
   } else if (doRead) {
     debug('do read');
     state.reading = true;
-    state.sync = true; // if the length is currently zero, then we *need* a readable event.
-
-    if (state.length === 0) state.needReadable = true; // call internal read method
-
+    state.sync = true;
+    // if the length is currently zero, then we *need* a readable event.
+    if (state.length === 0) state.needReadable = true;
+    // call internal read method
     this._read(state.highWaterMark);
-
-    state.sync = false; // If _read pushed data synchronously, then `reading` will be false,
+    state.sync = false;
+    // If _read pushed data synchronously, then `reading` will be false,
     // and we need to re-evaluate how much data we can return to the user.
-
     if (!state.reading) n = howMuchToRead(nOrig, state);
   }
-
   var ret;
   if (n > 0) ret = fromList(n, state);else ret = null;
-
   if (ret === null) {
     state.needReadable = state.length <= state.highWaterMark;
     n = 0;
@@ -3425,34 +3379,28 @@ Readable.prototype.read = function (n) {
     state.length -= n;
     state.awaitDrain = 0;
   }
-
   if (state.length === 0) {
     // If we have nothing in the buffer, then we want to know
     // as soon as we *do* get something into the buffer.
-    if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.
+    if (!state.ended) state.needReadable = true;
 
+    // If we tried to read() past the EOF, then emit end on the next tick.
     if (nOrig !== n && state.ended) endReadable(this);
   }
-
   if (ret !== null) this.emit('data', ret);
   return ret;
 };
-
 function onEofChunk(stream, state) {
   debug('onEofChunk');
   if (state.ended) return;
-
   if (state.decoder) {
     var chunk = state.decoder.end();
-
     if (chunk && chunk.length) {
       state.buffer.push(chunk);
       state.length += state.objectMode ? 1 : chunk.length;
     }
   }
-
   state.ended = true;
-
   if (state.sync) {
     // if we are sync, wait until next tick to emit the data.
     // Otherwise we risk emitting data in the flow()
@@ -3461,61 +3409,56 @@ function onEofChunk(stream, state) {
   } else {
     // emit 'readable' now to make sure it gets picked up.
     state.needReadable = false;
-
     if (!state.emittedReadable) {
       state.emittedReadable = true;
       emitReadable_(stream);
     }
   }
-} // Don't emit readable right away in sync mode, because this can trigger
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
 // another read() call => stack overflow.  This way, it might trigger
 // a nextTick recursion warning, but that's not so bad.
-
-
 function emitReadable(stream) {
   var state = stream._readableState;
   debug('emitReadable', state.needReadable, state.emittedReadable);
   state.needReadable = false;
-
   if (!state.emittedReadable) {
     debug('emitReadable', state.flowing);
     state.emittedReadable = true;
     process.nextTick(emitReadable_, stream);
   }
 }
-
 function emitReadable_(stream) {
   var state = stream._readableState;
   debug('emitReadable_', state.destroyed, state.length, state.ended);
-
   if (!state.destroyed && (state.length || state.ended)) {
     stream.emit('readable');
     state.emittedReadable = false;
-  } // The stream needs another readable event if
+  }
+
+  // The stream needs another readable event if
   // 1. It is not flowing, as the flow mechanism will take
   //    care of it.
   // 2. It is not ended.
   // 3. It is below the highWaterMark, so we can schedule
   //    another readable later.
-
-
   state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
   flow(stream);
-} // at this point, the user has presumably seen the 'readable' event,
+}
+
+// at this point, the user has presumably seen the 'readable' event,
 // and called read() to consume some data.  that may have triggered
 // in turn another _read(n) call, in which case reading = true if
 // it's in progress.
 // However, if we're not ended, or reading, and the length < hwm,
 // then go ahead and try to read some more preemptively.
-
-
 function maybeReadMore(stream, state) {
   if (!state.readingMore) {
     state.readingMore = true;
     process.nextTick(maybeReadMore_, stream, state);
   }
 }
-
 function maybeReadMore_(stream, state) {
   // Attempt to read more data if we should.
   //
@@ -3544,49 +3487,42 @@ function maybeReadMore_(stream, state) {
     var len = state.length;
     debug('maybeReadMore read 0');
     stream.read(0);
-    if (len === state.length) // didn't get any data, stop spinning.
+    if (len === state.length)
+      // didn't get any data, stop spinning.
       break;
   }
-
   state.readingMore = false;
-} // abstract method.  to be overridden in specific implementation classes.
+}
+
+// abstract method.  to be overridden in specific implementation classes.
 // call cb(er, data) where data is <= n in length.
 // for virtual (non-string, non-buffer) streams, "length" is somewhat
 // arbitrary, and perhaps not very meaningful.
-
-
 Readable.prototype._read = function (n) {
   errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));
 };
-
 Readable.prototype.pipe = function (dest, pipeOpts) {
   var src = this;
   var state = this._readableState;
-
   switch (state.pipesCount) {
     case 0:
       state.pipes = dest;
       break;
-
     case 1:
       state.pipes = [state.pipes, dest];
       break;
-
     default:
       state.pipes.push(dest);
       break;
   }
-
   state.pipesCount += 1;
   debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
   var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
   var endFn = doEnd ? onend : unpipe;
   if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);
   dest.on('unpipe', onunpipe);
-
   function onunpipe(readable, unpipeInfo) {
     debug('onunpipe');
-
     if (readable === src) {
       if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
         unpipeInfo.hasUnpiped = true;
@@ -3594,23 +3530,21 @@ Readable.prototype.pipe = function (dest, pipeOpts) {
       }
     }
   }
-
   function onend() {
     debug('onend');
     dest.end();
-  } // when the dest drains, it reduces the awaitDrain counter
+  }
+
+  // when the dest drains, it reduces the awaitDrain counter
   // on the source.  This would be more elegant with a .once()
   // handler in flow(), but adding and removing repeatedly is
   // too slow.
-
-
   var ondrain = pipeOnDrain(src);
   dest.on('drain', ondrain);
   var cleanedUp = false;
-
   function cleanup() {
-    debug('cleanup'); // cleanup event handlers once the pipe is broken
-
+    debug('cleanup');
+    // cleanup event handlers once the pipe is broken
     dest.removeListener('close', onclose);
     dest.removeListener('finish', onfinish);
     dest.removeListener('drain', ondrain);
@@ -3619,22 +3553,20 @@ Readable.prototype.pipe = function (dest, pipeOpts) {
     src.removeListener('end', onend);
     src.removeListener('end', unpipe);
     src.removeListener('data', ondata);
-    cleanedUp = true; // if the reader is waiting for a drain event from this
+    cleanedUp = true;
+
+    // if the reader is waiting for a drain event from this
     // specific writer, then it would cause it to never start
     // flowing again.
     // So, if this is awaiting a drain, then we just call it now.
     // If we don't know, then assume that we are waiting for one.
-
     if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
   }
-
   src.on('data', ondata);
-
   function ondata(chunk) {
     debug('ondata');
     var ret = dest.write(chunk);
     debug('dest.write', ret);
-
     if (ret === false) {
       // If the user unpiped during `dest.write()`, it is possible
       // to get stuck in a permanently paused state if that write
@@ -3644,87 +3576,84 @@ Readable.prototype.pipe = function (dest, pipeOpts) {
         debug('false write response, pause', state.awaitDrain);
         state.awaitDrain++;
       }
-
       src.pause();
     }
-  } // if the dest has an error, then stop piping into it.
-  // however, don't suppress the throwing behavior for this.
-
+  }
 
+  // if the dest has an error, then stop piping into it.
+  // however, don't suppress the throwing behavior for this.
   function onerror(er) {
     debug('onerror', er);
     unpipe();
     dest.removeListener('error', onerror);
     if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);
-  } // Make sure our error handler is attached before userland ones.
-
+  }
 
-  prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.
+  // Make sure our error handler is attached before userland ones.
+  prependListener(dest, 'error', onerror);
 
+  // Both close and finish should trigger unpipe, but only once.
   function onclose() {
     dest.removeListener('finish', onfinish);
     unpipe();
   }
-
   dest.once('close', onclose);
-
   function onfinish() {
     debug('onfinish');
     dest.removeListener('close', onclose);
     unpipe();
   }
-
   dest.once('finish', onfinish);
-
   function unpipe() {
     debug('unpipe');
     src.unpipe(dest);
-  } // tell the dest that it's being piped to
-
+  }
 
-  dest.emit('pipe', src); // start the flow if it hasn't been started already.
+  // tell the dest that it's being piped to
+  dest.emit('pipe', src);
 
+  // start the flow if it hasn't been started already.
   if (!state.flowing) {
     debug('pipe resume');
     src.resume();
   }
-
   return dest;
 };
-
 function pipeOnDrain(src) {
   return function pipeOnDrainFunctionResult() {
     var state = src._readableState;
     debug('pipeOnDrain', state.awaitDrain);
     if (state.awaitDrain) state.awaitDrain--;
-
     if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
       state.flowing = true;
       flow(src);
     }
   };
 }
-
 Readable.prototype.unpipe = function (dest) {
   var state = this._readableState;
   var unpipeInfo = {
     hasUnpiped: false
-  }; // if we're not piping anywhere, then do nothing.
+  };
 
-  if (state.pipesCount === 0) return this; // just one destination.  most common case.
+  // if we're not piping anywhere, then do nothing.
+  if (state.pipesCount === 0) return this;
 
+  // just one destination.  most common case.
   if (state.pipesCount === 1) {
     // passed in one, but it's not the right one.
     if (dest && dest !== state.pipes) return this;
-    if (!dest) dest = state.pipes; // got a match.
+    if (!dest) dest = state.pipes;
 
+    // got a match.
     state.pipes = null;
     state.pipesCount = 0;
     state.flowing = false;
     if (dest) dest.emit('unpipe', this, unpipeInfo);
     return this;
-  } // slow case. multiple pipe destinations.
+  }
 
+  // slow case. multiple pipe destinations.
 
   if (!dest) {
     // remove all.
@@ -3733,17 +3662,13 @@ Readable.prototype.unpipe = function (dest) {
     state.pipes = null;
     state.pipesCount = 0;
     state.flowing = false;
-
-    for (var i = 0; i < len; i++) {
-      dests[i].emit('unpipe', this, {
-        hasUnpiped: false
-      });
-    }
-
+    for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, {
+      hasUnpiped: false
+    });
     return this;
-  } // try to find the right one.
-
+  }
 
+  // try to find the right one.
   var index = indexOf(state.pipes, dest);
   if (index === -1) return this;
   state.pipes.splice(index, 1);
@@ -3751,19 +3676,19 @@ Readable.prototype.unpipe = function (dest) {
   if (state.pipesCount === 1) state.pipes = state.pipes[0];
   dest.emit('unpipe', this, unpipeInfo);
   return this;
-}; // set up data events if they are asked for
-// Ensure readable listeners eventually get something
-
+};
 
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
 Readable.prototype.on = function (ev, fn) {
   var res = Stream.prototype.on.call(this, ev, fn);
   var state = this._readableState;
-
   if (ev === 'data') {
     // update readableListening so that resume() may be a no-op
     // a few lines down. This is needed to support once('readable').
-    state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused
+    state.readableListening = this.listenerCount('readable') > 0;
 
+    // Try start flowing on next tick if stream isn't explicitly paused
     if (state.flowing !== false) this.resume();
   } else if (ev === 'readable') {
     if (!state.endEmitted && !state.readableListening) {
@@ -3771,7 +3696,6 @@ Readable.prototype.on = function (ev, fn) {
       state.flowing = false;
       state.emittedReadable = false;
       debug('on readable', state.length, state.reading);
-
       if (state.length) {
         emitReadable(this);
       } else if (!state.reading) {
@@ -3779,15 +3703,11 @@ Readable.prototype.on = function (ev, fn) {
       }
     }
   }
-
   return res;
 };
-
 Readable.prototype.addListener = Readable.prototype.on;
-
 Readable.prototype.removeListener = function (ev, fn) {
   var res = Stream.prototype.removeListener.call(this, ev, fn);
-
   if (ev === 'readable') {
     // We need to check if there is someone still listening to
     // readable and reset the state. However this needs to happen
@@ -3797,13 +3717,10 @@ Readable.prototype.removeListener = function (ev, fn) {
     // effect.
     process.nextTick(updateReadableListening, this);
   }
-
   return res;
 };
-
 Readable.prototype.removeAllListeners = function (ev) {
   var res = Stream.prototype.removeAllListeners.apply(this, arguments);
-
   if (ev === 'readable' || ev === undefined) {
     // We need to check if there is someone still listening to
     // readable and reset the state. However this needs to happen
@@ -3813,121 +3730,103 @@ Readable.prototype.removeAllListeners = function (ev) {
     // effect.
     process.nextTick(updateReadableListening, this);
   }
-
   return res;
 };
-
 function updateReadableListening(self) {
   var state = self._readableState;
   state.readableListening = self.listenerCount('readable') > 0;
-
   if (state.resumeScheduled && !state.paused) {
     // flowing needs to be set to true now, otherwise
     // the upcoming resume will not flow.
-    state.flowing = true; // crude way to check if we should resume
+    state.flowing = true;
+
+    // crude way to check if we should resume
   } else if (self.listenerCount('data') > 0) {
     self.resume();
   }
 }
-
 function nReadingNextTick(self) {
   debug('readable nexttick read 0');
   self.read(0);
-} // pause() and resume() are remnants of the legacy readable stream API
-// If the user uses them, then switch into old mode.
-
+}
 
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
 Readable.prototype.resume = function () {
   var state = this._readableState;
-
   if (!state.flowing) {
-    debug('resume'); // we flow only if there is no one listening
+    debug('resume');
+    // we flow only if there is no one listening
     // for readable, but we still have to call
     // resume()
-
     state.flowing = !state.readableListening;
     resume(this, state);
   }
-
   state.paused = false;
   return this;
 };
-
 function resume(stream, state) {
   if (!state.resumeScheduled) {
     state.resumeScheduled = true;
     process.nextTick(resume_, stream, state);
   }
 }
-
 function resume_(stream, state) {
   debug('resume', state.reading);
-
   if (!state.reading) {
     stream.read(0);
   }
-
   state.resumeScheduled = false;
   stream.emit('resume');
   flow(stream);
   if (state.flowing && !state.reading) stream.read(0);
 }
-
 Readable.prototype.pause = function () {
   debug('call pause flowing=%j', this._readableState.flowing);
-
   if (this._readableState.flowing !== false) {
     debug('pause');
     this._readableState.flowing = false;
     this.emit('pause');
   }
-
   this._readableState.paused = true;
   return this;
 };
-
 function flow(stream) {
   var state = stream._readableState;
   debug('flow', state.flowing);
+  while (state.flowing && stream.read() !== null);
+}
 
-  while (state.flowing && stream.read() !== null) {
-    ;
-  }
-} // wrap an old-style stream as the async data source.
+// wrap an old-style stream as the async data source.
 // This is *not* part of the readable stream interface.
 // It is an ugly unfortunate mess of history.
-
-
 Readable.prototype.wrap = function (stream) {
   var _this = this;
-
   var state = this._readableState;
   var paused = false;
   stream.on('end', function () {
     debug('wrapped end');
-
     if (state.decoder && !state.ended) {
       var chunk = state.decoder.end();
       if (chunk && chunk.length) _this.push(chunk);
     }
-
     _this.push(null);
   });
   stream.on('data', function (chunk) {
     debug('wrapped data');
-    if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode
+    if (state.decoder) chunk = state.decoder.write(chunk);
 
+    // don't skip over falsy values in objectMode
     if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
-
     var ret = _this.push(chunk);
-
     if (!ret) {
       paused = true;
       stream.pause();
     }
-  }); // proxy all the other methods.
-  // important when wrapping filters and duplexes.
+  });
 
+  // proxy all the other methods.
+  // important when wrapping filters and duplexes.
   for (var i in stream) {
     if (this[i] === undefined && typeof stream[i] === 'function') {
       this[i] = function methodWrap(method) {
@@ -3936,37 +3835,32 @@ Readable.prototype.wrap = function (stream) {
         };
       }(i);
     }
-  } // proxy certain important events.
-
+  }
 
+  // proxy certain important events.
   for (var n = 0; n < kProxyEvents.length; n++) {
     stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
-  } // when we try to consume some more bytes, simply unpause the
-  // underlying stream.
-
+  }
 
+  // when we try to consume some more bytes, simply unpause the
+  // underlying stream.
   this._read = function (n) {
     debug('wrapped _read', n);
-
     if (paused) {
       paused = false;
       stream.resume();
     }
   };
-
   return this;
 };
-
 if (typeof Symbol === 'function') {
   Readable.prototype[Symbol.asyncIterator] = function () {
     if (createReadableStreamAsyncIterator === undefined) {
       createReadableStreamAsyncIterator = __nccwpck_require__(3306);
     }
-
     return createReadableStreamAsyncIterator(this);
   };
 }
-
 Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
   // making it explicit this property is not enumerable
   // because otherwise some prototype manipulation in
@@ -3998,8 +3892,9 @@ Object.defineProperty(Readable.prototype, 'readableFlowing', {
       this._readableState.flowing = state;
     }
   }
-}); // exposed for testing purposes only.
+});
 
+// exposed for testing purposes only.
 Readable._fromList = fromList;
 Object.defineProperty(Readable.prototype, 'readableLength', {
   // making it explicit this property is not enumerable
@@ -4009,11 +3904,12 @@ Object.defineProperty(Readable.prototype, 'readableLength', {
   get: function get() {
     return this._readableState.length;
   }
-}); // Pluck off n bytes from an array of buffers.
+});
+
+// Pluck off n bytes from an array of buffers.
 // Length is the combined lengths of all the buffers in the list.
 // This function is designed to be inlinable, so please take care when making
 // changes to the function body.
-
 function fromList(n, state) {
   // nothing buffered
   if (state.length === 0) return null;
@@ -4028,52 +3924,44 @@ function fromList(n, state) {
   }
   return ret;
 }
-
 function endReadable(stream) {
   var state = stream._readableState;
   debug('endReadable', state.endEmitted);
-
   if (!state.endEmitted) {
     state.ended = true;
     process.nextTick(endReadableNT, state, stream);
   }
 }
-
 function endReadableNT(state, stream) {
-  debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.
+  debug('endReadableNT', state.endEmitted, state.length);
 
+  // Check that we didn't get one last unshift.
   if (!state.endEmitted && state.length === 0) {
     state.endEmitted = true;
     stream.readable = false;
     stream.emit('end');
-
     if (state.autoDestroy) {
       // In case of duplex streams we need a way to detect
       // if the writable side is ready for autoDestroy as well
       var wState = stream._writableState;
-
       if (!wState || wState.autoDestroy && wState.finished) {
         stream.destroy();
       }
     }
   }
 }
-
 if (typeof Symbol === 'function') {
   Readable.from = function (iterable, opts) {
     if (from === undefined) {
       from = __nccwpck_require__(5621);
     }
-
     return from(Readable, iterable, opts);
   };
 }
-
 function indexOf(xs, x) {
   for (var i = 0, l = xs.length; i < l; i++) {
     if (xs[i] === x) return i;
   }
-
   return -1;
 }
 
@@ -4102,6 +3990,7 @@ function indexOf(xs, x) {
 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 // a transform stream is a readable/writable stream where you do
 // something with the data.  Sometimes it's called a "filter",
 // but that's not a great name for it, since that implies a thing where
@@ -4145,40 +4034,34 @@ function indexOf(xs, x) {
 // the results of the previous transformed chunk were consumed.
 
 
-module.exports = Transform;
 
+module.exports = Transform;
 var _require$codes = (__nccwpck_require__(7214)/* .codes */ .q),
-    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
-    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
-    ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
-    ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
-
+  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
+  ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
+  ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
+  ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
 var Duplex = __nccwpck_require__(1359);
-
 __nccwpck_require__(4124)(Transform, Duplex);
-
 function afterTransform(er, data) {
   var ts = this._transformState;
   ts.transforming = false;
   var cb = ts.writecb;
-
   if (cb === null) {
     return this.emit('error', new ERR_MULTIPLE_CALLBACK());
   }
-
   ts.writechunk = null;
   ts.writecb = null;
-  if (data != null) // single equals check for both `null` and `undefined`
+  if (data != null)
+    // single equals check for both `null` and `undefined`
     this.push(data);
   cb(er);
   var rs = this._readableState;
   rs.reading = false;
-
   if (rs.needReadable || rs.length < rs.highWaterMark) {
     this._read(rs.highWaterMark);
   }
 }
-
 function Transform(options) {
   if (!(this instanceof Transform)) return new Transform(options);
   Duplex.call(this, options);
@@ -4189,26 +4072,25 @@ function Transform(options) {
     writecb: null,
     writechunk: null,
     writeencoding: null
-  }; // start out asking for a readable event once data is transformed.
+  };
+
+  // start out asking for a readable event once data is transformed.
+  this._readableState.needReadable = true;
 
-  this._readableState.needReadable = true; // we have implemented the _read method, and done the other things
+  // we have implemented the _read method, and done the other things
   // that Readable wants before the first _read call, so unset the
   // sync guard flag.
-
   this._readableState.sync = false;
-
   if (options) {
     if (typeof options.transform === 'function') this._transform = options.transform;
     if (typeof options.flush === 'function') this._flush = options.flush;
-  } // When the writable side finishes, then flush out anything remaining.
-
+  }
 
+  // When the writable side finishes, then flush out anything remaining.
   this.on('prefinish', prefinish);
 }
-
 function prefinish() {
   var _this = this;
-
   if (typeof this._flush === 'function' && !this._readableState.destroyed) {
     this._flush(function (er, data) {
       done(_this, er, data);
@@ -4217,11 +4099,12 @@ function prefinish() {
     done(this, null, null);
   }
 }
-
 Transform.prototype.push = function (chunk, encoding) {
   this._transformState.needTransform = false;
   return Duplex.prototype.push.call(this, chunk, encoding);
-}; // This is the part where you do stuff!
+};
+
+// This is the part where you do stuff!
 // override this function in implementation classes.
 // 'chunk' is an input chunk.
 //
@@ -4231,33 +4114,27 @@ Transform.prototype.push = function (chunk, encoding) {
 // Call `cb(err)` when you are done with this chunk.  If you pass
 // an error, then that'll put the hurt on the whole operation.  If you
 // never call cb(), then you'll never get another chunk.
-
-
 Transform.prototype._transform = function (chunk, encoding, cb) {
   cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));
 };
-
 Transform.prototype._write = function (chunk, encoding, cb) {
   var ts = this._transformState;
   ts.writecb = cb;
   ts.writechunk = chunk;
   ts.writeencoding = encoding;
-
   if (!ts.transforming) {
     var rs = this._readableState;
     if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
   }
-}; // Doesn't matter what the args are here.
+};
+
+// Doesn't matter what the args are here.
 // _transform does all the work.
 // That we got here means that the readable side wants more data.
-
-
 Transform.prototype._read = function (n) {
   var ts = this._transformState;
-
   if (ts.writechunk !== null && !ts.transforming) {
     ts.transforming = true;
-
     this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
   } else {
     // mark that we need a transform, so that any data that comes in
@@ -4265,20 +4142,20 @@ Transform.prototype._read = function (n) {
     ts.needTransform = true;
   }
 };
-
 Transform.prototype._destroy = function (err, cb) {
   Duplex.prototype._destroy.call(this, err, function (err2) {
     cb(err2);
   });
 };
-
 function done(stream, er, data) {
   if (er) return stream.emit('error', er);
-  if (data != null) // single equals check for both `null` and `undefined`
-    stream.push(data); // TODO(BridgeAR): Write a test for these two error cases
+  if (data != null)
+    // single equals check for both `null` and `undefined`
+    stream.push(data);
+
+  // TODO(BridgeAR): Write a test for these two error cases
   // if there's nothing in the write buffer, then that means
   // that nothing more will ever be provided
-
   if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
   if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
   return stream.push(null);
@@ -4309,29 +4186,29 @@ function done(stream, er, data) {
 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 // A bit simpler than readable streams.
 // Implement an async ._write(chunk, encoding, cb), and it'll handle all
 // the drain event emission and buffering.
 
 
+
 module.exports = Writable;
-/* <replacement> */
 
+/* <replacement> */
 function WriteReq(chunk, encoding, cb) {
   this.chunk = chunk;
   this.encoding = encoding;
   this.callback = cb;
   this.next = null;
-} // It seems a linked list but it is not
-// there will be only 2 of these for each stream
-
+}
 
+// It seems a linked list but it is not
+// there will be only 2 of these for each stream
 function CorkedRequest(state) {
   var _this = this;
-
   this.next = null;
   this.entry = null;
-
   this.finish = function () {
     onCorkedFinish(_this, state);
   };
@@ -4339,155 +4216,159 @@ function CorkedRequest(state) {
 /* </replacement> */
 
 /*<replacement>*/
-
-
 var Duplex;
 /*</replacement>*/
 
 Writable.WritableState = WritableState;
-/*<replacement>*/
 
+/*<replacement>*/
 var internalUtil = {
   deprecate: __nccwpck_require__(5278)
 };
 /*</replacement>*/
 
 /*<replacement>*/
-
 var Stream = __nccwpck_require__(2387);
 /*</replacement>*/
 
-
 var Buffer = (__nccwpck_require__(4300).Buffer);
-
-var OurUint8Array = global.Uint8Array || function () {};
-
+var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {};
 function _uint8ArrayToBuffer(chunk) {
   return Buffer.from(chunk);
 }
-
 function _isUint8Array(obj) {
   return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
 }
-
 var destroyImpl = __nccwpck_require__(7049);
-
 var _require = __nccwpck_require__(9948),
-    getHighWaterMark = _require.getHighWaterMark;
-
+  getHighWaterMark = _require.getHighWaterMark;
 var _require$codes = (__nccwpck_require__(7214)/* .codes */ .q),
-    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
-    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
-    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
-    ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
-    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
-    ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
-    ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
-    ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
-
+  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
+  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
+  ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
+  ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
+  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
+  ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
+  ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
+  ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
 var errorOrDestroy = destroyImpl.errorOrDestroy;
-
 __nccwpck_require__(4124)(Writable, Stream);
-
 function nop() {}
-
 function WritableState(options, stream, isDuplex) {
   Duplex = Duplex || __nccwpck_require__(1359);
-  options = options || {}; // Duplex streams are both readable and writable, but share
+  options = options || {};
+
+  // Duplex streams are both readable and writable, but share
   // the same options object.
   // However, some cases require setting options to different
   // values for the readable and the writable sides of the duplex stream,
   // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.
+  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex;
 
-  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream
+  // object stream flag to indicate whether or not this stream
   // contains buffers or objects.
-
   this.objectMode = !!options.objectMode;
-  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false
+  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
+
+  // the point at which write() starts returning false
   // Note: 0 is a valid value, means that we always return false if
   // the entire buffer is not flushed immediately on write()
+  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex);
 
-  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called
-
-  this.finalCalled = false; // drain event flag.
+  // if _final has been called
+  this.finalCalled = false;
 
-  this.needDrain = false; // at the start of calling end()
-
-  this.ending = false; // when end() has been called, and returned
-
-  this.ended = false; // when 'finish' is emitted
+  // drain event flag.
+  this.needDrain = false;
+  // at the start of calling end()
+  this.ending = false;
+  // when end() has been called, and returned
+  this.ended = false;
+  // when 'finish' is emitted
+  this.finished = false;
 
-  this.finished = false; // has it been destroyed
+  // has it been destroyed
+  this.destroyed = false;
 
-  this.destroyed = false; // should we decode strings into buffers before passing to _write?
+  // should we decode strings into buffers before passing to _write?
   // this is here so that some node-core streams can optimize string
   // handling at a lower level.
-
   var noDecode = options.decodeStrings === false;
-  this.decodeStrings = !noDecode; // Crypto is kind of old and crusty.  Historically, its default string
+  this.decodeStrings = !noDecode;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
   // encoding is 'binary' so we have to make this configurable.
   // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = options.defaultEncoding || 'utf8';
 
-  this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement
+  // not an actual buffer we keep track of, but a measurement
   // of how much we're waiting to get pushed to some underlying
   // socket or file.
+  this.length = 0;
 
-  this.length = 0; // a flag to see when we're in the middle of a write.
+  // a flag to see when we're in the middle of a write.
+  this.writing = false;
 
-  this.writing = false; // when true all writes will be buffered until .uncork() call
+  // when true all writes will be buffered until .uncork() call
+  this.corked = 0;
 
-  this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,
+  // a flag to be able to tell if the onwrite cb is called immediately,
   // or on a later tick.  We set this to true at first, because any
   // actions that shouldn't happen until "later" should generally also
   // not happen before the first write call.
+  this.sync = true;
 
-  this.sync = true; // a flag to know if we're processing previously buffered items, which
+  // a flag to know if we're processing previously buffered items, which
   // may call the _write() callback in the same tick, so that we don't
   // end up in an overlapped onwrite situation.
+  this.bufferProcessing = false;
 
-  this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)
-
+  // the callback that's passed to _write(chunk,cb)
   this.onwrite = function (er) {
     onwrite(stream, er);
-  }; // the callback that the user supplies to write(chunk,encoding,cb)
-
+  };
 
-  this.writecb = null; // the amount that is being written when _write is called.
+  // the callback that the user supplies to write(chunk,encoding,cb)
+  this.writecb = null;
 
+  // the amount that is being written when _write is called.
   this.writelen = 0;
   this.bufferedRequest = null;
-  this.lastBufferedRequest = null; // number of pending user-supplied write callbacks
+  this.lastBufferedRequest = null;
+
+  // number of pending user-supplied write callbacks
   // this must be 0 before 'finish' can be emitted
+  this.pendingcb = 0;
 
-  this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs
+  // emit prefinish if the only thing we're waiting for is _write cbs
   // This is relevant for synchronous Transform streams
+  this.prefinished = false;
 
-  this.prefinished = false; // True if the error was already emitted and should not be thrown again
+  // True if the error was already emitted and should not be thrown again
+  this.errorEmitted = false;
 
-  this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.
+  // Should close be emitted on destroy. Defaults to true.
+  this.emitClose = options.emitClose !== false;
 
-  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')
+  // Should .destroy() be called after 'finish' (and potentially 'end')
+  this.autoDestroy = !!options.autoDestroy;
 
-  this.autoDestroy = !!options.autoDestroy; // count buffered requests
+  // count buffered requests
+  this.bufferedRequestCount = 0;
 
-  this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always
+  // allocate the first CorkedRequest, there is always
   // one allocated and free to use, and we maintain at most two
-
   this.corkedRequestsFree = new CorkedRequest(this);
 }
-
 WritableState.prototype.getBuffer = function getBuffer() {
   var current = this.bufferedRequest;
   var out = [];
-
   while (current) {
     out.push(current);
     current = current.next;
   }
-
   return out;
 };
-
 (function () {
   try {
     Object.defineProperty(WritableState.prototype, 'buffer', {
@@ -4496,12 +4377,11 @@ WritableState.prototype.getBuffer = function getBuffer() {
       }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
     });
   } catch (_) {}
-})(); // Test _writableState for inheritance to account for Duplex streams,
-// whose prototype chain only points to Readable.
-
+})();
 
+// Test _writableState for inheritance to account for Duplex streams,
+// whose prototype chain only points to Readable.
 var realHasInstance;
-
 if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
   realHasInstance = Function.prototype[Symbol.hasInstance];
   Object.defineProperty(Writable, Symbol.hasInstance, {
@@ -4516,81 +4396,73 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot
     return object instanceof this;
   };
 }
-
 function Writable(options) {
-  Duplex = Duplex || __nccwpck_require__(1359); // Writable ctor is applied to Duplexes, too.
+  Duplex = Duplex || __nccwpck_require__(1359);
+
+  // Writable ctor is applied to Duplexes, too.
   // `realHasInstance` is necessary because using plain `instanceof`
   // would return false, as no `_writableState` property is attached.
+
   // Trying to use the custom `instanceof` for Writable here will also break the
   // Node.js LazyTransform implementation, which has a non-trivial getter for
   // `_writableState` that would lead to infinite recursion.
+
   // Checking for a Stream.Duplex instance is faster here instead of inside
   // the WritableState constructor, at least with V8 6.5
-
   var isDuplex = this instanceof Duplex;
   if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
-  this._writableState = new WritableState(options, this, isDuplex); // legacy.
+  this._writableState = new WritableState(options, this, isDuplex);
 
+  // legacy.
   this.writable = true;
-
   if (options) {
     if (typeof options.write === 'function') this._write = options.write;
     if (typeof options.writev === 'function') this._writev = options.writev;
     if (typeof options.destroy === 'function') this._destroy = options.destroy;
     if (typeof options.final === 'function') this._final = options.final;
   }
-
   Stream.call(this);
-} // Otherwise people can pipe Writable streams, which is just wrong.
-
+}
 
+// Otherwise people can pipe Writable streams, which is just wrong.
 Writable.prototype.pipe = function () {
   errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
 };
-
 function writeAfterEnd(stream, cb) {
-  var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb
-
+  var er = new ERR_STREAM_WRITE_AFTER_END();
+  // TODO: defer error events consistently everywhere, not just the cb
   errorOrDestroy(stream, er);
   process.nextTick(cb, er);
-} // Checks that a user-supplied chunk is valid, especially for the particular
+}
+
+// Checks that a user-supplied chunk is valid, especially for the particular
 // mode the stream is in. Currently this means that `null` is never accepted
 // and undefined/non-string values are only allowed in object mode.
-
-
 function validChunk(stream, state, chunk, cb) {
   var er;
-
   if (chunk === null) {
     er = new ERR_STREAM_NULL_VALUES();
   } else if (typeof chunk !== 'string' && !state.objectMode) {
     er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
   }
-
   if (er) {
     errorOrDestroy(stream, er);
     process.nextTick(cb, er);
     return false;
   }
-
   return true;
 }
-
 Writable.prototype.write = function (chunk, encoding, cb) {
   var state = this._writableState;
   var ret = false;
-
   var isBuf = !state.objectMode && _isUint8Array(chunk);
-
   if (isBuf && !Buffer.isBuffer(chunk)) {
     chunk = _uint8ArrayToBuffer(chunk);
   }
-
   if (typeof encoding === 'function') {
     cb = encoding;
     encoding = null;
   }
-
   if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
   if (typeof cb !== 'function') cb = nop;
   if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
@@ -4599,20 +4471,16 @@ Writable.prototype.write = function (chunk, encoding, cb) {
   }
   return ret;
 };
-
 Writable.prototype.cork = function () {
   this._writableState.corked++;
 };
-
 Writable.prototype.uncork = function () {
   var state = this._writableState;
-
   if (state.corked) {
     state.corked--;
     if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
   }
 };
-
 Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
   // node::ParseEncoding() requires lower case.
   if (typeof encoding === 'string') encoding = encoding.toLowerCase();
@@ -4620,7 +4488,6 @@ Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
   this._writableState.defaultEncoding = encoding;
   return this;
 };
-
 Object.defineProperty(Writable.prototype, 'writableBuffer', {
   // making it explicit this property is not enumerable
   // because otherwise some prototype manipulation in
@@ -4630,15 +4497,12 @@ Object.defineProperty(Writable.prototype, 'writableBuffer', {
     return this._writableState && this._writableState.getBuffer();
   }
 });
-
 function decodeChunk(state, chunk, encoding) {
   if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
     chunk = Buffer.from(chunk, encoding);
   }
-
   return chunk;
 }
-
 Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
   // making it explicit this property is not enumerable
   // because otherwise some prototype manipulation in
@@ -4647,27 +4511,25 @@ Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
   get: function get() {
     return this._writableState.highWaterMark;
   }
-}); // if we're already writing something, then just put this
+});
+
+// if we're already writing something, then just put this
 // in the queue, and wait our turn.  Otherwise, call _write
 // If we return false, then we need a drain event, so set that flag.
-
 function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
   if (!isBuf) {
     var newChunk = decodeChunk(state, chunk, encoding);
-
     if (chunk !== newChunk) {
       isBuf = true;
       encoding = 'buffer';
       chunk = newChunk;
     }
   }
-
   var len = state.objectMode ? 1 : chunk.length;
   state.length += len;
-  var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.
-
+  var ret = state.length < state.highWaterMark;
+  // we must ensure that previous needDrain will not be reset to false.
   if (!ret) state.needDrain = true;
-
   if (state.writing || state.corked) {
     var last = state.lastBufferedRequest;
     state.lastBufferedRequest = {
@@ -4677,21 +4539,17 @@ function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
       callback: cb,
       next: null
     };
-
     if (last) {
       last.next = state.lastBufferedRequest;
     } else {
       state.bufferedRequest = state.lastBufferedRequest;
     }
-
     state.bufferedRequestCount += 1;
   } else {
     doWrite(stream, state, false, len, chunk, encoding, cb);
   }
-
   return ret;
 }
-
 function doWrite(stream, state, writev, len, chunk, encoding, cb) {
   state.writelen = len;
   state.writecb = cb;
@@ -4700,16 +4558,14 @@ function doWrite(stream, state, writev, len, chunk, encoding, cb) {
   if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
   state.sync = false;
 }
-
 function onwriteError(stream, state, sync, er, cb) {
   --state.pendingcb;
-
   if (sync) {
     // defer the callback if we are being called synchronously
     // to avoid piling up things on the stack
-    process.nextTick(cb, er); // this can emit finish, and it will always happen
+    process.nextTick(cb, er);
+    // this can emit finish, and it will always happen
     // after error
-
     process.nextTick(finishMaybe, stream, state);
     stream._writableState.errorEmitted = true;
     errorOrDestroy(stream, er);
@@ -4718,20 +4574,18 @@ function onwriteError(stream, state, sync, er, cb) {
     // it is async
     cb(er);
     stream._writableState.errorEmitted = true;
-    errorOrDestroy(stream, er); // this can emit finish, but finish must
+    errorOrDestroy(stream, er);
+    // this can emit finish, but finish must
     // always follow error
-
     finishMaybe(stream, state);
   }
 }
-
 function onwriteStateUpdate(state) {
   state.writing = false;
   state.writecb = null;
   state.length -= state.writelen;
   state.writelen = 0;
 }
-
 function onwrite(stream, er) {
   var state = stream._writableState;
   var sync = state.sync;
@@ -4741,11 +4595,9 @@ function onwrite(stream, er) {
   if (er) onwriteError(stream, state, sync, er, cb);else {
     // Check if we're actually ready to finish, but don't emit yet
     var finished = needFinish(state) || stream.destroyed;
-
     if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
       clearBuffer(stream, state);
     }
-
     if (sync) {
       process.nextTick(afterWrite, stream, state, finished, cb);
     } else {
@@ -4753,29 +4605,27 @@ function onwrite(stream, er) {
     }
   }
 }
-
 function afterWrite(stream, state, finished, cb) {
   if (!finished) onwriteDrain(stream, state);
   state.pendingcb--;
   cb();
   finishMaybe(stream, state);
-} // Must force callback to be called on nextTick, so that we don't
+}
+
+// Must force callback to be called on nextTick, so that we don't
 // emit 'drain' before the write() consumer gets the 'false' return
 // value, and has a chance to attach a 'drain' listener.
-
-
 function onwriteDrain(stream, state) {
   if (state.length === 0 && state.needDrain) {
     state.needDrain = false;
     stream.emit('drain');
   }
-} // if there's something in the buffer waiting, then process it
-
+}
 
+// if there's something in the buffer waiting, then process it
 function clearBuffer(stream, state) {
   state.bufferProcessing = true;
   var entry = state.bufferedRequest;
-
   if (stream._writev && entry && entry.next) {
     // Fast case, write everything using _writev()
     var l = state.bufferedRequestCount;
@@ -4784,28 +4634,25 @@ function clearBuffer(stream, state) {
     holder.entry = entry;
     var count = 0;
     var allBuffers = true;
-
     while (entry) {
       buffer[count] = entry;
       if (!entry.isBuf) allBuffers = false;
       entry = entry.next;
       count += 1;
     }
-
     buffer.allBuffers = allBuffers;
-    doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time
-    // as the hot path ends with doWrite
+    doWrite(stream, state, true, state.length, buffer, '', holder.finish);
 
+    // doWrite is almost always async, defer these to save a bit of time
+    // as the hot path ends with doWrite
     state.pendingcb++;
     state.lastBufferedRequest = null;
-
     if (holder.next) {
       state.corkedRequestsFree = holder.next;
       holder.next = null;
     } else {
       state.corkedRequestsFree = new CorkedRequest(state);
     }
-
     state.bufferedRequestCount = 0;
   } else {
     // Slow case, write chunks one-by-one
@@ -4816,32 +4663,26 @@ function clearBuffer(stream, state) {
       var len = state.objectMode ? 1 : chunk.length;
       doWrite(stream, state, false, len, chunk, encoding, cb);
       entry = entry.next;
-      state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then
+      state.bufferedRequestCount--;
+      // if we didn't call the onwrite immediately, then
       // it means that we need to wait until it does.
       // also, that means that the chunk and cb are currently
       // being processed, so move the buffer counter past them.
-
       if (state.writing) {
         break;
       }
     }
-
     if (entry === null) state.lastBufferedRequest = null;
   }
-
   state.bufferedRequest = entry;
   state.bufferProcessing = false;
 }
-
 Writable.prototype._write = function (chunk, encoding, cb) {
   cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));
 };
-
 Writable.prototype._writev = null;
-
 Writable.prototype.end = function (chunk, encoding, cb) {
   var state = this._writableState;
-
   if (typeof chunk === 'function') {
     cb = chunk;
     chunk = null;
@@ -4850,19 +4691,18 @@ Writable.prototype.end = function (chunk, encoding, cb) {
     cb = encoding;
     encoding = null;
   }
+  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
 
-  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks
-
+  // .end() fully uncorks
   if (state.corked) {
     state.corked = 1;
     this.uncork();
-  } // ignore unnecessary end() calls.
-
+  }
 
+  // ignore unnecessary end() calls.
   if (!state.ending) endWritable(this, state, cb);
   return this;
 };
-
 Object.defineProperty(Writable.prototype, 'writableLength', {
   // making it explicit this property is not enumerable
   // because otherwise some prototype manipulation in
@@ -4872,25 +4712,20 @@ Object.defineProperty(Writable.prototype, 'writableLength', {
     return this._writableState.length;
   }
 });
-
 function needFinish(state) {
   return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
 }
-
 function callFinal(stream, state) {
   stream._final(function (err) {
     state.pendingcb--;
-
     if (err) {
       errorOrDestroy(stream, err);
     }
-
     state.prefinished = true;
     stream.emit('prefinish');
     finishMaybe(stream, state);
   });
 }
-
 function prefinish(stream, state) {
   if (!state.prefinished && !state.finalCalled) {
     if (typeof stream._final === 'function' && !state.destroyed) {
@@ -4903,59 +4738,47 @@ function prefinish(stream, state) {
     }
   }
 }
-
 function finishMaybe(stream, state) {
   var need = needFinish(state);
-
   if (need) {
     prefinish(stream, state);
-
     if (state.pendingcb === 0) {
       state.finished = true;
       stream.emit('finish');
-
       if (state.autoDestroy) {
         // In case of duplex streams we need a way to detect
         // if the readable side is ready for autoDestroy as well
         var rState = stream._readableState;
-
         if (!rState || rState.autoDestroy && rState.endEmitted) {
           stream.destroy();
         }
       }
     }
   }
-
   return need;
 }
-
 function endWritable(stream, state, cb) {
   state.ending = true;
   finishMaybe(stream, state);
-
   if (cb) {
     if (state.finished) process.nextTick(cb);else stream.once('finish', cb);
   }
-
   state.ended = true;
   stream.writable = false;
 }
-
 function onCorkedFinish(corkReq, state, err) {
   var entry = corkReq.entry;
   corkReq.entry = null;
-
   while (entry) {
     var cb = entry.callback;
     state.pendingcb--;
     cb(err);
     entry = entry.next;
-  } // reuse the free corkReq.
-
+  }
 
+  // reuse the free corkReq.
   state.corkedRequestsFree.next = corkReq;
 }
-
 Object.defineProperty(Writable.prototype, 'destroyed', {
   // making it explicit this property is not enumerable
   // because otherwise some prototype manipulation in
@@ -4965,7 +4788,6 @@ Object.defineProperty(Writable.prototype, 'destroyed', {
     if (this._writableState === undefined) {
       return false;
     }
-
     return this._writableState.destroyed;
   },
   set: function set(value) {
@@ -4973,16 +4795,15 @@ Object.defineProperty(Writable.prototype, 'destroyed', {
     // has not been initialized yet
     if (!this._writableState) {
       return;
-    } // backward compatibility, the user is explicitly
-    // managing destroyed
-
+    }
 
+    // backward compatibility, the user is explicitly
+    // managing destroyed
     this._writableState.destroyed = value;
   }
 });
 Writable.prototype.destroy = destroyImpl.destroy;
 Writable.prototype._undestroy = destroyImpl.undestroy;
-
 Writable.prototype._destroy = function (err, cb) {
   cb(err);
 };
@@ -4995,11 +4816,10 @@ Writable.prototype._destroy = function (err, cb) {
 
 
 var _Object$setPrototypeO;
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 var finished = __nccwpck_require__(6080);
-
 var kLastResolve = Symbol('lastResolve');
 var kLastReject = Symbol('lastReject');
 var kError = Symbol('error');
@@ -5007,22 +4827,19 @@ var kEnded = Symbol('ended');
 var kLastPromise = Symbol('lastPromise');
 var kHandlePromise = Symbol('handlePromise');
 var kStream = Symbol('stream');
-
 function createIterResult(value, done) {
   return {
     value: value,
     done: done
   };
 }
-
 function readAndResolve(iter) {
   var resolve = iter[kLastResolve];
-
   if (resolve !== null) {
-    var data = iter[kStream].read(); // we defer if data is null
+    var data = iter[kStream].read();
+    // we defer if data is null
     // we can be expecting either 'end' or
     // 'error'
-
     if (data !== null) {
       iter[kLastPromise] = null;
       iter[kLastResolve] = null;
@@ -5031,13 +4848,11 @@ function readAndResolve(iter) {
     }
   }
 }
-
 function onReadable(iter) {
   // we wait for the next tick, because it might
   // emit an error with process.nextTick
   process.nextTick(readAndResolve, iter);
 }
-
 function wrapForNext(lastPromise, iter) {
   return function (resolve, reject) {
     lastPromise.then(function () {
@@ -5045,33 +4860,26 @@ function wrapForNext(lastPromise, iter) {
         resolve(createIterResult(undefined, true));
         return;
       }
-
       iter[kHandlePromise](resolve, reject);
     }, reject);
   };
 }
-
 var AsyncIteratorPrototype = Object.getPrototypeOf(function () {});
 var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
   get stream() {
     return this[kStream];
   },
-
   next: function next() {
     var _this = this;
-
     // if we have detected an error in the meanwhile
     // reject straight away
     var error = this[kError];
-
     if (error !== null) {
       return Promise.reject(error);
     }
-
     if (this[kEnded]) {
       return Promise.resolve(createIterResult(undefined, true));
     }
-
     if (this[kStream].destroyed) {
       // We need to defer via nextTick because if .destroy(err) is
       // called, the error will be emitted via nextTick, and
@@ -5086,29 +4894,25 @@ var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPro
           }
         });
       });
-    } // if we have multiple next() calls
+    }
+
+    // if we have multiple next() calls
     // we will wait for the previous Promise to finish
     // this logic is optimized to support for await loops,
     // where next() is only called once at a time
-
-
     var lastPromise = this[kLastPromise];
     var promise;
-
     if (lastPromise) {
       promise = new Promise(wrapForNext(lastPromise, this));
     } else {
       // fast path needed to support multiple this.push()
       // without triggering the next() queue
       var data = this[kStream].read();
-
       if (data !== null) {
         return Promise.resolve(createIterResult(data, false));
       }
-
       promise = new Promise(this[kHandlePromise]);
     }
-
     this[kLastPromise] = promise;
     return promise;
   }
@@ -5116,7 +4920,6 @@ var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPro
   return this;
 }), _defineProperty(_Object$setPrototypeO, "return", function _return() {
   var _this2 = this;
-
   // destroy(err, cb) is a private API
   // we can guarantee we have that here, because we control the
   // Readable class this is attached to
@@ -5126,15 +4929,12 @@ var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPro
         reject(err);
         return;
       }
-
       resolve(createIterResult(undefined, true));
     });
   });
 }), _Object$setPrototypeO), AsyncIteratorPrototype);
-
 var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
   var _Object$create;
-
   var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
     value: stream,
     writable: true
@@ -5153,7 +4953,6 @@ var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterat
   }), _defineProperty(_Object$create, kHandlePromise, {
     value: function value(resolve, reject) {
       var data = iterator[kStream].read();
-
       if (data) {
         iterator[kLastPromise] = null;
         iterator[kLastResolve] = null;
@@ -5169,35 +4968,30 @@ var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterat
   iterator[kLastPromise] = null;
   finished(stream, function (err) {
     if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
-      var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise
+      var reject = iterator[kLastReject];
+      // reject if we are waiting for data in the Promise
       // returned by next() and store the error
-
       if (reject !== null) {
         iterator[kLastPromise] = null;
         iterator[kLastResolve] = null;
         iterator[kLastReject] = null;
         reject(err);
       }
-
       iterator[kError] = err;
       return;
     }
-
     var resolve = iterator[kLastResolve];
-
     if (resolve !== null) {
       iterator[kLastPromise] = null;
       iterator[kLastResolve] = null;
       iterator[kLastReject] = null;
       resolve(createIterResult(undefined, true));
     }
-
     iterator[kEnded] = true;
   });
   stream.on('readable', onReadable.bind(null, iterator));
   return iterator;
 };
-
 module.exports = createReadableStreamAsyncIterator;
 
 /***/ }),
@@ -5207,41 +5001,29 @@ module.exports = createReadableStreamAsyncIterator;
 
 
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 var _require = __nccwpck_require__(4300),
-    Buffer = _require.Buffer;
-
+  Buffer = _require.Buffer;
 var _require2 = __nccwpck_require__(3837),
-    inspect = _require2.inspect;
-
+  inspect = _require2.inspect;
 var custom = inspect && inspect.custom || 'inspect';
-
 function copyBuffer(src, target, offset) {
   Buffer.prototype.copy.call(src, target, offset);
 }
-
-module.exports =
-/*#__PURE__*/
-function () {
+module.exports = /*#__PURE__*/function () {
   function BufferList() {
     _classCallCheck(this, BufferList);
-
     this.head = null;
     this.tail = null;
     this.length = 0;
   }
-
   _createClass(BufferList, [{
     key: "push",
     value: function push(v) {
@@ -5285,11 +5067,7 @@ function () {
       if (this.length === 0) return '';
       var p = this.head;
       var ret = '' + p.data;
-
-      while (p = p.next) {
-        ret += s + p.data;
-      }
-
+      while (p = p.next) ret += s + p.data;
       return ret;
     }
   }, {
@@ -5299,21 +5077,19 @@ function () {
       var ret = Buffer.allocUnsafe(n >>> 0);
       var p = this.head;
       var i = 0;
-
       while (p) {
         copyBuffer(p.data, ret, i);
         i += p.data.length;
         p = p.next;
       }
-
       return ret;
-    } // Consumes a specified amount of bytes or characters from the buffered data.
+    }
 
+    // Consumes a specified amount of bytes or characters from the buffered data.
   }, {
     key: "consume",
     value: function consume(n, hasStrings) {
       var ret;
-
       if (n < this.head.data.length) {
         // `slice` is the same for buffers and strings.
         ret = this.head.data.slice(0, n);
@@ -5325,15 +5101,15 @@ function () {
         // Result spans more than one buffer.
         ret = hasStrings ? this._getString(n) : this._getBuffer(n);
       }
-
       return ret;
     }
   }, {
     key: "first",
     value: function first() {
       return this.head.data;
-    } // Consumes a specified amount of characters from the buffered data.
+    }
 
+    // Consumes a specified amount of characters from the buffered data.
   }, {
     key: "_getString",
     value: function _getString(n) {
@@ -5341,13 +5117,11 @@ function () {
       var c = 1;
       var ret = p.data;
       n -= ret.length;
-
       while (p = p.next) {
         var str = p.data;
         var nb = n > str.length ? str.length : n;
         if (nb === str.length) ret += str;else ret += str.slice(0, n);
         n -= nb;
-
         if (n === 0) {
           if (nb === str.length) {
             ++c;
@@ -5356,17 +5130,15 @@ function () {
             this.head = p;
             p.data = str.slice(nb);
           }
-
           break;
         }
-
         ++c;
       }
-
       this.length -= c;
       return ret;
-    } // Consumes a specified amount of bytes from the buffered data.
+    }
 
+    // Consumes a specified amount of bytes from the buffered data.
   }, {
     key: "_getBuffer",
     value: function _getBuffer(n) {
@@ -5375,13 +5147,11 @@ function () {
       var c = 1;
       p.data.copy(ret);
       n -= p.data.length;
-
       while (p = p.next) {
         var buf = p.data;
         var nb = n > buf.length ? buf.length : n;
         buf.copy(ret, ret.length - n, 0, nb);
         n -= nb;
-
         if (n === 0) {
           if (nb === buf.length) {
             ++c;
@@ -5390,21 +5160,19 @@ function () {
             this.head = p;
             p.data = buf.slice(nb);
           }
-
           break;
         }
-
         ++c;
       }
-
       this.length -= c;
       return ret;
-    } // Make sure the linked list only shows the minimal necessary information.
+    }
 
+    // Make sure the linked list only shows the minimal necessary information.
   }, {
     key: custom,
     value: function value(_, options) {
-      return inspect(this, _objectSpread({}, options, {
+      return inspect(this, _objectSpread(_objectSpread({}, options), {}, {
         // Only inspect one level.
         depth: 0,
         // It should not recurse.
@@ -5412,7 +5180,6 @@ function () {
       }));
     }
   }]);
-
   return BufferList;
 }();
 
@@ -5421,14 +5188,13 @@ function () {
 /***/ 7049:
 /***/ ((module) => {
 
- // undocumented cb() API, needed for core, not for public API
 
+
+// undocumented cb() API, needed for core, not for public API
 function destroy(err, cb) {
   var _this = this;
-
   var readableDestroyed = this._readableState && this._readableState.destroyed;
   var writableDestroyed = this._writableState && this._writableState.destroyed;
-
   if (readableDestroyed || writableDestroyed) {
     if (cb) {
       cb(err);
@@ -5440,21 +5206,20 @@ function destroy(err, cb) {
         process.nextTick(emitErrorNT, this, err);
       }
     }
-
     return this;
-  } // we set destroyed to true before firing error callbacks in order
-  // to make it re-entrance safe in case destroy() is called within callbacks
+  }
 
+  // we set destroyed to true before firing error callbacks in order
+  // to make it re-entrance safe in case destroy() is called within callbacks
 
   if (this._readableState) {
     this._readableState.destroyed = true;
-  } // if this is a duplex stream mark the writable part as destroyed as well
-
+  }
 
+  // if this is a duplex stream mark the writable part as destroyed as well
   if (this._writableState) {
     this._writableState.destroyed = true;
   }
-
   this._destroy(err || null, function (err) {
     if (!cb && err) {
       if (!_this._writableState) {
@@ -5472,21 +5237,17 @@ function destroy(err, cb) {
       process.nextTick(emitCloseNT, _this);
     }
   });
-
   return this;
 }
-
 function emitErrorAndCloseNT(self, err) {
   emitErrorNT(self, err);
   emitCloseNT(self);
 }
-
 function emitCloseNT(self) {
   if (self._writableState && !self._writableState.emitClose) return;
   if (self._readableState && !self._readableState.emitClose) return;
   self.emit('close');
 }
-
 function undestroy() {
   if (this._readableState) {
     this._readableState.destroyed = false;
@@ -5494,7 +5255,6 @@ function undestroy() {
     this._readableState.ended = false;
     this._readableState.endEmitted = false;
   }
-
   if (this._writableState) {
     this._writableState.destroyed = false;
     this._writableState.ended = false;
@@ -5505,22 +5265,20 @@ function undestroy() {
     this._writableState.errorEmitted = false;
   }
 }
-
 function emitErrorNT(self, err) {
   self.emit('error', err);
 }
-
 function errorOrDestroy(stream, err) {
   // We have tests that rely on errors being emitted
   // in the same tick, so changing this is semver major.
   // For now when you opt-in to autoDestroy we allow
   // the error to be emitted nextTick. In a future
   // semver major update we should change the default to this.
+
   var rState = stream._readableState;
   var wState = stream._writableState;
   if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
 }
-
 module.exports = {
   destroy: destroy,
   undestroy: undestroy,
@@ -5536,77 +5294,61 @@ module.exports = {
 // permission from the author, Mathias Buus (@mafintosh).
 
 
-var ERR_STREAM_PREMATURE_CLOSE = (__nccwpck_require__(7214)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.ERR_STREAM_PREMATURE_CLOSE);
 
+var ERR_STREAM_PREMATURE_CLOSE = (__nccwpck_require__(7214)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.ERR_STREAM_PREMATURE_CLOSE);
 function once(callback) {
   var called = false;
   return function () {
     if (called) return;
     called = true;
-
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
     callback.apply(this, args);
   };
 }
-
 function noop() {}
-
 function isRequest(stream) {
   return stream.setHeader && typeof stream.abort === 'function';
 }
-
 function eos(stream, opts, callback) {
   if (typeof opts === 'function') return eos(stream, null, opts);
   if (!opts) opts = {};
   callback = once(callback || noop);
   var readable = opts.readable || opts.readable !== false && stream.readable;
   var writable = opts.writable || opts.writable !== false && stream.writable;
-
   var onlegacyfinish = function onlegacyfinish() {
     if (!stream.writable) onfinish();
   };
-
   var writableEnded = stream._writableState && stream._writableState.finished;
-
   var onfinish = function onfinish() {
     writable = false;
     writableEnded = true;
     if (!readable) callback.call(stream);
   };
-
   var readableEnded = stream._readableState && stream._readableState.endEmitted;
-
   var onend = function onend() {
     readable = false;
     readableEnded = true;
     if (!writable) callback.call(stream);
   };
-
   var onerror = function onerror(err) {
     callback.call(stream, err);
   };
-
   var onclose = function onclose() {
     var err;
-
     if (readable && !readableEnded) {
       if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
       return callback.call(stream, err);
     }
-
     if (writable && !writableEnded) {
       if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
       return callback.call(stream, err);
     }
   };
-
   var onrequest = function onrequest() {
     stream.req.on('finish', onfinish);
   };
-
   if (isRequest(stream)) {
     stream.on('complete', onfinish);
     stream.on('abort', onclose);
@@ -5616,7 +5358,6 @@ function eos(stream, opts, callback) {
     stream.on('end', onlegacyfinish);
     stream.on('close', onlegacyfinish);
   }
-
   stream.on('end', onend);
   stream.on('finish', onfinish);
   if (opts.error !== false) stream.on('error', onerror);
@@ -5634,7 +5375,6 @@ function eos(stream, opts, callback) {
     stream.removeListener('close', onclose);
   };
 }
-
 module.exports = eos;
 
 /***/ }),
@@ -5645,52 +5385,42 @@ module.exports = eos;
 
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 var ERR_INVALID_ARG_TYPE = (__nccwpck_require__(7214)/* .codes.ERR_INVALID_ARG_TYPE */ .q.ERR_INVALID_ARG_TYPE);
-
 function from(Readable, iterable, opts) {
   var iterator;
-
   if (iterable && typeof iterable.next === 'function') {
     iterator = iterable;
   } else if (iterable && iterable[Symbol.asyncIterator]) iterator = iterable[Symbol.asyncIterator]();else if (iterable && iterable[Symbol.iterator]) iterator = iterable[Symbol.iterator]();else throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable);
-
   var readable = new Readable(_objectSpread({
     objectMode: true
-  }, opts)); // Reading boolean to protect against _read
+  }, opts));
+  // Reading boolean to protect against _read
   // being called before last iteration completion.
-
   var reading = false;
-
   readable._read = function () {
     if (!reading) {
       reading = true;
       next();
     }
   };
-
   function next() {
     return _next2.apply(this, arguments);
   }
-
   function _next2() {
     _next2 = _asyncToGenerator(function* () {
       try {
-        var _ref = yield iterator.next(),
-            value = _ref.value,
-            done = _ref.done;
-
+        var _yield$iterator$next = yield iterator.next(),
+          value = _yield$iterator$next.value,
+          done = _yield$iterator$next.done;
         if (done) {
           readable.push(null);
-        } else if (readable.push((yield value))) {
+        } else if (readable.push(yield value)) {
           next();
         } else {
           reading = false;
@@ -5701,12 +5431,11 @@ function from(Readable, iterable, opts) {
     });
     return _next2.apply(this, arguments);
   }
-
   return readable;
 }
-
 module.exports = from;
 
+
 /***/ }),
 
 /***/ 6989:
@@ -5716,8 +5445,8 @@ module.exports = from;
 // permission from the author, Mathias Buus (@mafintosh).
 
 
-var eos;
 
+var eos;
 function once(callback) {
   var called = false;
   return function () {
@@ -5726,20 +5455,16 @@ function once(callback) {
     callback.apply(void 0, arguments);
   };
 }
-
 var _require$codes = (__nccwpck_require__(7214)/* .codes */ .q),
-    ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
-    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
-
+  ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
+  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
 function noop(err) {
   // Rethrow the error if it exists to avoid swallowing it
   if (err) throw err;
 }
-
 function isRequest(stream) {
   return stream.setHeader && typeof stream.abort === 'function';
 }
-
 function destroyer(stream, reading, writing, callback) {
   callback = once(callback);
   var closed = false;
@@ -5759,40 +5484,34 @@ function destroyer(stream, reading, writing, callback) {
   return function (err) {
     if (closed) return;
     if (destroyed) return;
-    destroyed = true; // request.destroy just do .end - .abort is what we want
+    destroyed = true;
 
+    // request.destroy just do .end - .abort is what we want
     if (isRequest(stream)) return stream.abort();
     if (typeof stream.destroy === 'function') return stream.destroy();
     callback(err || new ERR_STREAM_DESTROYED('pipe'));
   };
 }
-
 function call(fn) {
   fn();
 }
-
 function pipe(from, to) {
   return from.pipe(to);
 }
-
 function popCallback(streams) {
   if (!streams.length) return noop;
   if (typeof streams[streams.length - 1] !== 'function') return noop;
   return streams.pop();
 }
-
 function pipeline() {
   for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
     streams[_key] = arguments[_key];
   }
-
   var callback = popCallback(streams);
   if (Array.isArray(streams[0])) streams = streams[0];
-
   if (streams.length < 2) {
     throw new ERR_MISSING_ARGS('streams');
   }
-
   var error;
   var destroys = streams.map(function (stream, i) {
     var reading = i < streams.length - 1;
@@ -5807,7 +5526,6 @@ function pipeline() {
   });
   return streams.reduce(pipe);
 }
-
 module.exports = pipeline;
 
 /***/ }),
@@ -5818,27 +5536,22 @@ module.exports = pipeline;
 
 
 var ERR_INVALID_OPT_VALUE = (__nccwpck_require__(7214)/* .codes.ERR_INVALID_OPT_VALUE */ .q.ERR_INVALID_OPT_VALUE);
-
 function highWaterMarkFrom(options, isDuplex, duplexKey) {
   return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
 }
-
 function getHighWaterMark(state, options, duplexKey, isDuplex) {
   var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
-
   if (hwm != null) {
     if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
       var name = isDuplex ? duplexKey : 'highWaterMark';
       throw new ERR_INVALID_OPT_VALUE(name, hwm);
     }
-
     return Math.floor(hwm);
-  } // Default value
-
+  }
 
+  // Default value
   return state.objectMode ? 16 : 16 * 1024;
 }
-
 module.exports = {
   getHighWaterMark: getHighWaterMark
 };
@@ -7123,16 +6836,16 @@ function chalkTemplate(firstString, ...arguments_) {
 
 /***/ }),
 
-/***/ 67:
+/***/ 2719:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
 
 
 // EXPORTS
 __nccwpck_require__.d(__webpack_exports__, {
-  "Z": () => (/* binding */ ora)
+  "ZP": () => (/* binding */ ora)
 });
 
-// UNUSED EXPORTS: oraPromise
+// UNUSED EXPORTS: oraPromise, spinners
 
 // EXTERNAL MODULE: external "node:process"
 var external_node_process_ = __nccwpck_require__(7742);
@@ -7930,7 +7643,7 @@ function isInteractive({stream = process.stdout} = {}) {
 const external_node_readline_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:readline");
 // EXTERNAL MODULE: ./node_modules/bl/bl.js
 var bl = __nccwpck_require__(336);
-;// CONCATENATED MODULE: ./node_modules/ora/utilities.js
+;// CONCATENATED MODULE: ./node_modules/stdin-discarder/index.js
 
 
 
@@ -7947,7 +7660,7 @@ class StdinDiscarder {
 		this.#mutedStream.pipe(external_node_process_.stdout);
 
 		const self = this; // eslint-disable-line unicorn/no-this-assignment
-		this.#ourEmit = function (event, data, ...args) {
+		this.#ourEmit = function (event, data, ...arguments_) {
 			const {stdin} = external_node_process_;
 			if (self.#requests > 0 || stdin.emit === self.#ourEmit) {
 				if (event === 'keypress') { // Fixes readline behavior
@@ -7958,9 +7671,9 @@ class StdinDiscarder {
 					external_node_process_.emit('SIGINT');
 				}
 
-				Reflect.apply(self.#ourEmit, this, [event, data, ...args]);
+				Reflect.apply(self.#ourEmit, this, [event, data, ...arguments_]);
 			} else {
-				Reflect.apply(external_node_process_.stdin.emit, this, [event, data, ...args]);
+				Reflect.apply(external_node_process_.stdin.emit, this, [event, data, ...arguments_]);
 			}
 		};
 	}
@@ -8017,8 +7730,11 @@ class StdinDiscarder {
 	}
 }
 
-;// CONCATENATED MODULE: ./node_modules/ora/index.js
+const stdinDiscarder = new StdinDiscarder();
+
+/* harmony default export */ const stdin_discarder = (stdinDiscarder);
 
+;// CONCATENATED MODULE: ./node_modules/ora/index.js
 
 
 
@@ -8029,7 +7745,6 @@ class StdinDiscarder {
 
 
 
-let stdinDiscarder;
 
 class Ora {
 	#linesToClear = 0;
@@ -8050,10 +7765,6 @@ class Ora {
 	color;
 
 	constructor(options) {
-		if (!stdinDiscarder) {
-			stdinDiscarder = new StdinDiscarder();
-		}
-
 		if (typeof options === 'string') {
 			options = {
 				text: options,
@@ -8303,7 +8014,7 @@ class Ora {
 
 		if (this.#options.discardStdin && external_node_process_.stdin.isTTY) {
 			this.#isDiscardingStdin = true;
-			stdinDiscarder.start();
+			stdin_discarder.start();
 		}
 
 		this.render();
@@ -8326,7 +8037,7 @@ class Ora {
 		}
 
 		if (this.#options.discardStdin && external_node_process_.stdin.isTTY && this.#isDiscardingStdin) {
-			stdinDiscarder.stop();
+			stdin_discarder.stop();
 			this.#isDiscardingStdin = false;
 		}
 
@@ -8406,6 +8117,8 @@ async function oraPromise(action, options) {
 }
 
 
+
+
 /***/ }),
 
 /***/ 1124:
@@ -8465,6 +8178,8 @@ __nccwpck_require__.d(__webpack_exports__, {
 
 
 
+
+
 function characters(str) {
     return str.split("");
 }
@@ -8518,48 +8233,26 @@ function return_this() { return this; }
 function return_null() { return null; }
 
 var MAP = (function() {
-    function MAP(a, f, backwards) {
-        var ret = [], top = [], i;
-        function doit() {
-            var val = f(a[i], i);
-            var is_last = val instanceof Last;
-            if (is_last) val = val.v;
-            if (val instanceof AtTop) {
-                val = val.v;
-                if (val instanceof Splice) {
-                    top.push.apply(top, backwards ? val.v.slice().reverse() : val.v);
-                } else {
-                    top.push(val);
-                }
-            } else if (val !== skip) {
-                if (val instanceof Splice) {
-                    ret.push.apply(ret, backwards ? val.v.slice().reverse() : val.v);
-                } else {
-                    ret.push(val);
-                }
-            }
-            return is_last;
-        }
-        if (Array.isArray(a)) {
-            if (backwards) {
-                for (i = a.length; --i >= 0;) if (doit()) break;
-                ret.reverse();
-                top.reverse();
-            } else {
-                for (i = 0; i < a.length; ++i) if (doit()) break;
+    function MAP(a, tw, allow_splicing = true) {
+        const new_a = [];
+
+        for (let i = 0; i < a.length; ++i) {
+            let item = a[i];
+            let ret = item.transform(tw, allow_splicing);
+
+            if (ret instanceof ast_AST_Node) {
+                new_a.push(ret);
+            } else if (ret instanceof Splice) {
+                new_a.push(...ret.v);
             }
-        } else {
-            for (i in a) if (HOP(a, i)) if (doit()) break;
         }
-        return top.concat(ret);
+
+        return new_a;
     }
-    MAP.at_top = function(val) { return new AtTop(val); };
+
     MAP.splice = function(val) { return new Splice(val); };
-    MAP.last = function(val) { return new Last(val); };
-    var skip = MAP.skip = {};
-    function AtTop(val) { this.v = val; }
+    MAP.skip = {};
     function Splice(val) { this.v = val; }
-    function Last(val) { this.v = val; }
     return MAP;
 })();
 
@@ -8852,6 +8545,19 @@ var UNICODE = {
     ID_Continue: /(?:[$0-9A-Z_a-z\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF])+/,
 };
 
+try {
+    UNICODE = {
+        // https://262.ecma-international.org/13.0/#prod-IdentifierStartChar
+        // $, _, ID_Start
+        ID_Start: new RegExp("[_$\\p{ID_Start}]", "u"),
+        // https://262.ecma-international.org/13.0/#prod-IdentifierPartChar
+        // $, zero-width-joiner, zero-width-non-joiner, ID_Continue
+        ID_Continue: new RegExp("[$\\u200C\\u200D\\p{ID_Continue}]+", "u"),
+    };
+} catch(e) {
+    // Could not use modern JS \p{...}. UNICODE is already defined above so let's continue
+}
+
 function get_full_char(str, pos) {
     if (is_surrogate_pair_head(str.charCodeAt(pos))) {
         if (is_surrogate_pair_tail(str.charCodeAt(pos + 1))) {
@@ -10645,7 +10351,12 @@ function parse_parse($TEXT, options) {
     }
 
     function try_() {
-        var body = block_(), bcatch = null, bfinally = null;
+        var body, bcatch = null, bfinally = null;
+        body = new AST_TryBlock({
+            start : S.token,
+            body  : block_(),
+            end   : prev(),
+        });
         if (is("keyword", "catch")) {
             var start = S.token;
             next();
@@ -10681,14 +10392,20 @@ function parse_parse($TEXT, options) {
         });
     }
 
+    /**
+     * var
+     *   vardef1 = 2,
+     *   vardef2 = 3;
+     */
     function vardefs(no_in, kind) {
-        var a = [];
+        var var_defs = [];
         var def;
         for (;;) {
             var sym_type =
                 kind === "var" ? AST_SymbolVar :
                 kind === "const" ? AST_SymbolConst :
                 kind === "let" ? AST_SymbolLet : null;
+            // var { a } = b
             if (is("punc", "{") || is("punc", "[")) {
                 def = new AST_VarDef({
                     start: S.token,
@@ -10708,12 +10425,12 @@ function parse_parse($TEXT, options) {
                 });
                 if (def.name.name == "import") croak("Unexpected token: import");
             }
-            a.push(def);
+            var_defs.push(def);
             if (!is("punc", ","))
                 break;
             next();
         }
-        return a;
+        return var_defs;
     }
 
     var var_ = function(no_in) {
@@ -10874,7 +10591,7 @@ function parse_parse($TEXT, options) {
         if (is("operator", "new")) {
             return new_(allow_calls);
         }
-        if (is("operator", "import")) {
+        if (is("name", "import") && is_token(peek(), "punc", ".")) {
             return import_meta();
         }
         var start = S.token;
@@ -11370,7 +11087,7 @@ function parse_parse($TEXT, options) {
 
     function import_meta() {
         var start = S.token;
-        expect_token("operator", "import");
+        expect_token("name", "import");
         expect_token("punc", ".");
         expect_token("name", "meta");
         return subscripts(new AST_ImportMeta({
@@ -11380,9 +11097,10 @@ function parse_parse($TEXT, options) {
     }
 
     function map_name(is_import) {
-        function make_symbol(type) {
+        function make_symbol(type, quote) {
             return new type({
                 name: as_property_name(),
+                quote: quote || undefined,
                 start: prev(),
                 end: prev()
             });
@@ -11395,16 +11113,16 @@ function parse_parse($TEXT, options) {
         var name;
 
         if (is_import) {
-            foreign_name = make_symbol(foreign_type);
+            foreign_name = make_symbol(foreign_type, start.quote);
         } else {
-            name = make_symbol(type);
+            name = make_symbol(type, start.quote);
         }
         if (is("name", "as")) {
             next();  // The "as" word
             if (is_import) {
                 name = make_symbol(type);
             } else {
-                foreign_name = make_symbol(foreign_type);
+                foreign_name = make_symbol(foreign_type, S.token.quote);
             }
         } else if (is_import) {
             name = new type(foreign_name);
@@ -11420,20 +11138,26 @@ function parse_parse($TEXT, options) {
         });
     }
 
-    function map_nameAsterisk(is_import, name) {
+    function map_nameAsterisk(is_import, import_or_export_foreign_name) {
         var foreign_type = is_import ? AST_SymbolImportForeign : AST_SymbolExportForeign;
         var type = is_import ? AST_SymbolImport : AST_SymbolExport;
         var start = S.token;
-        var foreign_name;
+        var name, foreign_name;
         var end = prev();
 
+        if (is_import) {
+            name = import_or_export_foreign_name;
+        } else {
+            foreign_name = import_or_export_foreign_name;
+        }
+
         name = name || new type({
             start: start,
             name: "*",
             end: end,
         });
 
-        foreign_name = new foreign_type({
+        foreign_name = foreign_name || new foreign_type({
             start: start,
             name: "*",
             end: end,
@@ -11462,9 +11186,9 @@ function parse_parse($TEXT, options) {
         } else if (is("operator", "*")) {
             var name;
             next();
-            if (is_import && is("name", "as")) {
+            if (is("name", "as")) {
                 next();  // The "as" word
-                name = as_symbol(is_import ? AST_SymbolImport : AST_SymbolExportForeign);
+                name = is_import ? as_symbol(AST_SymbolImport) : as_symbol_or_string(AST_SymbolExportForeign);
             }
             names = [map_nameAsterisk(is_import, name)];
         }
@@ -11629,6 +11353,27 @@ function parse_parse($TEXT, options) {
         return sym;
     }
 
+    function as_symbol_or_string(type) {
+        if (!is("name")) {
+            if (!is("string")) {
+                croak("Name or string expected");
+            }
+            var tok = S.token;
+            var ret = new type({
+                start : tok,
+                end   : tok,
+                name : tok.value,
+                quote : tok.quote
+            });
+            next();
+            return ret;
+        }
+        var sym = _make_symbol(type);
+        _verify_symbol(sym);
+        next();
+        return sym;
+    }
+
     // Annotate AST_Call, AST_Lambda or AST_New with the special comments
     function annotate(node) {
         var start = node.start;
@@ -12114,6 +11859,14 @@ class ast_AST_Token {
         Object.seal(this);
     }
 
+    // Return a string summary of the token for node.js console.log
+    [Symbol.for("nodejs.util.inspect.custom")](_depth, options) {
+        const special = str => options.stylize(str, "special");
+        const quote = typeof this.value === "string" && this.value.includes("`") ? "'" : "`";
+        const value = `${quote}${this.value}${quote}`;
+        return `${special("[AST_Token")} ${value} at ${this.line}:${this.col}${special("]")}`;
+    }
+
     get nlb() {
         return has_tok_flag(this, TOK_FLAG_NLB);
     }
@@ -12244,8 +11997,21 @@ var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", function AST_Simple
 
 function walk_body(node, visitor) {
     const body = node.body;
-    for (var i = 0, len = body.length; i < len; i++) {
-        body[i]._walk(visitor);
+    if (visitor.walk_defun_first) {
+        for (var i = 0, len = body.length; i < len; i++) {
+            if (body[i] instanceof AST_Defun) {
+                body[i]._walk(visitor);
+            }
+        }
+        for (var i = 0, len = body.length; i < len; i++) {
+            if (!(body[i] instanceof AST_Defun)) {
+                body[i]._walk(visitor);
+            }
+        }
+    } else {
+        for (var i = 0, len = body.length; i < len; i++) {
+            body[i]._walk(visitor);
+        }
     }
 }
 
@@ -12997,6 +12763,7 @@ var AST_Jump = DEFNODE("Jump", null, function AST_Jump(props) {
     $documentation: "Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)"
 }, AST_Statement);
 
+/** Base class for “exits” (`return` and `throw`) */
 var AST_Exit = DEFNODE("Exit", "value", function AST_Exit(props) {
     if (props) {
         this.value = props.value;
@@ -13259,12 +13026,11 @@ var AST_Case = DEFNODE("Case", "expression", function AST_Case(props) {
 
 /* -----[ EXCEPTIONS ]----- */
 
-var AST_Try = DEFNODE("Try", "bcatch bfinally", function AST_Try(props) {
+var AST_Try = DEFNODE("Try", "body bcatch bfinally", function AST_Try(props) {
     if (props) {
+        this.body = props.body;
         this.bcatch = props.bcatch;
         this.bfinally = props.bfinally;
-        this.body = props.body;
-        this.block_scope = props.block_scope;
         this.start = props.start;
         this.end = props.end;
     }
@@ -13273,12 +13039,13 @@ var AST_Try = DEFNODE("Try", "bcatch bfinally", function AST_Try(props) {
 }, {
     $documentation: "A `try` statement",
     $propdoc: {
+        body: "[AST_TryBlock] the try block",
         bcatch: "[AST_Catch?] the catch block, or null if not present",
         bfinally: "[AST_Finally?] the finally block, or null if not present"
     },
     _walk: function(visitor) {
         return visitor._visit(this, function() {
-            walk_body(this, visitor);
+            this.body._walk(visitor);
             if (this.bcatch) this.bcatch._walk(visitor);
             if (this.bfinally) this.bfinally._walk(visitor);
         });
@@ -13286,9 +13053,21 @@ var AST_Try = DEFNODE("Try", "bcatch bfinally", function AST_Try(props) {
     _children_backwards(push) {
         if (this.bfinally) push(this.bfinally);
         if (this.bcatch) push(this.bcatch);
-        let i = this.body.length;
-        while (i--) push(this.body[i]);
+        push(this.body);
     },
+}, AST_Statement);
+
+var AST_TryBlock = DEFNODE("TryBlock", null, function AST_TryBlock(props) {
+    if (props) {
+        this.body = props.body;
+        this.block_scope = props.block_scope;
+        this.start = props.start;
+        this.end = props.end;
+    }
+
+    this.flags = 0;
+}, {
+    $documentation: "The `try` block of a try statement"
 }, AST_Block);
 
 var AST_Catch = DEFNODE("Catch", "argname", function AST_Catch(props) {
@@ -14591,6 +14370,7 @@ var AST_SymbolImportForeign = DEFNODE("SymbolImportForeign", null, function AST_
         this.scope = props.scope;
         this.name = props.name;
         this.thedef = props.thedef;
+        this.quote = props.quote;
         this.start = props.start;
         this.end = props.end;
     }
@@ -14642,6 +14422,7 @@ var AST_SymbolExport = DEFNODE("SymbolExport", null, function AST_SymbolExport(p
         this.scope = props.scope;
         this.name = props.name;
         this.thedef = props.thedef;
+        this.quote = props.quote;
         this.start = props.start;
         this.end = props.end;
     }
@@ -14656,6 +14437,7 @@ var AST_SymbolExportForeign = DEFNODE("SymbolExportForeign", null, function AST_
         this.scope = props.scope;
         this.name = props.name;
         this.thedef = props.thedef;
+        this.quote = props.quote;
         this.start = props.start;
         this.end = props.end;
     }
@@ -15008,10 +14790,11 @@ const walk_abort = Symbol("abort walk");
 /* -----[ TreeWalker ]----- */
 
 class TreeWalker {
-    constructor(callback) {
+    constructor(callback, { walk_defun_first = false } = {}) {
         this.visit = callback;
         this.stack = [];
         this.directives = Object.create(null);
+        this.walk_defun_first = walk_defun_first;
     }
 
     _visit(node, descend) {
@@ -15183,12 +14966,6 @@ function def_transform(node, descend) {
     });
 }
 
-function do_list(list, tw) {
-    return MAP(list, function(node) {
-        return node.transform(tw, true);
-    });
-}
-
 def_transform(ast_AST_Node, noop);
 
 def_transform(AST_LabeledStatement, function(self, tw) {
@@ -15201,7 +14978,7 @@ def_transform(AST_SimpleStatement, function(self, tw) {
 });
 
 def_transform(AST_Block, function(self, tw) {
-    self.body = do_list(self.body, tw);
+    self.body = MAP(self.body, tw);
 });
 
 def_transform(AST_Do, function(self, tw) {
@@ -15248,27 +15025,27 @@ def_transform(AST_If, function(self, tw) {
 
 def_transform(AST_Switch, function(self, tw) {
     self.expression = self.expression.transform(tw);
-    self.body = do_list(self.body, tw);
+    self.body = MAP(self.body, tw);
 });
 
 def_transform(AST_Case, function(self, tw) {
     self.expression = self.expression.transform(tw);
-    self.body = do_list(self.body, tw);
+    self.body = MAP(self.body, tw);
 });
 
 def_transform(AST_Try, function(self, tw) {
-    self.body = do_list(self.body, tw);
+    self.body = self.body.transform(tw);
     if (self.bcatch) self.bcatch = self.bcatch.transform(tw);
     if (self.bfinally) self.bfinally = self.bfinally.transform(tw);
 });
 
 def_transform(AST_Catch, function(self, tw) {
     if (self.argname) self.argname = self.argname.transform(tw);
-    self.body = do_list(self.body, tw);
+    self.body = MAP(self.body, tw);
 });
 
 def_transform(AST_Definitions, function(self, tw) {
-    self.definitions = do_list(self.definitions, tw);
+    self.definitions = MAP(self.definitions, tw);
 });
 
 def_transform(AST_VarDef, function(self, tw) {
@@ -15277,26 +15054,26 @@ def_transform(AST_VarDef, function(self, tw) {
 });
 
 def_transform(AST_Destructuring, function(self, tw) {
-    self.names = do_list(self.names, tw);
+    self.names = MAP(self.names, tw);
 });
 
 def_transform(AST_Lambda, function(self, tw) {
     if (self.name) self.name = self.name.transform(tw);
-    self.argnames = do_list(self.argnames, tw);
+    self.argnames = MAP(self.argnames, tw, /* allow_splicing */ false);
     if (self.body instanceof ast_AST_Node) {
         self.body = self.body.transform(tw);
     } else {
-        self.body = do_list(self.body, tw);
+        self.body = MAP(self.body, tw);
     }
 });
 
 def_transform(AST_Call, function(self, tw) {
     self.expression = self.expression.transform(tw);
-    self.args = do_list(self.args, tw);
+    self.args = MAP(self.args, tw, /* allow_splicing */ false);
 });
 
 def_transform(ast_AST_Sequence, function(self, tw) {
-    const result = do_list(self.expressions, tw);
+    const result = MAP(self.expressions, tw);
     self.expressions = result.length
         ? result
         : [new AST_Number({ value: 0 })];
@@ -15344,11 +15121,11 @@ def_transform(AST_Conditional, function(self, tw) {
 });
 
 def_transform(ast_AST_Array, function(self, tw) {
-    self.elements = do_list(self.elements, tw);
+    self.elements = MAP(self.elements, tw);
 });
 
 def_transform(AST_Object, function(self, tw) {
-    self.properties = do_list(self.properties, tw);
+    self.properties = MAP(self.properties, tw);
 });
 
 def_transform(AST_ObjectProperty, function(self, tw) {
@@ -15361,11 +15138,11 @@ def_transform(AST_ObjectProperty, function(self, tw) {
 def_transform(AST_Class, function(self, tw) {
     if (self.name) self.name = self.name.transform(tw);
     if (self.extends) self.extends = self.extends.transform(tw);
-    self.properties = do_list(self.properties, tw);
+    self.properties = MAP(self.properties, tw);
 });
 
 def_transform(AST_ClassStaticBlock, function(self, tw) {
-    self.body = do_list(self.body, tw);
+    self.body = MAP(self.body, tw);
 });
 
 def_transform(AST_Expansion, function(self, tw) {
@@ -15379,19 +15156,19 @@ def_transform(AST_NameMapping, function(self, tw) {
 
 def_transform(AST_Import, function(self, tw) {
     if (self.imported_name) self.imported_name = self.imported_name.transform(tw);
-    if (self.imported_names) do_list(self.imported_names, tw);
+    if (self.imported_names) MAP(self.imported_names, tw);
     self.module_name = self.module_name.transform(tw);
 });
 
 def_transform(AST_Export, function(self, tw) {
     if (self.exported_definition) self.exported_definition = self.exported_definition.transform(tw);
     if (self.exported_value) self.exported_value = self.exported_value.transform(tw);
-    if (self.exported_names) do_list(self.exported_names, tw);
+    if (self.exported_names) MAP(self.exported_names, tw);
     if (self.module_name) self.module_name = self.module_name.transform(tw);
 });
 
 def_transform(AST_TemplateString, function(self, tw) {
-    self.segments = do_list(self.segments, tw);
+    self.segments = MAP(self.segments, tw);
 });
 
 def_transform(AST_PrefixedTemplateString, function(self, tw) {
@@ -15630,7 +15407,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             return new AST_Try({
                 start    : my_start_token(M),
                 end      : my_end_token(M),
-                body     : from_moz(M.block).body,
+                body     : new AST_TryBlock(from_moz(M.block)),
                 bcatch   : from_moz(handlers[0]),
                 bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null
             });
@@ -15815,24 +15592,11 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             var imported_name = null;
             var imported_names = null;
             M.specifiers.forEach(function (specifier) {
-                if (specifier.type === "ImportSpecifier") {
+                if (specifier.type === "ImportSpecifier" || specifier.type === "ImportNamespaceSpecifier") {
                     if (!imported_names) { imported_names = []; }
-                    imported_names.push(new AST_NameMapping({
-                        start: my_start_token(specifier),
-                        end: my_end_token(specifier),
-                        foreign_name: from_moz(specifier.imported),
-                        name: from_moz(specifier.local)
-                    }));
+                    imported_names.push(from_moz(specifier));
                 } else if (specifier.type === "ImportDefaultSpecifier") {
-                    imported_name = from_moz(specifier.local);
-                } else if (specifier.type === "ImportNamespaceSpecifier") {
-                    if (!imported_names) { imported_names = []; }
-                    imported_names.push(new AST_NameMapping({
-                        start: my_start_token(specifier),
-                        end: my_end_token(specifier),
-                        foreign_name: new AST_SymbolImportForeign({ name: "*" }),
-                        name: from_moz(specifier.local)
-                    }));
+                    imported_name = from_moz(specifier);
                 }
             });
             return new AST_Import({
@@ -15845,14 +15609,39 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             });
         },
 
+        ImportSpecifier: function(M) {
+            return new AST_NameMapping({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                foreign_name: from_moz(M.imported),
+                name: from_moz(M.local)
+            });
+        },
+
+        ImportDefaultSpecifier: function(M) {
+            return from_moz(M.local);
+        },
+
+        ImportNamespaceSpecifier: function(M) {
+            return new AST_NameMapping({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                foreign_name: new AST_SymbolImportForeign({ name: "*" }),
+                name: from_moz(M.local)
+            });
+        },
+
         ExportAllDeclaration: function(M) {
+            var foreign_name = M.exported == null ? 
+                new AST_SymbolExportForeign({ name: "*" }) :
+                from_moz(M.exported);
             return new AST_Export({
                 start: my_start_token(M),
                 end: my_end_token(M),
                 exported_names: [
                     new AST_NameMapping({
                         name: new AST_SymbolExportForeign({ name: "*" }),
-                        foreign_name: new AST_SymbolExportForeign({ name: "*" })
+                        foreign_name: foreign_name
                     })
                 ],
                 module_name: from_moz(M.source),
@@ -15866,10 +15655,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 end: my_end_token(M),
                 exported_definition: from_moz(M.declaration),
                 exported_names: M.specifiers && M.specifiers.length ? M.specifiers.map(function (specifier) {
-                    return new AST_NameMapping({
-                        foreign_name: from_moz(specifier.exported),
-                        name: from_moz(specifier.local)
-                    });
+                    return from_moz(specifier);
                 }) : null,
                 module_name: from_moz(M.source),
                 assert_clause: assert_clause_from_moz(M.assertions)
@@ -15885,6 +15671,13 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             });
         },
 
+        ExportSpecifier: function(M) {
+            return new AST_NameMapping({
+                foreign_name: from_moz(M.exported),
+                name: from_moz(M.local)
+            });
+        },
+
         Literal: function(M) {
             var val = M.value, args = {
                 start  : my_start_token(M),
@@ -15910,6 +15703,22 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             if (val === null) return new AST_Null(args);
             switch (typeof val) {
               case "string":
+                args.quote = "\"";
+                var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
+                if (p.type == "ImportSpecifier") {
+                    args.name = val;
+                    return new AST_SymbolImportForeign(args);
+                } else if (p.type == "ExportSpecifier") {
+                    args.name = val;
+                    if (M == p.exported) {
+                        return new AST_SymbolExportForeign(args);
+                    } else {
+                        return new AST_SymbolExport(args);
+                    }
+                } else if (p.type == "ExportAllDeclaration" && M == p.exported) {
+                    args.name = val;
+                    return new AST_SymbolExportForeign(args);
+                }
                 args.value = val;
                 return new AST_String(args);
               case "number":
@@ -16569,7 +16378,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
     def_to_moz(AST_Try, function To_Moz_TryStatement(M) {
         return {
             type: "TryStatement",
-            block: to_moz_block(M),
+            block: to_moz_block(M.body),
             handler: to_moz(M.bcatch),
             guardedHandlers: [],
             finalizer: to_moz(M.bfinally)
@@ -16614,10 +16423,17 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
 
     def_to_moz(AST_Export, function To_Moz_ExportDeclaration(M) {
         if (M.exported_names) {
-            if (M.exported_names[0].name.name === "*") {
+            var first_exported = M.exported_names[0];
+            var first_exported_name = first_exported.name;
+            if (first_exported_name.name === "*" && !first_exported_name.quote) {
+                var foreign_name = first_exported.foreign_name;
+                var exported = foreign_name.name === "*" && !foreign_name.quote
+                    ? null
+                    : to_moz(foreign_name);
                 return {
                     type: "ExportAllDeclaration",
                     source: to_moz(M.module_name),
+                    exported: exported,
                     assertions: assert_clause_to_moz(M.assert_clause)
                 };
             }
@@ -16649,19 +16465,22 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 local: to_moz(M.imported_name)
             });
         }
-        if (M.imported_names && M.imported_names[0].foreign_name.name === "*") {
-            specifiers.push({
-                type: "ImportNamespaceSpecifier",
-                local: to_moz(M.imported_names[0].name)
-            });
-        } else if (M.imported_names) {
-            M.imported_names.forEach(function(name_mapping) {
+        if (M.imported_names) {
+            var first_imported_foreign_name = M.imported_names[0].foreign_name;
+            if (first_imported_foreign_name.name === "*" && !first_imported_foreign_name.quote) {
                 specifiers.push({
-                    type: "ImportSpecifier",
-                    local: to_moz(name_mapping.name),
-                    imported: to_moz(name_mapping.foreign_name)
+                    type: "ImportNamespaceSpecifier",
+                    local: to_moz(M.imported_names[0].name)
                 });
-            });
+            } else {
+                M.imported_names.forEach(function(name_mapping) {
+                    specifiers.push({
+                        type: "ImportSpecifier",
+                        local: to_moz(name_mapping.name),
+                        imported: to_moz(name_mapping.foreign_name)
+                    });
+                });
+            }
         }
         return {
             type: "ImportDeclaration",
@@ -16925,7 +16744,14 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
     });
 
     def_to_moz(ast_AST_Symbol, function To_Moz_Identifier(M, parent) {
-        if (M instanceof AST_SymbolMethod && parent.quote) {
+        if (
+            (M instanceof AST_SymbolMethod && parent.quote) ||
+            ((
+                M instanceof AST_SymbolImportForeign ||
+                M instanceof AST_SymbolExportForeign ||
+                M instanceof AST_SymbolExport
+                ) && M.quote)
+         ) {
             return {
                 type: "Literal",
                 value: M.name
@@ -18250,7 +18076,7 @@ function output_OutputStream(options) {
     }
 
     AST_StatementWithBody.DEFMETHOD("_do_print_body", function(output) {
-        force_statement(this.body, output);
+        print_maybe_braced_body(this.body, output);
     });
 
     DEFPRINT(AST_Statement, function(self, output) {
@@ -18579,7 +18405,7 @@ function output_OutputStream(options) {
                 b = b.body;
             } else break;
         }
-        force_statement(self.body, output);
+        print_maybe_braced_body(self.body, output);
     }
     DEFPRINT(AST_If, function(self, output) {
         output.print("if");
@@ -18596,7 +18422,7 @@ function output_OutputStream(options) {
             if (self.alternative instanceof AST_If)
                 self.alternative.print(output);
             else
-                force_statement(self.alternative, output);
+                print_maybe_braced_body(self.alternative, output);
         } else {
             self._do_print_body(output);
         }
@@ -18645,7 +18471,7 @@ function output_OutputStream(options) {
     DEFPRINT(AST_Try, function(self, output) {
         output.print("try");
         output.space();
-        print_braced(self, output);
+        self.body.print(output);
         if (self.bcatch) {
             output.space();
             self.bcatch.print(output);
@@ -18655,6 +18481,9 @@ function output_OutputStream(options) {
             self.bfinally.print(output);
         }
     });
+    DEFPRINT(AST_TryBlock, function(self, output) {
+        print_braced(self, output);
+    });
     DEFPRINT(AST_Catch, function(self, output) {
         output.print("catch");
         if (self.argname) {
@@ -18706,7 +18535,9 @@ function output_OutputStream(options) {
             output.space();
         }
         if (self.imported_names) {
-            if (self.imported_names.length === 1 && self.imported_names[0].foreign_name.name === "*") {
+            if (self.imported_names.length === 1 &&
+                self.imported_names[0].foreign_name.name === "*" &&
+                !self.imported_names[0].foreign_name.quote) {
                 self.imported_names[0].print(output);
             } else {
                 output.print("{");
@@ -18740,14 +18571,31 @@ function output_OutputStream(options) {
     DEFPRINT(AST_NameMapping, function(self, output) {
         var is_import = output.parent() instanceof AST_Import;
         var definition = self.name.definition();
+        var foreign_name = self.foreign_name;
         var names_are_different =
             (definition && definition.mangled_name || self.name.name) !==
-            self.foreign_name.name;
+            foreign_name.name;
+        if (!names_are_different &&
+            foreign_name.name === "*" &&
+            foreign_name.quote != self.name.quote) {
+                // export * as "*"
+            names_are_different = true;
+        }
+        var foreign_name_is_name = foreign_name.quote == null;
         if (names_are_different) {
             if (is_import) {
-                output.print(self.foreign_name.name);
+                if (foreign_name_is_name) {
+                    output.print(foreign_name.name);
+                } else {
+                    output.print_string(foreign_name.name, foreign_name.quote);
+                }
             } else {
-                self.name.print(output);
+                if (self.name.quote == null) {
+                    self.name.print(output);
+                } else {
+                    output.print_string(self.name.name, self.name.quote);
+                }
+                
             }
             output.space();
             output.print("as");
@@ -18755,10 +18603,18 @@ function output_OutputStream(options) {
             if (is_import) {
                 self.name.print(output);
             } else {
-                output.print(self.foreign_name.name);
+                if (foreign_name_is_name) {
+                    output.print(foreign_name.name);
+                } else {
+                    output.print_string(foreign_name.name, foreign_name.quote);
+                }
             }
         } else {
-            self.name.print(output);
+            if (self.name.quote == null) {
+                self.name.print(output);
+            } else {
+                output.print_string(self.name.name, self.name.quote);
+            }
         }
     });
 
@@ -18770,8 +18626,10 @@ function output_OutputStream(options) {
             output.space();
         }
         if (self.exported_names) {
-            if (self.exported_names.length === 1 && self.exported_names[0].name.name === "*") {
-                self.exported_names[0].print(output);
+            if (self.exported_names.length === 1 &&
+                self.exported_names[0].name.name === "*" &&
+                !self.exported_names[0].name.quote) {
+                    self.exported_names[0].print(output);
             } else {
                 output.print("{");
                 self.exported_names.forEach(function(name_export, i) {
@@ -19291,12 +19149,15 @@ function output_OutputStream(options) {
         }
     });
 
-    function force_statement(stat, output) {
+    /** if, for, while, may or may not have braces surrounding its body */
+    function print_maybe_braced_body(stat, output) {
         if (output.option("braces")) {
             make_block(stat, output);
         } else {
             if (!stat || stat instanceof AST_EmptyStatement)
                 output.force_semicolon();
+            else if (stat instanceof AST_Let || stat instanceof AST_Const || stat instanceof AST_Class)
+                make_block(stat, output);
             else
                 stat.print(output);
         }
@@ -19520,7 +19381,7 @@ AST_Switch.prototype.shallow_cmp = pass_through;
 AST_SwitchBranch.prototype.shallow_cmp = pass_through;
 
 AST_Try.prototype.shallow_cmp = function(other) {
-    return (this.bcatch == null ? other.bcatch == null : this.bcatch === other.bcatch) && (this.bfinally == null ? other.bfinally == null : this.bfinally === other.bfinally);
+    return (this.body === other.body) && (this.bcatch == null ? other.bcatch == null : this.bcatch === other.bcatch) && (this.bfinally == null ? other.bfinally == null : this.bfinally === other.bfinally);
 };
 
 AST_Catch.prototype.shallow_cmp = function(other) {
@@ -19794,16 +19655,12 @@ AST_Scope.DEFMETHOD("figure_out_scope", function(options, { parent_scope = null,
             const save_scope = scope;
             node.block_scope = scope = new AST_Scope(node);
             scope._block_scope = true;
-            // AST_Try in the AST sadly *is* (not has) a body itself,
-            // and its catch and finally branches are children of the AST_Try itself
-            const parent_scope = node instanceof AST_Catch
-                ? save_scope.parent_scope
-                : save_scope;
-            scope.init_scope_vars(parent_scope);
+            scope.init_scope_vars(save_scope);
             scope.uses_with = save_scope.uses_with;
             scope.uses_eval = save_scope.uses_eval;
+
             if (options.safari10) {
-                if (node instanceof AST_For || node instanceof AST_ForIn) {
+                if (node instanceof AST_For || node instanceof AST_ForIn || node instanceof AST_ForOf) {
                     for_scopes.push(scope);
                 }
             }
@@ -19813,7 +19670,7 @@ AST_Scope.DEFMETHOD("figure_out_scope", function(options, { parent_scope = null,
                 // AST_Switch has a scope within the body, but it itself "is a block scope"
                 // This means the switched expression has to belong to the outer scope
                 // while the body inside belongs to the switch itself.
-                // This is pretty nasty and warrants an AST change similar to AST_Try (read above)
+                // This is pretty nasty and warrants an AST change
                 const the_block_scope = scope;
                 scope = save_scope;
                 node.expression.walk(tw);
@@ -20765,9 +20622,7 @@ AST_Default.prototype._size = function () {
     return 8 + list_overhead(this.body);
 };
 
-AST_Try.prototype._size = function () {
-    return 3 + list_overhead(this.body);
-};
+AST_Try.prototype._size = () => 3;
 
 AST_Catch.prototype._size = function () {
     let size = 7 + list_overhead(this.body);
@@ -21312,9 +21167,10 @@ function is_func_expr(node) {
     return node instanceof AST_Arrow || node instanceof AST_Function;
 }
 
+/**
+ * Used to determine whether the node can benefit from negation.
+ * Not the case with arrow functions (you need an extra set of parens). */
 function is_iife_call(node) {
-    // Used to determine whether the node can benefit from negation.
-    // Not the case with arrow functions (you need an extra set of parens).
     if (node.TYPE != "Call") return false;
     return node.expression instanceof AST_Function || is_iife_call(node.expression);
 }
@@ -21497,6 +21353,9 @@ const object_methods = [
 
 const is_pure_native_method = make_nested_lookup({
     Array: [
+        "at",
+        "flat",
+        "includes",
         "indexOf",
         "join",
         "lastIndexOf",
@@ -21517,22 +21376,41 @@ const is_pure_native_method = make_nested_lookup({
         ...object_methods,
     ],
     String: [
+        "at",
         "charAt",
         "charCodeAt",
+        "charPointAt",
         "concat",
+        "endsWith",
+        "fromCharCode",
+        "fromCodePoint",
+        "includes",
         "indexOf",
         "italics",
         "lastIndexOf",
+        "localeCompare",
         "match",
+        "matchAll",
+        "normalize",
+        "padStart",
+        "padEnd",
+        "repeat",
         "replace",
+        "replaceAll",
         "search",
         "slice",
         "split",
+        "startsWith",
         "substr",
         "substring",
+        "repeat",
+        "toLocaleLowerCase",
+        "toLocaleUpperCase",
         "toLowerCase",
         "toUpperCase",
         "trim",
+        "trimEnd",
+        "trimStart",
         ...object_methods,
     ],
 });
@@ -21697,7 +21575,7 @@ const unary_side_effects = makePredicate("delete ++ --");
     def_is_number(AST_Number, return_true);
     const unary = makePredicate("+ - ~ ++ --");
     def_is_number(AST_Unary, function() {
-        return unary.has(this.operator);
+        return unary.has(this.operator) && !(this.expression instanceof AST_BigInt);
     });
     const numeric_ops = makePredicate("- * / % & | ^ << >> >>>");
     def_is_number(AST_Binary, function(compressor) {
@@ -21826,7 +21704,7 @@ function is_nullish(node, compressor) {
             || any(this.body, compressor);
     });
     def_has_side_effects(AST_Try, function(compressor) {
-        return any(this.body, compressor)
+        return this.body.has_side_effects(compressor)
             || this.bcatch && this.bcatch.has_side_effects(compressor)
             || this.bfinally && this.bfinally.has_side_effects(compressor);
     });
@@ -21835,6 +21713,7 @@ function is_nullish(node, compressor) {
             || this.body && this.body.has_side_effects(compressor)
             || this.alternative && this.alternative.has_side_effects(compressor);
     });
+    def_has_side_effects(AST_ImportMeta, return_false);
     def_has_side_effects(AST_LabeledStatement, function(compressor) {
         return this.body.has_side_effects(compressor);
     });
@@ -21938,6 +21817,7 @@ function is_nullish(node, compressor) {
     def_may_throw(AST_Lambda, return_false);
     def_may_throw(AST_SymbolDeclaration, return_false);
     def_may_throw(AST_This, return_false);
+    def_may_throw(AST_ImportMeta, return_false);
 
     function any(list, compressor) {
         for (var i = list.length; --i >= 0;)
@@ -22055,7 +21935,7 @@ function is_nullish(node, compressor) {
     });
     def_may_throw(AST_SymbolClassProperty, return_false);
     def_may_throw(AST_Try, function(compressor) {
-        return this.bcatch ? this.bcatch.may_throw(compressor) : any(this.body, compressor)
+        return this.bcatch ? this.bcatch.may_throw(compressor) : this.body.may_throw(compressor)
             || this.bfinally && this.bfinally.may_throw(compressor);
     });
     def_may_throw(AST_Unary, function(compressor) {
@@ -22301,6 +22181,11 @@ function is_lhs(node, parent) {
         var name = this.name + suffix;
         if (HOP(defines, name)) return to_node(defines[name], this);
     });
+    def_find_defs(AST_ImportMeta, function(compressor, suffix) {
+        var defines = compressor.option("global_defs");
+        var name = "import.meta" + suffix;
+        if (HOP(defines, name)) return to_node(defines[name], this);
+    });
 })(function(node, func) {
     node.DEFMETHOD("_find_defs", func);
 });
@@ -23737,15 +23622,17 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
 
 
 
-// Define the method AST_Node#reduce_vars, which goes through the AST in
-// execution order to perform basic flow analysis
-
+/**
+ * Define the method AST_Node#reduce_vars, which goes through the AST in
+ * execution order to perform basic flow analysis
+ */
 function def_reduce_vars(node, func) {
     node.DEFMETHOD("reduce_vars", func);
 }
 
 def_reduce_vars(ast_AST_Node, noop);
 
+/** Clear definition properties */
 function reset_def(compressor, def) {
     def.assignments = 0;
     def.chained = false;
@@ -23754,7 +23641,10 @@ function reset_def(compressor, def) {
     def.recursive_refs = 0;
     def.references = [];
     def.single_use = undefined;
-    if (def.scope.pinned()) {
+    if (
+        def.scope.pinned()
+        || (def.orig[0] instanceof AST_SymbolFunarg && def.scope.uses_arguments)
+    ) {
         def.fixed = false;
     } else if (def.orig[0] instanceof AST_SymbolConst || !compressor.exposed(def)) {
         def.fixed = def.init;
@@ -24076,15 +23966,15 @@ def_reduce_vars(AST_Default, function(tw, descend) {
 
 function mark_lambda(tw, descend, compressor) {
     clear_flag(this, INLINED);
+
     push(tw);
+
     reset_variables(tw, compressor, this);
-    if (this.uses_arguments) {
-        descend();
-        pop(tw);
-        return;
-    }
+
     var iife;
     if (!this.name
+        && !this.uses_arguments
+        && !this.pinned()
         && (iife = tw.parent()) instanceof AST_Call
         && iife.expression === this
         && !iife.args.some(arg => arg instanceof AST_Expansion)
@@ -24109,8 +23999,10 @@ function mark_lambda(tw, descend, compressor) {
             }
         });
     }
+
     descend();
     pop(tw);
+
     return true;
 }
 
@@ -24239,7 +24131,7 @@ def_reduce_vars(AST_Toplevel, function(tw, descend, compressor) {
 def_reduce_vars(AST_Try, function(tw, descend, compressor) {
     reset_block_variables(compressor, this);
     push(tw);
-    walk_body(this, tw);
+    this.body.walk(tw);
     pop(tw);
     if (this.bcatch) {
         push(tw);
@@ -24452,13 +24344,11 @@ function tighten_body(statements, compressor) {
     function find_loop_scope_try() {
         var node = compressor.self(), level = 0, in_loop = false, in_try = false;
         do {
-            if (node instanceof AST_Catch || node instanceof AST_Finally) {
-                level++;
-            } else if (node instanceof AST_IterationStatement) {
+            if (node instanceof AST_IterationStatement) {
                 in_loop = true;
             } else if (node instanceof AST_Scope) {
                 break;
-            } else if (node instanceof AST_Try) {
+            } else if (node instanceof AST_TryBlock) {
                 in_try = true;
             }
         } while (node = compressor.parent(level++));
@@ -24502,6 +24392,9 @@ function tighten_body(statements, compressor) {
                     && (node.logical || node.operator != "=" && lhs.equivalent_to(node.left))
                 || node instanceof AST_Await
                 || node instanceof AST_Call && lhs instanceof ast_AST_PropAccess && lhs.equivalent_to(node.expression)
+                ||
+                    (node instanceof AST_Call || node instanceof ast_AST_PropAccess)
+                    && node.optional
                 || node instanceof AST_Debugger
                 || node instanceof AST_Destructuring
                 || node instanceof AST_Expansion
@@ -24675,7 +24568,11 @@ function tighten_body(statements, compressor) {
                 var hit = funarg;
                 var abort = false, replaced = 0, can_replace = !args || !hit;
                 if (!can_replace) {
-                    for (var j = compressor.self().argnames.lastIndexOf(candidate.name) + 1; !abort && j < args.length; j++) {
+                    for (
+                        let j = compressor.self().argnames.lastIndexOf(candidate.name) + 1;
+                        !abort && j < args.length;
+                        j++
+                    ) {
                         args[j].transform(scanner);
                     }
                     can_replace = true;
@@ -25622,14 +25519,21 @@ function tighten_body(statements, compressor) {
                     CHANGED = true;
                     stat.init = exprs.length ? make_sequence(stat.init, exprs) : null;
                     statements[++j] = stat;
-                } else if (prev instanceof AST_Var && (!stat.init || stat.init.TYPE == prev.TYPE)) {
+                } else if (
+                    prev instanceof AST_Var
+                    && (!stat.init || stat.init.TYPE == prev.TYPE)
+                ) {
                     if (stat.init) {
                         prev.definitions = prev.definitions.concat(stat.init.definitions);
                     }
                     stat.init = prev;
                     statements[j] = stat;
                     CHANGED = true;
-                } else if (defs && stat.init && defs.TYPE == stat.init.TYPE && declarations_only(stat.init)) {
+                } else if (
+                    defs instanceof AST_Var
+                    && stat.init instanceof AST_Var
+                    && declarations_only(stat.init)
+                ) {
                     defs.definitions = defs.definitions.concat(stat.init.definitions);
                     stat.init = null;
                     statements[++j] = stat;
@@ -25732,7 +25636,13 @@ function tighten_body(statements, compressor) {
 
 
 
-
+/**
+ * Module that contains the inlining logic.
+ *
+ * @module
+ *
+ * The stars of the show are `inline_into_symbolref` and `inline_into_call`.
+ */
 
 function within_array_or_object_literal(compressor) {
     var node, level = 0;
@@ -25763,136 +25673,135 @@ function scope_encloses_variables_in_this_scope(scope, pulled_scope) {
 
 function inline_into_symbolref(self, compressor) {
     const parent = compressor.parent();
-    if (compressor.option("reduce_vars") && is_lhs(self, parent) !== self) {
-        const def = self.definition();
-        const nearest_scope = compressor.find_scope();
-        if (compressor.top_retain && def.global && compressor.top_retain(def)) {
-            def.fixed = false;
-            def.single_use = false;
-            return self;
+
+    const def = self.definition();
+    const nearest_scope = compressor.find_scope();
+    if (compressor.top_retain && def.global && compressor.top_retain(def)) {
+        def.fixed = false;
+        def.single_use = false;
+        return self;
+    }
+
+    let fixed = self.fixed_value();
+    let single_use = def.single_use
+        && !(parent instanceof AST_Call
+            && (parent.is_callee_pure(compressor))
+                || has_annotation(parent, _NOINLINE))
+        && !(parent instanceof AST_Export
+            && fixed instanceof AST_Lambda
+            && fixed.name);
+
+    if (single_use && fixed instanceof ast_AST_Node) {
+        single_use =
+            !fixed.has_side_effects(compressor)
+            && !fixed.may_throw(compressor);
+    }
+
+    if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
+        if (retain_top_func(fixed, compressor)) {
+            single_use = false;
+        } else if (def.scope !== self.scope
+            && (def.escaped == 1
+                || has_flag(fixed, INLINED)
+                || within_array_or_object_literal(compressor)
+                || !compressor.option("reduce_funcs"))) {
+            single_use = false;
+        } else if (is_recursive_ref(compressor, def)) {
+            single_use = false;
+        } else if (def.scope !== self.scope || def.orig[0] instanceof AST_SymbolFunarg) {
+            single_use = fixed.is_constant_expression(self.scope);
+            if (single_use == "f") {
+                var scope = self.scope;
+                do {
+                    if (scope instanceof AST_Defun || is_func_expr(scope)) {
+                        set_flag(scope, INLINED);
+                    }
+                } while (scope = scope.parent_scope);
+            }
         }
+    }
 
-        let fixed = self.fixed_value();
-        let single_use = def.single_use
-            && !(parent instanceof AST_Call
-                && (parent.is_callee_pure(compressor))
-                    || has_annotation(parent, _NOINLINE))
-            && !(parent instanceof AST_Export
-                && fixed instanceof AST_Lambda
-                && fixed.name);
-
-        if (single_use && fixed instanceof ast_AST_Node) {
-            single_use =
-                !fixed.has_side_effects(compressor)
-                && !fixed.may_throw(compressor);
-        }
-
-        if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
-            if (retain_top_func(fixed, compressor)) {
-                single_use = false;
-            } else if (def.scope !== self.scope
-                && (def.escaped == 1
-                    || has_flag(fixed, INLINED)
-                    || within_array_or_object_literal(compressor)
-                    || !compressor.option("reduce_funcs"))) {
-                single_use = false;
-            } else if (is_recursive_ref(compressor, def)) {
-                single_use = false;
-            } else if (def.scope !== self.scope || def.orig[0] instanceof AST_SymbolFunarg) {
-                single_use = fixed.is_constant_expression(self.scope);
-                if (single_use == "f") {
-                    var scope = self.scope;
-                    do {
-                        if (scope instanceof AST_Defun || is_func_expr(scope)) {
-                            set_flag(scope, INLINED);
-                        }
-                    } while (scope = scope.parent_scope);
+    if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
+        single_use =
+            def.scope === self.scope
+                && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
+            || parent instanceof AST_Call
+                && parent.expression === self
+                && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
+                && !(fixed.name && fixed.name.definition().recursive_refs > 0);
+    }
+
+    if (single_use && fixed) {
+        if (fixed instanceof AST_DefClass) {
+            set_flag(fixed, SQUEEZED);
+            fixed = make_node(AST_ClassExpression, fixed, fixed);
+        }
+        if (fixed instanceof AST_Defun) {
+            set_flag(fixed, SQUEEZED);
+            fixed = make_node(AST_Function, fixed, fixed);
+        }
+        if (def.recursive_refs > 0 && fixed.name instanceof AST_SymbolDefun) {
+            const defun_def = fixed.name.definition();
+            let lambda_def = fixed.variables.get(fixed.name.name);
+            let name = lambda_def && lambda_def.orig[0];
+            if (!(name instanceof AST_SymbolLambda)) {
+                name = make_node(AST_SymbolLambda, fixed.name, fixed.name);
+                name.scope = fixed;
+                fixed.name = name;
+                lambda_def = fixed.def_function(name);
+            }
+            ast_walk(fixed, node => {
+                if (node instanceof AST_SymbolRef && node.definition() === defun_def) {
+                    node.thedef = lambda_def;
+                    lambda_def.references.push(node);
                 }
-            }
+            });
         }
+        if (
+            (fixed instanceof AST_Lambda || fixed instanceof AST_Class)
+            && fixed.parent_scope !== nearest_scope
+        ) {
+            fixed = fixed.clone(true, compressor.get_toplevel());
 
-        if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
-            single_use =
-                def.scope === self.scope
-                    && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
-                || parent instanceof AST_Call
-                    && parent.expression === self
-                    && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
-                    && !(fixed.name && fixed.name.definition().recursive_refs > 0);
+            nearest_scope.add_child_scope(fixed);
         }
+        return fixed.optimize(compressor);
+    }
 
-        if (single_use && fixed) {
-            if (fixed instanceof AST_DefClass) {
-                set_flag(fixed, SQUEEZED);
-                fixed = make_node(AST_ClassExpression, fixed, fixed);
-            }
-            if (fixed instanceof AST_Defun) {
-                set_flag(fixed, SQUEEZED);
-                fixed = make_node(AST_Function, fixed, fixed);
-            }
-            if (def.recursive_refs > 0 && fixed.name instanceof AST_SymbolDefun) {
-                const defun_def = fixed.name.definition();
-                let lambda_def = fixed.variables.get(fixed.name.name);
-                let name = lambda_def && lambda_def.orig[0];
-                if (!(name instanceof AST_SymbolLambda)) {
-                    name = make_node(AST_SymbolLambda, fixed.name, fixed.name);
-                    name.scope = fixed;
-                    fixed.name = name;
-                    lambda_def = fixed.def_function(name);
-                }
-                ast_walk(fixed, node => {
-                    if (node instanceof AST_SymbolRef && node.definition() === defun_def) {
-                        node.thedef = lambda_def;
-                        lambda_def.references.push(node);
-                    }
-                });
+    // multiple uses
+    if (fixed) {
+        let replace;
+
+        if (fixed instanceof AST_This) {
+            if (!(def.orig[0] instanceof AST_SymbolFunarg)
+                && def.references.every((ref) =>
+                    def.scope === ref.scope
+                )) {
+                replace = fixed;
             }
+        } else {
+            var ev = fixed.evaluate(compressor);
             if (
-                (fixed instanceof AST_Lambda || fixed instanceof AST_Class)
-                && fixed.parent_scope !== nearest_scope
+                ev !== fixed
+                && (compressor.option("unsafe_regexp") || !(ev instanceof RegExp))
             ) {
-                fixed = fixed.clone(true, compressor.get_toplevel());
-
-                nearest_scope.add_child_scope(fixed);
+                replace = make_node_from_constant(ev, fixed);
             }
-            return fixed.optimize(compressor);
         }
 
-        // multiple uses
-        if (fixed) {
-            let replace;
+        if (replace) {
+            const name_length = self.size(compressor);
+            const replace_size = replace.size(compressor);
 
-            if (fixed instanceof AST_This) {
-                if (!(def.orig[0] instanceof AST_SymbolFunarg)
-                    && def.references.every((ref) =>
-                        def.scope === ref.scope
-                    )) {
-                    replace = fixed;
-                }
-            } else {
-                var ev = fixed.evaluate(compressor);
-                if (
-                    ev !== fixed
-                    && (compressor.option("unsafe_regexp") || !(ev instanceof RegExp))
-                ) {
-                    replace = make_node_from_constant(ev, fixed);
-                }
+            let overhead = 0;
+            if (compressor.option("unused") && !compressor.exposed(def)) {
+                overhead =
+                    (name_length + 2 + replace_size) /
+                    (def.references.length - def.assignments);
             }
 
-            if (replace) {
-                const name_length = self.size(compressor);
-                const replace_size = replace.size(compressor);
-
-                let overhead = 0;
-                if (compressor.option("unused") && !compressor.exposed(def)) {
-                    overhead =
-                        (name_length + 2 + replace_size) /
-                        (def.references.length - def.assignments);
-                }
-
-                if (replace_size <= name_length + overhead) {
-                    return replace;
-                }
+            if (replace_size <= name_length + overhead) {
+                return replace;
             }
         }
     }
@@ -26632,7 +26541,7 @@ AST_Toplevel.DEFMETHOD("reset_opt_flags", function(compressor) {
             }
             return node.reduce_vars(preparation, descend, compressor);
         }
-    });
+    }, { walk_defun_first: true });
     // Stack of look-up tables to keep track of whether a `SymbolDef` has been
     // properly assigned before use:
     // - `push()` & `pop()` when visiting conditional branches
@@ -27622,9 +27531,9 @@ def_optimize(AST_Switch, function(self, compressor) {
 });
 
 def_optimize(AST_Try, function(self, compressor) {
-    tighten_body(self.body, compressor);
     if (self.bcatch && self.bfinally && self.bfinally.body.every(is_empty)) self.bfinally = null;
-    if (compressor.option("dead_code") && self.body.every(is_empty)) {
+
+    if (compressor.option("dead_code") && self.body.body.every(is_empty)) {
         var body = [];
         if (self.bcatch) {
             trim_unreachable_code(compressor, self.bcatch, body);
@@ -28830,16 +28739,21 @@ def_optimize(ast_AST_Assign, function(self, compressor) {
     return self;
 
     function in_try(level, node) {
-        var right = self.right;
-        self.right = make_node(AST_Null, right);
-        var may_throw = node.may_throw(compressor);
-        self.right = right;
-        var scope = self.left.definition().scope;
+        function may_assignment_throw() {
+            const right = self.right;
+            self.right = make_node(AST_Null, right);
+            const may_throw = node.may_throw(compressor);
+            self.right = right;
+
+            return may_throw;
+        }
+
+        var stop_at = self.left.definition().scope.get_defun_scope();
         var parent;
-        while ((parent = compressor.parent(level++)) !== scope) {
+        while ((parent = compressor.parent(level++)) !== stop_at) {
             if (parent instanceof AST_Try) {
                 if (parent.bfinally) return true;
-                if (may_throw && parent.bcatch) return true;
+                if (parent.bcatch && may_assignment_throw()) return true;
             }
         }
     }
@@ -28852,7 +28766,13 @@ def_optimize(AST_DefaultAssign, function(self, compressor) {
     var evaluateRight = self.right.evaluate(compressor);
 
     // `[x = undefined] = foo` ---> `[x] = foo`
-    if (evaluateRight === undefined) {
+    // `(arg = undefined) => ...` ---> `(arg) => ...` (unless `keep_fargs`)
+    if (
+        evaluateRight === undefined &&
+        (compressor.parent() instanceof AST_Lambda
+            ? compressor.option("keep_fargs") === false
+            : true)
+    ) {
         self = self.left;
     } else if (evaluateRight !== self.right) {
         evaluateRight = make_node_from_constant(evaluateRight, self.right);
@@ -39081,12 +39001,15 @@ function mangle_properties(ast, options) {
 
 
 
-var to_ascii = typeof atob == "undefined" ? function(b64) {
-    return Buffer.from(b64, "base64").toString();
-} : atob;
-var to_base64 = typeof btoa == "undefined" ? function(str) {
-    return Buffer.from(str).toString("base64");
-} : btoa;
+// to/from base64 functions
+// Prefer built-in Buffer, if available, then use hack
+// https://developer.mozilla.org/en-US/docs/Glossary/Base64#The_Unicode_Problem
+var to_ascii = typeof Buffer !== "undefined"
+    ? (b64) => Buffer.from(b64, "base64").toString()
+    : (b64) => decodeURIComponent(escape(atob(b64)));
+var to_base64 = typeof Buffer !== "undefined"
+    ? (str) => Buffer.from(str).toString("base64")
+    : (str) => btoa(unescape(encodeURIComponent(str)));
 
 function read_source_map(code) {
     var match = /(?:^|[^.])\/\/# sourceMappingURL=data:application\/json(;[\w=-]*)?;base64,([+/0-9A-Za-z]*=*)\s*$/.exec(code);
@@ -39336,10 +39259,13 @@ async function minify_minify(files, options, _fs_module) {
     if (options.format.spidermonkey) {
         result.ast = toplevel.to_mozilla_ast();
     }
+    let format_options;
     if (!HOP(options.format, "code") || options.format.code) {
-        if (!options.format.ast) {
+        // Make a shallow copy so that we can modify without mutating the user's input.
+        format_options = {...options.format};
+        if (!format_options.ast) {
             // Destroy stuff to save RAM. (unless the deprecated `ast` option is on)
-            options.format._destroy_ast = true;
+            format_options._destroy_ast = true;
 
             ast_walk(toplevel, node => {
                 if (node instanceof AST_Scope) {
@@ -39359,17 +39285,17 @@ async function minify_minify(files, options, _fs_module) {
             if (options.sourceMap.includeSources && files instanceof AST_Toplevel) {
                 throw new Error("original source content unavailable");
             }
-            options.format.source_map = await SourceMap({
+            format_options.source_map = await SourceMap({
                 file: options.sourceMap.filename,
                 orig: options.sourceMap.content,
                 root: options.sourceMap.root,
                 files: options.sourceMap.includeSources ? files : null,
             });
         }
-        delete options.format.ast;
-        delete options.format.code;
-        delete options.format.spidermonkey;
-        var stream = output_OutputStream(options.format);
+        delete format_options.ast;
+        delete format_options.code;
+        delete format_options.spidermonkey;
+        var stream = output_OutputStream(format_options);
         toplevel.print(stream);
         result.code = stream.get();
         if (options.sourceMap) {
@@ -39377,7 +39303,7 @@ async function minify_minify(files, options, _fs_module) {
                 configurable: true,
                 enumerable: true,
                 get() {
-                    const map = options.format.source_map.getEncoded();
+                    const map = format_options.source_map.getEncoded();
                     return (result.map = options.sourceMap.asObject ? map : JSON.stringify(map));
                 },
                 set(value) {
@@ -39387,7 +39313,7 @@ async function minify_minify(files, options, _fs_module) {
                     });
                 }
             });
-            result.decoded_map = options.format.source_map.getDecoded();
+            result.decoded_map = format_options.source_map.getDecoded();
             if (options.sourceMap.url == "inline") {
                 var sourceMap = typeof result.map === "object" ? JSON.stringify(result.map) : result.map;
                 result.code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + to_base64(sourceMap);
@@ -39402,8 +39328,8 @@ async function minify_minify(files, options, _fs_module) {
             options.nameCache.props = cache_to_json(options.mangle.properties.cache);
         }
     }
-    if (options.format && options.format.source_map) {
-        options.format.source_map.destroy();
+    if (format_options && format_options.source_map) {
+        format_options.source_map.destroy();
     }
     if (timings) {
         timings.end = Date.now();
@@ -40920,7 +40846,9 @@ __nccwpck_require__.a(__webpack_module__, async (__webpack_handle_async_dependen
 /* harmony export */   "S0": () => (/* binding */ print),
 /* harmony export */   "Xs": () => (/* binding */ metadataAdd),
 /* harmony export */   "YO": () => (/* binding */ componentWit),
-/* harmony export */   "eL": () => (/* binding */ metadataShow)
+/* harmony export */   "eL": () => (/* binding */ metadataShow),
+/* harmony export */   "ol": () => (/* binding */ preview1AdapterCommandPath),
+/* harmony export */   "tc": () => (/* binding */ preview1AdapterReactorPath)
 /* harmony export */ });
 /* harmony import */ var _cmd_opt_js__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(5862);
 /* harmony import */ var _cmd_transpile_js__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(2229);
@@ -40931,6 +40859,12 @@ var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([_cmd
 
 
 const { parse, print, componentNew, componentWit, componentEmbed, metadataAdd, metadataShow } = _obj_wasm_tools_js__WEBPACK_IMPORTED_MODULE_2__/* .exports */ .I;
+function preview1AdapterCommandPath () {
+  return __nccwpck_require__.ab + "wasi_snapshot_preview1.command.wasm";
+}
+function preview1AdapterReactorPath () {
+  return __nccwpck_require__.ab + "wasi_snapshot_preview1.reactor.wasm";
+}
 
 __webpack_async_result__();
 } catch(e) { __webpack_async_result__(e); } });
@@ -40950,7 +40884,7 @@ __nccwpck_require__.a(__webpack_module__, async (__webpack_handle_async_dependen
 /* harmony import */ var url__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(7310);
 /* harmony import */ var chalk_template__WEBPACK_IMPORTED_MODULE_3__ = __nccwpck_require__(267);
 /* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_4__ = __nccwpck_require__(8649);
-/* harmony import */ var ora__WEBPACK_IMPORTED_MODULE_5__ = __nccwpck_require__(67);
+/* harmony import */ var ora__WEBPACK_IMPORTED_MODULE_5__ = __nccwpck_require__(2719);
 var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([_obj_wasm_tools_js__WEBPACK_IMPORTED_MODULE_0__]);
 _obj_wasm_tools_js__WEBPACK_IMPORTED_MODULE_0__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
 
@@ -41021,7 +40955,7 @@ async function optimizeComponent (componentBytes, opts) {
     let completed = 0;
     const spinnerText = () => chalk_template__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z`{cyan ${completed} / ${coreModules.length}} Running Binaryen on WebAssembly Component Internal Core Modules \n`;
     if (showSpinner) {
-      spinner = (0,ora__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)({
+      spinner = (0,ora__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .ZP)({
         color: 'cyan',
         spinner: 'bouncingBar'
       }).start();
@@ -41093,7 +41027,7 @@ async function optimizeComponent (componentBytes, opts) {
  * @param {Uint8Array} source 
  * @returns {Promise<Uint8Array>}
  */
-async function wasmOpt (source, args = ['-tnh', '--gufa', '--flatten', '--rereloop', '-Oz', '-Oz', '--low-memory-unused', '--enable-bulk-memory']) {
+async function wasmOpt (source, args = ['-O1', '--low-memory-unused', '--enable-bulk-memory']) {
   try {
     return await (0,_common_js__WEBPACK_IMPORTED_MODULE_4__/* .spawnIOTmp */ .np)(WASM_OPT, source, [
       ...args, '-o'
@@ -41126,7 +41060,7 @@ __nccwpck_require__.a(__webpack_module__, async (__webpack_handle_async_dependen
 /* harmony import */ var _opt_js__WEBPACK_IMPORTED_MODULE_5__ = __nccwpck_require__(5862);
 /* harmony import */ var terser__WEBPACK_IMPORTED_MODULE_6__ = __nccwpck_require__(1124);
 /* harmony import */ var url__WEBPACK_IMPORTED_MODULE_7__ = __nccwpck_require__(7310);
-/* harmony import */ var ora__WEBPACK_IMPORTED_MODULE_8__ = __nccwpck_require__(67);
+/* harmony import */ var ora__WEBPACK_IMPORTED_MODULE_8__ = __nccwpck_require__(2719);
 var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([_obj_js_component_bindgen_component_js__WEBPACK_IMPORTED_MODULE_0__, _opt_js__WEBPACK_IMPORTED_MODULE_5__]);
 ([_obj_js_component_bindgen_component_js__WEBPACK_IMPORTED_MODULE_0__, _opt_js__WEBPACK_IMPORTED_MODULE_5__] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);
 
@@ -41249,7 +41183,7 @@ async function transpileComponent (component, opts = {}) {
     let completed = 0;
     const spinnerText = () => chalk_template__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z`{cyan ${completed} / ${wasmFiles.length}} Running Binaryen wasm2js on Wasm core modules (this takes a while)...\n`;
     if (showSpinner) {
-      spinner = (0,ora__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .Z)({
+      spinner = (0,ora__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .ZP)({
         color: 'cyan',
         spinner: 'bouncingBar'
       }).start();
@@ -41828,7 +41762,9 @@ module.exports = JSON.parse('{"dots":{"interval":80,"frames":["⠋","⠙","⠹",
 /******/ var __webpack_exports__metadataShow = __webpack_exports__.eL;
 /******/ var __webpack_exports__opt = __webpack_exports__.MD;
 /******/ var __webpack_exports__parse = __webpack_exports__.Qc;
+/******/ var __webpack_exports__preview1AdapterCommandPath = __webpack_exports__.ol;
+/******/ var __webpack_exports__preview1AdapterReactorPath = __webpack_exports__.tc;
 /******/ var __webpack_exports__print = __webpack_exports__.S0;
 /******/ var __webpack_exports__transpile = __webpack_exports__.LZ;
-/******/ export { __webpack_exports__componentEmbed as componentEmbed, __webpack_exports__componentNew as componentNew, __webpack_exports__componentWit as componentWit, __webpack_exports__metadataAdd as metadataAdd, __webpack_exports__metadataShow as metadataShow, __webpack_exports__opt as opt, __webpack_exports__parse as parse, __webpack_exports__print as print, __webpack_exports__transpile as transpile };
+/******/ export { __webpack_exports__componentEmbed as componentEmbed, __webpack_exports__componentNew as componentNew, __webpack_exports__componentWit as componentWit, __webpack_exports__metadataAdd as metadataAdd, __webpack_exports__metadataShow as metadataShow, __webpack_exports__opt as opt, __webpack_exports__parse as parse, __webpack_exports__preview1AdapterCommandPath as preview1AdapterCommandPath, __webpack_exports__preview1AdapterReactorPath as preview1AdapterReactorPath, __webpack_exports__print as print, __webpack_exports__transpile as transpile };
 /******/