npm-pkg-lint 3.10.0 → 3.10.1

package/dist/index.js

@@ -6512,6 +6512,14 @@ function getLiteralValue(value, token, json5 = false) {
     case "Boolean":
       return value === "true";
     case "Number":
+      if (json5) {
+        if (value.charCodeAt(0) === 45) {
+          return -Number(value.slice(1));
+        }
+        if (value.charCodeAt(0) === 43) {
+          return Number(value.slice(1));
+        }
+      }
       return Number(value);
     case "String":
       return getStringValue(value.slice(1, -1), token, json5);
@@ -6828,13 +6836,13 @@ var import_argparse = __toESM(require_argparse(), 1);
 // node_modules/find-up/index.js
 import path2 from "path";
 
-// node_modules/find-up/node_modules/locate-path/index.js
+// node_modules/locate-path/index.js
 import process2 from "process";
 import path from "path";
 import fs, { promises as fsPromises } from "fs";
 import { fileURLToPath } from "url";
 
-// node_modules/find-up/node_modules/yocto-queue/index.js
+// node_modules/p-locate/node_modules/yocto-queue/index.js
 var Node = class {
   value;
   next;
@@ -6896,7 +6904,7 @@ _head = new WeakMap();
 _tail = new WeakMap();
 _size = new WeakMap();
 
-// node_modules/find-up/node_modules/p-limit/index.js
+// node_modules/p-locate/node_modules/p-limit/index.js
 function pLimit(concurrency) {
   if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
     throw new TypeError("Expected `concurrency` to be a number from 1 and up");
@@ -6947,7 +6955,7 @@ function pLimit(concurrency) {
   return generator;
 }
 
-// node_modules/find-up/node_modules/p-locate/index.js
+// node_modules/p-locate/index.js
 var EndError = class extends Error {
   constructor(value) {
     super();
@@ -6979,7 +6987,7 @@ async function pLocate(iterable, tester, {
   }
 }
 
-// node_modules/find-up/node_modules/locate-path/index.js
+// node_modules/locate-path/index.js
 var typeMappings = {
   directory: "isDirectory",
   file: "isFile"
@@ -7060,7 +7068,7 @@ async function findUp(name2, options = {}) {
 // src/index.ts
 var import_tmp = __toESM(require_tmp(), 1);
 
-// node_modules/@html-validate/stylish/node_modules/kleur/colors.mjs
+// node_modules/kleur/colors.mjs
 var FORCE_COLOR;
 var NODE_DISABLE_COLORS;
 var NO_COLOR;
@@ -7556,7 +7564,7 @@ import fs12 from "fs";
 import EE from "events";
 import fs2 from "fs";
 
-// node_modules/minipass/dist/esm/index.js
+// node_modules/@isaacs/fs-minipass/node_modules/minipass/dist/esm/index.js
 import { EventEmitter } from "events";
 import Stream from "stream";
 import { StringDecoder } from "string_decoder";
@@ -8927,1196 +8935,2958 @@ import { EventEmitter as EE2 } from "events";
 // node_modules/minizlib/dist/esm/index.js
 import assert from "assert";
 import { Buffer as Buffer2 } from "buffer";
-import realZlib2 from "zlib";
-
-// node_modules/minizlib/dist/esm/constants.js
-import realZlib from "zlib";
-var realZlibConstants = realZlib.constants || { ZLIB_VERNUM: 4736 };
-var constants = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), {
-  Z_NO_FLUSH: 0,
-  Z_PARTIAL_FLUSH: 1,
-  Z_SYNC_FLUSH: 2,
-  Z_FULL_FLUSH: 3,
-  Z_FINISH: 4,
-  Z_BLOCK: 5,
-  Z_OK: 0,
-  Z_STREAM_END: 1,
-  Z_NEED_DICT: 2,
-  Z_ERRNO: -1,
-  Z_STREAM_ERROR: -2,
-  Z_DATA_ERROR: -3,
-  Z_MEM_ERROR: -4,
-  Z_BUF_ERROR: -5,
-  Z_VERSION_ERROR: -6,
-  Z_NO_COMPRESSION: 0,
-  Z_BEST_SPEED: 1,
-  Z_BEST_COMPRESSION: 9,
-  Z_DEFAULT_COMPRESSION: -1,
-  Z_FILTERED: 1,
-  Z_HUFFMAN_ONLY: 2,
-  Z_RLE: 3,
-  Z_FIXED: 4,
-  Z_DEFAULT_STRATEGY: 0,
-  DEFLATE: 1,
-  INFLATE: 2,
-  GZIP: 3,
-  GUNZIP: 4,
-  DEFLATERAW: 5,
-  INFLATERAW: 6,
-  UNZIP: 7,
-  BROTLI_DECODE: 8,
-  BROTLI_ENCODE: 9,
-  Z_MIN_WINDOWBITS: 8,
-  Z_MAX_WINDOWBITS: 15,
-  Z_DEFAULT_WINDOWBITS: 15,
-  Z_MIN_CHUNK: 64,
-  Z_MAX_CHUNK: Infinity,
-  Z_DEFAULT_CHUNK: 16384,
-  Z_MIN_MEMLEVEL: 1,
-  Z_MAX_MEMLEVEL: 9,
-  Z_DEFAULT_MEMLEVEL: 8,
-  Z_MIN_LEVEL: -1,
-  Z_MAX_LEVEL: 9,
-  Z_DEFAULT_LEVEL: -1,
-  BROTLI_OPERATION_PROCESS: 0,
-  BROTLI_OPERATION_FLUSH: 1,
-  BROTLI_OPERATION_FINISH: 2,
-  BROTLI_OPERATION_EMIT_METADATA: 3,
-  BROTLI_MODE_GENERIC: 0,
-  BROTLI_MODE_TEXT: 1,
-  BROTLI_MODE_FONT: 2,
-  BROTLI_DEFAULT_MODE: 0,
-  BROTLI_MIN_QUALITY: 0,
-  BROTLI_MAX_QUALITY: 11,
-  BROTLI_DEFAULT_QUALITY: 11,
-  BROTLI_MIN_WINDOW_BITS: 10,
-  BROTLI_MAX_WINDOW_BITS: 24,
-  BROTLI_LARGE_MAX_WINDOW_BITS: 30,
-  BROTLI_DEFAULT_WINDOW: 22,
-  BROTLI_MIN_INPUT_BLOCK_BITS: 16,
-  BROTLI_MAX_INPUT_BLOCK_BITS: 24,
-  BROTLI_PARAM_MODE: 0,
-  BROTLI_PARAM_QUALITY: 1,
-  BROTLI_PARAM_LGWIN: 2,
-  BROTLI_PARAM_LGBLOCK: 3,
-  BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4,
-  BROTLI_PARAM_SIZE_HINT: 5,
-  BROTLI_PARAM_LARGE_WINDOW: 6,
-  BROTLI_PARAM_NPOSTFIX: 7,
-  BROTLI_PARAM_NDIRECT: 8,
-  BROTLI_DECODER_RESULT_ERROR: 0,
-  BROTLI_DECODER_RESULT_SUCCESS: 1,
-  BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2,
-  BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3,
-  BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0,
-  BROTLI_DECODER_PARAM_LARGE_WINDOW: 1,
-  BROTLI_DECODER_NO_ERROR: 0,
-  BROTLI_DECODER_SUCCESS: 1,
-  BROTLI_DECODER_NEEDS_MORE_INPUT: 2,
-  BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3,
-  BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1,
-  BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2,
-  BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3,
-  BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4,
-  BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5,
-  BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6,
-  BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7,
-  BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8,
-  BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9,
-  BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10,
-  BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11,
-  BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12,
-  BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13,
-  BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14,
-  BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15,
-  BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16,
-  BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19,
-  BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20,
-  BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21,
-  BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22,
-  BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25,
-  BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26,
-  BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27,
-  BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30,
-  BROTLI_DECODER_ERROR_UNREACHABLE: -31
-}, realZlibConstants));
 
-// node_modules/minizlib/dist/esm/index.js
-var OriginalBufferConcat = Buffer2.concat;
-var _superWrite = Symbol("_superWrite");
-var ZlibError = class extends Error {
-  code;
-  errno;
-  constructor(err) {
-    super("zlib: " + err.message);
-    this.code = err.code;
-    this.errno = err.errno;
-    if (!this.code)
-      this.code = "ZLIB_ERROR";
-    this.message = "zlib: " + err.message;
-    Error.captureStackTrace(this, this.constructor);
-  }
-  get name() {
-    return "ZlibError";
-  }
+// node_modules/minizlib/node_modules/minipass/dist/esm/index.js
+import { EventEmitter as EventEmitter2 } from "events";
+import Stream2 from "stream";
+import { StringDecoder as StringDecoder2 } from "string_decoder";
+var proc2 = typeof process === "object" && process ? process : {
+  stdout: null,
+  stderr: null
 };
-var _flushFlag = Symbol("flushFlag");
-var _sawError, _ended3, _flushFlag2, _finishFlushFlag, _fullFlushFlag, _handle, _onError;
-var ZlibBase = class extends Minipass {
-  /* c8 ignore stop */
-  constructor(opts, mode) {
-    var _a;
-    if (!opts || typeof opts !== "object")
-      throw new TypeError("invalid options for ZlibBase constructor");
-    super(opts);
-    __privateAdd(this, _sawError, false);
-    __privateAdd(this, _ended3, false);
-    __privateAdd(this, _flushFlag2);
-    __privateAdd(this, _finishFlushFlag);
-    __privateAdd(this, _fullFlushFlag);
-    __privateAdd(this, _handle);
-    __privateAdd(this, _onError);
-    __privateSet(this, _flushFlag2, opts.flush ?? 0);
-    __privateSet(this, _finishFlushFlag, opts.finishFlush ?? 0);
-    __privateSet(this, _fullFlushFlag, opts.fullFlushFlag ?? 0);
-    try {
-      __privateSet(this, _handle, new realZlib2[mode](opts));
-    } catch (er) {
-      throw new ZlibError(er);
-    }
-    __privateSet(this, _onError, (err) => {
-      if (__privateGet(this, _sawError))
-        return;
-      __privateSet(this, _sawError, true);
-      this.close();
-      this.emit("error", err);
-    });
-    (_a = __privateGet(this, _handle)) == null ? void 0 : _a.on("error", (er) => __privateGet(this, _onError).call(this, new ZlibError(er)));
-    this.once("end", () => this.close);
-  }
-  get sawError() {
-    return __privateGet(this, _sawError);
+var isStream2 = (s) => !!s && typeof s === "object" && (s instanceof Minipass2 || s instanceof Stream2 || isReadable2(s) || isWritable2(s));
+var isReadable2 = (s) => !!s && typeof s === "object" && s instanceof EventEmitter2 && typeof s.pipe === "function" && // node core Writable streams have a pipe() method, but it throws
+s.pipe !== Stream2.Writable.prototype.pipe;
+var isWritable2 = (s) => !!s && typeof s === "object" && s instanceof EventEmitter2 && typeof s.write === "function" && typeof s.end === "function";
+var EOF2 = Symbol("EOF");
+var MAYBE_EMIT_END2 = Symbol("maybeEmitEnd");
+var EMITTED_END2 = Symbol("emittedEnd");
+var EMITTING_END2 = Symbol("emittingEnd");
+var EMITTED_ERROR2 = Symbol("emittedError");
+var CLOSED2 = Symbol("closed");
+var READ2 = Symbol("read");
+var FLUSH2 = Symbol("flush");
+var FLUSHCHUNK2 = Symbol("flushChunk");
+var ENCODING2 = Symbol("encoding");
+var DECODER2 = Symbol("decoder");
+var FLOWING2 = Symbol("flowing");
+var PAUSED2 = Symbol("paused");
+var RESUME2 = Symbol("resume");
+var BUFFER2 = Symbol("buffer");
+var PIPES2 = Symbol("pipes");
+var BUFFERLENGTH2 = Symbol("bufferLength");
+var BUFFERPUSH2 = Symbol("bufferPush");
+var BUFFERSHIFT2 = Symbol("bufferShift");
+var OBJECTMODE2 = Symbol("objectMode");
+var DESTROYED2 = Symbol("destroyed");
+var ERROR2 = Symbol("error");
+var EMITDATA2 = Symbol("emitData");
+var EMITEND3 = Symbol("emitEnd");
+var EMITEND22 = Symbol("emitEnd2");
+var ASYNC2 = Symbol("async");
+var ABORT2 = Symbol("abort");
+var ABORTED2 = Symbol("aborted");
+var SIGNAL2 = Symbol("signal");
+var DATALISTENERS2 = Symbol("dataListeners");
+var DISCARDED2 = Symbol("discarded");
+var defer2 = (fn) => Promise.resolve().then(fn);
+var nodefer2 = (fn) => fn();
+var isEndish2 = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
+var isArrayBufferLike2 = (b) => b instanceof ArrayBuffer || !!b && typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
+var isArrayBufferView2 = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
+var Pipe2 = class {
+  src;
+  dest;
+  opts;
+  ondrain;
+  constructor(src, dest, opts) {
+    this.src = src;
+    this.dest = dest;
+    this.opts = opts;
+    this.ondrain = () => src[RESUME2]();
+    this.dest.on("drain", this.ondrain);
   }
-  get handle() {
-    return __privateGet(this, _handle);
+  unpipe() {
+    this.dest.removeListener("drain", this.ondrain);
   }
+  // only here for the prototype
   /* c8 ignore start */
-  get flushFlag() {
-    return __privateGet(this, _flushFlag2);
+  proxyErrors(_er) {
   }
-  close() {
-    if (__privateGet(this, _handle)) {
-      __privateGet(this, _handle).close();
-      __privateSet(this, _handle, void 0);
-      this.emit("close");
-    }
+  /* c8 ignore stop */
+  end() {
+    this.unpipe();
+    if (this.opts.end)
+      this.dest.end();
   }
-  reset() {
-    var _a, _b;
-    if (!__privateGet(this, _sawError)) {
-      assert(__privateGet(this, _handle), "zlib binding closed");
-      return (_b = (_a = __privateGet(this, _handle)).reset) == null ? void 0 : _b.call(_a);
-    }
+};
+var PipeProxyErrors2 = class extends Pipe2 {
+  unpipe() {
+    this.src.removeListener("error", this.proxyErrors);
+    super.unpipe();
   }
-  flush(flushFlag) {
-    if (this.ended)
-      return;
-    if (typeof flushFlag !== "number")
-      flushFlag = __privateGet(this, _fullFlushFlag);
-    this.write(Object.assign(Buffer2.alloc(0), { [_flushFlag]: flushFlag }));
+  constructor(src, dest, opts) {
+    super(src, dest, opts);
+    this.proxyErrors = (er) => dest.emit("error", er);
+    src.on("error", this.proxyErrors);
   }
-  end(chunk, encoding, cb) {
-    if (typeof chunk === "function") {
-      cb = chunk;
-      encoding = void 0;
-      chunk = void 0;
+};
+var isObjectModeOptions2 = (o) => !!o.objectMode;
+var isEncodingOptions2 = (o) => !o.objectMode && !!o.encoding && o.encoding !== "buffer";
+var Minipass2 = class extends EventEmitter2 {
+  [FLOWING2] = false;
+  [PAUSED2] = false;
+  [PIPES2] = [];
+  [BUFFER2] = [];
+  [OBJECTMODE2];
+  [ENCODING2];
+  [ASYNC2];
+  [DECODER2];
+  [EOF2] = false;
+  [EMITTED_END2] = false;
+  [EMITTING_END2] = false;
+  [CLOSED2] = false;
+  [EMITTED_ERROR2] = null;
+  [BUFFERLENGTH2] = 0;
+  [DESTROYED2] = false;
+  [SIGNAL2];
+  [ABORTED2] = false;
+  [DATALISTENERS2] = 0;
+  [DISCARDED2] = false;
+  /**
+   * true if the stream can be written
+   */
+  writable = true;
+  /**
+   * true if the stream can be read
+   */
+  readable = true;
+  /**
+   * If `RType` is Buffer, then options do not need to be provided.
+   * Otherwise, an options object must be provided to specify either
+   * {@link Minipass.SharedOptions.objectMode} or
+   * {@link Minipass.SharedOptions.encoding}, as appropriate.
+   */
+  constructor(...args) {
+    const options = args[0] || {};
+    super();
+    if (options.objectMode && typeof options.encoding === "string") {
+      throw new TypeError("Encoding and objectMode may not be used together");
     }
-    if (typeof encoding === "function") {
-      cb = encoding;
-      encoding = void 0;
+    if (isObjectModeOptions2(options)) {
+      this[OBJECTMODE2] = true;
+      this[ENCODING2] = null;
+    } else if (isEncodingOptions2(options)) {
+      this[ENCODING2] = options.encoding;
+      this[OBJECTMODE2] = false;
+    } else {
+      this[OBJECTMODE2] = false;
+      this[ENCODING2] = null;
     }
-    if (chunk) {
-      if (encoding)
-        this.write(chunk, encoding);
-      else
-        this.write(chunk);
+    this[ASYNC2] = !!options.async;
+    this[DECODER2] = this[ENCODING2] ? new StringDecoder2(this[ENCODING2]) : null;
+    if (options && options.debugExposeBuffer === true) {
+      Object.defineProperty(this, "buffer", { get: () => this[BUFFER2] });
     }
-    this.flush(__privateGet(this, _finishFlushFlag));
-    __privateSet(this, _ended3, true);
-    return super.end(cb);
-  }
-  get ended() {
-    return __privateGet(this, _ended3);
-  }
-  // overridden in the gzip classes to do portable writes
-  [_superWrite](data) {
-    return super.write(data);
-  }
-  write(chunk, encoding, cb) {
-    if (typeof encoding === "function")
-      cb = encoding, encoding = "utf8";
-    if (typeof chunk === "string")
-      chunk = Buffer2.from(chunk, encoding);
-    if (__privateGet(this, _sawError))
-      return;
-    assert(__privateGet(this, _handle), "zlib binding closed");
-    const nativeHandle = __privateGet(this, _handle)._handle;
-    const originalNativeClose = nativeHandle.close;
-    nativeHandle.close = () => {
-    };
-    const originalClose = __privateGet(this, _handle).close;
-    __privateGet(this, _handle).close = () => {
-    };
-    Buffer2.concat = (args) => args;
-    let result = void 0;
-    try {
-      const flushFlag = typeof chunk[_flushFlag] === "number" ? chunk[_flushFlag] : __privateGet(this, _flushFlag2);
-      result = __privateGet(this, _handle)._processChunk(chunk, flushFlag);
-      Buffer2.concat = OriginalBufferConcat;
-    } catch (err) {
-      Buffer2.concat = OriginalBufferConcat;
-      __privateGet(this, _onError).call(this, new ZlibError(err));
-    } finally {
-      if (__privateGet(this, _handle)) {
-        ;
-        __privateGet(this, _handle)._handle = nativeHandle;
-        nativeHandle.close = originalNativeClose;
-        __privateGet(this, _handle).close = originalClose;
-        __privateGet(this, _handle).removeAllListeners("error");
-      }
+    if (options && options.debugExposePipes === true) {
+      Object.defineProperty(this, "pipes", { get: () => this[PIPES2] });
     }
-    if (__privateGet(this, _handle))
-      __privateGet(this, _handle).on("error", (er) => __privateGet(this, _onError).call(this, new ZlibError(er)));
-    let writeReturn;
-    if (result) {
-      if (Array.isArray(result) && result.length > 0) {
-        const r = result[0];
-        writeReturn = this[_superWrite](Buffer2.from(r));
-        for (let i = 1; i < result.length; i++) {
-          writeReturn = this[_superWrite](result[i]);
-        }
+    const { signal } = options;
+    if (signal) {
+      this[SIGNAL2] = signal;
+      if (signal.aborted) {
+        this[ABORT2]();
       } else {
-        writeReturn = this[_superWrite](Buffer2.from(result));
+        signal.addEventListener("abort", () => this[ABORT2]());
       }
     }
-    if (cb)
-      cb();
-    return writeReturn;
   }
-};
-_sawError = new WeakMap();
-_ended3 = new WeakMap();
-_flushFlag2 = new WeakMap();
-_finishFlushFlag = new WeakMap();
-_fullFlushFlag = new WeakMap();
-_handle = new WeakMap();
-_onError = new WeakMap();
-var _level, _strategy;
-var Zlib = class extends ZlibBase {
-  constructor(opts, mode) {
-    opts = opts || {};
-    opts.flush = opts.flush || constants.Z_NO_FLUSH;
-    opts.finishFlush = opts.finishFlush || constants.Z_FINISH;
-    opts.fullFlushFlag = constants.Z_FULL_FLUSH;
-    super(opts, mode);
-    __privateAdd(this, _level);
-    __privateAdd(this, _strategy);
-    __privateSet(this, _level, opts.level);
-    __privateSet(this, _strategy, opts.strategy);
+  /**
+   * The amount of data stored in the buffer waiting to be read.
+   *
+   * For Buffer strings, this will be the total byte length.
+   * For string encoding streams, this will be the string character length,
+   * according to JavaScript's `string.length` logic.
+   * For objectMode streams, this is a count of the items waiting to be
+   * emitted.
+   */
+  get bufferLength() {
+    return this[BUFFERLENGTH2];
   }
-  params(level, strategy) {
-    if (this.sawError)
-      return;
-    if (!this.handle)
-      throw new Error("cannot switch params when binding is closed");
-    if (!this.handle.params)
-      throw new Error("not supported in this implementation");
-    if (__privateGet(this, _level) !== level || __privateGet(this, _strategy) !== strategy) {
-      this.flush(constants.Z_SYNC_FLUSH);
-      assert(this.handle, "zlib binding closed");
-      const origFlush = this.handle.flush;
-      this.handle.flush = (flushFlag, cb) => {
-        if (typeof flushFlag === "function") {
-          cb = flushFlag;
-          flushFlag = this.flushFlag;
-        }
-        this.flush(flushFlag);
-        cb == null ? void 0 : cb();
-      };
-      try {
-        ;
-        this.handle.params(level, strategy);
-      } finally {
-        this.handle.flush = origFlush;
-      }
-      if (this.handle) {
-        __privateSet(this, _level, level);
-        __privateSet(this, _strategy, strategy);
-      }
-    }
+  /**
+   * The `BufferEncoding` currently in use, or `null`
+   */
+  get encoding() {
+    return this[ENCODING2];
   }
-};
-_level = new WeakMap();
-_strategy = new WeakMap();
-var _portable;
-var Gzip = class extends Zlib {
-  constructor(opts) {
-    super(opts, "Gzip");
-    __privateAdd(this, _portable);
-    __privateSet(this, _portable, opts && !!opts.portable);
+  /**
+   * @deprecated - This is a read only property
+   */
+  set encoding(_enc) {
+    throw new Error("Encoding must be set at instantiation time");
   }
-  [_superWrite](data) {
-    if (!__privateGet(this, _portable))
-      return super[_superWrite](data);
-    __privateSet(this, _portable, false);
-    data[9] = 255;
-    return super[_superWrite](data);
+  /**
+   * @deprecated - Encoding may only be set at instantiation time
+   */
+  setEncoding(_enc) {
+    throw new Error("Encoding must be set at instantiation time");
   }
-};
-_portable = new WeakMap();
-var Unzip = class extends Zlib {
-  constructor(opts) {
-    super(opts, "Unzip");
+  /**
+   * True if this is an objectMode stream
+   */
+  get objectMode() {
+    return this[OBJECTMODE2];
   }
-};
-var Brotli = class extends ZlibBase {
-  constructor(opts, mode) {
-    opts = opts || {};
-    opts.flush = opts.flush || constants.BROTLI_OPERATION_PROCESS;
-    opts.finishFlush = opts.finishFlush || constants.BROTLI_OPERATION_FINISH;
-    opts.fullFlushFlag = constants.BROTLI_OPERATION_FLUSH;
-    super(opts, mode);
+  /**
+   * @deprecated - This is a read-only property
+   */
+  set objectMode(_om) {
+    throw new Error("objectMode must be set at instantiation time");
   }
-};
-var BrotliCompress = class extends Brotli {
-  constructor(opts) {
-    super(opts, "BrotliCompress");
+  /**
+   * true if this is an async stream
+   */
+  get ["async"]() {
+    return this[ASYNC2];
   }
-};
-var BrotliDecompress = class extends Brotli {
-  constructor(opts) {
-    super(opts, "BrotliDecompress");
+  /**
+   * Set to true to make this stream async.
+   *
+   * Once set, it cannot be unset, as this would potentially cause incorrect
+   * behavior.  Ie, a sync stream can be made async, but an async stream
+   * cannot be safely made sync.
+   */
+  set ["async"](a) {
+    this[ASYNC2] = this[ASYNC2] || !!a;
   }
-};
-
-// node_modules/yallist/dist/esm/index.js
-var Yallist = class _Yallist {
-  tail;
-  head;
-  length = 0;
-  static create(list2 = []) {
-    return new _Yallist(list2);
+  // drop everything and get out of the flow completely
+  [ABORT2]() {
+    var _a, _b;
+    this[ABORTED2] = true;
+    this.emit("abort", (_a = this[SIGNAL2]) == null ? void 0 : _a.reason);
+    this.destroy((_b = this[SIGNAL2]) == null ? void 0 : _b.reason);
   }
-  constructor(list2 = []) {
-    for (const item of list2) {
-      this.push(item);
-    }
+  /**
+   * True if the stream has been aborted.
+   */
+  get aborted() {
+    return this[ABORTED2];
   }
-  *[Symbol.iterator]() {
-    for (let walker = this.head; walker; walker = walker.next) {
-      yield walker.value;
-    }
+  /**
+   * No-op setter. Stream aborted status is set via the AbortSignal provided
+   * in the constructor options.
+   */
+  set aborted(_) {
   }
-  removeNode(node) {
-    if (node.list !== this) {
-      throw new Error("removing node which does not belong to this list");
+  write(chunk, encoding, cb) {
+    var _a;
+    if (this[ABORTED2])
+      return false;
+    if (this[EOF2])
+      throw new Error("write after end");
+    if (this[DESTROYED2]) {
+      this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" }));
+      return true;
     }
-    const next = node.next;
-    const prev = node.prev;
-    if (next) {
-      next.prev = prev;
+    if (typeof encoding === "function") {
+      cb = encoding;
+      encoding = "utf8";
     }
-    if (prev) {
-      prev.next = next;
+    if (!encoding)
+      encoding = "utf8";
+    const fn = this[ASYNC2] ? defer2 : nodefer2;
+    if (!this[OBJECTMODE2] && !Buffer.isBuffer(chunk)) {
+      if (isArrayBufferView2(chunk)) {
+        chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+      } else if (isArrayBufferLike2(chunk)) {
+        chunk = Buffer.from(chunk);
+      } else if (typeof chunk !== "string") {
+        throw new Error("Non-contiguous data written to non-objectMode stream");
+      }
     }
-    if (node === this.head) {
-      this.head = next;
+    if (this[OBJECTMODE2]) {
+      if (this[FLOWING2] && this[BUFFERLENGTH2] !== 0)
+        this[FLUSH2](true);
+      if (this[FLOWING2])
+        this.emit("data", chunk);
+      else
+        this[BUFFERPUSH2](chunk);
+      if (this[BUFFERLENGTH2] !== 0)
+        this.emit("readable");
+      if (cb)
+        fn(cb);
+      return this[FLOWING2];
     }
-    if (node === this.tail) {
-      this.tail = prev;
+    if (!chunk.length) {
+      if (this[BUFFERLENGTH2] !== 0)
+        this.emit("readable");
+      if (cb)
+        fn(cb);
+      return this[FLOWING2];
     }
-    this.length--;
-    node.next = void 0;
-    node.prev = void 0;
-    node.list = void 0;
-    return next;
-  }
-  unshiftNode(node) {
-    if (node === this.head) {
-      return;
+    if (typeof chunk === "string" && // unless it is a string already ready for us to use
+    !(encoding === this[ENCODING2] && !((_a = this[DECODER2]) == null ? void 0 : _a.lastNeed))) {
+      chunk = Buffer.from(chunk, encoding);
     }
-    if (node.list) {
-      node.list.removeNode(node);
+    if (Buffer.isBuffer(chunk) && this[ENCODING2]) {
+      chunk = this[DECODER2].write(chunk);
     }
-    const head = this.head;
-    node.list = this;
-    node.next = head;
-    if (head) {
-      head.prev = node;
+    if (this[FLOWING2] && this[BUFFERLENGTH2] !== 0)
+      this[FLUSH2](true);
+    if (this[FLOWING2])
+      this.emit("data", chunk);
+    else
+      this[BUFFERPUSH2](chunk);
+    if (this[BUFFERLENGTH2] !== 0)
+      this.emit("readable");
+    if (cb)
+      fn(cb);
+    return this[FLOWING2];
+  }
+  /**
+   * Low-level explicit read method.
+   *
+   * In objectMode, the argument is ignored, and one item is returned if
+   * available.
+   *
+   * `n` is the number of bytes (or in the case of encoding streams,
+   * characters) to consume. If `n` is not provided, then the entire buffer
+   * is returned, or `null` is returned if no data is available.
+   *
+   * If `n` is greater that the amount of data in the internal buffer,
+   * then `null` is returned.
+   */
+  read(n) {
+    if (this[DESTROYED2])
+      return null;
+    this[DISCARDED2] = false;
+    if (this[BUFFERLENGTH2] === 0 || n === 0 || n && n > this[BUFFERLENGTH2]) {
+      this[MAYBE_EMIT_END2]();
+      return null;
     }
-    this.head = node;
-    if (!this.tail) {
-      this.tail = node;
+    if (this[OBJECTMODE2])
+      n = null;
+    if (this[BUFFER2].length > 1 && !this[OBJECTMODE2]) {
+      this[BUFFER2] = [
+        this[ENCODING2] ? this[BUFFER2].join("") : Buffer.concat(this[BUFFER2], this[BUFFERLENGTH2])
+      ];
     }
-    this.length++;
+    const ret = this[READ2](n || null, this[BUFFER2][0]);
+    this[MAYBE_EMIT_END2]();
+    return ret;
   }
-  pushNode(node) {
-    if (node === this.tail) {
-      return;
-    }
-    if (node.list) {
-      node.list.removeNode(node);
+  [READ2](n, chunk) {
+    if (this[OBJECTMODE2])
+      this[BUFFERSHIFT2]();
+    else {
+      const c = chunk;
+      if (n === c.length || n === null)
+        this[BUFFERSHIFT2]();
+      else if (typeof c === "string") {
+        this[BUFFER2][0] = c.slice(n);
+        chunk = c.slice(0, n);
+        this[BUFFERLENGTH2] -= n;
+      } else {
+        this[BUFFER2][0] = c.subarray(n);
+        chunk = c.subarray(0, n);
+        this[BUFFERLENGTH2] -= n;
+      }
     }
-    const tail = this.tail;
-    node.list = this;
-    node.prev = tail;
-    if (tail) {
-      tail.next = node;
+    this.emit("data", chunk);
+    if (!this[BUFFER2].length && !this[EOF2])
+      this.emit("drain");
+    return chunk;
+  }
+  end(chunk, encoding, cb) {
+    if (typeof chunk === "function") {
+      cb = chunk;
+      chunk = void 0;
     }
-    this.tail = node;
-    if (!this.head) {
-      this.head = node;
+    if (typeof encoding === "function") {
+      cb = encoding;
+      encoding = "utf8";
     }
-    this.length++;
+    if (chunk !== void 0)
+      this.write(chunk, encoding);
+    if (cb)
+      this.once("end", cb);
+    this[EOF2] = true;
+    this.writable = false;
+    if (this[FLOWING2] || !this[PAUSED2])
+      this[MAYBE_EMIT_END2]();
+    return this;
   }
-  push(...args) {
-    for (let i = 0, l = args.length; i < l; i++) {
-      push(this, args[i]);
+  // don't let the internal resume be overwritten
+  [RESUME2]() {
+    if (this[DESTROYED2])
+      return;
+    if (!this[DATALISTENERS2] && !this[PIPES2].length) {
+      this[DISCARDED2] = true;
     }
-    return this.length;
+    this[PAUSED2] = false;
+    this[FLOWING2] = true;
+    this.emit("resume");
+    if (this[BUFFER2].length)
+      this[FLUSH2]();
+    else if (this[EOF2])
+      this[MAYBE_EMIT_END2]();
+    else
+      this.emit("drain");
   }
-  unshift(...args) {
-    for (var i = 0, l = args.length; i < l; i++) {
-      unshift(this, args[i]);
-    }
-    return this.length;
+  /**
+   * Resume the stream if it is currently in a paused state
+   *
+   * If called when there are no pipe destinations or `data` event listeners,
+   * this will place the stream in a "discarded" state, where all data will
+   * be thrown away. The discarded state is removed if a pipe destination or
+   * data handler is added, if pause() is called, or if any synchronous or
+   * asynchronous iteration is started.
+   */
+  resume() {
+    return this[RESUME2]();
   }
-  pop() {
-    if (!this.tail) {
-      return void 0;
-    }
-    const res = this.tail.value;
-    const t = this.tail;
-    this.tail = this.tail.prev;
-    if (this.tail) {
-      this.tail.next = void 0;
-    } else {
-      this.head = void 0;
-    }
-    t.list = void 0;
-    this.length--;
-    return res;
+  /**
+   * Pause the stream
+   */
+  pause() {
+    this[FLOWING2] = false;
+    this[PAUSED2] = true;
+    this[DISCARDED2] = false;
   }
-  shift() {
-    if (!this.head) {
-      return void 0;
-    }
-    const res = this.head.value;
-    const h = this.head;
-    this.head = this.head.next;
-    if (this.head) {
-      this.head.prev = void 0;
-    } else {
-      this.tail = void 0;
-    }
-    h.list = void 0;
-    this.length--;
-    return res;
+  /**
+   * true if the stream has been forcibly destroyed
+   */
+  get destroyed() {
+    return this[DESTROYED2];
   }
-  forEach(fn, thisp) {
-    thisp = thisp || this;
-    for (let walker = this.head, i = 0; !!walker; i++) {
-      fn.call(thisp, walker.value, i, this);
-      walker = walker.next;
-    }
+  /**
+   * true if the stream is currently in a flowing state, meaning that
+   * any writes will be immediately emitted.
+   */
+  get flowing() {
+    return this[FLOWING2];
   }
-  forEachReverse(fn, thisp) {
-    thisp = thisp || this;
-    for (let walker = this.tail, i = this.length - 1; !!walker; i--) {
-      fn.call(thisp, walker.value, i, this);
-      walker = walker.prev;
-    }
+  /**
+   * true if the stream is currently in a paused state
+   */
+  get paused() {
+    return this[PAUSED2];
   }
-  get(n) {
-    let i = 0;
-    let walker = this.head;
-    for (; !!walker && i < n; i++) {
-      walker = walker.next;
-    }
-    if (i === n && !!walker) {
-      return walker.value;
-    }
+  [BUFFERPUSH2](chunk) {
+    if (this[OBJECTMODE2])
+      this[BUFFERLENGTH2] += 1;
+    else
+      this[BUFFERLENGTH2] += chunk.length;
+    this[BUFFER2].push(chunk);
   }
-  getReverse(n) {
-    let i = 0;
-    let walker = this.tail;
-    for (; !!walker && i < n; i++) {
-      walker = walker.prev;
-    }
-    if (i === n && !!walker) {
-      return walker.value;
-    }
+  [BUFFERSHIFT2]() {
+    if (this[OBJECTMODE2])
+      this[BUFFERLENGTH2] -= 1;
+    else
+      this[BUFFERLENGTH2] -= this[BUFFER2][0].length;
+    return this[BUFFER2].shift();
   }
-  map(fn, thisp) {
-    thisp = thisp || this;
-    const res = new _Yallist();
-    for (let walker = this.head; !!walker; ) {
-      res.push(fn.call(thisp, walker.value, this));
-      walker = walker.next;
-    }
-    return res;
+  [FLUSH2](noDrain = false) {
+    do {
+    } while (this[FLUSHCHUNK2](this[BUFFERSHIFT2]()) && this[BUFFER2].length);
+    if (!noDrain && !this[BUFFER2].length && !this[EOF2])
+      this.emit("drain");
   }
-  mapReverse(fn, thisp) {
-    thisp = thisp || this;
-    var res = new _Yallist();
-    for (let walker = this.tail; !!walker; ) {
-      res.push(fn.call(thisp, walker.value, this));
-      walker = walker.prev;
-    }
-    return res;
+  [FLUSHCHUNK2](chunk) {
+    this.emit("data", chunk);
+    return this[FLOWING2];
   }
-  reduce(fn, initial) {
-    let acc;
-    let walker = this.head;
-    if (arguments.length > 1) {
-      acc = initial;
-    } else if (this.head) {
-      walker = this.head.next;
-      acc = this.head.value;
+  /**
+   * Pipe all data emitted by this stream into the destination provided.
+   *
+   * Triggers the flow of data.
+   */
+  pipe(dest, opts) {
+    if (this[DESTROYED2])
+      return dest;
+    this[DISCARDED2] = false;
+    const ended = this[EMITTED_END2];
+    opts = opts || {};
+    if (dest === proc2.stdout || dest === proc2.stderr)
+      opts.end = false;
+    else
+      opts.end = opts.end !== false;
+    opts.proxyErrors = !!opts.proxyErrors;
+    if (ended) {
+      if (opts.end)
+        dest.end();
     } else {
-      throw new TypeError("Reduce of empty list with no initial value");
-    }
-    for (var i = 0; !!walker; i++) {
-      acc = fn(acc, walker.value, i);
-      walker = walker.next;
+      this[PIPES2].push(!opts.proxyErrors ? new Pipe2(this, dest, opts) : new PipeProxyErrors2(this, dest, opts));
+      if (this[ASYNC2])
+        defer2(() => this[RESUME2]());
+      else
+        this[RESUME2]();
     }
-    return acc;
+    return dest;
   }
-  reduceReverse(fn, initial) {
-    let acc;
-    let walker = this.tail;
-    if (arguments.length > 1) {
-      acc = initial;
-    } else if (this.tail) {
-      walker = this.tail.prev;
-      acc = this.tail.value;
-    } else {
-      throw new TypeError("Reduce of empty list with no initial value");
-    }
-    for (let i = this.length - 1; !!walker; i--) {
-      acc = fn(acc, walker.value, i);
-      walker = walker.prev;
+  /**
+   * Fully unhook a piped destination stream.
+   *
+   * If the destination stream was the only consumer of this stream (ie,
+   * there are no other piped destinations or `'data'` event listeners)
+   * then the flow of data will stop until there is another consumer or
+   * {@link Minipass#resume} is explicitly called.
+   */
+  unpipe(dest) {
+    const p = this[PIPES2].find((p2) => p2.dest === dest);
+    if (p) {
+      if (this[PIPES2].length === 1) {
+        if (this[FLOWING2] && this[DATALISTENERS2] === 0) {
+          this[FLOWING2] = false;
+        }
+        this[PIPES2] = [];
+      } else
+        this[PIPES2].splice(this[PIPES2].indexOf(p), 1);
+      p.unpipe();
     }
-    return acc;
   }
-  toArray() {
-    const arr = new Array(this.length);
-    for (let i = 0, walker = this.head; !!walker; i++) {
-      arr[i] = walker.value;
-      walker = walker.next;
-    }
-    return arr;
+  /**
+   * Alias for {@link Minipass#on}
+   */
+  addListener(ev, handler) {
+    return this.on(ev, handler);
   }
-  toArrayReverse() {
-    const arr = new Array(this.length);
-    for (let i = 0, walker = this.tail; !!walker; i++) {
-      arr[i] = walker.value;
-      walker = walker.prev;
+  /**
+   * Mostly identical to `EventEmitter.on`, with the following
+   * behavior differences to prevent data loss and unnecessary hangs:
+   *
+   * - Adding a 'data' event handler will trigger the flow of data
+   *
+   * - Adding a 'readable' event handler when there is data waiting to be read
+   *   will cause 'readable' to be emitted immediately.
+   *
+   * - Adding an 'endish' event handler ('end', 'finish', etc.) which has
+   *   already passed will cause the event to be emitted immediately and all
+   *   handlers removed.
+   *
+   * - Adding an 'error' event handler after an error has been emitted will
+   *   cause the event to be re-emitted immediately with the error previously
+   *   raised.
+   */
+  on(ev, handler) {
+    const ret = super.on(ev, handler);
+    if (ev === "data") {
+      this[DISCARDED2] = false;
+      this[DATALISTENERS2]++;
+      if (!this[PIPES2].length && !this[FLOWING2]) {
+        this[RESUME2]();
+      }
+    } else if (ev === "readable" && this[BUFFERLENGTH2] !== 0) {
+      super.emit("readable");
+    } else if (isEndish2(ev) && this[EMITTED_END2]) {
+      super.emit(ev);
+      this.removeAllListeners(ev);
+    } else if (ev === "error" && this[EMITTED_ERROR2]) {
+      const h = handler;
+      if (this[ASYNC2])
+        defer2(() => h.call(this, this[EMITTED_ERROR2]));
+      else
+        h.call(this, this[EMITTED_ERROR2]);
     }
-    return arr;
+    return ret;
   }
-  slice(from = 0, to = this.length) {
-    if (to < 0) {
-      to += this.length;
-    }
-    if (from < 0) {
-      from += this.length;
-    }
-    const ret = new _Yallist();
-    if (to < from || to < 0) {
-      return ret;
-    }
-    if (from < 0) {
-      from = 0;
-    }
-    if (to > this.length) {
-      to = this.length;
-    }
-    let walker = this.head;
-    let i = 0;
-    for (i = 0; !!walker && i < from; i++) {
-      walker = walker.next;
-    }
-    for (; !!walker && i < to; i++, walker = walker.next) {
-      ret.push(walker.value);
+  /**
+   * Alias for {@link Minipass#off}
+   */
+  removeListener(ev, handler) {
+    return this.off(ev, handler);
+  }
+  /**
+   * Mostly identical to `EventEmitter.off`
+   *
+   * If a 'data' event handler is removed, and it was the last consumer
+   * (ie, there are no pipe destinations or other 'data' event listeners),
+   * then the flow of data will stop until there is another consumer or
+   * {@link Minipass#resume} is explicitly called.
+   */
+  off(ev, handler) {
+    const ret = super.off(ev, handler);
+    if (ev === "data") {
+      this[DATALISTENERS2] = this.listeners("data").length;
+      if (this[DATALISTENERS2] === 0 && !this[DISCARDED2] && !this[PIPES2].length) {
+        this[FLOWING2] = false;
+      }
     }
     return ret;
   }
-  sliceReverse(from = 0, to = this.length) {
-    if (to < 0) {
-      to += this.length;
-    }
-    if (from < 0) {
-      from += this.length;
-    }
-    const ret = new _Yallist();
-    if (to < from || to < 0) {
-      return ret;
-    }
-    if (from < 0) {
-      from = 0;
-    }
-    if (to > this.length) {
-      to = this.length;
-    }
-    let i = this.length;
-    let walker = this.tail;
-    for (; !!walker && i > to; i--) {
-      walker = walker.prev;
-    }
-    for (; !!walker && i > from; i--, walker = walker.prev) {
-      ret.push(walker.value);
+  /**
+   * Mostly identical to `EventEmitter.removeAllListeners`
+   *
+   * If all 'data' event handlers are removed, and they were the last consumer
+   * (ie, there are no pipe destinations), then the flow of data will stop
+   * until there is another consumer or {@link Minipass#resume} is explicitly
+   * called.
+   */
+  removeAllListeners(ev) {
+    const ret = super.removeAllListeners(ev);
+    if (ev === "data" || ev === void 0) {
+      this[DATALISTENERS2] = 0;
+      if (!this[DISCARDED2] && !this[PIPES2].length) {
+        this[FLOWING2] = false;
+      }
     }
     return ret;
   }
-  splice(start, deleteCount = 0, ...nodes) {
-    if (start > this.length) {
-      start = this.length - 1;
-    }
-    if (start < 0) {
-      start = this.length + start;
-    }
-    let walker = this.head;
-    for (let i = 0; !!walker && i < start; i++) {
-      walker = walker.next;
-    }
-    const ret = [];
-    for (let i = 0; !!walker && i < deleteCount; i++) {
-      ret.push(walker.value);
-      walker = this.removeNode(walker);
-    }
-    if (!walker) {
-      walker = this.tail;
-    } else if (walker !== this.tail) {
-      walker = walker.prev;
+  /**
+   * true if the 'end' event has been emitted
+   */
+  get emittedEnd() {
+    return this[EMITTED_END2];
+  }
+  [MAYBE_EMIT_END2]() {
+    if (!this[EMITTING_END2] && !this[EMITTED_END2] && !this[DESTROYED2] && this[BUFFER2].length === 0 && this[EOF2]) {
+      this[EMITTING_END2] = true;
+      this.emit("end");
+      this.emit("prefinish");
+      this.emit("finish");
+      if (this[CLOSED2])
+        this.emit("close");
+      this[EMITTING_END2] = false;
     }
-    for (const v of nodes) {
-      walker = insertAfter(this, walker, v);
+  }
+  /**
+   * Mostly identical to `EventEmitter.emit`, with the following
+   * behavior differences to prevent data loss and unnecessary hangs:
+   *
+   * If the stream has been destroyed, and the event is something other
+   * than 'close' or 'error', then `false` is returned and no handlers
+   * are called.
+   *
+   * If the event is 'end', and has already been emitted, then the event
+   * is ignored. If the stream is in a paused or non-flowing state, then
+   * the event will be deferred until data flow resumes. If the stream is
+   * async, then handlers will be called on the next tick rather than
+   * immediately.
+   *
+   * If the event is 'close', and 'end' has not yet been emitted, then
+   * the event will be deferred until after 'end' is emitted.
+   *
+   * If the event is 'error', and an AbortSignal was provided for the stream,
+   * and there are no listeners, then the event is ignored, matching the
+   * behavior of node core streams in the presense of an AbortSignal.
+   *
+   * If the event is 'finish' or 'prefinish', then all listeners will be
+   * removed after emitting the event, to prevent double-firing.
+   */
+  emit(ev, ...args) {
+    const data = args[0];
+    if (ev !== "error" && ev !== "close" && ev !== DESTROYED2 && this[DESTROYED2]) {
+      return false;
+    } else if (ev === "data") {
+      return !this[OBJECTMODE2] && !data ? false : this[ASYNC2] ? (defer2(() => this[EMITDATA2](data)), true) : this[EMITDATA2](data);
+    } else if (ev === "end") {
+      return this[EMITEND3]();
+    } else if (ev === "close") {
+      this[CLOSED2] = true;
+      if (!this[EMITTED_END2] && !this[DESTROYED2])
+        return false;
+      const ret2 = super.emit("close");
+      this.removeAllListeners("close");
+      return ret2;
+    } else if (ev === "error") {
+      this[EMITTED_ERROR2] = data;
+      super.emit(ERROR2, data);
+      const ret2 = !this[SIGNAL2] || this.listeners("error").length ? super.emit("error", data) : false;
+      this[MAYBE_EMIT_END2]();
+      return ret2;
+    } else if (ev === "resume") {
+      const ret2 = super.emit("resume");
+      this[MAYBE_EMIT_END2]();
+      return ret2;
+    } else if (ev === "finish" || ev === "prefinish") {
+      const ret2 = super.emit(ev);
+      this.removeAllListeners(ev);
+      return ret2;
     }
+    const ret = super.emit(ev, ...args);
+    this[MAYBE_EMIT_END2]();
     return ret;
   }
-  reverse() {
-    const head = this.head;
-    const tail = this.tail;
-    for (let walker = head; !!walker; walker = walker.prev) {
-      const p = walker.prev;
-      walker.prev = walker.next;
-      walker.next = p;
+  [EMITDATA2](data) {
+    for (const p of this[PIPES2]) {
+      if (p.dest.write(data) === false)
+        this.pause();
     }
-    this.head = tail;
-    this.tail = head;
-    return this;
+    const ret = this[DISCARDED2] ? false : super.emit("data", data);
+    this[MAYBE_EMIT_END2]();
+    return ret;
   }
-};
-function insertAfter(self, node, value) {
-  const prev = node;
-  const next = node ? node.next : self.head;
-  const inserted = new Node2(value, prev, next, self);
-  if (inserted.next === void 0) {
-    self.tail = inserted;
+  [EMITEND3]() {
+    if (this[EMITTED_END2])
+      return false;
+    this[EMITTED_END2] = true;
+    this.readable = false;
+    return this[ASYNC2] ? (defer2(() => this[EMITEND22]()), true) : this[EMITEND22]();
   }
-  if (inserted.prev === void 0) {
-    self.head = inserted;
+  [EMITEND22]() {
+    if (this[DECODER2]) {
+      const data = this[DECODER2].end();
+      if (data) {
+        for (const p of this[PIPES2]) {
+          p.dest.write(data);
+        }
+        if (!this[DISCARDED2])
+          super.emit("data", data);
+      }
+    }
+    for (const p of this[PIPES2]) {
+      p.end();
+    }
+    const ret = super.emit("end");
+    this.removeAllListeners("end");
+    return ret;
   }
-  self.length++;
-  return inserted;
-}
-function push(self, item) {
-  self.tail = new Node2(item, self.tail, void 0, self);
+  /**
+   * Return a Promise that resolves to an array of all emitted data once
+   * the stream ends.
+   */
+  async collect() {
+    const buf = Object.assign([], {
+      dataLength: 0
+    });
+    if (!this[OBJECTMODE2])
+      buf.dataLength = 0;
+    const p = this.promise();
+    this.on("data", (c) => {
+      buf.push(c);
+      if (!this[OBJECTMODE2])
+        buf.dataLength += c.length;
+    });
+    await p;
+    return buf;
+  }
+  /**
+   * Return a Promise that resolves to the concatenation of all emitted data
+   * once the stream ends.
+   *
+   * Not allowed on objectMode streams.
+   */
+  async concat() {
+    if (this[OBJECTMODE2]) {
+      throw new Error("cannot concat in objectMode");
+    }
+    const buf = await this.collect();
+    return this[ENCODING2] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
+  }
+  /**
+   * Return a void Promise that resolves once the stream ends.
+   */
+  async promise() {
+    return new Promise((resolve2, reject) => {
+      this.on(DESTROYED2, () => reject(new Error("stream destroyed")));
+      this.on("error", (er) => reject(er));
+      this.on("end", () => resolve2());
+    });
+  }
+  /**
+   * Asynchronous `for await of` iteration.
+   *
+   * This will continue emitting all chunks until the stream terminates.
+   */
+  [Symbol.asyncIterator]() {
+    this[DISCARDED2] = false;
+    let stopped = false;
+    const stop = async () => {
+      this.pause();
+      stopped = true;
+      return { value: void 0, done: true };
+    };
+    const next = () => {
+      if (stopped)
+        return stop();
+      const res = this.read();
+      if (res !== null)
+        return Promise.resolve({ done: false, value: res });
+      if (this[EOF2])
+        return stop();
+      let resolve2;
+      let reject;
+      const onerr = (er) => {
+        this.off("data", ondata);
+        this.off("end", onend);
+        this.off(DESTROYED2, ondestroy);
+        stop();
+        reject(er);
+      };
+      const ondata = (value) => {
+        this.off("error", onerr);
+        this.off("end", onend);
+        this.off(DESTROYED2, ondestroy);
+        this.pause();
+        resolve2({ value, done: !!this[EOF2] });
+      };
+      const onend = () => {
+        this.off("error", onerr);
+        this.off("data", ondata);
+        this.off(DESTROYED2, ondestroy);
+        stop();
+        resolve2({ done: true, value: void 0 });
+      };
+      const ondestroy = () => onerr(new Error("stream destroyed"));
+      return new Promise((res2, rej) => {
+        reject = rej;
+        resolve2 = res2;
+        this.once(DESTROYED2, ondestroy);
+        this.once("error", onerr);
+        this.once("end", onend);
+        this.once("data", ondata);
+      });
+    };
+    return {
+      next,
+      throw: stop,
+      return: stop,
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+  /**
+   * Synchronous `for of` iteration.
+   *
+   * The iteration will terminate when the internal buffer runs out, even
+   * if the stream has not yet terminated.
+   */
+  [Symbol.iterator]() {
+    this[DISCARDED2] = false;
+    let stopped = false;
+    const stop = () => {
+      this.pause();
+      this.off(ERROR2, stop);
+      this.off(DESTROYED2, stop);
+      this.off("end", stop);
+      stopped = true;
+      return { done: true, value: void 0 };
+    };
+    const next = () => {
+      if (stopped)
+        return stop();
+      const value = this.read();
+      return value === null ? stop() : { done: false, value };
+    };
+    this.once("end", stop);
+    this.once(ERROR2, stop);
+    this.once(DESTROYED2, stop);
+    return {
+      next,
+      throw: stop,
+      return: stop,
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  }
+  /**
+   * Destroy a stream, preventing it from being used for any further purpose.
+   *
+   * If the stream has a `close()` method, then it will be called on
+   * destruction.
+   *
+   * After destruction, any attempt to write data, read data, or emit most
+   * events will be ignored.
+   *
+   * If an error argument is provided, then it will be emitted in an
+   * 'error' event.
+   */
+  destroy(er) {
+    if (this[DESTROYED2]) {
+      if (er)
+        this.emit("error", er);
+      else
+        this.emit(DESTROYED2);
+      return this;
+    }
+    this[DESTROYED2] = true;
+    this[DISCARDED2] = true;
+    this[BUFFER2].length = 0;
+    this[BUFFERLENGTH2] = 0;
+    const wc = this;
+    if (typeof wc.close === "function" && !this[CLOSED2])
+      wc.close();
+    if (er)
+      this.emit("error", er);
+    else
+      this.emit(DESTROYED2);
+    return this;
+  }
+  /**
+   * Alias for {@link isStream}
+   *
+   * Former export location, maintained for backwards compatibility.
+   *
+   * @deprecated
+   */
+  static get isStream() {
+    return isStream2;
+  }
+};
+
+// node_modules/minizlib/dist/esm/index.js
+import realZlib2 from "zlib";
+
+// node_modules/minizlib/dist/esm/constants.js
+import realZlib from "zlib";
+var realZlibConstants = realZlib.constants || { ZLIB_VERNUM: 4736 };
+var constants = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), {
+  Z_NO_FLUSH: 0,
+  Z_PARTIAL_FLUSH: 1,
+  Z_SYNC_FLUSH: 2,
+  Z_FULL_FLUSH: 3,
+  Z_FINISH: 4,
+  Z_BLOCK: 5,
+  Z_OK: 0,
+  Z_STREAM_END: 1,
+  Z_NEED_DICT: 2,
+  Z_ERRNO: -1,
+  Z_STREAM_ERROR: -2,
+  Z_DATA_ERROR: -3,
+  Z_MEM_ERROR: -4,
+  Z_BUF_ERROR: -5,
+  Z_VERSION_ERROR: -6,
+  Z_NO_COMPRESSION: 0,
+  Z_BEST_SPEED: 1,
+  Z_BEST_COMPRESSION: 9,
+  Z_DEFAULT_COMPRESSION: -1,
+  Z_FILTERED: 1,
+  Z_HUFFMAN_ONLY: 2,
+  Z_RLE: 3,
+  Z_FIXED: 4,
+  Z_DEFAULT_STRATEGY: 0,
+  DEFLATE: 1,
+  INFLATE: 2,
+  GZIP: 3,
+  GUNZIP: 4,
+  DEFLATERAW: 5,
+  INFLATERAW: 6,
+  UNZIP: 7,
+  BROTLI_DECODE: 8,
+  BROTLI_ENCODE: 9,
+  Z_MIN_WINDOWBITS: 8,
+  Z_MAX_WINDOWBITS: 15,
+  Z_DEFAULT_WINDOWBITS: 15,
+  Z_MIN_CHUNK: 64,
+  Z_MAX_CHUNK: Infinity,
+  Z_DEFAULT_CHUNK: 16384,
+  Z_MIN_MEMLEVEL: 1,
+  Z_MAX_MEMLEVEL: 9,
+  Z_DEFAULT_MEMLEVEL: 8,
+  Z_MIN_LEVEL: -1,
+  Z_MAX_LEVEL: 9,
+  Z_DEFAULT_LEVEL: -1,
+  BROTLI_OPERATION_PROCESS: 0,
+  BROTLI_OPERATION_FLUSH: 1,
+  BROTLI_OPERATION_FINISH: 2,
+  BROTLI_OPERATION_EMIT_METADATA: 3,
+  BROTLI_MODE_GENERIC: 0,
+  BROTLI_MODE_TEXT: 1,
+  BROTLI_MODE_FONT: 2,
+  BROTLI_DEFAULT_MODE: 0,
+  BROTLI_MIN_QUALITY: 0,
+  BROTLI_MAX_QUALITY: 11,
+  BROTLI_DEFAULT_QUALITY: 11,
+  BROTLI_MIN_WINDOW_BITS: 10,
+  BROTLI_MAX_WINDOW_BITS: 24,
+  BROTLI_LARGE_MAX_WINDOW_BITS: 30,
+  BROTLI_DEFAULT_WINDOW: 22,
+  BROTLI_MIN_INPUT_BLOCK_BITS: 16,
+  BROTLI_MAX_INPUT_BLOCK_BITS: 24,
+  BROTLI_PARAM_MODE: 0,
+  BROTLI_PARAM_QUALITY: 1,
+  BROTLI_PARAM_LGWIN: 2,
+  BROTLI_PARAM_LGBLOCK: 3,
+  BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4,
+  BROTLI_PARAM_SIZE_HINT: 5,
+  BROTLI_PARAM_LARGE_WINDOW: 6,
+  BROTLI_PARAM_NPOSTFIX: 7,
+  BROTLI_PARAM_NDIRECT: 8,
+  BROTLI_DECODER_RESULT_ERROR: 0,
+  BROTLI_DECODER_RESULT_SUCCESS: 1,
+  BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2,
+  BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3,
+  BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0,
+  BROTLI_DECODER_PARAM_LARGE_WINDOW: 1,
+  BROTLI_DECODER_NO_ERROR: 0,
+  BROTLI_DECODER_SUCCESS: 1,
+  BROTLI_DECODER_NEEDS_MORE_INPUT: 2,
+  BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3,
+  BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1,
+  BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2,
+  BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3,
+  BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4,
+  BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5,
+  BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6,
+  BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7,
+  BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8,
+  BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9,
+  BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10,
+  BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11,
+  BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12,
+  BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13,
+  BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14,
+  BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15,
+  BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16,
+  BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19,
+  BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20,
+  BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21,
+  BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22,
+  BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25,
+  BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26,
+  BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27,
+  BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30,
+  BROTLI_DECODER_ERROR_UNREACHABLE: -31
+}, realZlibConstants));
+
+// node_modules/minizlib/dist/esm/index.js
+var OriginalBufferConcat = Buffer2.concat;
+var _superWrite = Symbol("_superWrite");
+var ZlibError = class extends Error {
+  code;
+  errno;
+  constructor(err) {
+    super("zlib: " + err.message);
+    this.code = err.code;
+    this.errno = err.errno;
+    if (!this.code)
+      this.code = "ZLIB_ERROR";
+    this.message = "zlib: " + err.message;
+    Error.captureStackTrace(this, this.constructor);
+  }
+  get name() {
+    return "ZlibError";
+  }
+};
+var _flushFlag = Symbol("flushFlag");
+var _sawError, _ended3, _flushFlag2, _finishFlushFlag, _fullFlushFlag, _handle, _onError;
+var ZlibBase = class extends Minipass2 {
+  /* c8 ignore stop */
+  constructor(opts, mode) {
+    var _a;
+    if (!opts || typeof opts !== "object")
+      throw new TypeError("invalid options for ZlibBase constructor");
+    super(opts);
+    __privateAdd(this, _sawError, false);
+    __privateAdd(this, _ended3, false);
+    __privateAdd(this, _flushFlag2);
+    __privateAdd(this, _finishFlushFlag);
+    __privateAdd(this, _fullFlushFlag);
+    __privateAdd(this, _handle);
+    __privateAdd(this, _onError);
+    __privateSet(this, _flushFlag2, opts.flush ?? 0);
+    __privateSet(this, _finishFlushFlag, opts.finishFlush ?? 0);
+    __privateSet(this, _fullFlushFlag, opts.fullFlushFlag ?? 0);
+    try {
+      __privateSet(this, _handle, new realZlib2[mode](opts));
+    } catch (er) {
+      throw new ZlibError(er);
+    }
+    __privateSet(this, _onError, (err) => {
+      if (__privateGet(this, _sawError))
+        return;
+      __privateSet(this, _sawError, true);
+      this.close();
+      this.emit("error", err);
+    });
+    (_a = __privateGet(this, _handle)) == null ? void 0 : _a.on("error", (er) => __privateGet(this, _onError).call(this, new ZlibError(er)));
+    this.once("end", () => this.close);
+  }
+  get sawError() {
+    return __privateGet(this, _sawError);
+  }
+  get handle() {
+    return __privateGet(this, _handle);
+  }
+  /* c8 ignore start */
+  get flushFlag() {
+    return __privateGet(this, _flushFlag2);
+  }
+  close() {
+    if (__privateGet(this, _handle)) {
+      __privateGet(this, _handle).close();
+      __privateSet(this, _handle, void 0);
+      this.emit("close");
+    }
+  }
+  reset() {
+    var _a, _b;
+    if (!__privateGet(this, _sawError)) {
+      assert(__privateGet(this, _handle), "zlib binding closed");
+      return (_b = (_a = __privateGet(this, _handle)).reset) == null ? void 0 : _b.call(_a);
+    }
+  }
+  flush(flushFlag) {
+    if (this.ended)
+      return;
+    if (typeof flushFlag !== "number")
+      flushFlag = __privateGet(this, _fullFlushFlag);
+    this.write(Object.assign(Buffer2.alloc(0), { [_flushFlag]: flushFlag }));
+  }
+  end(chunk, encoding, cb) {
+    if (typeof chunk === "function") {
+      cb = chunk;
+      encoding = void 0;
+      chunk = void 0;
+    }
+    if (typeof encoding === "function") {
+      cb = encoding;
+      encoding = void 0;
+    }
+    if (chunk) {
+      if (encoding)
+        this.write(chunk, encoding);
+      else
+        this.write(chunk);
+    }
+    this.flush(__privateGet(this, _finishFlushFlag));
+    __privateSet(this, _ended3, true);
+    return super.end(cb);
+  }
+  get ended() {
+    return __privateGet(this, _ended3);
+  }
+  // overridden in the gzip classes to do portable writes
+  [_superWrite](data) {
+    return super.write(data);
+  }
+  write(chunk, encoding, cb) {
+    if (typeof encoding === "function")
+      cb = encoding, encoding = "utf8";
+    if (typeof chunk === "string")
+      chunk = Buffer2.from(chunk, encoding);
+    if (__privateGet(this, _sawError))
+      return;
+    assert(__privateGet(this, _handle), "zlib binding closed");
+    const nativeHandle = __privateGet(this, _handle)._handle;
+    const originalNativeClose = nativeHandle.close;
+    nativeHandle.close = () => {
+    };
+    const originalClose = __privateGet(this, _handle).close;
+    __privateGet(this, _handle).close = () => {
+    };
+    Buffer2.concat = (args) => args;
+    let result = void 0;
+    try {
+      const flushFlag = typeof chunk[_flushFlag] === "number" ? chunk[_flushFlag] : __privateGet(this, _flushFlag2);
+      result = __privateGet(this, _handle)._processChunk(chunk, flushFlag);
+      Buffer2.concat = OriginalBufferConcat;
+    } catch (err) {
+      Buffer2.concat = OriginalBufferConcat;
+      __privateGet(this, _onError).call(this, new ZlibError(err));
+    } finally {
+      if (__privateGet(this, _handle)) {
+        ;
+        __privateGet(this, _handle)._handle = nativeHandle;
+        nativeHandle.close = originalNativeClose;
+        __privateGet(this, _handle).close = originalClose;
+        __privateGet(this, _handle).removeAllListeners("error");
+      }
+    }
+    if (__privateGet(this, _handle))
+      __privateGet(this, _handle).on("error", (er) => __privateGet(this, _onError).call(this, new ZlibError(er)));
+    let writeReturn;
+    if (result) {
+      if (Array.isArray(result) && result.length > 0) {
+        const r = result[0];
+        writeReturn = this[_superWrite](Buffer2.from(r));
+        for (let i = 1; i < result.length; i++) {
+          writeReturn = this[_superWrite](result[i]);
+        }
+      } else {
+        writeReturn = this[_superWrite](Buffer2.from(result));
+      }
+    }
+    if (cb)
+      cb();
+    return writeReturn;
+  }
+};
+_sawError = new WeakMap();
+_ended3 = new WeakMap();
+_flushFlag2 = new WeakMap();
+_finishFlushFlag = new WeakMap();
+_fullFlushFlag = new WeakMap();
+_handle = new WeakMap();
+_onError = new WeakMap();
+var _level, _strategy;
+var Zlib = class extends ZlibBase {
+  constructor(opts, mode) {
+    opts = opts || {};
+    opts.flush = opts.flush || constants.Z_NO_FLUSH;
+    opts.finishFlush = opts.finishFlush || constants.Z_FINISH;
+    opts.fullFlushFlag = constants.Z_FULL_FLUSH;
+    super(opts, mode);
+    __privateAdd(this, _level);
+    __privateAdd(this, _strategy);
+    __privateSet(this, _level, opts.level);
+    __privateSet(this, _strategy, opts.strategy);
+  }
+  params(level, strategy) {
+    if (this.sawError)
+      return;
+    if (!this.handle)
+      throw new Error("cannot switch params when binding is closed");
+    if (!this.handle.params)
+      throw new Error("not supported in this implementation");
+    if (__privateGet(this, _level) !== level || __privateGet(this, _strategy) !== strategy) {
+      this.flush(constants.Z_SYNC_FLUSH);
+      assert(this.handle, "zlib binding closed");
+      const origFlush = this.handle.flush;
+      this.handle.flush = (flushFlag, cb) => {
+        if (typeof flushFlag === "function") {
+          cb = flushFlag;
+          flushFlag = this.flushFlag;
+        }
+        this.flush(flushFlag);
+        cb == null ? void 0 : cb();
+      };
+      try {
+        ;
+        this.handle.params(level, strategy);
+      } finally {
+        this.handle.flush = origFlush;
+      }
+      if (this.handle) {
+        __privateSet(this, _level, level);
+        __privateSet(this, _strategy, strategy);
+      }
+    }
+  }
+};
+_level = new WeakMap();
+_strategy = new WeakMap();
+var _portable;
+var Gzip = class extends Zlib {
+  constructor(opts) {
+    super(opts, "Gzip");
+    __privateAdd(this, _portable);
+    __privateSet(this, _portable, opts && !!opts.portable);
+  }
+  [_superWrite](data) {
+    if (!__privateGet(this, _portable))
+      return super[_superWrite](data);
+    __privateSet(this, _portable, false);
+    data[9] = 255;
+    return super[_superWrite](data);
+  }
+};
+_portable = new WeakMap();
+var Unzip = class extends Zlib {
+  constructor(opts) {
+    super(opts, "Unzip");
+  }
+};
+var Brotli = class extends ZlibBase {
+  constructor(opts, mode) {
+    opts = opts || {};
+    opts.flush = opts.flush || constants.BROTLI_OPERATION_PROCESS;
+    opts.finishFlush = opts.finishFlush || constants.BROTLI_OPERATION_FINISH;
+    opts.fullFlushFlag = constants.BROTLI_OPERATION_FLUSH;
+    super(opts, mode);
+  }
+};
+var BrotliCompress = class extends Brotli {
+  constructor(opts) {
+    super(opts, "BrotliCompress");
+  }
+};
+var BrotliDecompress = class extends Brotli {
+  constructor(opts) {
+    super(opts, "BrotliDecompress");
+  }
+};
+
+// node_modules/tar/node_modules/yallist/dist/esm/index.js
+var Yallist = class _Yallist {
+  tail;
+  head;
+  length = 0;
+  static create(list2 = []) {
+    return new _Yallist(list2);
+  }
+  constructor(list2 = []) {
+    for (const item of list2) {
+      this.push(item);
+    }
+  }
+  *[Symbol.iterator]() {
+    for (let walker = this.head; walker; walker = walker.next) {
+      yield walker.value;
+    }
+  }
+  removeNode(node) {
+    if (node.list !== this) {
+      throw new Error("removing node which does not belong to this list");
+    }
+    const next = node.next;
+    const prev = node.prev;
+    if (next) {
+      next.prev = prev;
+    }
+    if (prev) {
+      prev.next = next;
+    }
+    if (node === this.head) {
+      this.head = next;
+    }
+    if (node === this.tail) {
+      this.tail = prev;
+    }
+    this.length--;
+    node.next = void 0;
+    node.prev = void 0;
+    node.list = void 0;
+    return next;
+  }
+  unshiftNode(node) {
+    if (node === this.head) {
+      return;
+    }
+    if (node.list) {
+      node.list.removeNode(node);
+    }
+    const head = this.head;
+    node.list = this;
+    node.next = head;
+    if (head) {
+      head.prev = node;
+    }
+    this.head = node;
+    if (!this.tail) {
+      this.tail = node;
+    }
+    this.length++;
+  }
+  pushNode(node) {
+    if (node === this.tail) {
+      return;
+    }
+    if (node.list) {
+      node.list.removeNode(node);
+    }
+    const tail = this.tail;
+    node.list = this;
+    node.prev = tail;
+    if (tail) {
+      tail.next = node;
+    }
+    this.tail = node;
+    if (!this.head) {
+      this.head = node;
+    }
+    this.length++;
+  }
+  push(...args) {
+    for (let i = 0, l = args.length; i < l; i++) {
+      push(this, args[i]);
+    }
+    return this.length;
+  }
+  unshift(...args) {
+    for (var i = 0, l = args.length; i < l; i++) {
+      unshift(this, args[i]);
+    }
+    return this.length;
+  }
+  pop() {
+    if (!this.tail) {
+      return void 0;
+    }
+    const res = this.tail.value;
+    const t = this.tail;
+    this.tail = this.tail.prev;
+    if (this.tail) {
+      this.tail.next = void 0;
+    } else {
+      this.head = void 0;
+    }
+    t.list = void 0;
+    this.length--;
+    return res;
+  }
+  shift() {
+    if (!this.head) {
+      return void 0;
+    }
+    const res = this.head.value;
+    const h = this.head;
+    this.head = this.head.next;
+    if (this.head) {
+      this.head.prev = void 0;
+    } else {
+      this.tail = void 0;
+    }
+    h.list = void 0;
+    this.length--;
+    return res;
+  }
+  forEach(fn, thisp) {
+    thisp = thisp || this;
+    for (let walker = this.head, i = 0; !!walker; i++) {
+      fn.call(thisp, walker.value, i, this);
+      walker = walker.next;
+    }
+  }
+  forEachReverse(fn, thisp) {
+    thisp = thisp || this;
+    for (let walker = this.tail, i = this.length - 1; !!walker; i--) {
+      fn.call(thisp, walker.value, i, this);
+      walker = walker.prev;
+    }
+  }
+  get(n) {
+    let i = 0;
+    let walker = this.head;
+    for (; !!walker && i < n; i++) {
+      walker = walker.next;
+    }
+    if (i === n && !!walker) {
+      return walker.value;
+    }
+  }
+  getReverse(n) {
+    let i = 0;
+    let walker = this.tail;
+    for (; !!walker && i < n; i++) {
+      walker = walker.prev;
+    }
+    if (i === n && !!walker) {
+      return walker.value;
+    }
+  }
+  map(fn, thisp) {
+    thisp = thisp || this;
+    const res = new _Yallist();
+    for (let walker = this.head; !!walker; ) {
+      res.push(fn.call(thisp, walker.value, this));
+      walker = walker.next;
+    }
+    return res;
+  }
+  mapReverse(fn, thisp) {
+    thisp = thisp || this;
+    var res = new _Yallist();
+    for (let walker = this.tail; !!walker; ) {
+      res.push(fn.call(thisp, walker.value, this));
+      walker = walker.prev;
+    }
+    return res;
+  }
+  reduce(fn, initial) {
+    let acc;
+    let walker = this.head;
+    if (arguments.length > 1) {
+      acc = initial;
+    } else if (this.head) {
+      walker = this.head.next;
+      acc = this.head.value;
+    } else {
+      throw new TypeError("Reduce of empty list with no initial value");
+    }
+    for (var i = 0; !!walker; i++) {
+      acc = fn(acc, walker.value, i);
+      walker = walker.next;
+    }
+    return acc;
+  }
+  reduceReverse(fn, initial) {
+    let acc;
+    let walker = this.tail;
+    if (arguments.length > 1) {
+      acc = initial;
+    } else if (this.tail) {
+      walker = this.tail.prev;
+      acc = this.tail.value;
+    } else {
+      throw new TypeError("Reduce of empty list with no initial value");
+    }
+    for (let i = this.length - 1; !!walker; i--) {
+      acc = fn(acc, walker.value, i);
+      walker = walker.prev;
+    }
+    return acc;
+  }
+  toArray() {
+    const arr = new Array(this.length);
+    for (let i = 0, walker = this.head; !!walker; i++) {
+      arr[i] = walker.value;
+      walker = walker.next;
+    }
+    return arr;
+  }
+  toArrayReverse() {
+    const arr = new Array(this.length);
+    for (let i = 0, walker = this.tail; !!walker; i++) {
+      arr[i] = walker.value;
+      walker = walker.prev;
+    }
+    return arr;
+  }
+  slice(from = 0, to = this.length) {
+    if (to < 0) {
+      to += this.length;
+    }
+    if (from < 0) {
+      from += this.length;
+    }
+    const ret = new _Yallist();
+    if (to < from || to < 0) {
+      return ret;
+    }
+    if (from < 0) {
+      from = 0;
+    }
+    if (to > this.length) {
+      to = this.length;
+    }
+    let walker = this.head;
+    let i = 0;
+    for (i = 0; !!walker && i < from; i++) {
+      walker = walker.next;
+    }
+    for (; !!walker && i < to; i++, walker = walker.next) {
+      ret.push(walker.value);
+    }
+    return ret;
+  }
+  sliceReverse(from = 0, to = this.length) {
+    if (to < 0) {
+      to += this.length;
+    }
+    if (from < 0) {
+      from += this.length;
+    }
+    const ret = new _Yallist();
+    if (to < from || to < 0) {
+      return ret;
+    }
+    if (from < 0) {
+      from = 0;
+    }
+    if (to > this.length) {
+      to = this.length;
+    }
+    let i = this.length;
+    let walker = this.tail;
+    for (; !!walker && i > to; i--) {
+      walker = walker.prev;
+    }
+    for (; !!walker && i > from; i--, walker = walker.prev) {
+      ret.push(walker.value);
+    }
+    return ret;
+  }
+  splice(start, deleteCount = 0, ...nodes) {
+    if (start > this.length) {
+      start = this.length - 1;
+    }
+    if (start < 0) {
+      start = this.length + start;
+    }
+    let walker = this.head;
+    for (let i = 0; !!walker && i < start; i++) {
+      walker = walker.next;
+    }
+    const ret = [];
+    for (let i = 0; !!walker && i < deleteCount; i++) {
+      ret.push(walker.value);
+      walker = this.removeNode(walker);
+    }
+    if (!walker) {
+      walker = this.tail;
+    } else if (walker !== this.tail) {
+      walker = walker.prev;
+    }
+    for (const v of nodes) {
+      walker = insertAfter(this, walker, v);
+    }
+    return ret;
+  }
+  reverse() {
+    const head = this.head;
+    const tail = this.tail;
+    for (let walker = head; !!walker; walker = walker.prev) {
+      const p = walker.prev;
+      walker.prev = walker.next;
+      walker.next = p;
+    }
+    this.head = tail;
+    this.tail = head;
+    return this;
+  }
+};
+function insertAfter(self, node, value) {
+  const prev = node;
+  const next = node ? node.next : self.head;
+  const inserted = new Node2(value, prev, next, self);
+  if (inserted.next === void 0) {
+    self.tail = inserted;
+  }
+  if (inserted.prev === void 0) {
+    self.head = inserted;
+  }
+  self.length++;
+  return inserted;
+}
+function push(self, item) {
+  self.tail = new Node2(item, self.tail, void 0, self);
   if (!self.head) {
     self.head = self.tail;
   }
-  self.length++;
-}
-function unshift(self, item) {
-  self.head = new Node2(item, void 0, self.head, self);
-  if (!self.tail) {
-    self.tail = self.head;
+  self.length++;
+}
+function unshift(self, item) {
+  self.head = new Node2(item, void 0, self.head, self);
+  if (!self.tail) {
+    self.tail = self.head;
+  }
+  self.length++;
+}
+var Node2 = class {
+  list;
+  next;
+  prev;
+  value;
+  constructor(value, prev, next, list2) {
+    this.list = list2;
+    this.value = value;
+    if (prev) {
+      prev.next = this;
+      this.prev = prev;
+    } else {
+      this.prev = void 0;
+    }
+    if (next) {
+      next.prev = this;
+      this.next = next;
+    } else {
+      this.next = void 0;
+    }
+  }
+};
+
+// node_modules/tar/dist/esm/header.js
+import { posix as pathModule } from "path";
+
+// node_modules/tar/dist/esm/large-numbers.js
+var encode = (num, buf) => {
+  if (!Number.isSafeInteger(num)) {
+    throw Error("cannot encode number outside of javascript safe integer range");
+  } else if (num < 0) {
+    encodeNegative(num, buf);
+  } else {
+    encodePositive(num, buf);
+  }
+  return buf;
+};
+var encodePositive = (num, buf) => {
+  buf[0] = 128;
+  for (var i = buf.length; i > 1; i--) {
+    buf[i - 1] = num & 255;
+    num = Math.floor(num / 256);
+  }
+};
+var encodeNegative = (num, buf) => {
+  buf[0] = 255;
+  var flipped = false;
+  num = num * -1;
+  for (var i = buf.length; i > 1; i--) {
+    var byte = num & 255;
+    num = Math.floor(num / 256);
+    if (flipped) {
+      buf[i - 1] = onesComp(byte);
+    } else if (byte === 0) {
+      buf[i - 1] = 0;
+    } else {
+      flipped = true;
+      buf[i - 1] = twosComp(byte);
+    }
+  }
+};
+var parse2 = (buf) => {
+  const pre = buf[0];
+  const value = pre === 128 ? pos(buf.subarray(1, buf.length)) : pre === 255 ? twos(buf) : null;
+  if (value === null) {
+    throw Error("invalid base256 encoding");
+  }
+  if (!Number.isSafeInteger(value)) {
+    throw Error("parsed number outside of javascript safe integer range");
+  }
+  return value;
+};
+var twos = (buf) => {
+  var len = buf.length;
+  var sum = 0;
+  var flipped = false;
+  for (var i = len - 1; i > -1; i--) {
+    var byte = Number(buf[i]);
+    var f;
+    if (flipped) {
+      f = onesComp(byte);
+    } else if (byte === 0) {
+      f = byte;
+    } else {
+      flipped = true;
+      f = twosComp(byte);
+    }
+    if (f !== 0) {
+      sum -= f * Math.pow(256, len - i - 1);
+    }
+  }
+  return sum;
+};
+var pos = (buf) => {
+  var len = buf.length;
+  var sum = 0;
+  for (var i = len - 1; i > -1; i--) {
+    var byte = Number(buf[i]);
+    if (byte !== 0) {
+      sum += byte * Math.pow(256, len - i - 1);
+    }
+  }
+  return sum;
+};
+var onesComp = (byte) => (255 ^ byte) & 255;
+var twosComp = (byte) => (255 ^ byte) + 1 & 255;
+
+// node_modules/tar/dist/esm/types.js
+var isCode = (c) => name.has(c);
+var name = /* @__PURE__ */ new Map([
+  ["0", "File"],
+  // same as File
+  ["", "OldFile"],
+  ["1", "Link"],
+  ["2", "SymbolicLink"],
+  // Devices and FIFOs aren't fully supported
+  // they are parsed, but skipped when unpacking
+  ["3", "CharacterDevice"],
+  ["4", "BlockDevice"],
+  ["5", "Directory"],
+  ["6", "FIFO"],
+  // same as File
+  ["7", "ContiguousFile"],
+  // pax headers
+  ["g", "GlobalExtendedHeader"],
+  ["x", "ExtendedHeader"],
+  // vendor-specific stuff
+  // skip
+  ["A", "SolarisACL"],
+  // like 5, but with data, which should be skipped
+  ["D", "GNUDumpDir"],
+  // metadata only, skip
+  ["I", "Inode"],
+  // data = link path of next file
+  ["K", "NextFileHasLongLinkpath"],
+  // data = path of next file
+  ["L", "NextFileHasLongPath"],
+  // skip
+  ["M", "ContinuationFile"],
+  // like L
+  ["N", "OldGnuLongPath"],
+  // skip
+  ["S", "SparseFile"],
+  // skip
+  ["V", "TapeVolumeHeader"],
+  // like x
+  ["X", "OldExtendedHeader"]
+]);
+var code = new Map(Array.from(name).map((kv) => [kv[1], kv[0]]));
+
+// node_modules/tar/dist/esm/header.js
+var _type, _Header_instances, slurp_fn;
+var Header = class {
+  constructor(data, off = 0, ex, gex) {
+    __privateAdd(this, _Header_instances);
+    __publicField(this, "cksumValid", false);
+    __publicField(this, "needPax", false);
+    __publicField(this, "nullBlock", false);
+    __publicField(this, "block");
+    __publicField(this, "path");
+    __publicField(this, "mode");
+    __publicField(this, "uid");
+    __publicField(this, "gid");
+    __publicField(this, "size");
+    __publicField(this, "cksum");
+    __privateAdd(this, _type, "Unsupported");
+    __publicField(this, "linkpath");
+    __publicField(this, "uname");
+    __publicField(this, "gname");
+    __publicField(this, "devmaj", 0);
+    __publicField(this, "devmin", 0);
+    __publicField(this, "atime");
+    __publicField(this, "ctime");
+    __publicField(this, "mtime");
+    __publicField(this, "charset");
+    __publicField(this, "comment");
+    if (Buffer.isBuffer(data)) {
+      this.decode(data, off || 0, ex, gex);
+    } else if (data) {
+      __privateMethod(this, _Header_instances, slurp_fn).call(this, data);
+    }
+  }
+  decode(buf, off, ex, gex) {
+    if (!off) {
+      off = 0;
+    }
+    if (!buf || !(buf.length >= off + 512)) {
+      throw new Error("need 512 bytes for header");
+    }
+    this.path = decString(buf, off, 100);
+    this.mode = decNumber(buf, off + 100, 8);
+    this.uid = decNumber(buf, off + 108, 8);
+    this.gid = decNumber(buf, off + 116, 8);
+    this.size = decNumber(buf, off + 124, 12);
+    this.mtime = decDate(buf, off + 136, 12);
+    this.cksum = decNumber(buf, off + 148, 12);
+    if (gex)
+      __privateMethod(this, _Header_instances, slurp_fn).call(this, gex, true);
+    if (ex)
+      __privateMethod(this, _Header_instances, slurp_fn).call(this, ex);
+    const t = decString(buf, off + 156, 1);
+    if (isCode(t)) {
+      __privateSet(this, _type, t || "0");
+    }
+    if (__privateGet(this, _type) === "0" && this.path.slice(-1) === "/") {
+      __privateSet(this, _type, "5");
+    }
+    if (__privateGet(this, _type) === "5") {
+      this.size = 0;
+    }
+    this.linkpath = decString(buf, off + 157, 100);
+    if (buf.subarray(off + 257, off + 265).toString() === "ustar\x0000") {
+      this.uname = decString(buf, off + 265, 32);
+      this.gname = decString(buf, off + 297, 32);
+      this.devmaj = decNumber(buf, off + 329, 8) ?? 0;
+      this.devmin = decNumber(buf, off + 337, 8) ?? 0;
+      if (buf[off + 475] !== 0) {
+        const prefix2 = decString(buf, off + 345, 155);
+        this.path = prefix2 + "/" + this.path;
+      } else {
+        const prefix2 = decString(buf, off + 345, 130);
+        if (prefix2) {
+          this.path = prefix2 + "/" + this.path;
+        }
+        this.atime = decDate(buf, off + 476, 12);
+        this.ctime = decDate(buf, off + 488, 12);
+      }
+    }
+    let sum = 8 * 32;
+    for (let i = off; i < off + 148; i++) {
+      sum += buf[i];
+    }
+    for (let i = off + 156; i < off + 512; i++) {
+      sum += buf[i];
+    }
+    this.cksumValid = sum === this.cksum;
+    if (this.cksum === void 0 && sum === 8 * 32) {
+      this.nullBlock = true;
+    }
+  }
+  encode(buf, off = 0) {
+    if (!buf) {
+      buf = this.block = Buffer.alloc(512);
+    }
+    if (__privateGet(this, _type) === "Unsupported") {
+      __privateSet(this, _type, "0");
+    }
+    if (!(buf.length >= off + 512)) {
+      throw new Error("need 512 bytes for header");
+    }
+    const prefixSize = this.ctime || this.atime ? 130 : 155;
+    const split = splitPrefix(this.path || "", prefixSize);
+    const path15 = split[0];
+    const prefix2 = split[1];
+    this.needPax = !!split[2];
+    this.needPax = encString(buf, off, 100, path15) || this.needPax;
+    this.needPax = encNumber(buf, off + 100, 8, this.mode) || this.needPax;
+    this.needPax = encNumber(buf, off + 108, 8, this.uid) || this.needPax;
+    this.needPax = encNumber(buf, off + 116, 8, this.gid) || this.needPax;
+    this.needPax = encNumber(buf, off + 124, 12, this.size) || this.needPax;
+    this.needPax = encDate(buf, off + 136, 12, this.mtime) || this.needPax;
+    buf[off + 156] = __privateGet(this, _type).charCodeAt(0);
+    this.needPax = encString(buf, off + 157, 100, this.linkpath) || this.needPax;
+    buf.write("ustar\x0000", off + 257, 8);
+    this.needPax = encString(buf, off + 265, 32, this.uname) || this.needPax;
+    this.needPax = encString(buf, off + 297, 32, this.gname) || this.needPax;
+    this.needPax = encNumber(buf, off + 329, 8, this.devmaj) || this.needPax;
+    this.needPax = encNumber(buf, off + 337, 8, this.devmin) || this.needPax;
+    this.needPax = encString(buf, off + 345, prefixSize, prefix2) || this.needPax;
+    if (buf[off + 475] !== 0) {
+      this.needPax = encString(buf, off + 345, 155, prefix2) || this.needPax;
+    } else {
+      this.needPax = encString(buf, off + 345, 130, prefix2) || this.needPax;
+      this.needPax = encDate(buf, off + 476, 12, this.atime) || this.needPax;
+      this.needPax = encDate(buf, off + 488, 12, this.ctime) || this.needPax;
+    }
+    let sum = 8 * 32;
+    for (let i = off; i < off + 148; i++) {
+      sum += buf[i];
+    }
+    for (let i = off + 156; i < off + 512; i++) {
+      sum += buf[i];
+    }
+    this.cksum = sum;
+    encNumber(buf, off + 148, 8, this.cksum);
+    this.cksumValid = true;
+    return this.needPax;
   }
-  self.length++;
-}
-var Node2 = class {
-  list;
-  next;
-  prev;
-  value;
-  constructor(value, prev, next, list2) {
-    this.list = list2;
-    this.value = value;
-    if (prev) {
-      prev.next = this;
-      this.prev = prev;
+  get type() {
+    return __privateGet(this, _type) === "Unsupported" ? __privateGet(this, _type) : name.get(__privateGet(this, _type));
+  }
+  get typeKey() {
+    return __privateGet(this, _type);
+  }
+  set type(type) {
+    const c = String(code.get(type));
+    if (isCode(c) || c === "Unsupported") {
+      __privateSet(this, _type, c);
+    } else if (isCode(type)) {
+      __privateSet(this, _type, type);
     } else {
-      this.prev = void 0;
+      throw new TypeError("invalid entry type: " + type);
+    }
+  }
+};
+_type = new WeakMap();
+_Header_instances = new WeakSet();
+slurp_fn = function(ex, gex = false) {
+  Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
+    return !(v === null || v === void 0 || k === "path" && gex || k === "linkpath" && gex || k === "global");
+  })));
+};
+var splitPrefix = (p, prefixSize) => {
+  const pathSize = 100;
+  let pp = p;
+  let prefix2 = "";
+  let ret = void 0;
+  const root = pathModule.parse(p).root || ".";
+  if (Buffer.byteLength(pp) < pathSize) {
+    ret = [pp, prefix2, false];
+  } else {
+    prefix2 = pathModule.dirname(pp);
+    pp = pathModule.basename(pp);
+    do {
+      if (Buffer.byteLength(pp) <= pathSize && Buffer.byteLength(prefix2) <= prefixSize) {
+        ret = [pp, prefix2, false];
+      } else if (Buffer.byteLength(pp) > pathSize && Buffer.byteLength(prefix2) <= prefixSize) {
+        ret = [pp.slice(0, pathSize - 1), prefix2, true];
+      } else {
+        pp = pathModule.join(pathModule.basename(prefix2), pp);
+        prefix2 = pathModule.dirname(prefix2);
+      }
+    } while (prefix2 !== root && ret === void 0);
+    if (!ret) {
+      ret = [p.slice(0, pathSize - 1), "", true];
+    }
+  }
+  return ret;
+};
+var decString = (buf, off, size) => buf.subarray(off, off + size).toString("utf8").replace(/\0.*/, "");
+var decDate = (buf, off, size) => numToDate(decNumber(buf, off, size));
+var numToDate = (num) => num === void 0 ? void 0 : new Date(num * 1e3);
+var decNumber = (buf, off, size) => Number(buf[off]) & 128 ? parse2(buf.subarray(off, off + size)) : decSmallNumber(buf, off, size);
+var nanUndef = (value) => isNaN(value) ? void 0 : value;
+var decSmallNumber = (buf, off, size) => nanUndef(parseInt(buf.subarray(off, off + size).toString("utf8").replace(/\0.*$/, "").trim(), 8));
+var MAXNUM = {
+  12: 8589934591,
+  8: 2097151
+};
+var encNumber = (buf, off, size, num) => num === void 0 ? false : num > MAXNUM[size] || num < 0 ? (encode(num, buf.subarray(off, off + size)), true) : (encSmallNumber(buf, off, size, num), false);
+var encSmallNumber = (buf, off, size, num) => buf.write(octalString(num, size), off, size, "ascii");
+var octalString = (num, size) => padOctal(Math.floor(num).toString(8), size);
+var padOctal = (str, size) => (str.length === size - 1 ? str : new Array(size - str.length - 1).join("0") + str + " ") + "\0";
+var encDate = (buf, off, size, date) => date === void 0 ? false : encNumber(buf, off, size, date.getTime() / 1e3);
+var NULLS = new Array(156).join("\0");
+var encString = (buf, off, size, str) => str === void 0 ? false : (buf.write(str + NULLS, off, size, "utf8"), str.length !== Buffer.byteLength(str) || str.length > size);
+
+// node_modules/tar/dist/esm/pax.js
+import { basename } from "path";
+var Pax = class _Pax {
+  atime;
+  mtime;
+  ctime;
+  charset;
+  comment;
+  gid;
+  uid;
+  gname;
+  uname;
+  linkpath;
+  dev;
+  ino;
+  nlink;
+  path;
+  size;
+  mode;
+  global;
+  constructor(obj, global = false) {
+    this.atime = obj.atime;
+    this.charset = obj.charset;
+    this.comment = obj.comment;
+    this.ctime = obj.ctime;
+    this.dev = obj.dev;
+    this.gid = obj.gid;
+    this.global = global;
+    this.gname = obj.gname;
+    this.ino = obj.ino;
+    this.linkpath = obj.linkpath;
+    this.mtime = obj.mtime;
+    this.nlink = obj.nlink;
+    this.path = obj.path;
+    this.size = obj.size;
+    this.uid = obj.uid;
+    this.uname = obj.uname;
+  }
+  encode() {
+    const body = this.encodeBody();
+    if (body === "") {
+      return Buffer.allocUnsafe(0);
+    }
+    const bodyLen = Buffer.byteLength(body);
+    const bufLen = 512 * Math.ceil(1 + bodyLen / 512);
+    const buf = Buffer.allocUnsafe(bufLen);
+    for (let i = 0; i < 512; i++) {
+      buf[i] = 0;
+    }
+    new Header({
+      // XXX split the path
+      // then the path should be PaxHeader + basename, but less than 99,
+      // prepend with the dirname
+      /* c8 ignore start */
+      path: ("PaxHeader/" + basename(this.path ?? "")).slice(0, 99),
+      /* c8 ignore stop */
+      mode: this.mode || 420,
+      uid: this.uid,
+      gid: this.gid,
+      size: bodyLen,
+      mtime: this.mtime,
+      type: this.global ? "GlobalExtendedHeader" : "ExtendedHeader",
+      linkpath: "",
+      uname: this.uname || "",
+      gname: this.gname || "",
+      devmaj: 0,
+      devmin: 0,
+      atime: this.atime,
+      ctime: this.ctime
+    }).encode(buf);
+    buf.write(body, 512, bodyLen, "utf8");
+    for (let i = bodyLen + 512; i < buf.length; i++) {
+      buf[i] = 0;
     }
-    if (next) {
-      next.prev = this;
-      this.next = next;
-    } else {
-      this.next = void 0;
+    return buf;
+  }
+  encodeBody() {
+    return this.encodeField("path") + this.encodeField("ctime") + this.encodeField("atime") + this.encodeField("dev") + this.encodeField("ino") + this.encodeField("nlink") + this.encodeField("charset") + this.encodeField("comment") + this.encodeField("gid") + this.encodeField("gname") + this.encodeField("linkpath") + this.encodeField("mtime") + this.encodeField("size") + this.encodeField("uid") + this.encodeField("uname");
+  }
+  encodeField(field) {
+    if (this[field] === void 0) {
+      return "";
+    }
+    const r = this[field];
+    const v = r instanceof Date ? r.getTime() / 1e3 : r;
+    const s = " " + (field === "dev" || field === "ino" || field === "nlink" ? "SCHILY." : "") + field + "=" + v + "\n";
+    const byteLen = Buffer.byteLength(s);
+    let digits = Math.floor(Math.log(byteLen) / Math.log(10)) + 1;
+    if (byteLen + digits >= Math.pow(10, digits)) {
+      digits += 1;
     }
+    const len = digits + byteLen;
+    return len + s;
   }
-};
-
-// node_modules/tar/dist/esm/header.js
-import { posix as pathModule } from "path";
-
-// node_modules/tar/dist/esm/large-numbers.js
-var encode = (num, buf) => {
-  if (!Number.isSafeInteger(num)) {
-    throw Error("cannot encode number outside of javascript safe integer range");
-  } else if (num < 0) {
-    encodeNegative(num, buf);
-  } else {
-    encodePositive(num, buf);
+  static parse(str, ex, g = false) {
+    return new _Pax(merge(parseKV(str), ex), g);
   }
-  return buf;
 };
-var encodePositive = (num, buf) => {
-  buf[0] = 128;
-  for (var i = buf.length; i > 1; i--) {
-    buf[i - 1] = num & 255;
-    num = Math.floor(num / 256);
+var merge = (a, b) => b ? Object.assign({}, b, a) : a;
+var parseKV = (str) => str.replace(/\n$/, "").split("\n").reduce(parseKVLine, /* @__PURE__ */ Object.create(null));
+var parseKVLine = (set, line) => {
+  const n = parseInt(line, 10);
+  if (n !== Buffer.byteLength(line) + 1) {
+    return set;
+  }
+  line = line.slice((n + " ").length);
+  const kv = line.split("=");
+  const r = kv.shift();
+  if (!r) {
+    return set;
   }
+  const k = r.replace(/^SCHILY\.(dev|ino|nlink)/, "$1");
+  const v = kv.join("=");
+  set[k] = /^([A-Z]+\.)?([mac]|birth|creation)time$/.test(k) ? new Date(Number(v) * 1e3) : /^[0-9]+$/.test(v) ? +v : v;
+  return set;
 };
-var encodeNegative = (num, buf) => {
-  buf[0] = 255;
-  var flipped = false;
-  num = num * -1;
-  for (var i = buf.length; i > 1; i--) {
-    var byte = num & 255;
-    num = Math.floor(num / 256);
-    if (flipped) {
-      buf[i - 1] = onesComp(byte);
-    } else if (byte === 0) {
-      buf[i - 1] = 0;
-    } else {
-      flipped = true;
-      buf[i - 1] = twosComp(byte);
-    }
+
+// node_modules/tar/node_modules/minipass/dist/esm/index.js
+import { EventEmitter as EventEmitter3 } from "events";
+import Stream3 from "stream";
+import { StringDecoder as StringDecoder3 } from "string_decoder";
+var proc3 = typeof process === "object" && process ? process : {
+  stdout: null,
+  stderr: null
+};
+var isStream3 = (s) => !!s && typeof s === "object" && (s instanceof Minipass3 || s instanceof Stream3 || isReadable3(s) || isWritable3(s));
+var isReadable3 = (s) => !!s && typeof s === "object" && s instanceof EventEmitter3 && typeof s.pipe === "function" && // node core Writable streams have a pipe() method, but it throws
+s.pipe !== Stream3.Writable.prototype.pipe;
+var isWritable3 = (s) => !!s && typeof s === "object" && s instanceof EventEmitter3 && typeof s.write === "function" && typeof s.end === "function";
+var EOF3 = Symbol("EOF");
+var MAYBE_EMIT_END3 = Symbol("maybeEmitEnd");
+var EMITTED_END3 = Symbol("emittedEnd");
+var EMITTING_END3 = Symbol("emittingEnd");
+var EMITTED_ERROR3 = Symbol("emittedError");
+var CLOSED3 = Symbol("closed");
+var READ3 = Symbol("read");
+var FLUSH3 = Symbol("flush");
+var FLUSHCHUNK3 = Symbol("flushChunk");
+var ENCODING3 = Symbol("encoding");
+var DECODER3 = Symbol("decoder");
+var FLOWING3 = Symbol("flowing");
+var PAUSED3 = Symbol("paused");
+var RESUME3 = Symbol("resume");
+var BUFFER3 = Symbol("buffer");
+var PIPES3 = Symbol("pipes");
+var BUFFERLENGTH3 = Symbol("bufferLength");
+var BUFFERPUSH3 = Symbol("bufferPush");
+var BUFFERSHIFT3 = Symbol("bufferShift");
+var OBJECTMODE3 = Symbol("objectMode");
+var DESTROYED3 = Symbol("destroyed");
+var ERROR3 = Symbol("error");
+var EMITDATA3 = Symbol("emitData");
+var EMITEND4 = Symbol("emitEnd");
+var EMITEND23 = Symbol("emitEnd2");
+var ASYNC3 = Symbol("async");
+var ABORT3 = Symbol("abort");
+var ABORTED3 = Symbol("aborted");
+var SIGNAL3 = Symbol("signal");
+var DATALISTENERS3 = Symbol("dataListeners");
+var DISCARDED3 = Symbol("discarded");
+var defer3 = (fn) => Promise.resolve().then(fn);
+var nodefer3 = (fn) => fn();
+var isEndish3 = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
+var isArrayBufferLike3 = (b) => b instanceof ArrayBuffer || !!b && typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
+var isArrayBufferView3 = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
+var Pipe3 = class {
+  src;
+  dest;
+  opts;
+  ondrain;
+  constructor(src, dest, opts) {
+    this.src = src;
+    this.dest = dest;
+    this.opts = opts;
+    this.ondrain = () => src[RESUME3]();
+    this.dest.on("drain", this.ondrain);
+  }
+  unpipe() {
+    this.dest.removeListener("drain", this.ondrain);
+  }
+  // only here for the prototype
+  /* c8 ignore start */
+  proxyErrors(_er) {
+  }
+  /* c8 ignore stop */
+  end() {
+    this.unpipe();
+    if (this.opts.end)
+      this.dest.end();
   }
 };
-var parse2 = (buf) => {
-  const pre = buf[0];
-  const value = pre === 128 ? pos(buf.subarray(1, buf.length)) : pre === 255 ? twos(buf) : null;
-  if (value === null) {
-    throw Error("invalid base256 encoding");
+var PipeProxyErrors3 = class extends Pipe3 {
+  unpipe() {
+    this.src.removeListener("error", this.proxyErrors);
+    super.unpipe();
   }
-  if (!Number.isSafeInteger(value)) {
-    throw Error("parsed number outside of javascript safe integer range");
+  constructor(src, dest, opts) {
+    super(src, dest, opts);
+    this.proxyErrors = (er) => dest.emit("error", er);
+    src.on("error", this.proxyErrors);
   }
-  return value;
 };
-var twos = (buf) => {
-  var len = buf.length;
-  var sum = 0;
-  var flipped = false;
-  for (var i = len - 1; i > -1; i--) {
-    var byte = Number(buf[i]);
-    var f;
-    if (flipped) {
-      f = onesComp(byte);
-    } else if (byte === 0) {
-      f = byte;
+var isObjectModeOptions3 = (o) => !!o.objectMode;
+var isEncodingOptions3 = (o) => !o.objectMode && !!o.encoding && o.encoding !== "buffer";
+var Minipass3 = class extends EventEmitter3 {
+  [FLOWING3] = false;
+  [PAUSED3] = false;
+  [PIPES3] = [];
+  [BUFFER3] = [];
+  [OBJECTMODE3];
+  [ENCODING3];
+  [ASYNC3];
+  [DECODER3];
+  [EOF3] = false;
+  [EMITTED_END3] = false;
+  [EMITTING_END3] = false;
+  [CLOSED3] = false;
+  [EMITTED_ERROR3] = null;
+  [BUFFERLENGTH3] = 0;
+  [DESTROYED3] = false;
+  [SIGNAL3];
+  [ABORTED3] = false;
+  [DATALISTENERS3] = 0;
+  [DISCARDED3] = false;
+  /**
+   * true if the stream can be written
+   */
+  writable = true;
+  /**
+   * true if the stream can be read
+   */
+  readable = true;
+  /**
+   * If `RType` is Buffer, then options do not need to be provided.
+   * Otherwise, an options object must be provided to specify either
+   * {@link Minipass.SharedOptions.objectMode} or
+   * {@link Minipass.SharedOptions.encoding}, as appropriate.
+   */
+  constructor(...args) {
+    const options = args[0] || {};
+    super();
+    if (options.objectMode && typeof options.encoding === "string") {
+      throw new TypeError("Encoding and objectMode may not be used together");
+    }
+    if (isObjectModeOptions3(options)) {
+      this[OBJECTMODE3] = true;
+      this[ENCODING3] = null;
+    } else if (isEncodingOptions3(options)) {
+      this[ENCODING3] = options.encoding;
+      this[OBJECTMODE3] = false;
     } else {
-      flipped = true;
-      f = twosComp(byte);
+      this[OBJECTMODE3] = false;
+      this[ENCODING3] = null;
     }
-    if (f !== 0) {
-      sum -= f * Math.pow(256, len - i - 1);
+    this[ASYNC3] = !!options.async;
+    this[DECODER3] = this[ENCODING3] ? new StringDecoder3(this[ENCODING3]) : null;
+    if (options && options.debugExposeBuffer === true) {
+      Object.defineProperty(this, "buffer", { get: () => this[BUFFER3] });
     }
-  }
-  return sum;
-};
-var pos = (buf) => {
-  var len = buf.length;
-  var sum = 0;
-  for (var i = len - 1; i > -1; i--) {
-    var byte = Number(buf[i]);
-    if (byte !== 0) {
-      sum += byte * Math.pow(256, len - i - 1);
+    if (options && options.debugExposePipes === true) {
+      Object.defineProperty(this, "pipes", { get: () => this[PIPES3] });
     }
-  }
-  return sum;
-};
-var onesComp = (byte) => (255 ^ byte) & 255;
-var twosComp = (byte) => (255 ^ byte) + 1 & 255;
-
-// node_modules/tar/dist/esm/types.js
-var isCode = (c) => name.has(c);
-var name = /* @__PURE__ */ new Map([
-  ["0", "File"],
-  // same as File
-  ["", "OldFile"],
-  ["1", "Link"],
-  ["2", "SymbolicLink"],
-  // Devices and FIFOs aren't fully supported
-  // they are parsed, but skipped when unpacking
-  ["3", "CharacterDevice"],
-  ["4", "BlockDevice"],
-  ["5", "Directory"],
-  ["6", "FIFO"],
-  // same as File
-  ["7", "ContiguousFile"],
-  // pax headers
-  ["g", "GlobalExtendedHeader"],
-  ["x", "ExtendedHeader"],
-  // vendor-specific stuff
-  // skip
-  ["A", "SolarisACL"],
-  // like 5, but with data, which should be skipped
-  ["D", "GNUDumpDir"],
-  // metadata only, skip
-  ["I", "Inode"],
-  // data = link path of next file
-  ["K", "NextFileHasLongLinkpath"],
-  // data = path of next file
-  ["L", "NextFileHasLongPath"],
-  // skip
-  ["M", "ContinuationFile"],
-  // like L
-  ["N", "OldGnuLongPath"],
-  // skip
-  ["S", "SparseFile"],
-  // skip
-  ["V", "TapeVolumeHeader"],
-  // like x
-  ["X", "OldExtendedHeader"]
-]);
-var code = new Map(Array.from(name).map((kv) => [kv[1], kv[0]]));
-
-// node_modules/tar/dist/esm/header.js
-var _type, _Header_instances, slurp_fn;
-var Header = class {
-  constructor(data, off = 0, ex, gex) {
-    __privateAdd(this, _Header_instances);
-    __publicField(this, "cksumValid", false);
-    __publicField(this, "needPax", false);
-    __publicField(this, "nullBlock", false);
-    __publicField(this, "block");
-    __publicField(this, "path");
-    __publicField(this, "mode");
-    __publicField(this, "uid");
-    __publicField(this, "gid");
-    __publicField(this, "size");
-    __publicField(this, "cksum");
-    __privateAdd(this, _type, "Unsupported");
-    __publicField(this, "linkpath");
-    __publicField(this, "uname");
-    __publicField(this, "gname");
-    __publicField(this, "devmaj", 0);
-    __publicField(this, "devmin", 0);
-    __publicField(this, "atime");
-    __publicField(this, "ctime");
-    __publicField(this, "mtime");
-    __publicField(this, "charset");
-    __publicField(this, "comment");
-    if (Buffer.isBuffer(data)) {
-      this.decode(data, off || 0, ex, gex);
-    } else if (data) {
-      __privateMethod(this, _Header_instances, slurp_fn).call(this, data);
+    const { signal } = options;
+    if (signal) {
+      this[SIGNAL3] = signal;
+      if (signal.aborted) {
+        this[ABORT3]();
+      } else {
+        signal.addEventListener("abort", () => this[ABORT3]());
+      }
     }
   }
-  decode(buf, off, ex, gex) {
-    if (!off) {
-      off = 0;
+  /**
+   * The amount of data stored in the buffer waiting to be read.
+   *
+   * For Buffer strings, this will be the total byte length.
+   * For string encoding streams, this will be the string character length,
+   * according to JavaScript's `string.length` logic.
+   * For objectMode streams, this is a count of the items waiting to be
+   * emitted.
+   */
+  get bufferLength() {
+    return this[BUFFERLENGTH3];
+  }
+  /**
+   * The `BufferEncoding` currently in use, or `null`
+   */
+  get encoding() {
+    return this[ENCODING3];
+  }
+  /**
+   * @deprecated - This is a read only property
+   */
+  set encoding(_enc) {
+    throw new Error("Encoding must be set at instantiation time");
+  }
+  /**
+   * @deprecated - Encoding may only be set at instantiation time
+   */
+  setEncoding(_enc) {
+    throw new Error("Encoding must be set at instantiation time");
+  }
+  /**
+   * True if this is an objectMode stream
+   */
+  get objectMode() {
+    return this[OBJECTMODE3];
+  }
+  /**
+   * @deprecated - This is a read-only property
+   */
+  set objectMode(_om) {
+    throw new Error("objectMode must be set at instantiation time");
+  }
+  /**
+   * true if this is an async stream
+   */
+  get ["async"]() {
+    return this[ASYNC3];
+  }
+  /**
+   * Set to true to make this stream async.
+   *
+   * Once set, it cannot be unset, as this would potentially cause incorrect
+   * behavior.  Ie, a sync stream can be made async, but an async stream
+   * cannot be safely made sync.
+   */
+  set ["async"](a) {
+    this[ASYNC3] = this[ASYNC3] || !!a;
+  }
+  // drop everything and get out of the flow completely
+  [ABORT3]() {
+    var _a, _b;
+    this[ABORTED3] = true;
+    this.emit("abort", (_a = this[SIGNAL3]) == null ? void 0 : _a.reason);
+    this.destroy((_b = this[SIGNAL3]) == null ? void 0 : _b.reason);
+  }
+  /**
+   * True if the stream has been aborted.
+   */
+  get aborted() {
+    return this[ABORTED3];
+  }
+  /**
+   * No-op setter. Stream aborted status is set via the AbortSignal provided
+   * in the constructor options.
+   */
+  set aborted(_) {
+  }
+  write(chunk, encoding, cb) {
+    var _a;
+    if (this[ABORTED3])
+      return false;
+    if (this[EOF3])
+      throw new Error("write after end");
+    if (this[DESTROYED3]) {
+      this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" }));
+      return true;
     }
-    if (!buf || !(buf.length >= off + 512)) {
-      throw new Error("need 512 bytes for header");
+    if (typeof encoding === "function") {
+      cb = encoding;
+      encoding = "utf8";
     }
-    this.path = decString(buf, off, 100);
-    this.mode = decNumber(buf, off + 100, 8);
-    this.uid = decNumber(buf, off + 108, 8);
-    this.gid = decNumber(buf, off + 116, 8);
-    this.size = decNumber(buf, off + 124, 12);
-    this.mtime = decDate(buf, off + 136, 12);
-    this.cksum = decNumber(buf, off + 148, 12);
-    if (gex)
-      __privateMethod(this, _Header_instances, slurp_fn).call(this, gex, true);
-    if (ex)
-      __privateMethod(this, _Header_instances, slurp_fn).call(this, ex);
-    const t = decString(buf, off + 156, 1);
-    if (isCode(t)) {
-      __privateSet(this, _type, t || "0");
+    if (!encoding)
+      encoding = "utf8";
+    const fn = this[ASYNC3] ? defer3 : nodefer3;
+    if (!this[OBJECTMODE3] && !Buffer.isBuffer(chunk)) {
+      if (isArrayBufferView3(chunk)) {
+        chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+      } else if (isArrayBufferLike3(chunk)) {
+        chunk = Buffer.from(chunk);
+      } else if (typeof chunk !== "string") {
+        throw new Error("Non-contiguous data written to non-objectMode stream");
+      }
     }
-    if (__privateGet(this, _type) === "0" && this.path.slice(-1) === "/") {
-      __privateSet(this, _type, "5");
+    if (this[OBJECTMODE3]) {
+      if (this[FLOWING3] && this[BUFFERLENGTH3] !== 0)
+        this[FLUSH3](true);
+      if (this[FLOWING3])
+        this.emit("data", chunk);
+      else
+        this[BUFFERPUSH3](chunk);
+      if (this[BUFFERLENGTH3] !== 0)
+        this.emit("readable");
+      if (cb)
+        fn(cb);
+      return this[FLOWING3];
     }
-    if (__privateGet(this, _type) === "5") {
-      this.size = 0;
+    if (!chunk.length) {
+      if (this[BUFFERLENGTH3] !== 0)
+        this.emit("readable");
+      if (cb)
+        fn(cb);
+      return this[FLOWING3];
     }
-    this.linkpath = decString(buf, off + 157, 100);
-    if (buf.subarray(off + 257, off + 265).toString() === "ustar\x0000") {
-      this.uname = decString(buf, off + 265, 32);
-      this.gname = decString(buf, off + 297, 32);
-      this.devmaj = decNumber(buf, off + 329, 8) ?? 0;
-      this.devmin = decNumber(buf, off + 337, 8) ?? 0;
-      if (buf[off + 475] !== 0) {
-        const prefix2 = decString(buf, off + 345, 155);
-        this.path = prefix2 + "/" + this.path;
-      } else {
-        const prefix2 = decString(buf, off + 345, 130);
-        if (prefix2) {
-          this.path = prefix2 + "/" + this.path;
-        }
-        this.atime = decDate(buf, off + 476, 12);
-        this.ctime = decDate(buf, off + 488, 12);
-      }
+    if (typeof chunk === "string" && // unless it is a string already ready for us to use
+    !(encoding === this[ENCODING3] && !((_a = this[DECODER3]) == null ? void 0 : _a.lastNeed))) {
+      chunk = Buffer.from(chunk, encoding);
     }
-    let sum = 8 * 32;
-    for (let i = off; i < off + 148; i++) {
-      sum += buf[i];
+    if (Buffer.isBuffer(chunk) && this[ENCODING3]) {
+      chunk = this[DECODER3].write(chunk);
     }
-    for (let i = off + 156; i < off + 512; i++) {
-      sum += buf[i];
+    if (this[FLOWING3] && this[BUFFERLENGTH3] !== 0)
+      this[FLUSH3](true);
+    if (this[FLOWING3])
+      this.emit("data", chunk);
+    else
+      this[BUFFERPUSH3](chunk);
+    if (this[BUFFERLENGTH3] !== 0)
+      this.emit("readable");
+    if (cb)
+      fn(cb);
+    return this[FLOWING3];
+  }
+  /**
+   * Low-level explicit read method.
+   *
+   * In objectMode, the argument is ignored, and one item is returned if
+   * available.
+   *
+   * `n` is the number of bytes (or in the case of encoding streams,
+   * characters) to consume. If `n` is not provided, then the entire buffer
+   * is returned, or `null` is returned if no data is available.
+   *
+   * If `n` is greater that the amount of data in the internal buffer,
+   * then `null` is returned.
+   */
+  read(n) {
+    if (this[DESTROYED3])
+      return null;
+    this[DISCARDED3] = false;
+    if (this[BUFFERLENGTH3] === 0 || n === 0 || n && n > this[BUFFERLENGTH3]) {
+      this[MAYBE_EMIT_END3]();
+      return null;
     }
-    this.cksumValid = sum === this.cksum;
-    if (this.cksum === void 0 && sum === 8 * 32) {
-      this.nullBlock = true;
+    if (this[OBJECTMODE3])
+      n = null;
+    if (this[BUFFER3].length > 1 && !this[OBJECTMODE3]) {
+      this[BUFFER3] = [
+        this[ENCODING3] ? this[BUFFER3].join("") : Buffer.concat(this[BUFFER3], this[BUFFERLENGTH3])
+      ];
     }
+    const ret = this[READ3](n || null, this[BUFFER3][0]);
+    this[MAYBE_EMIT_END3]();
+    return ret;
   }
-  encode(buf, off = 0) {
-    if (!buf) {
-      buf = this.block = Buffer.alloc(512);
+  [READ3](n, chunk) {
+    if (this[OBJECTMODE3])
+      this[BUFFERSHIFT3]();
+    else {
+      const c = chunk;
+      if (n === c.length || n === null)
+        this[BUFFERSHIFT3]();
+      else if (typeof c === "string") {
+        this[BUFFER3][0] = c.slice(n);
+        chunk = c.slice(0, n);
+        this[BUFFERLENGTH3] -= n;
+      } else {
+        this[BUFFER3][0] = c.subarray(n);
+        chunk = c.subarray(0, n);
+        this[BUFFERLENGTH3] -= n;
+      }
     }
-    if (__privateGet(this, _type) === "Unsupported") {
-      __privateSet(this, _type, "0");
+    this.emit("data", chunk);
+    if (!this[BUFFER3].length && !this[EOF3])
+      this.emit("drain");
+    return chunk;
+  }
+  end(chunk, encoding, cb) {
+    if (typeof chunk === "function") {
+      cb = chunk;
+      chunk = void 0;
     }
-    if (!(buf.length >= off + 512)) {
-      throw new Error("need 512 bytes for header");
+    if (typeof encoding === "function") {
+      cb = encoding;
+      encoding = "utf8";
     }
-    const prefixSize = this.ctime || this.atime ? 130 : 155;
-    const split = splitPrefix(this.path || "", prefixSize);
-    const path15 = split[0];
-    const prefix2 = split[1];
-    this.needPax = !!split[2];
-    this.needPax = encString(buf, off, 100, path15) || this.needPax;
-    this.needPax = encNumber(buf, off + 100, 8, this.mode) || this.needPax;
-    this.needPax = encNumber(buf, off + 108, 8, this.uid) || this.needPax;
-    this.needPax = encNumber(buf, off + 116, 8, this.gid) || this.needPax;
-    this.needPax = encNumber(buf, off + 124, 12, this.size) || this.needPax;
-    this.needPax = encDate(buf, off + 136, 12, this.mtime) || this.needPax;
-    buf[off + 156] = __privateGet(this, _type).charCodeAt(0);
-    this.needPax = encString(buf, off + 157, 100, this.linkpath) || this.needPax;
-    buf.write("ustar\x0000", off + 257, 8);
-    this.needPax = encString(buf, off + 265, 32, this.uname) || this.needPax;
-    this.needPax = encString(buf, off + 297, 32, this.gname) || this.needPax;
-    this.needPax = encNumber(buf, off + 329, 8, this.devmaj) || this.needPax;
-    this.needPax = encNumber(buf, off + 337, 8, this.devmin) || this.needPax;
-    this.needPax = encString(buf, off + 345, prefixSize, prefix2) || this.needPax;
-    if (buf[off + 475] !== 0) {
-      this.needPax = encString(buf, off + 345, 155, prefix2) || this.needPax;
+    if (chunk !== void 0)
+      this.write(chunk, encoding);
+    if (cb)
+      this.once("end", cb);
+    this[EOF3] = true;
+    this.writable = false;
+    if (this[FLOWING3] || !this[PAUSED3])
+      this[MAYBE_EMIT_END3]();
+    return this;
+  }
+  // don't let the internal resume be overwritten
+  [RESUME3]() {
+    if (this[DESTROYED3])
+      return;
+    if (!this[DATALISTENERS3] && !this[PIPES3].length) {
+      this[DISCARDED3] = true;
+    }
+    this[PAUSED3] = false;
+    this[FLOWING3] = true;
+    this.emit("resume");
+    if (this[BUFFER3].length)
+      this[FLUSH3]();
+    else if (this[EOF3])
+      this[MAYBE_EMIT_END3]();
+    else
+      this.emit("drain");
+  }
+  /**
+   * Resume the stream if it is currently in a paused state
+   *
+   * If called when there are no pipe destinations or `data` event listeners,
+   * this will place the stream in a "discarded" state, where all data will
+   * be thrown away. The discarded state is removed if a pipe destination or
+   * data handler is added, if pause() is called, or if any synchronous or
+   * asynchronous iteration is started.
+   */
+  resume() {
+    return this[RESUME3]();
+  }
+  /**
+   * Pause the stream
+   */
+  pause() {
+    this[FLOWING3] = false;
+    this[PAUSED3] = true;
+    this[DISCARDED3] = false;
+  }
+  /**
+   * true if the stream has been forcibly destroyed
+   */
+  get destroyed() {
+    return this[DESTROYED3];
+  }
+  /**
+   * true if the stream is currently in a flowing state, meaning that
+   * any writes will be immediately emitted.
+   */
+  get flowing() {
+    return this[FLOWING3];
+  }
+  /**
+   * true if the stream is currently in a paused state
+   */
+  get paused() {
+    return this[PAUSED3];
+  }
+  [BUFFERPUSH3](chunk) {
+    if (this[OBJECTMODE3])
+      this[BUFFERLENGTH3] += 1;
+    else
+      this[BUFFERLENGTH3] += chunk.length;
+    this[BUFFER3].push(chunk);
+  }
+  [BUFFERSHIFT3]() {
+    if (this[OBJECTMODE3])
+      this[BUFFERLENGTH3] -= 1;
+    else
+      this[BUFFERLENGTH3] -= this[BUFFER3][0].length;
+    return this[BUFFER3].shift();
+  }
+  [FLUSH3](noDrain = false) {
+    do {
+    } while (this[FLUSHCHUNK3](this[BUFFERSHIFT3]()) && this[BUFFER3].length);
+    if (!noDrain && !this[BUFFER3].length && !this[EOF3])
+      this.emit("drain");
+  }
+  [FLUSHCHUNK3](chunk) {
+    this.emit("data", chunk);
+    return this[FLOWING3];
+  }
+  /**
+   * Pipe all data emitted by this stream into the destination provided.
+   *
+   * Triggers the flow of data.
+   */
+  pipe(dest, opts) {
+    if (this[DESTROYED3])
+      return dest;
+    this[DISCARDED3] = false;
+    const ended = this[EMITTED_END3];
+    opts = opts || {};
+    if (dest === proc3.stdout || dest === proc3.stderr)
+      opts.end = false;
+    else
+      opts.end = opts.end !== false;
+    opts.proxyErrors = !!opts.proxyErrors;
+    if (ended) {
+      if (opts.end)
+        dest.end();
     } else {
-      this.needPax = encString(buf, off + 345, 130, prefix2) || this.needPax;
-      this.needPax = encDate(buf, off + 476, 12, this.atime) || this.needPax;
-      this.needPax = encDate(buf, off + 488, 12, this.ctime) || this.needPax;
-    }
-    let sum = 8 * 32;
-    for (let i = off; i < off + 148; i++) {
-      sum += buf[i];
+      this[PIPES3].push(!opts.proxyErrors ? new Pipe3(this, dest, opts) : new PipeProxyErrors3(this, dest, opts));
+      if (this[ASYNC3])
+        defer3(() => this[RESUME3]());
+      else
+        this[RESUME3]();
     }
-    for (let i = off + 156; i < off + 512; i++) {
-      sum += buf[i];
+    return dest;
+  }
+  /**
+   * Fully unhook a piped destination stream.
+   *
+   * If the destination stream was the only consumer of this stream (ie,
+   * there are no other piped destinations or `'data'` event listeners)
+   * then the flow of data will stop until there is another consumer or
+   * {@link Minipass#resume} is explicitly called.
+   */
+  unpipe(dest) {
+    const p = this[PIPES3].find((p2) => p2.dest === dest);
+    if (p) {
+      if (this[PIPES3].length === 1) {
+        if (this[FLOWING3] && this[DATALISTENERS3] === 0) {
+          this[FLOWING3] = false;
+        }
+        this[PIPES3] = [];
+      } else
+        this[PIPES3].splice(this[PIPES3].indexOf(p), 1);
+      p.unpipe();
     }
-    this.cksum = sum;
-    encNumber(buf, off + 148, 8, this.cksum);
-    this.cksumValid = true;
-    return this.needPax;
   }
-  get type() {
-    return __privateGet(this, _type) === "Unsupported" ? __privateGet(this, _type) : name.get(__privateGet(this, _type));
+  /**
+   * Alias for {@link Minipass#on}
+   */
+  addListener(ev, handler) {
+    return this.on(ev, handler);
   }
-  get typeKey() {
-    return __privateGet(this, _type);
+  /**
+   * Mostly identical to `EventEmitter.on`, with the following
+   * behavior differences to prevent data loss and unnecessary hangs:
+   *
+   * - Adding a 'data' event handler will trigger the flow of data
+   *
+   * - Adding a 'readable' event handler when there is data waiting to be read
+   *   will cause 'readable' to be emitted immediately.
+   *
+   * - Adding an 'endish' event handler ('end', 'finish', etc.) which has
+   *   already passed will cause the event to be emitted immediately and all
+   *   handlers removed.
+   *
+   * - Adding an 'error' event handler after an error has been emitted will
+   *   cause the event to be re-emitted immediately with the error previously
+   *   raised.
+   */
+  on(ev, handler) {
+    const ret = super.on(ev, handler);
+    if (ev === "data") {
+      this[DISCARDED3] = false;
+      this[DATALISTENERS3]++;
+      if (!this[PIPES3].length && !this[FLOWING3]) {
+        this[RESUME3]();
+      }
+    } else if (ev === "readable" && this[BUFFERLENGTH3] !== 0) {
+      super.emit("readable");
+    } else if (isEndish3(ev) && this[EMITTED_END3]) {
+      super.emit(ev);
+      this.removeAllListeners(ev);
+    } else if (ev === "error" && this[EMITTED_ERROR3]) {
+      const h = handler;
+      if (this[ASYNC3])
+        defer3(() => h.call(this, this[EMITTED_ERROR3]));
+      else
+        h.call(this, this[EMITTED_ERROR3]);
+    }
+    return ret;
   }
-  set type(type) {
-    const c = String(code.get(type));
-    if (isCode(c) || c === "Unsupported") {
-      __privateSet(this, _type, c);
-    } else if (isCode(type)) {
-      __privateSet(this, _type, type);
-    } else {
-      throw new TypeError("invalid entry type: " + type);
+  /**
+   * Alias for {@link Minipass#off}
+   */
+  removeListener(ev, handler) {
+    return this.off(ev, handler);
+  }
+  /**
+   * Mostly identical to `EventEmitter.off`
+   *
+   * If a 'data' event handler is removed, and it was the last consumer
+   * (ie, there are no pipe destinations or other 'data' event listeners),
+   * then the flow of data will stop until there is another consumer or
+   * {@link Minipass#resume} is explicitly called.
+   */
+  off(ev, handler) {
+    const ret = super.off(ev, handler);
+    if (ev === "data") {
+      this[DATALISTENERS3] = this.listeners("data").length;
+      if (this[DATALISTENERS3] === 0 && !this[DISCARDED3] && !this[PIPES3].length) {
+        this[FLOWING3] = false;
+      }
     }
+    return ret;
   }
-};
-_type = new WeakMap();
-_Header_instances = new WeakSet();
-slurp_fn = function(ex, gex = false) {
-  Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
-    return !(v === null || v === void 0 || k === "path" && gex || k === "linkpath" && gex || k === "global");
-  })));
-};
-var splitPrefix = (p, prefixSize) => {
-  const pathSize = 100;
-  let pp = p;
-  let prefix2 = "";
-  let ret = void 0;
-  const root = pathModule.parse(p).root || ".";
-  if (Buffer.byteLength(pp) < pathSize) {
-    ret = [pp, prefix2, false];
-  } else {
-    prefix2 = pathModule.dirname(pp);
-    pp = pathModule.basename(pp);
-    do {
-      if (Buffer.byteLength(pp) <= pathSize && Buffer.byteLength(prefix2) <= prefixSize) {
-        ret = [pp, prefix2, false];
-      } else if (Buffer.byteLength(pp) > pathSize && Buffer.byteLength(prefix2) <= prefixSize) {
-        ret = [pp.slice(0, pathSize - 1), prefix2, true];
-      } else {
-        pp = pathModule.join(pathModule.basename(prefix2), pp);
-        prefix2 = pathModule.dirname(prefix2);
+  /**
+   * Mostly identical to `EventEmitter.removeAllListeners`
+   *
+   * If all 'data' event handlers are removed, and they were the last consumer
+   * (ie, there are no pipe destinations), then the flow of data will stop
+   * until there is another consumer or {@link Minipass#resume} is explicitly
+   * called.
+   */
+  removeAllListeners(ev) {
+    const ret = super.removeAllListeners(ev);
+    if (ev === "data" || ev === void 0) {
+      this[DATALISTENERS3] = 0;
+      if (!this[DISCARDED3] && !this[PIPES3].length) {
+        this[FLOWING3] = false;
       }
-    } while (prefix2 !== root && ret === void 0);
-    if (!ret) {
-      ret = [p.slice(0, pathSize - 1), "", true];
     }
+    return ret;
   }
-  return ret;
-};
-var decString = (buf, off, size) => buf.subarray(off, off + size).toString("utf8").replace(/\0.*/, "");
-var decDate = (buf, off, size) => numToDate(decNumber(buf, off, size));
-var numToDate = (num) => num === void 0 ? void 0 : new Date(num * 1e3);
-var decNumber = (buf, off, size) => Number(buf[off]) & 128 ? parse2(buf.subarray(off, off + size)) : decSmallNumber(buf, off, size);
-var nanUndef = (value) => isNaN(value) ? void 0 : value;
-var decSmallNumber = (buf, off, size) => nanUndef(parseInt(buf.subarray(off, off + size).toString("utf8").replace(/\0.*$/, "").trim(), 8));
-var MAXNUM = {
-  12: 8589934591,
-  8: 2097151
-};
-var encNumber = (buf, off, size, num) => num === void 0 ? false : num > MAXNUM[size] || num < 0 ? (encode(num, buf.subarray(off, off + size)), true) : (encSmallNumber(buf, off, size, num), false);
-var encSmallNumber = (buf, off, size, num) => buf.write(octalString(num, size), off, size, "ascii");
-var octalString = (num, size) => padOctal(Math.floor(num).toString(8), size);
-var padOctal = (str, size) => (str.length === size - 1 ? str : new Array(size - str.length - 1).join("0") + str + " ") + "\0";
-var encDate = (buf, off, size, date) => date === void 0 ? false : encNumber(buf, off, size, date.getTime() / 1e3);
-var NULLS = new Array(156).join("\0");
-var encString = (buf, off, size, str) => str === void 0 ? false : (buf.write(str + NULLS, off, size, "utf8"), str.length !== Buffer.byteLength(str) || str.length > size);
-
-// node_modules/tar/dist/esm/pax.js
-import { basename } from "path";
-var Pax = class _Pax {
-  atime;
-  mtime;
-  ctime;
-  charset;
-  comment;
-  gid;
-  uid;
-  gname;
-  uname;
-  linkpath;
-  dev;
-  ino;
-  nlink;
-  path;
-  size;
-  mode;
-  global;
-  constructor(obj, global = false) {
-    this.atime = obj.atime;
-    this.charset = obj.charset;
-    this.comment = obj.comment;
-    this.ctime = obj.ctime;
-    this.dev = obj.dev;
-    this.gid = obj.gid;
-    this.global = global;
-    this.gname = obj.gname;
-    this.ino = obj.ino;
-    this.linkpath = obj.linkpath;
-    this.mtime = obj.mtime;
-    this.nlink = obj.nlink;
-    this.path = obj.path;
-    this.size = obj.size;
-    this.uid = obj.uid;
-    this.uname = obj.uname;
+  /**
+   * true if the 'end' event has been emitted
+   */
+  get emittedEnd() {
+    return this[EMITTED_END3];
+  }
+  [MAYBE_EMIT_END3]() {
+    if (!this[EMITTING_END3] && !this[EMITTED_END3] && !this[DESTROYED3] && this[BUFFER3].length === 0 && this[EOF3]) {
+      this[EMITTING_END3] = true;
+      this.emit("end");
+      this.emit("prefinish");
+      this.emit("finish");
+      if (this[CLOSED3])
+        this.emit("close");
+      this[EMITTING_END3] = false;
+    }
+  }
+  /**
+   * Mostly identical to `EventEmitter.emit`, with the following
+   * behavior differences to prevent data loss and unnecessary hangs:
+   *
+   * If the stream has been destroyed, and the event is something other
+   * than 'close' or 'error', then `false` is returned and no handlers
+   * are called.
+   *
+   * If the event is 'end', and has already been emitted, then the event
+   * is ignored. If the stream is in a paused or non-flowing state, then
+   * the event will be deferred until data flow resumes. If the stream is
+   * async, then handlers will be called on the next tick rather than
+   * immediately.
+   *
+   * If the event is 'close', and 'end' has not yet been emitted, then
+   * the event will be deferred until after 'end' is emitted.
+   *
+   * If the event is 'error', and an AbortSignal was provided for the stream,
+   * and there are no listeners, then the event is ignored, matching the
+   * behavior of node core streams in the presense of an AbortSignal.
+   *
+   * If the event is 'finish' or 'prefinish', then all listeners will be
+   * removed after emitting the event, to prevent double-firing.
+   */
+  emit(ev, ...args) {
+    const data = args[0];
+    if (ev !== "error" && ev !== "close" && ev !== DESTROYED3 && this[DESTROYED3]) {
+      return false;
+    } else if (ev === "data") {
+      return !this[OBJECTMODE3] && !data ? false : this[ASYNC3] ? (defer3(() => this[EMITDATA3](data)), true) : this[EMITDATA3](data);
+    } else if (ev === "end") {
+      return this[EMITEND4]();
+    } else if (ev === "close") {
+      this[CLOSED3] = true;
+      if (!this[EMITTED_END3] && !this[DESTROYED3])
+        return false;
+      const ret2 = super.emit("close");
+      this.removeAllListeners("close");
+      return ret2;
+    } else if (ev === "error") {
+      this[EMITTED_ERROR3] = data;
+      super.emit(ERROR3, data);
+      const ret2 = !this[SIGNAL3] || this.listeners("error").length ? super.emit("error", data) : false;
+      this[MAYBE_EMIT_END3]();
+      return ret2;
+    } else if (ev === "resume") {
+      const ret2 = super.emit("resume");
+      this[MAYBE_EMIT_END3]();
+      return ret2;
+    } else if (ev === "finish" || ev === "prefinish") {
+      const ret2 = super.emit(ev);
+      this.removeAllListeners(ev);
+      return ret2;
+    }
+    const ret = super.emit(ev, ...args);
+    this[MAYBE_EMIT_END3]();
+    return ret;
   }
-  encode() {
-    const body = this.encodeBody();
-    if (body === "") {
-      return Buffer.allocUnsafe(0);
+  [EMITDATA3](data) {
+    for (const p of this[PIPES3]) {
+      if (p.dest.write(data) === false)
+        this.pause();
     }
-    const bodyLen = Buffer.byteLength(body);
-    const bufLen = 512 * Math.ceil(1 + bodyLen / 512);
-    const buf = Buffer.allocUnsafe(bufLen);
-    for (let i = 0; i < 512; i++) {
-      buf[i] = 0;
+    const ret = this[DISCARDED3] ? false : super.emit("data", data);
+    this[MAYBE_EMIT_END3]();
+    return ret;
+  }
+  [EMITEND4]() {
+    if (this[EMITTED_END3])
+      return false;
+    this[EMITTED_END3] = true;
+    this.readable = false;
+    return this[ASYNC3] ? (defer3(() => this[EMITEND23]()), true) : this[EMITEND23]();
+  }
+  [EMITEND23]() {
+    if (this[DECODER3]) {
+      const data = this[DECODER3].end();
+      if (data) {
+        for (const p of this[PIPES3]) {
+          p.dest.write(data);
+        }
+        if (!this[DISCARDED3])
+          super.emit("data", data);
+      }
     }
-    new Header({
-      // XXX split the path
-      // then the path should be PaxHeader + basename, but less than 99,
-      // prepend with the dirname
-      /* c8 ignore start */
-      path: ("PaxHeader/" + basename(this.path ?? "")).slice(0, 99),
-      /* c8 ignore stop */
-      mode: this.mode || 420,
-      uid: this.uid,
-      gid: this.gid,
-      size: bodyLen,
-      mtime: this.mtime,
-      type: this.global ? "GlobalExtendedHeader" : "ExtendedHeader",
-      linkpath: "",
-      uname: this.uname || "",
-      gname: this.gname || "",
-      devmaj: 0,
-      devmin: 0,
-      atime: this.atime,
-      ctime: this.ctime
-    }).encode(buf);
-    buf.write(body, 512, bodyLen, "utf8");
-    for (let i = bodyLen + 512; i < buf.length; i++) {
-      buf[i] = 0;
+    for (const p of this[PIPES3]) {
+      p.end();
     }
-    return buf;
+    const ret = super.emit("end");
+    this.removeAllListeners("end");
+    return ret;
   }
-  encodeBody() {
-    return this.encodeField("path") + this.encodeField("ctime") + this.encodeField("atime") + this.encodeField("dev") + this.encodeField("ino") + this.encodeField("nlink") + this.encodeField("charset") + this.encodeField("comment") + this.encodeField("gid") + this.encodeField("gname") + this.encodeField("linkpath") + this.encodeField("mtime") + this.encodeField("size") + this.encodeField("uid") + this.encodeField("uname");
+  /**
+   * Return a Promise that resolves to an array of all emitted data once
+   * the stream ends.
+   */
+  async collect() {
+    const buf = Object.assign([], {
+      dataLength: 0
+    });
+    if (!this[OBJECTMODE3])
+      buf.dataLength = 0;
+    const p = this.promise();
+    this.on("data", (c) => {
+      buf.push(c);
+      if (!this[OBJECTMODE3])
+        buf.dataLength += c.length;
+    });
+    await p;
+    return buf;
   }
-  encodeField(field) {
-    if (this[field] === void 0) {
-      return "";
-    }
-    const r = this[field];
-    const v = r instanceof Date ? r.getTime() / 1e3 : r;
-    const s = " " + (field === "dev" || field === "ino" || field === "nlink" ? "SCHILY." : "") + field + "=" + v + "\n";
-    const byteLen = Buffer.byteLength(s);
-    let digits = Math.floor(Math.log(byteLen) / Math.log(10)) + 1;
-    if (byteLen + digits >= Math.pow(10, digits)) {
-      digits += 1;
+  /**
+   * Return a Promise that resolves to the concatenation of all emitted data
+   * once the stream ends.
+   *
+   * Not allowed on objectMode streams.
+   */
+  async concat() {
+    if (this[OBJECTMODE3]) {
+      throw new Error("cannot concat in objectMode");
     }
-    const len = digits + byteLen;
-    return len + s;
+    const buf = await this.collect();
+    return this[ENCODING3] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
-  static parse(str, ex, g = false) {
-    return new _Pax(merge(parseKV(str), ex), g);
+  /**
+   * Return a void Promise that resolves once the stream ends.
+   */
+  async promise() {
+    return new Promise((resolve2, reject) => {
+      this.on(DESTROYED3, () => reject(new Error("stream destroyed")));
+      this.on("error", (er) => reject(er));
+      this.on("end", () => resolve2());
+    });
   }
-};
-var merge = (a, b) => b ? Object.assign({}, b, a) : a;
-var parseKV = (str) => str.replace(/\n$/, "").split("\n").reduce(parseKVLine, /* @__PURE__ */ Object.create(null));
-var parseKVLine = (set, line) => {
-  const n = parseInt(line, 10);
-  if (n !== Buffer.byteLength(line) + 1) {
-    return set;
+  /**
+   * Asynchronous `for await of` iteration.
+   *
+   * This will continue emitting all chunks until the stream terminates.
+   */
+  [Symbol.asyncIterator]() {
+    this[DISCARDED3] = false;
+    let stopped = false;
+    const stop = async () => {
+      this.pause();
+      stopped = true;
+      return { value: void 0, done: true };
+    };
+    const next = () => {
+      if (stopped)
+        return stop();
+      const res = this.read();
+      if (res !== null)
+        return Promise.resolve({ done: false, value: res });
+      if (this[EOF3])
+        return stop();
+      let resolve2;
+      let reject;
+      const onerr = (er) => {
+        this.off("data", ondata);
+        this.off("end", onend);
+        this.off(DESTROYED3, ondestroy);
+        stop();
+        reject(er);
+      };
+      const ondata = (value) => {
+        this.off("error", onerr);
+        this.off("end", onend);
+        this.off(DESTROYED3, ondestroy);
+        this.pause();
+        resolve2({ value, done: !!this[EOF3] });
+      };
+      const onend = () => {
+        this.off("error", onerr);
+        this.off("data", ondata);
+        this.off(DESTROYED3, ondestroy);
+        stop();
+        resolve2({ done: true, value: void 0 });
+      };
+      const ondestroy = () => onerr(new Error("stream destroyed"));
+      return new Promise((res2, rej) => {
+        reject = rej;
+        resolve2 = res2;
+        this.once(DESTROYED3, ondestroy);
+        this.once("error", onerr);
+        this.once("end", onend);
+        this.once("data", ondata);
+      });
+    };
+    return {
+      next,
+      throw: stop,
+      return: stop,
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
   }
-  line = line.slice((n + " ").length);
-  const kv = line.split("=");
-  const r = kv.shift();
-  if (!r) {
-    return set;
+  /**
+   * Synchronous `for of` iteration.
+   *
+   * The iteration will terminate when the internal buffer runs out, even
+   * if the stream has not yet terminated.
+   */
+  [Symbol.iterator]() {
+    this[DISCARDED3] = false;
+    let stopped = false;
+    const stop = () => {
+      this.pause();
+      this.off(ERROR3, stop);
+      this.off(DESTROYED3, stop);
+      this.off("end", stop);
+      stopped = true;
+      return { done: true, value: void 0 };
+    };
+    const next = () => {
+      if (stopped)
+        return stop();
+      const value = this.read();
+      return value === null ? stop() : { done: false, value };
+    };
+    this.once("end", stop);
+    this.once(ERROR3, stop);
+    this.once(DESTROYED3, stop);
+    return {
+      next,
+      throw: stop,
+      return: stop,
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  }
+  /**
+   * Destroy a stream, preventing it from being used for any further purpose.
+   *
+   * If the stream has a `close()` method, then it will be called on
+   * destruction.
+   *
+   * After destruction, any attempt to write data, read data, or emit most
+   * events will be ignored.
+   *
+   * If an error argument is provided, then it will be emitted in an
+   * 'error' event.
+   */
+  destroy(er) {
+    if (this[DESTROYED3]) {
+      if (er)
+        this.emit("error", er);
+      else
+        this.emit(DESTROYED3);
+      return this;
+    }
+    this[DESTROYED3] = true;
+    this[DISCARDED3] = true;
+    this[BUFFER3].length = 0;
+    this[BUFFERLENGTH3] = 0;
+    const wc = this;
+    if (typeof wc.close === "function" && !this[CLOSED3])
+      wc.close();
+    if (er)
+      this.emit("error", er);
+    else
+      this.emit(DESTROYED3);
+    return this;
+  }
+  /**
+   * Alias for {@link isStream}
+   *
+   * Former export location, maintained for backwards compatibility.
+   *
+   * @deprecated
+   */
+  static get isStream() {
+    return isStream3;
   }
-  const k = r.replace(/^SCHILY\.(dev|ino|nlink)/, "$1");
-  const v = kv.join("=");
-  set[k] = /^([A-Z]+\.)?([mac]|birth|creation)time$/.test(k) ? new Date(Number(v) * 1e3) : /^[0-9]+$/.test(v) ? +v : v;
-  return set;
 };
 
 // node_modules/tar/dist/esm/normalize-windows-path.js
@@ -10125,7 +11895,7 @@ var normalizeWindowsPath = platform !== "win32" ? (p) => p : (p) => p && p.repla
 
 // node_modules/tar/dist/esm/read-entry.js
 var _ReadEntry_instances, slurp_fn2;
-var ReadEntry = class extends Minipass {
+var ReadEntry = class extends Minipass3 {
   constructor(header, ex, gex) {
     super({});
     __privateAdd(this, _ReadEntry_instances);
@@ -10278,7 +12048,7 @@ var EX = Symbol("extendedHeader");
 var GEX = Symbol("globalExtendedHeader");
 var META = Symbol("meta");
 var EMITMETA = Symbol("emitMeta");
-var BUFFER2 = Symbol("buffer");
+var BUFFER4 = Symbol("buffer");
 var QUEUE = Symbol("queue");
 var ENDED = Symbol("ended");
 var EMITTEDEND = Symbol("emittedEnd");
@@ -10293,7 +12063,7 @@ var CONSUMING = Symbol("consuming");
 var BUFFERCONCAT = Symbol("bufferConcat");
 var MAYBEEND = Symbol("maybeEnd");
 var WRITING = Symbol("writing");
-var ABORTED2 = Symbol("aborted");
+var ABORTED4 = Symbol("aborted");
 var DONE = Symbol("onDone");
 var SAW_VALID_ENTRY = Symbol("sawValidEntry");
 var SAW_NULL_BLOCK = Symbol("sawNullBlock");
@@ -10309,7 +12079,7 @@ var Parser = class extends EE2 {
   writable = true;
   readable = false;
   [QUEUE] = new Yallist();
-  [BUFFER2];
+  [BUFFER4];
   [READENTRY];
   [WRITEENTRY];
   [STATE] = "begin";
@@ -10318,7 +12088,7 @@ var Parser = class extends EE2 {
   [GEX];
   [ENDED] = false;
   [UNZIP];
-  [ABORTED2] = false;
+  [ABORTED4] = false;
   [SAW_VALID_ENTRY];
   [SAW_NULL_BLOCK] = false;
   [SAW_EOF] = false;
@@ -10541,7 +12311,7 @@ var Parser = class extends EE2 {
     }
   }
   abort(error) {
-    this[ABORTED2] = true;
+    this[ABORTED4] = true;
     this.emit("abort", error);
     this.warn("TAR_ABORT", error, { recoverable: false });
   }
@@ -10558,18 +12328,18 @@ var Parser = class extends EE2 {
         typeof encoding === "string" ? encoding : "utf8"
       );
     }
-    if (this[ABORTED2]) {
+    if (this[ABORTED4]) {
       cb == null ? void 0 : cb();
       return false;
     }
     const needSniff = this[UNZIP] === void 0 || this.brotli === void 0 && this[UNZIP] === false;
     if (needSniff && chunk) {
-      if (this[BUFFER2]) {
-        chunk = Buffer.concat([this[BUFFER2], chunk]);
-        this[BUFFER2] = void 0;
+      if (this[BUFFER4]) {
+        chunk = Buffer.concat([this[BUFFER4], chunk]);
+        this[BUFFER4] = void 0;
       }
       if (chunk.length < gzipHeader.length) {
-        this[BUFFER2] = chunk;
+        this[BUFFER4] = chunk;
         cb == null ? void 0 : cb();
         return true;
       }
@@ -10584,7 +12354,7 @@ var Parser = class extends EE2 {
           if (this[ENDED]) {
             this.brotli = true;
           } else {
-            this[BUFFER2] = chunk;
+            this[BUFFER4] = chunk;
             cb == null ? void 0 : cb();
             return true;
           }
@@ -10629,19 +12399,19 @@ var Parser = class extends EE2 {
     return ret;
   }
   [BUFFERCONCAT](c) {
-    if (c && !this[ABORTED2]) {
-      this[BUFFER2] = this[BUFFER2] ? Buffer.concat([this[BUFFER2], c]) : c;
+    if (c && !this[ABORTED4]) {
+      this[BUFFER4] = this[BUFFER4] ? Buffer.concat([this[BUFFER4], c]) : c;
     }
   }
   [MAYBEEND]() {
-    if (this[ENDED] && !this[EMITTEDEND] && !this[ABORTED2] && !this[CONSUMING]) {
+    if (this[ENDED] && !this[EMITTEDEND] && !this[ABORTED4] && !this[CONSUMING]) {
       this[EMITTEDEND] = true;
       const entry = this[WRITEENTRY];
       if (entry && entry.blockRemain) {
-        const have = this[BUFFER2] ? this[BUFFER2].length : 0;
+        const have = this[BUFFER4] ? this[BUFFER4].length : 0;
         this.warn("TAR_BAD_ARCHIVE", `Truncated input (needed ${entry.blockRemain} more bytes, only ${have} available)`, { entry });
-        if (this[BUFFER2]) {
-          entry.write(this[BUFFER2]);
+        if (this[BUFFER4]) {
+          entry.write(this[BUFFER4]);
         }
         entry.end();
       }
@@ -10652,33 +12422,33 @@ var Parser = class extends EE2 {
     var _a;
     if (this[CONSUMING] && chunk) {
       this[BUFFERCONCAT](chunk);
-    } else if (!chunk && !this[BUFFER2]) {
+    } else if (!chunk && !this[BUFFER4]) {
       this[MAYBEEND]();
     } else if (chunk) {
       this[CONSUMING] = true;
-      if (this[BUFFER2]) {
+      if (this[BUFFER4]) {
         this[BUFFERCONCAT](chunk);
-        const c = this[BUFFER2];
-        this[BUFFER2] = void 0;
+        const c = this[BUFFER4];
+        this[BUFFER4] = void 0;
         this[CONSUMECHUNKSUB](c);
       } else {
         this[CONSUMECHUNKSUB](chunk);
       }
-      while (this[BUFFER2] && ((_a = this[BUFFER2]) == null ? void 0 : _a.length) >= 512 && !this[ABORTED2] && !this[SAW_EOF]) {
-        const c = this[BUFFER2];
-        this[BUFFER2] = void 0;
+      while (this[BUFFER4] && ((_a = this[BUFFER4]) == null ? void 0 : _a.length) >= 512 && !this[ABORTED4] && !this[SAW_EOF]) {
+        const c = this[BUFFER4];
+        this[BUFFER4] = void 0;
         this[CONSUMECHUNKSUB](c);
       }
       this[CONSUMING] = false;
     }
-    if (!this[BUFFER2] || this[ENDED]) {
+    if (!this[BUFFER4] || this[ENDED]) {
       this[MAYBEEND]();
     }
   }
   [CONSUMECHUNKSUB](chunk) {
     let position = 0;
     const length = chunk.length;
-    while (position + 512 <= length && !this[ABORTED2] && !this[SAW_EOF]) {
+    while (position + 512 <= length && !this[ABORTED4] && !this[SAW_EOF]) {
       switch (this[STATE]) {
         case "begin":
         case "header":
@@ -10698,13 +12468,13 @@ var Parser = class extends EE2 {
       }
     }
     if (position < length) {
-      if (this[BUFFER2]) {
-        this[BUFFER2] = Buffer.concat([
+      if (this[BUFFER4]) {
+        this[BUFFER4] = Buffer.concat([
           chunk.subarray(position),
-          this[BUFFER2]
+          this[BUFFER4]
         ]);
       } else {
-        this[BUFFER2] = chunk.subarray(position);
+        this[BUFFER4] = chunk.subarray(position);
       }
     }
   }
@@ -10723,7 +12493,7 @@ var Parser = class extends EE2 {
     }
     if (cb)
       this.once("finish", cb);
-    if (!this[ABORTED2]) {
+    if (!this[ABORTED4]) {
       if (this[UNZIP]) {
         if (chunk)
           this[UNZIP].write(chunk);
@@ -10904,7 +12674,7 @@ var DIRECTORY = Symbol("directory");
 var SYMLINK = Symbol("symlink");
 var HARDLINK = Symbol("hardlink");
 var HEADER = Symbol("header");
-var READ2 = Symbol("read");
+var READ4 = Symbol("read");
 var LSTAT = Symbol("lstat");
 var ONLSTAT = Symbol("onlstat");
 var ONREAD = Symbol("onread");
@@ -10917,7 +12687,7 @@ var AWAITDRAIN = Symbol("awaitDrain");
 var ONDRAIN = Symbol("ondrain");
 var PREFIX = Symbol("prefix");
 var _hadError;
-var WriteEntry = class extends Minipass {
+var WriteEntry = class extends Minipass3 {
   constructor(p, opt_ = {}) {
     const opt = dealias(opt_);
     super();
@@ -11168,9 +12938,9 @@ var WriteEntry = class extends Minipass {
     this.pos = 0;
     this.remain = this.stat.size;
     this.length = this.buf.length;
-    this[READ2]();
+    this[READ4]();
   }
-  [READ2]() {
+  [READ4]() {
     const { fd, buf, offset, length, pos: pos2 } = this;
     if (fd === void 0 || buf === void 0) {
       throw new Error("cannot read file without first opening");
@@ -11261,7 +13031,7 @@ var WriteEntry = class extends Minipass {
       this.offset = 0;
     }
     this.length = this.buf.length - this.offset;
-    this[READ2]();
+    this[READ4]();
   }
 };
 _hadError = new WeakMap();
@@ -11276,7 +13046,7 @@ var WriteEntrySync = class extends WriteEntry {
   [OPENFILE]() {
     this[ONOPENFILE](fs4.openSync(this.absolute, "r"));
   }
-  [READ2]() {
+  [READ4]() {
     let threw = true;
     try {
       const { fd, buf, offset, length, pos: pos2 } = this;
@@ -11307,7 +13077,7 @@ var WriteEntrySync = class extends WriteEntry {
     cb();
   }
 };
-var WriteEntryTar = class extends Minipass {
+var WriteEntryTar = class extends Minipass3 {
   blockLen = 0;
   blockRemain = 0;
   buf = 0;
@@ -11487,7 +13257,7 @@ var PackJob = class {
     this.absolute = absolute;
   }
 };
-var EOF2 = Buffer.alloc(1024);
+var EOF4 = Buffer.alloc(1024);
 var ONSTAT = Symbol("onStat");
 var ENDED2 = Symbol("ended");
 var QUEUE2 = Symbol("queue");
@@ -11508,7 +13278,7 @@ var ENTRYOPT = Symbol("entryOpt");
 var WRITEENTRYCLASS = Symbol("writeEntryClass");
 var WRITE = Symbol("write");
 var ONDRAIN2 = Symbol("ondrain");
-var Pack = class extends Minipass {
+var Pack = class extends Minipass3 {
   opt;
   cwd;
   maxReadSize;
@@ -11703,9 +13473,9 @@ var Pack = class extends Minipass {
     this[PROCESSING] = false;
     if (this[ENDED2] && !this[QUEUE2].length && this[JOBS] === 0) {
       if (this.zip) {
-        this.zip.end(EOF2);
+        this.zip.end(EOF4);
       } else {
-        super.write(EOF2);
+        super.write(EOF4);
         super.end();
       }
     }