@malloy-publisher/server 0.0.198-dev2 → 0.0.198-dev3

package/dist/server.mjs

@@ -196773,2295 +196773,1640 @@ var require_dist10 = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/adm-zip/util/constants.js
-var require_constants24 = __commonJS((exports, module) => {
-  module.exports = {
-    LOCHDR: 30,
-    LOCSIG: 67324752,
-    LOCVER: 4,
-    LOCFLG: 6,
-    LOCHOW: 8,
-    LOCTIM: 10,
-    LOCCRC: 14,
-    LOCSIZ: 18,
-    LOCLEN: 22,
-    LOCNAM: 26,
-    LOCEXT: 28,
-    EXTSIG: 134695760,
-    EXTHDR: 16,
-    EXTCRC: 4,
-    EXTSIZ: 8,
-    EXTLEN: 12,
-    CENHDR: 46,
-    CENSIG: 33639248,
-    CENVEM: 4,
-    CENVER: 6,
-    CENFLG: 8,
-    CENHOW: 10,
-    CENTIM: 12,
-    CENCRC: 16,
-    CENSIZ: 20,
-    CENLEN: 24,
-    CENNAM: 28,
-    CENEXT: 30,
-    CENCOM: 32,
-    CENDSK: 34,
-    CENATT: 36,
-    CENATX: 38,
-    CENOFF: 42,
-    ENDHDR: 22,
-    ENDSIG: 101010256,
-    ENDSUB: 8,
-    ENDTOT: 10,
-    ENDSIZ: 12,
-    ENDOFF: 16,
-    ENDCOM: 20,
-    END64HDR: 20,
-    END64SIG: 117853008,
-    END64START: 4,
-    END64OFF: 8,
-    END64NUMDISKS: 16,
-    ZIP64SIG: 101075792,
-    ZIP64HDR: 56,
-    ZIP64LEAD: 12,
-    ZIP64SIZE: 4,
-    ZIP64VEM: 12,
-    ZIP64VER: 14,
-    ZIP64DSK: 16,
-    ZIP64DSKDIR: 20,
-    ZIP64SUB: 24,
-    ZIP64TOT: 32,
-    ZIP64SIZB: 40,
-    ZIP64OFF: 48,
-    ZIP64EXTRA: 56,
-    STORED: 0,
-    SHRUNK: 1,
-    REDUCED1: 2,
-    REDUCED2: 3,
-    REDUCED3: 4,
-    REDUCED4: 5,
-    IMPLODED: 6,
-    DEFLATED: 8,
-    ENHANCED_DEFLATED: 9,
-    PKWARE: 10,
-    BZIP2: 12,
-    LZMA: 14,
-    IBM_TERSE: 18,
-    IBM_LZ77: 19,
-    AES_ENCRYPT: 99,
-    FLG_ENC: 1,
-    FLG_COMP1: 2,
-    FLG_COMP2: 4,
-    FLG_DESC: 8,
-    FLG_ENH: 16,
-    FLG_PATCH: 32,
-    FLG_STR: 64,
-    FLG_EFS: 2048,
-    FLG_MSK: 4096,
-    FILE: 2,
-    BUFFER: 1,
-    NONE: 0,
-    EF_ID: 0,
-    EF_SIZE: 2,
-    ID_ZIP64: 1,
-    ID_AVINFO: 7,
-    ID_PFS: 8,
-    ID_OS2: 9,
-    ID_NTFS: 10,
-    ID_OPENVMS: 12,
-    ID_UNIX: 13,
-    ID_FORK: 14,
-    ID_PATCH: 15,
-    ID_X509_PKCS7: 20,
-    ID_X509_CERTID_F: 21,
-    ID_X509_CERTID_C: 22,
-    ID_STRONGENC: 23,
-    ID_RECORD_MGT: 24,
-    ID_X509_PKCS7_RL: 25,
-    ID_IBM1: 101,
-    ID_IBM2: 102,
-    ID_POSZIP: 18064,
-    EF_ZIP64_OR_32: 4294967295,
-    EF_ZIP64_OR_16: 65535,
-    EF_ZIP64_SUNCOMP: 0,
-    EF_ZIP64_SCOMP: 8,
-    EF_ZIP64_RHO: 16,
-    EF_ZIP64_DSN: 24
-  };
-});
-
-// ../../node_modules/adm-zip/util/errors.js
-var require_errors6 = __commonJS((exports) => {
-  var errors2 = {
-    INVALID_LOC: "Invalid LOC header (bad signature)",
-    INVALID_CEN: "Invalid CEN header (bad signature)",
-    INVALID_END: "Invalid END header (bad signature)",
-    DESCRIPTOR_NOT_EXIST: "No descriptor present",
-    DESCRIPTOR_UNKNOWN: "Unknown descriptor format",
-    DESCRIPTOR_FAULTY: "Descriptor data is malformed",
-    NO_DATA: "Nothing to decompress",
-    BAD_CRC: "CRC32 checksum failed {0}",
-    FILE_IN_THE_WAY: "There is a file in the way: {0}",
-    UNKNOWN_METHOD: "Invalid/unsupported compression method",
-    AVAIL_DATA: "inflate::Available inflate data did not terminate",
-    INVALID_DISTANCE: "inflate::Invalid literal/length or distance code in fixed or dynamic block",
-    TO_MANY_CODES: "inflate::Dynamic block code description: too many length or distance codes",
-    INVALID_REPEAT_LEN: "inflate::Dynamic block code description: repeat more than specified lengths",
-    INVALID_REPEAT_FIRST: "inflate::Dynamic block code description: repeat lengths with no first length",
-    INCOMPLETE_CODES: "inflate::Dynamic block code description: code lengths codes incomplete",
-    INVALID_DYN_DISTANCE: "inflate::Dynamic block code description: invalid distance code lengths",
-    INVALID_CODES_LEN: "inflate::Dynamic block code description: invalid literal/length code lengths",
-    INVALID_STORE_BLOCK: "inflate::Stored block length did not match one's complement",
-    INVALID_BLOCK_TYPE: "inflate::Invalid block type (type == 3)",
-    CANT_EXTRACT_FILE: "Could not extract the file",
-    CANT_OVERRIDE: "Target file already exists",
-    DISK_ENTRY_TOO_LARGE: "Number of disk entries is too large",
-    NO_ZIP: "No zip file was loaded",
-    NO_ENTRY: "Entry doesn't exist",
-    DIRECTORY_CONTENT_ERROR: "A directory cannot have content",
-    FILE_NOT_FOUND: 'File not found: "{0}"',
-    NOT_IMPLEMENTED: "Not implemented",
-    INVALID_FILENAME: "Invalid filename",
-    INVALID_FORMAT: "Invalid or unsupported zip format. No END header found",
-    INVALID_PASS_PARAM: "Incompatible password parameter",
-    WRONG_PASSWORD: "Wrong Password",
-    COMMENT_TOO_LONG: "Comment is too long",
-    EXTRA_FIELD_PARSE_ERROR: "Extra field parsing error"
-  };
-  function E(message) {
-    return function(...args) {
-      if (args.length) {
-        message = message.replace(/\{(\d)\}/g, (_, n) => args[n] || "");
-      }
-      return new Error("ADM-ZIP: " + message);
+// ../../node_modules/pump/index.js
+var require_pump = __commonJS((exports, module) => {
+  var once = require_once2();
+  var eos = require_end_of_stream4();
+  var fs2;
+  try {
+    fs2 = __require("fs");
+  } catch (e) {}
+  var noop2 = function() {};
+  var ancient = typeof process === "undefined" ? false : /^v?\.0/.test(process.version);
+  var isFn = function(fn) {
+    return typeof fn === "function";
+  };
+  var isFS = function(stream4) {
+    if (!ancient)
+      return false;
+    if (!fs2)
+      return false;
+    return (stream4 instanceof (fs2.ReadStream || noop2) || stream4 instanceof (fs2.WriteStream || noop2)) && isFn(stream4.close);
+  };
+  var isRequest2 = function(stream4) {
+    return stream4.setHeader && isFn(stream4.abort);
+  };
+  var destroyer = function(stream4, reading, writing, callback) {
+    callback = once(callback);
+    var closed = false;
+    stream4.on("close", function() {
+      closed = true;
+    });
+    eos(stream4, { readable: reading, writable: writing }, function(err) {
+      if (err)
+        return callback(err);
+      closed = true;
+      callback();
+    });
+    var destroyed = false;
+    return function(err) {
+      if (closed)
+        return;
+      if (destroyed)
+        return;
+      destroyed = true;
+      if (isFS(stream4))
+        return stream4.close(noop2);
+      if (isRequest2(stream4))
+        return stream4.abort();
+      if (isFn(stream4.destroy))
+        return stream4.destroy();
+      callback(err || new Error("stream was destroyed"));
     };
-  }
-  for (const msg of Object.keys(errors2)) {
-    exports[msg] = E(errors2[msg]);
-  }
+  };
+  var call = function(fn) {
+    fn();
+  };
+  var pipe = function(from, to) {
+    return from.pipe(to);
+  };
+  var pump = function() {
+    var streams = Array.prototype.slice.call(arguments);
+    var callback = isFn(streams[streams.length - 1] || noop2) && streams.pop() || noop2;
+    if (Array.isArray(streams[0]))
+      streams = streams[0];
+    if (streams.length < 2)
+      throw new Error("pump requires two streams per minimum");
+    var error;
+    var destroys = streams.map(function(stream4, i) {
+      var reading = i < streams.length - 1;
+      var writing = i > 0;
+      return destroyer(stream4, reading, writing, function(err) {
+        if (!error)
+          error = err;
+        if (err)
+          destroys.forEach(call);
+        if (reading)
+          return;
+        destroys.forEach(call);
+        callback(error);
+      });
+    });
+    return streams.reduce(pipe);
+  };
+  module.exports = pump;
 });
 
-// ../../node_modules/adm-zip/util/utils.js
-var require_utils74 = __commonJS((exports, module) => {
-  var fsystem = __require("fs");
-  var pth = __require("path");
-  var Constants = require_constants24();
-  var Errors = require_errors6();
-  var isWin = typeof process === "object" && process.platform === "win32";
-  var is_Obj = (obj) => typeof obj === "object" && obj !== null;
-  var crcTable = new Uint32Array(256).map((t, c) => {
-    for (let k = 0;k < 8; k++) {
-      if ((c & 1) !== 0) {
-        c = 3988292384 ^ c >>> 1;
+// ../../node_modules/get-stream/buffer-stream.js
+var require_buffer_stream = __commonJS((exports, module) => {
+  var { PassThrough: PassThroughStream } = __require("stream");
+  module.exports = (options) => {
+    options = { ...options };
+    const { array } = options;
+    let { encoding } = options;
+    const isBuffer2 = encoding === "buffer";
+    let objectMode = false;
+    if (array) {
+      objectMode = !(encoding || isBuffer2);
+    } else {
+      encoding = encoding || "utf8";
+    }
+    if (isBuffer2) {
+      encoding = null;
+    }
+    const stream4 = new PassThroughStream({ objectMode });
+    if (encoding) {
+      stream4.setEncoding(encoding);
+    }
+    let length = 0;
+    const chunks = [];
+    stream4.on("data", (chunk) => {
+      chunks.push(chunk);
+      if (objectMode) {
+        length = chunks.length;
       } else {
-        c >>>= 1;
+        length += chunk.length;
       }
-    }
-    return c >>> 0;
-  });
-  function Utils(opts) {
-    this.sep = pth.sep;
-    this.fs = fsystem;
-    if (is_Obj(opts)) {
-      if (is_Obj(opts.fs) && typeof opts.fs.statSync === "function") {
-        this.fs = opts.fs;
+    });
+    stream4.getBufferedValue = () => {
+      if (array) {
+        return chunks;
       }
+      return isBuffer2 ? Buffer.concat(chunks, length) : chunks.join("");
+    };
+    stream4.getBufferedLength = () => length;
+    return stream4;
+  };
+});
+
+// ../../node_modules/get-stream/index.js
+var require_get_stream = __commonJS((exports, module) => {
+  var { constants: BufferConstants } = __require("buffer");
+  var pump = require_pump();
+  var bufferStream = require_buffer_stream();
+
+  class MaxBufferError extends Error {
+    constructor() {
+      super("maxBuffer exceeded");
+      this.name = "MaxBufferError";
     }
   }
-  module.exports = Utils;
-  Utils.prototype.makeDir = function(folder) {
-    const self2 = this;
-    function mkdirSync(fpath) {
-      let resolvedPath = fpath.split(self2.sep)[0];
-      fpath.split(self2.sep).forEach(function(name) {
-        if (!name || name.substr(-1, 1) === ":")
+  async function getStream(inputStream, options) {
+    if (!inputStream) {
+      return Promise.reject(new Error("Expected a stream"));
+    }
+    options = {
+      maxBuffer: Infinity,
+      ...options
+    };
+    const { maxBuffer } = options;
+    let stream4;
+    await new Promise((resolve3, reject) => {
+      const rejectPromise = (error) => {
+        if (error && stream4.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
+          error.bufferedData = stream4.getBufferedValue();
+        }
+        reject(error);
+      };
+      stream4 = pump(inputStream, bufferStream(options), (error) => {
+        if (error) {
+          rejectPromise(error);
           return;
-        resolvedPath += self2.sep + name;
-        var stat4;
-        try {
-          stat4 = self2.fs.statSync(resolvedPath);
-        } catch (e) {
-          self2.fs.mkdirSync(resolvedPath);
         }
-        if (stat4 && stat4.isFile())
-          throw Errors.FILE_IN_THE_WAY(`"${resolvedPath}"`);
+        resolve3();
       });
+      stream4.on("data", () => {
+        if (stream4.getBufferedLength() > maxBuffer) {
+          rejectPromise(new MaxBufferError);
+        }
+      });
+    });
+    return stream4.getBufferedValue();
+  }
+  module.exports = getStream;
+  module.exports.default = getStream;
+  module.exports.buffer = (stream4, options) => getStream(stream4, { ...options, encoding: "buffer" });
+  module.exports.array = (stream4, options) => getStream(stream4, { ...options, array: true });
+  module.exports.MaxBufferError = MaxBufferError;
+});
+
+// ../../node_modules/pend/index.js
+var require_pend = __commonJS((exports, module) => {
+  module.exports = Pend;
+  function Pend() {
+    this.pending = 0;
+    this.max = Infinity;
+    this.listeners = [];
+    this.waiting = [];
+    this.error = null;
+  }
+  Pend.prototype.go = function(fn) {
+    if (this.pending < this.max) {
+      pendGo(this, fn);
+    } else {
+      this.waiting.push(fn);
     }
-    mkdirSync(folder);
   };
-  Utils.prototype.writeFileTo = function(path3, content, overwrite, attr) {
-    const self2 = this;
-    if (self2.fs.existsSync(path3)) {
-      if (!overwrite)
-        return false;
-      var stat4 = self2.fs.statSync(path3);
-      if (stat4.isDirectory()) {
-        return false;
-      }
-    }
-    var folder = pth.dirname(path3);
-    if (!self2.fs.existsSync(folder)) {
-      self2.makeDir(folder);
-    }
-    var fd;
-    try {
-      fd = self2.fs.openSync(path3, "w", 438);
-    } catch (e) {
-      self2.fs.chmodSync(path3, 438);
-      fd = self2.fs.openSync(path3, "w", 438);
+  Pend.prototype.wait = function(cb) {
+    if (this.pending === 0) {
+      cb(this.error);
+    } else {
+      this.listeners.push(cb);
     }
-    if (fd) {
-      try {
-        self2.fs.writeSync(fd, content, 0, content.length, 0);
-      } finally {
-        self2.fs.closeSync(fd);
+  };
+  Pend.prototype.hold = function() {
+    return pendHold(this);
+  };
+  function pendHold(self2) {
+    self2.pending += 1;
+    var called = false;
+    return onCb;
+    function onCb(err) {
+      if (called)
+        throw new Error("callback called twice");
+      called = true;
+      self2.error = self2.error || err;
+      self2.pending -= 1;
+      if (self2.waiting.length > 0 && self2.pending < self2.max) {
+        pendGo(self2, self2.waiting.shift());
+      } else if (self2.pending === 0) {
+        var listeners = self2.listeners;
+        self2.listeners = [];
+        listeners.forEach(cbListener);
       }
     }
-    self2.fs.chmodSync(path3, attr || 438);
-    return true;
-  };
-  Utils.prototype.writeFileToAsync = function(path3, content, overwrite, attr, callback) {
-    if (typeof attr === "function") {
-      callback = attr;
-      attr = undefined;
+    function cbListener(listener) {
+      listener(self2.error);
     }
-    const self2 = this;
-    self2.fs.exists(path3, function(exist) {
-      if (exist && !overwrite)
-        return callback(false);
-      self2.fs.stat(path3, function(err, stat4) {
-        if (exist && stat4.isDirectory()) {
-          return callback(false);
-        }
-        var folder = pth.dirname(path3);
-        self2.fs.exists(folder, function(exists) {
-          if (!exists)
-            self2.makeDir(folder);
-          self2.fs.open(path3, "w", 438, function(err2, fd) {
-            if (err2) {
-              self2.fs.chmod(path3, 438, function() {
-                self2.fs.open(path3, "w", 438, function(err3, fd2) {
-                  self2.fs.write(fd2, content, 0, content.length, 0, function() {
-                    self2.fs.close(fd2, function() {
-                      self2.fs.chmod(path3, attr || 438, function() {
-                        callback(true);
-                      });
-                    });
-                  });
-                });
-              });
-            } else if (fd) {
-              self2.fs.write(fd, content, 0, content.length, 0, function() {
-                self2.fs.close(fd, function() {
-                  self2.fs.chmod(path3, attr || 438, function() {
-                    callback(true);
-                  });
-                });
-              });
-            } else {
-              self2.fs.chmod(path3, attr || 438, function() {
-                callback(true);
-              });
-            }
-          });
-        });
+  }
+  function pendGo(self2, fn) {
+    fn(pendHold(self2));
+  }
+});
+
+// ../../node_modules/fd-slicer/index.js
+var require_fd_slicer = __commonJS((exports) => {
+  var fs2 = __require("fs");
+  var util5 = __require("util");
+  var stream4 = __require("stream");
+  var Readable3 = stream4.Readable;
+  var Writable = stream4.Writable;
+  var PassThrough = stream4.PassThrough;
+  var Pend = require_pend();
+  var EventEmitter3 = __require("events").EventEmitter;
+  exports.createFromBuffer = createFromBuffer;
+  exports.createFromFd = createFromFd;
+  exports.BufferSlicer = BufferSlicer;
+  exports.FdSlicer = FdSlicer;
+  util5.inherits(FdSlicer, EventEmitter3);
+  function FdSlicer(fd, options) {
+    options = options || {};
+    EventEmitter3.call(this);
+    this.fd = fd;
+    this.pend = new Pend;
+    this.pend.max = 1;
+    this.refCount = 0;
+    this.autoClose = !!options.autoClose;
+  }
+  FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
+    var self2 = this;
+    self2.pend.go(function(cb) {
+      fs2.read(self2.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        cb();
+        callback(err, bytesRead, buffer2);
       });
     });
   };
-  Utils.prototype.findFiles = function(path3) {
-    const self2 = this;
-    function findSync(dir, pattern, recursive) {
-      if (typeof pattern === "boolean") {
-        recursive = pattern;
-        pattern = undefined;
-      }
-      let files = [];
-      self2.fs.readdirSync(dir).forEach(function(file) {
-        const path4 = pth.join(dir, file);
-        const stat4 = self2.fs.statSync(path4);
-        if (!pattern || pattern.test(path4)) {
-          files.push(pth.normalize(path4) + (stat4.isDirectory() ? self2.sep : ""));
-        }
-        if (stat4.isDirectory() && recursive)
-          files = files.concat(findSync(path4, pattern, recursive));
-      });
-      return files;
-    }
-    return findSync(path3, undefined, true);
-  };
-  Utils.prototype.findFilesAsync = function(dir, cb) {
-    const self2 = this;
-    let results = [];
-    self2.fs.readdir(dir, function(err, list) {
-      if (err)
-        return cb(err);
-      let list_length = list.length;
-      if (!list_length)
-        return cb(null, results);
-      list.forEach(function(file) {
-        file = pth.join(dir, file);
-        self2.fs.stat(file, function(err2, stat4) {
-          if (err2)
-            return cb(err2);
-          if (stat4) {
-            results.push(pth.normalize(file) + (stat4.isDirectory() ? self2.sep : ""));
-            if (stat4.isDirectory()) {
-              self2.findFilesAsync(file, function(err3, res) {
-                if (err3)
-                  return cb(err3);
-                results = results.concat(res);
-                if (!--list_length)
-                  cb(null, results);
-              });
-            } else {
-              if (!--list_length)
-                cb(null, results);
-            }
-          }
-        });
+  FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
+    var self2 = this;
+    self2.pend.go(function(cb) {
+      fs2.write(self2.fd, buffer, offset, length, position, function(err, written, buffer2) {
+        cb();
+        callback(err, written, buffer2);
       });
     });
   };
-  Utils.prototype.getAttributes = function() {};
-  Utils.prototype.setAttributes = function() {};
-  Utils.crc32update = function(crc, byte) {
-    return crcTable[(crc ^ byte) & 255] ^ crc >>> 8;
-  };
-  Utils.crc32 = function(buf) {
-    if (typeof buf === "string") {
-      buf = Buffer.from(buf, "utf8");
-    }
-    let len = buf.length;
-    let crc = ~0;
-    for (let off = 0;off < len; )
-      crc = Utils.crc32update(crc, buf[off++]);
-    return ~crc >>> 0;
-  };
-  Utils.methodToString = function(method) {
-    switch (method) {
-      case Constants.STORED:
-        return "STORED (" + method + ")";
-      case Constants.DEFLATED:
-        return "DEFLATED (" + method + ")";
-      default:
-        return "UNSUPPORTED (" + method + ")";
-    }
+  FdSlicer.prototype.createReadStream = function(options) {
+    return new ReadStream(this, options);
   };
-  Utils.canonical = function(path3) {
-    if (!path3)
-      return "";
-    const safeSuffix = pth.posix.normalize("/" + path3.split("\\").join("/"));
-    return pth.join(".", safeSuffix);
+  FdSlicer.prototype.createWriteStream = function(options) {
+    return new WriteStream(this, options);
   };
-  Utils.zipnamefix = function(path3) {
-    if (!path3)
-      return "";
-    const safeSuffix = pth.posix.normalize("/" + path3.split("\\").join("/"));
-    return pth.posix.join(".", safeSuffix);
+  FdSlicer.prototype.ref = function() {
+    this.refCount += 1;
   };
-  Utils.findLast = function(arr, callback) {
-    if (!Array.isArray(arr))
-      throw new TypeError("arr is not array");
-    const len = arr.length >>> 0;
-    for (let i = len - 1;i >= 0; i--) {
-      if (callback(arr[i], i, arr)) {
-        return arr[i];
-      }
+  FdSlicer.prototype.unref = function() {
+    var self2 = this;
+    self2.refCount -= 1;
+    if (self2.refCount > 0)
+      return;
+    if (self2.refCount < 0)
+      throw new Error("invalid unref");
+    if (self2.autoClose) {
+      fs2.close(self2.fd, onCloseDone);
     }
-    return;
-  };
-  Utils.sanitize = function(prefix, name) {
-    prefix = pth.resolve(pth.normalize(prefix));
-    var parts = name.split("/");
-    for (var i = 0, l = parts.length;i < l; i++) {
-      var path3 = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep)));
-      if (path3.indexOf(prefix) === 0) {
-        return path3;
+    function onCloseDone(err) {
+      if (err) {
+        self2.emit("error", err);
+      } else {
+        self2.emit("close");
       }
     }
-    return pth.normalize(pth.join(prefix, pth.basename(name)));
   };
-  Utils.toBuffer = function toBuffer(input, encoder) {
-    if (Buffer.isBuffer(input)) {
-      return input;
-    } else if (input instanceof Uint8Array) {
-      return Buffer.from(input);
-    } else {
-      return typeof input === "string" ? encoder(input) : Buffer.alloc(0);
+  util5.inherits(ReadStream, Readable3);
+  function ReadStream(context, options) {
+    options = options || {};
+    Readable3.call(this, options);
+    this.context = context;
+    this.context.ref();
+    this.start = options.start || 0;
+    this.endOffset = options.end;
+    this.pos = this.start;
+    this.destroyed = false;
+  }
+  ReadStream.prototype._read = function(n) {
+    var self2 = this;
+    if (self2.destroyed)
+      return;
+    var toRead = Math.min(self2._readableState.highWaterMark, n);
+    if (self2.endOffset != null) {
+      toRead = Math.min(toRead, self2.endOffset - self2.pos);
     }
+    if (toRead <= 0) {
+      self2.destroyed = true;
+      self2.push(null);
+      self2.context.unref();
+      return;
+    }
+    self2.context.pend.go(function(cb) {
+      if (self2.destroyed)
+        return cb();
+      var buffer = new Buffer(toRead);
+      fs2.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) {
+        if (err) {
+          self2.destroy(err);
+        } else if (bytesRead === 0) {
+          self2.destroyed = true;
+          self2.push(null);
+          self2.context.unref();
+        } else {
+          self2.pos += bytesRead;
+          self2.push(buffer.slice(0, bytesRead));
+        }
+        cb();
+      });
+    });
   };
-  Utils.readBigUInt64LE = function(buffer, index) {
-    var slice = Buffer.from(buffer.slice(index, index + 8));
-    slice.swap64();
-    return parseInt(`0x${slice.toString("hex")}`);
-  };
-  Utils.fromDOS2Date = function(val) {
-    return new Date((val >> 25 & 127) + 1980, Math.max((val >> 21 & 15) - 1, 0), Math.max(val >> 16 & 31, 1), val >> 11 & 31, val >> 5 & 63, (val & 31) << 1);
+  ReadStream.prototype.destroy = function(err) {
+    if (this.destroyed)
+      return;
+    err = err || new Error("stream destroyed");
+    this.destroyed = true;
+    this.emit("error", err);
+    this.context.unref();
   };
-  Utils.fromDate2DOS = function(val) {
-    let date = 0;
-    let time = 0;
-    if (val.getFullYear() > 1979) {
-      date = (val.getFullYear() - 1980 & 127) << 9 | val.getMonth() + 1 << 5 | val.getDate();
-      time = val.getHours() << 11 | val.getMinutes() << 5 | val.getSeconds() >> 1;
+  util5.inherits(WriteStream, Writable);
+  function WriteStream(context, options) {
+    options = options || {};
+    Writable.call(this, options);
+    this.context = context;
+    this.context.ref();
+    this.start = options.start || 0;
+    this.endOffset = options.end == null ? Infinity : +options.end;
+    this.bytesWritten = 0;
+    this.pos = this.start;
+    this.destroyed = false;
+    this.on("finish", this.destroy.bind(this));
+  }
+  WriteStream.prototype._write = function(buffer, encoding, callback) {
+    var self2 = this;
+    if (self2.destroyed)
+      return;
+    if (self2.pos + buffer.length > self2.endOffset) {
+      var err = new Error("maximum file length exceeded");
+      err.code = "ETOOBIG";
+      self2.destroy();
+      callback(err);
+      return;
     }
-    return date << 16 | time;
+    self2.context.pend.go(function(cb) {
+      if (self2.destroyed)
+        return cb();
+      fs2.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) {
+        if (err2) {
+          self2.destroy();
+          cb();
+          callback(err2);
+        } else {
+          self2.bytesWritten += bytes;
+          self2.pos += bytes;
+          self2.emit("progress");
+          cb();
+          callback();
+        }
+      });
+    });
   };
-  Utils.isWin = isWin;
-  Utils.crcTable = crcTable;
-});
-
-// ../../node_modules/adm-zip/util/fattr.js
-var require_fattr = __commonJS((exports, module) => {
-  var pth = __require("path");
-  module.exports = function(path3, { fs: fs2 }) {
-    var _path = path3 || "", _obj = newAttr(), _stat = null;
-    function newAttr() {
-      return {
-        directory: false,
-        readonly: false,
-        hidden: false,
-        executable: false,
-        mtime: 0,
-        atime: 0
-      };
-    }
-    if (_path && fs2.existsSync(_path)) {
-      _stat = fs2.statSync(_path);
-      _obj.directory = _stat.isDirectory();
-      _obj.mtime = _stat.mtime;
-      _obj.atime = _stat.atime;
-      _obj.executable = (73 & _stat.mode) !== 0;
-      _obj.readonly = (128 & _stat.mode) === 0;
-      _obj.hidden = pth.basename(_path)[0] === ".";
-    } else {
-      console.warn("Invalid path: " + _path);
-    }
-    return {
-      get directory() {
-        return _obj.directory;
-      },
-      get readOnly() {
-        return _obj.readonly;
-      },
-      get hidden() {
-        return _obj.hidden;
-      },
-      get mtime() {
-        return _obj.mtime;
-      },
-      get atime() {
-        return _obj.atime;
-      },
-      get executable() {
-        return _obj.executable;
-      },
-      decodeAttributes: function() {},
-      encodeAttributes: function() {},
-      toJSON: function() {
-        return {
-          path: _path,
-          isDirectory: _obj.directory,
-          isReadOnly: _obj.readonly,
-          isHidden: _obj.hidden,
-          isExecutable: _obj.executable,
-          mTime: _obj.mtime,
-          aTime: _obj.atime
-        };
-      },
-      toString: function() {
-        return JSON.stringify(this.toJSON(), null, "\t");
-      }
-    };
+  WriteStream.prototype.destroy = function() {
+    if (this.destroyed)
+      return;
+    this.destroyed = true;
+    this.context.unref();
   };
-});
-
-// ../../node_modules/adm-zip/util/decoder.js
-var require_decoder2 = __commonJS((exports, module) => {
-  module.exports = {
-    efs: true,
-    encode: (data) => Buffer.from(data, "utf8"),
-    decode: (data) => data.toString("utf8")
+  util5.inherits(BufferSlicer, EventEmitter3);
+  function BufferSlicer(buffer, options) {
+    EventEmitter3.call(this);
+    options = options || {};
+    this.refCount = 0;
+    this.buffer = buffer;
+    this.maxChunkSize = options.maxChunkSize || Number.MAX_SAFE_INTEGER;
+  }
+  BufferSlicer.prototype.read = function(buffer, offset, length, position, callback) {
+    var end = position + length;
+    var delta = end - this.buffer.length;
+    var written = delta > 0 ? delta : length;
+    this.buffer.copy(buffer, offset, position, end);
+    setImmediate(function() {
+      callback(null, written);
+    });
   };
-});
-
-// ../../node_modules/adm-zip/util/index.js
-var require_util12 = __commonJS((exports, module) => {
-  module.exports = require_utils74();
-  module.exports.Constants = require_constants24();
-  module.exports.Errors = require_errors6();
-  module.exports.FileAttr = require_fattr();
-  module.exports.decoder = require_decoder2();
-});
-
-// ../../node_modules/adm-zip/headers/entryHeader.js
-var require_entryHeader = __commonJS((exports, module) => {
-  var Utils = require_util12();
-  var Constants = Utils.Constants;
-  module.exports = function() {
-    var _verMade = 20, _version = 10, _flags = 0, _method = 0, _time = 0, _crc = 0, _compressedSize = 0, _size = 0, _fnameLen = 0, _extraLen = 0, _comLen = 0, _diskStart = 0, _inattr = 0, _attr = 0, _offset = 0;
-    _verMade |= Utils.isWin ? 2560 : 768;
-    _flags |= Constants.FLG_EFS;
-    const _localHeader = {
-      extraLen: 0
-    };
-    const uint32 = (val) => Math.max(0, val) >>> 0;
-    const uint16 = (val) => Math.max(0, val) & 65535;
-    const uint8 = (val) => Math.max(0, val) & 255;
-    _time = Utils.fromDate2DOS(new Date);
-    return {
-      get made() {
-        return _verMade;
-      },
-      set made(val) {
-        _verMade = val;
-      },
-      get version() {
-        return _version;
-      },
-      set version(val) {
-        _version = val;
-      },
-      get flags() {
-        return _flags;
-      },
-      set flags(val) {
-        _flags = val;
-      },
-      get flags_efs() {
-        return (_flags & Constants.FLG_EFS) > 0;
-      },
-      set flags_efs(val) {
-        if (val) {
-          _flags |= Constants.FLG_EFS;
-        } else {
-          _flags &= ~Constants.FLG_EFS;
-        }
-      },
-      get flags_desc() {
-        return (_flags & Constants.FLG_DESC) > 0;
-      },
-      set flags_desc(val) {
-        if (val) {
-          _flags |= Constants.FLG_DESC;
-        } else {
-          _flags &= ~Constants.FLG_DESC;
-        }
-      },
-      get method() {
-        return _method;
-      },
-      set method(val) {
-        switch (val) {
-          case Constants.STORED:
-            this.version = 10;
-          case Constants.DEFLATED:
-          default:
-            this.version = 20;
+  BufferSlicer.prototype.write = function(buffer, offset, length, position, callback) {
+    buffer.copy(this.buffer, position, offset, offset + length);
+    setImmediate(function() {
+      callback(null, length, buffer);
+    });
+  };
+  BufferSlicer.prototype.createReadStream = function(options) {
+    options = options || {};
+    var readStream2 = new PassThrough(options);
+    readStream2.destroyed = false;
+    readStream2.start = options.start || 0;
+    readStream2.endOffset = options.end;
+    readStream2.pos = readStream2.endOffset || this.buffer.length;
+    var entireSlice = this.buffer.slice(readStream2.start, readStream2.pos);
+    var offset = 0;
+    while (true) {
+      var nextOffset = offset + this.maxChunkSize;
+      if (nextOffset >= entireSlice.length) {
+        if (offset < entireSlice.length) {
+          readStream2.write(entireSlice.slice(offset, entireSlice.length));
         }
-        _method = val;
-      },
-      get time() {
-        return Utils.fromDOS2Date(this.timeval);
-      },
-      set time(val) {
-        this.timeval = Utils.fromDate2DOS(val);
-      },
-      get timeval() {
-        return _time;
-      },
-      set timeval(val) {
-        _time = uint32(val);
-      },
-      get timeHighByte() {
-        return uint8(_time >>> 8);
-      },
-      get crc() {
-        return _crc;
-      },
-      set crc(val) {
-        _crc = uint32(val);
-      },
-      get compressedSize() {
-        return _compressedSize;
-      },
-      set compressedSize(val) {
-        _compressedSize = uint32(val);
-      },
-      get size() {
-        return _size;
-      },
-      set size(val) {
-        _size = uint32(val);
-      },
-      get fileNameLength() {
-        return _fnameLen;
-      },
-      set fileNameLength(val) {
-        _fnameLen = val;
-      },
-      get extraLength() {
-        return _extraLen;
-      },
-      set extraLength(val) {
-        _extraLen = val;
-      },
-      get extraLocalLength() {
-        return _localHeader.extraLen;
-      },
-      set extraLocalLength(val) {
-        _localHeader.extraLen = val;
-      },
-      get commentLength() {
-        return _comLen;
-      },
-      set commentLength(val) {
-        _comLen = val;
-      },
-      get diskNumStart() {
-        return _diskStart;
-      },
-      set diskNumStart(val) {
-        _diskStart = uint32(val);
-      },
-      get inAttr() {
-        return _inattr;
-      },
-      set inAttr(val) {
-        _inattr = uint32(val);
-      },
-      get attr() {
-        return _attr;
-      },
-      set attr(val) {
-        _attr = uint32(val);
-      },
-      get fileAttr() {
-        return (_attr || 0) >> 16 & 4095;
-      },
-      get offset() {
-        return _offset;
-      },
-      set offset(val) {
-        _offset = uint32(val);
-      },
-      get encrypted() {
-        return (_flags & Constants.FLG_ENC) === Constants.FLG_ENC;
-      },
-      get centralHeaderSize() {
-        return Constants.CENHDR + _fnameLen + _extraLen + _comLen;
-      },
-      get realDataOffset() {
-        return _offset + Constants.LOCHDR + _localHeader.fnameLen + _localHeader.extraLen;
-      },
-      get localHeader() {
-        return _localHeader;
-      },
-      loadLocalHeaderFromBinary: function(input) {
-        var data = input.slice(_offset, _offset + Constants.LOCHDR);
-        if (data.readUInt32LE(0) !== Constants.LOCSIG) {
-          throw Utils.Errors.INVALID_LOC();
-        }
-        _localHeader.version = data.readUInt16LE(Constants.LOCVER);
-        _localHeader.flags = data.readUInt16LE(Constants.LOCFLG);
-        _localHeader.method = data.readUInt16LE(Constants.LOCHOW);
-        _localHeader.time = data.readUInt32LE(Constants.LOCTIM);
-        _localHeader.crc = data.readUInt32LE(Constants.LOCCRC);
-        _localHeader.compressedSize = data.readUInt32LE(Constants.LOCSIZ);
-        _localHeader.size = data.readUInt32LE(Constants.LOCLEN);
-        _localHeader.fnameLen = data.readUInt16LE(Constants.LOCNAM);
-        _localHeader.extraLen = data.readUInt16LE(Constants.LOCEXT);
-        const extraStart = _offset + Constants.LOCHDR + _localHeader.fnameLen;
-        const extraEnd = extraStart + _localHeader.extraLen;
-        return input.slice(extraStart, extraEnd);
-      },
-      loadFromBinary: function(data) {
-        if (data.length !== Constants.CENHDR || data.readUInt32LE(0) !== Constants.CENSIG) {
-          throw Utils.Errors.INVALID_CEN();
-        }
-        _verMade = data.readUInt16LE(Constants.CENVEM);
-        _version = data.readUInt16LE(Constants.CENVER);
-        _flags = data.readUInt16LE(Constants.CENFLG);
-        _method = data.readUInt16LE(Constants.CENHOW);
-        _time = data.readUInt32LE(Constants.CENTIM);
-        _crc = data.readUInt32LE(Constants.CENCRC);
-        _compressedSize = data.readUInt32LE(Constants.CENSIZ);
-        _size = data.readUInt32LE(Constants.CENLEN);
-        _fnameLen = data.readUInt16LE(Constants.CENNAM);
-        _extraLen = data.readUInt16LE(Constants.CENEXT);
-        _comLen = data.readUInt16LE(Constants.CENCOM);
-        _diskStart = data.readUInt16LE(Constants.CENDSK);
-        _inattr = data.readUInt16LE(Constants.CENATT);
-        _attr = data.readUInt32LE(Constants.CENATX);
-        _offset = data.readUInt32LE(Constants.CENOFF);
-      },
-      localHeaderToBinary: function() {
-        var data = Buffer.alloc(Constants.LOCHDR);
-        data.writeUInt32LE(Constants.LOCSIG, 0);
-        data.writeUInt16LE(_version, Constants.LOCVER);
-        data.writeUInt16LE(_flags, Constants.LOCFLG);
-        data.writeUInt16LE(_method, Constants.LOCHOW);
-        data.writeUInt32LE(_time, Constants.LOCTIM);
-        data.writeUInt32LE(_crc, Constants.LOCCRC);
-        data.writeUInt32LE(_compressedSize, Constants.LOCSIZ);
-        data.writeUInt32LE(_size, Constants.LOCLEN);
-        data.writeUInt16LE(_fnameLen, Constants.LOCNAM);
-        data.writeUInt16LE(_localHeader.extraLen, Constants.LOCEXT);
-        return data;
-      },
-      centralHeaderToBinary: function() {
-        var data = Buffer.alloc(Constants.CENHDR + _fnameLen + _extraLen + _comLen);
-        data.writeUInt32LE(Constants.CENSIG, 0);
-        data.writeUInt16LE(_verMade, Constants.CENVEM);
-        data.writeUInt16LE(_version, Constants.CENVER);
-        data.writeUInt16LE(_flags, Constants.CENFLG);
-        data.writeUInt16LE(_method, Constants.CENHOW);
-        data.writeUInt32LE(_time, Constants.CENTIM);
-        data.writeUInt32LE(_crc, Constants.CENCRC);
-        data.writeUInt32LE(_compressedSize, Constants.CENSIZ);
-        data.writeUInt32LE(_size, Constants.CENLEN);
-        data.writeUInt16LE(_fnameLen, Constants.CENNAM);
-        data.writeUInt16LE(_extraLen, Constants.CENEXT);
-        data.writeUInt16LE(_comLen, Constants.CENCOM);
-        data.writeUInt16LE(_diskStart, Constants.CENDSK);
-        data.writeUInt16LE(_inattr, Constants.CENATT);
-        data.writeUInt32LE(_attr, Constants.CENATX);
-        data.writeUInt32LE(_offset, Constants.CENOFF);
-        return data;
-      },
-      toJSON: function() {
-        const bytes = function(nr) {
-          return nr + " bytes";
-        };
-        return {
-          made: _verMade,
-          version: _version,
-          flags: _flags,
-          method: Utils.methodToString(_method),
-          time: this.time,
-          crc: "0x" + _crc.toString(16).toUpperCase(),
-          compressedSize: bytes(_compressedSize),
-          size: bytes(_size),
-          fileNameLength: bytes(_fnameLen),
-          extraLength: bytes(_extraLen),
-          commentLength: bytes(_comLen),
-          diskNumStart: _diskStart,
-          inAttr: _inattr,
-          attr: _attr,
-          offset: _offset,
-          centralHeaderSize: bytes(Constants.CENHDR + _fnameLen + _extraLen + _comLen)
-        };
-      },
-      toString: function() {
-        return JSON.stringify(this.toJSON(), null, "\t");
+        break;
       }
+      readStream2.write(entireSlice.slice(offset, nextOffset));
+      offset = nextOffset;
+    }
+    readStream2.end();
+    readStream2.destroy = function() {
+      readStream2.destroyed = true;
     };
+    return readStream2;
   };
-});
-
-// ../../node_modules/adm-zip/headers/mainHeader.js
-var require_mainHeader = __commonJS((exports, module) => {
-  var Utils = require_util12();
-  var Constants = Utils.Constants;
-  module.exports = function() {
-    var _volumeEntries = 0, _totalEntries = 0, _size = 0, _offset = 0, _commentLength = 0;
-    return {
-      get diskEntries() {
-        return _volumeEntries;
-      },
-      set diskEntries(val) {
-        _volumeEntries = _totalEntries = val;
-      },
-      get totalEntries() {
-        return _totalEntries;
-      },
-      set totalEntries(val) {
-        _totalEntries = _volumeEntries = val;
-      },
-      get size() {
-        return _size;
-      },
-      set size(val) {
-        _size = val;
-      },
-      get offset() {
-        return _offset;
-      },
-      set offset(val) {
-        _offset = val;
-      },
-      get commentLength() {
-        return _commentLength;
-      },
-      set commentLength(val) {
-        _commentLength = val;
-      },
-      get mainHeaderSize() {
-        return Constants.ENDHDR + _commentLength;
-      },
-      loadFromBinary: function(data) {
-        if ((data.length !== Constants.ENDHDR || data.readUInt32LE(0) !== Constants.ENDSIG) && (data.length < Constants.ZIP64HDR || data.readUInt32LE(0) !== Constants.ZIP64SIG)) {
-          throw Utils.Errors.INVALID_END();
-        }
-        if (data.readUInt32LE(0) === Constants.ENDSIG) {
-          _volumeEntries = data.readUInt16LE(Constants.ENDSUB);
-          _totalEntries = data.readUInt16LE(Constants.ENDTOT);
-          _size = data.readUInt32LE(Constants.ENDSIZ);
-          _offset = data.readUInt32LE(Constants.ENDOFF);
-          _commentLength = data.readUInt16LE(Constants.ENDCOM);
-        } else {
-          _volumeEntries = Utils.readBigUInt64LE(data, Constants.ZIP64SUB);
-          _totalEntries = Utils.readBigUInt64LE(data, Constants.ZIP64TOT);
-          _size = Utils.readBigUInt64LE(data, Constants.ZIP64SIZE);
-          _offset = Utils.readBigUInt64LE(data, Constants.ZIP64OFF);
-          _commentLength = 0;
-        }
-      },
-      toBinary: function() {
-        var b = Buffer.alloc(Constants.ENDHDR + _commentLength);
-        b.writeUInt32LE(Constants.ENDSIG, 0);
-        b.writeUInt32LE(0, 4);
-        b.writeUInt16LE(_volumeEntries, Constants.ENDSUB);
-        b.writeUInt16LE(_totalEntries, Constants.ENDTOT);
-        b.writeUInt32LE(_size, Constants.ENDSIZ);
-        b.writeUInt32LE(_offset, Constants.ENDOFF);
-        b.writeUInt16LE(_commentLength, Constants.ENDCOM);
-        b.fill(" ", Constants.ENDHDR);
-        return b;
-      },
-      toJSON: function() {
-        const offset = function(nr, len) {
-          let offs = nr.toString(16).toUpperCase();
-          while (offs.length < len)
-            offs = "0" + offs;
-          return "0x" + offs;
-        };
-        return {
-          diskEntries: _volumeEntries,
-          totalEntries: _totalEntries,
-          size: _size + " bytes",
-          offset: offset(_offset, 4),
-          commentLength: _commentLength
-        };
-      },
-      toString: function() {
-        return JSON.stringify(this.toJSON(), null, "\t");
+  BufferSlicer.prototype.createWriteStream = function(options) {
+    var bufferSlicer = this;
+    options = options || {};
+    var writeStream = new Writable(options);
+    writeStream.start = options.start || 0;
+    writeStream.endOffset = options.end == null ? this.buffer.length : +options.end;
+    writeStream.bytesWritten = 0;
+    writeStream.pos = writeStream.start;
+    writeStream.destroyed = false;
+    writeStream._write = function(buffer, encoding, callback) {
+      if (writeStream.destroyed)
+        return;
+      var end = writeStream.pos + buffer.length;
+      if (end > writeStream.endOffset) {
+        var err = new Error("maximum file length exceeded");
+        err.code = "ETOOBIG";
+        writeStream.destroyed = true;
+        callback(err);
+        return;
       }
+      buffer.copy(bufferSlicer.buffer, writeStream.pos, 0, buffer.length);
+      writeStream.bytesWritten += buffer.length;
+      writeStream.pos = end;
+      writeStream.emit("progress");
+      callback();
+    };
+    writeStream.destroy = function() {
+      writeStream.destroyed = true;
     };
+    return writeStream;
   };
+  BufferSlicer.prototype.ref = function() {
+    this.refCount += 1;
+  };
+  BufferSlicer.prototype.unref = function() {
+    this.refCount -= 1;
+    if (this.refCount < 0) {
+      throw new Error("invalid unref");
+    }
+  };
+  function createFromBuffer(buffer, options) {
+    return new BufferSlicer(buffer, options);
+  }
+  function createFromFd(fd, options) {
+    return new FdSlicer(fd, options);
+  }
 });
 
-// ../../node_modules/adm-zip/headers/index.js
-var require_headers = __commonJS((exports) => {
-  exports.EntryHeader = require_entryHeader();
-  exports.MainHeader = require_mainHeader();
-});
-
-// ../../node_modules/adm-zip/methods/deflater.js
-var require_deflater = __commonJS((exports, module) => {
-  module.exports = function(inbuf) {
-    var zlib2 = __require("zlib");
-    var opts = { chunkSize: (parseInt(inbuf.length / 1024) + 1) * 1024 };
-    return {
-      deflate: function() {
-        return zlib2.deflateRawSync(inbuf, opts);
-      },
-      deflateAsync: function(callback) {
-        var tmp = zlib2.createDeflateRaw(opts), parts = [], total = 0;
-        tmp.on("data", function(data) {
-          parts.push(data);
-          total += data.length;
-        });
-        tmp.on("end", function() {
-          var buf = Buffer.alloc(total), written = 0;
-          buf.fill(0);
-          for (var i = 0;i < parts.length; i++) {
-            var part = parts[i];
-            part.copy(buf, written);
-            written += part.length;
-          }
-          callback && callback(buf);
-        });
-        tmp.end(inbuf);
-      }
-    };
+// ../../node_modules/yauzl/node_modules/buffer-crc32/index.js
+var require_buffer_crc32 = __commonJS((exports, module) => {
+  var Buffer2 = __require("buffer").Buffer;
+  var CRC_TABLE = [
+    0,
+    1996959894,
+    3993919788,
+    2567524794,
+    124634137,
+    1886057615,
+    3915621685,
+    2657392035,
+    249268274,
+    2044508324,
+    3772115230,
+    2547177864,
+    162941995,
+    2125561021,
+    3887607047,
+    2428444049,
+    498536548,
+    1789927666,
+    4089016648,
+    2227061214,
+    450548861,
+    1843258603,
+    4107580753,
+    2211677639,
+    325883990,
+    1684777152,
+    4251122042,
+    2321926636,
+    335633487,
+    1661365465,
+    4195302755,
+    2366115317,
+    997073096,
+    1281953886,
+    3579855332,
+    2724688242,
+    1006888145,
+    1258607687,
+    3524101629,
+    2768942443,
+    901097722,
+    1119000684,
+    3686517206,
+    2898065728,
+    853044451,
+    1172266101,
+    3705015759,
+    2882616665,
+    651767980,
+    1373503546,
+    3369554304,
+    3218104598,
+    565507253,
+    1454621731,
+    3485111705,
+    3099436303,
+    671266974,
+    1594198024,
+    3322730930,
+    2970347812,
+    795835527,
+    1483230225,
+    3244367275,
+    3060149565,
+    1994146192,
+    31158534,
+    2563907772,
+    4023717930,
+    1907459465,
+    112637215,
+    2680153253,
+    3904427059,
+    2013776290,
+    251722036,
+    2517215374,
+    3775830040,
+    2137656763,
+    141376813,
+    2439277719,
+    3865271297,
+    1802195444,
+    476864866,
+    2238001368,
+    4066508878,
+    1812370925,
+    453092731,
+    2181625025,
+    4111451223,
+    1706088902,
+    314042704,
+    2344532202,
+    4240017532,
+    1658658271,
+    366619977,
+    2362670323,
+    4224994405,
+    1303535960,
+    984961486,
+    2747007092,
+    3569037538,
+    1256170817,
+    1037604311,
+    2765210733,
+    3554079995,
+    1131014506,
+    879679996,
+    2909243462,
+    3663771856,
+    1141124467,
+    855842277,
+    2852801631,
+    3708648649,
+    1342533948,
+    654459306,
+    3188396048,
+    3373015174,
+    1466479909,
+    544179635,
+    3110523913,
+    3462522015,
+    1591671054,
+    702138776,
+    2966460450,
+    3352799412,
+    1504918807,
+    783551873,
+    3082640443,
+    3233442989,
+    3988292384,
+    2596254646,
+    62317068,
+    1957810842,
+    3939845945,
+    2647816111,
+    81470997,
+    1943803523,
+    3814918930,
+    2489596804,
+    225274430,
+    2053790376,
+    3826175755,
+    2466906013,
+    167816743,
+    2097651377,
+    4027552580,
+    2265490386,
+    503444072,
+    1762050814,
+    4150417245,
+    2154129355,
+    426522225,
+    1852507879,
+    4275313526,
+    2312317920,
+    282753626,
+    1742555852,
+    4189708143,
+    2394877945,
+    397917763,
+    1622183637,
+    3604390888,
+    2714866558,
+    953729732,
+    1340076626,
+    3518719985,
+    2797360999,
+    1068828381,
+    1219638859,
+    3624741850,
+    2936675148,
+    906185462,
+    1090812512,
+    3747672003,
+    2825379669,
+    829329135,
+    1181335161,
+    3412177804,
+    3160834842,
+    628085408,
+    1382605366,
+    3423369109,
+    3138078467,
+    570562233,
+    1426400815,
+    3317316542,
+    2998733608,
+    733239954,
+    1555261956,
+    3268935591,
+    3050360625,
+    752459403,
+    1541320221,
+    2607071920,
+    3965973030,
+    1969922972,
+    40735498,
+    2617837225,
+    3943577151,
+    1913087877,
+    83908371,
+    2512341634,
+    3803740692,
+    2075208622,
+    213261112,
+    2463272603,
+    3855990285,
+    2094854071,
+    198958881,
+    2262029012,
+    4057260610,
+    1759359992,
+    534414190,
+    2176718541,
+    4139329115,
+    1873836001,
+    414664567,
+    2282248934,
+    4279200368,
+    1711684554,
+    285281116,
+    2405801727,
+    4167216745,
+    1634467795,
+    376229701,
+    2685067896,
+    3608007406,
+    1308918612,
+    956543938,
+    2808555105,
+    3495958263,
+    1231636301,
+    1047427035,
+    2932959818,
+    3654703836,
+    1088359270,
+    936918000,
+    2847714899,
+    3736837829,
+    1202900863,
+    817233897,
+    3183342108,
+    3401237130,
+    1404277552,
+    615818150,
+    3134207493,
+    3453421203,
+    1423857449,
+    601450431,
+    3009837614,
+    3294710456,
+    1567103746,
+    711928724,
+    3020668471,
+    3272380065,
+    1510334235,
+    755167117
+  ];
+  if (typeof Int32Array !== "undefined") {
+    CRC_TABLE = new Int32Array(CRC_TABLE);
+  }
+  function ensureBuffer(input) {
+    if (Buffer2.isBuffer(input)) {
+      return input;
+    }
+    var hasNewBufferAPI = typeof Buffer2.alloc === "function" && typeof Buffer2.from === "function";
+    if (typeof input === "number") {
+      return hasNewBufferAPI ? Buffer2.alloc(input) : new Buffer2(input);
+    } else if (typeof input === "string") {
+      return hasNewBufferAPI ? Buffer2.from(input) : new Buffer2(input);
+    } else {
+      throw new Error("input must be buffer, number, or string, received " + typeof input);
+    }
+  }
+  function bufferizeInt(num) {
+    var tmp = ensureBuffer(4);
+    tmp.writeInt32BE(num, 0);
+    return tmp;
+  }
+  function _crc32(buf, previous) {
+    buf = ensureBuffer(buf);
+    if (Buffer2.isBuffer(previous)) {
+      previous = previous.readUInt32BE(0);
+    }
+    var crc = ~~previous ^ -1;
+    for (var n = 0;n < buf.length; n++) {
+      crc = CRC_TABLE[(crc ^ buf[n]) & 255] ^ crc >>> 8;
+    }
+    return crc ^ -1;
+  }
+  function crc32() {
+    return bufferizeInt(_crc32.apply(null, arguments));
+  }
+  crc32.signed = function() {
+    return _crc32.apply(null, arguments);
   };
-});
-
-// ../../node_modules/adm-zip/methods/inflater.js
-var require_inflater = __commonJS((exports, module) => {
-  var version = +(process.versions ? process.versions.node : "").split(".")[0] || 0;
-  module.exports = function(inbuf, expectedLength) {
-    var zlib2 = __require("zlib");
-    const option = version >= 15 && expectedLength > 0 ? { maxOutputLength: expectedLength } : {};
-    return {
-      inflate: function() {
-        return zlib2.inflateRawSync(inbuf, option);
-      },
-      inflateAsync: function(callback) {
-        var tmp = zlib2.createInflateRaw(option), parts = [], total = 0;
-        tmp.on("data", function(data) {
-          parts.push(data);
-          total += data.length;
-        });
-        tmp.on("end", function() {
-          var buf = Buffer.alloc(total), written = 0;
-          buf.fill(0);
-          for (var i = 0;i < parts.length; i++) {
-            var part = parts[i];
-            part.copy(buf, written);
-            written += part.length;
-          }
-          callback && callback(buf);
-        });
-        tmp.end(inbuf);
-      }
-    };
+  crc32.unsigned = function() {
+    return _crc32.apply(null, arguments) >>> 0;
   };
+  module.exports = crc32;
 });
 
-// ../../node_modules/adm-zip/methods/zipcrypto.js
-var require_zipcrypto = __commonJS((exports, module) => {
-  var { randomFillSync } = __require("crypto");
-  var Errors = require_errors6();
-  var crctable = new Uint32Array(256).map((t, crc) => {
-    for (let j = 0;j < 8; j++) {
-      if ((crc & 1) !== 0) {
-        crc = crc >>> 1 ^ 3988292384;
-      } else {
-        crc >>>= 1;
-      }
+// ../../node_modules/yauzl/index.js
+var require_yauzl = __commonJS((exports) => {
+  var fs2 = __require("fs");
+  var zlib2 = __require("zlib");
+  var fd_slicer = require_fd_slicer();
+  var crc32 = require_buffer_crc32();
+  var util5 = __require("util");
+  var EventEmitter3 = __require("events").EventEmitter;
+  var Transform = __require("stream").Transform;
+  var PassThrough = __require("stream").PassThrough;
+  var Writable = __require("stream").Writable;
+  exports.open = open2;
+  exports.fromFd = fromFd;
+  exports.fromBuffer = fromBuffer;
+  exports.fromRandomAccessReader = fromRandomAccessReader;
+  exports.dosDateTimeToDate = dosDateTimeToDate;
+  exports.validateFileName = validateFileName;
+  exports.ZipFile = ZipFile;
+  exports.Entry = Entry;
+  exports.RandomAccessReader = RandomAccessReader;
+  function open2(path3, options, callback) {
+    if (typeof options === "function") {
+      callback = options;
+      options = null;
     }
-    return crc >>> 0;
-  });
-  var uMul = (a, b) => Math.imul(a, b) >>> 0;
-  var crc32update = (pCrc32, bval) => {
-    return crctable[(pCrc32 ^ bval) & 255] ^ pCrc32 >>> 8;
-  };
-  var genSalt = () => {
-    if (typeof randomFillSync === "function") {
-      return randomFillSync(Buffer.alloc(12));
-    } else {
-      return genSalt.node();
-    }
-  };
-  genSalt.node = () => {
-    const salt = Buffer.alloc(12);
-    const len = salt.length;
-    for (let i = 0;i < len; i++)
-      salt[i] = Math.random() * 256 & 255;
-    return salt;
-  };
-  var config = {
-    genSalt
-  };
-  function Initkeys(pw) {
-    const pass = Buffer.isBuffer(pw) ? pw : Buffer.from(pw);
-    this.keys = new Uint32Array([305419896, 591751049, 878082192]);
-    for (let i = 0;i < pass.length; i++) {
-      this.updateKeys(pass[i]);
-    }
-  }
-  Initkeys.prototype.updateKeys = function(byteValue) {
-    const keys = this.keys;
-    keys[0] = crc32update(keys[0], byteValue);
-    keys[1] += keys[0] & 255;
-    keys[1] = uMul(keys[1], 134775813) + 1;
-    keys[2] = crc32update(keys[2], keys[1] >>> 24);
-    return byteValue;
-  };
-  Initkeys.prototype.next = function() {
-    const k = (this.keys[2] | 2) >>> 0;
-    return uMul(k, k ^ 1) >> 8 & 255;
-  };
-  function make_decrypter(pwd) {
-    const keys = new Initkeys(pwd);
-    return function(data) {
-      const result = Buffer.alloc(data.length);
-      let pos = 0;
-      for (let c of data) {
-        result[pos++] = keys.updateKeys(c ^ keys.next());
-      }
-      return result;
-    };
+    if (options == null)
+      options = {};
+    if (options.autoClose == null)
+      options.autoClose = true;
+    if (options.lazyEntries == null)
+      options.lazyEntries = false;
+    if (options.decodeStrings == null)
+      options.decodeStrings = true;
+    if (options.validateEntrySizes == null)
+      options.validateEntrySizes = true;
+    if (options.strictFileNames == null)
+      options.strictFileNames = false;
+    if (callback == null)
+      callback = defaultCallback;
+    fs2.open(path3, "r", function(err, fd) {
+      if (err)
+        return callback(err);
+      fromFd(fd, options, function(err2, zipfile) {
+        if (err2)
+          fs2.close(fd, defaultCallback);
+        callback(err2, zipfile);
+      });
+    });
   }
-  function make_encrypter(pwd) {
-    const keys = new Initkeys(pwd);
-    return function(data, result, pos = 0) {
-      if (!result)
-        result = Buffer.alloc(data.length);
-      for (let c of data) {
-        const k = keys.next();
-        result[pos++] = c ^ k;
-        keys.updateKeys(c);
-      }
-      return result;
-    };
+  function fromFd(fd, options, callback) {
+    if (typeof options === "function") {
+      callback = options;
+      options = null;
+    }
+    if (options == null)
+      options = {};
+    if (options.autoClose == null)
+      options.autoClose = false;
+    if (options.lazyEntries == null)
+      options.lazyEntries = false;
+    if (options.decodeStrings == null)
+      options.decodeStrings = true;
+    if (options.validateEntrySizes == null)
+      options.validateEntrySizes = true;
+    if (options.strictFileNames == null)
+      options.strictFileNames = false;
+    if (callback == null)
+      callback = defaultCallback;
+    fs2.fstat(fd, function(err, stats) {
+      if (err)
+        return callback(err);
+      var reader = fd_slicer.createFromFd(fd, { autoClose: true });
+      fromRandomAccessReader(reader, stats.size, options, callback);
+    });
   }
-  function decrypt(data, header, pwd) {
-    if (!data || !Buffer.isBuffer(data) || data.length < 12) {
-      return Buffer.alloc(0);
+  function fromBuffer(buffer, options, callback) {
+    if (typeof options === "function") {
+      callback = options;
+      options = null;
     }
-    const decrypter = make_decrypter(pwd);
-    const salt = decrypter(data.slice(0, 12));
-    const verifyByte = (header.flags & 8) === 8 ? header.timeHighByte : header.crc >>> 24;
-    if (salt[11] !== verifyByte) {
-      throw Errors.WRONG_PASSWORD();
+    if (options == null)
+      options = {};
+    options.autoClose = false;
+    if (options.lazyEntries == null)
+      options.lazyEntries = false;
+    if (options.decodeStrings == null)
+      options.decodeStrings = true;
+    if (options.validateEntrySizes == null)
+      options.validateEntrySizes = true;
+    if (options.strictFileNames == null)
+      options.strictFileNames = false;
+    var reader = fd_slicer.createFromBuffer(buffer, { maxChunkSize: 65536 });
+    fromRandomAccessReader(reader, buffer.length, options, callback);
+  }
+  function fromRandomAccessReader(reader, totalSize, options, callback) {
+    if (typeof options === "function") {
+      callback = options;
+      options = null;
     }
-    return decrypter(data.slice(12));
-  }
-  function _salter(data) {
-    if (Buffer.isBuffer(data) && data.length >= 12) {
-      config.genSalt = function() {
-        return data.slice(0, 12);
-      };
-    } else if (data === "node") {
-      config.genSalt = genSalt.node;
-    } else {
-      config.genSalt = genSalt;
-    }
-  }
-  function encrypt(data, header, pwd, oldlike = false) {
-    if (data == null)
-      data = Buffer.alloc(0);
-    if (!Buffer.isBuffer(data))
-      data = Buffer.from(data.toString());
-    const encrypter = make_encrypter(pwd);
-    const salt = config.genSalt();
-    salt[11] = header.crc >>> 24 & 255;
-    if (oldlike)
-      salt[10] = header.crc >>> 16 & 255;
-    const result = Buffer.alloc(data.length + 12);
-    encrypter(salt, result);
-    return encrypter(data, result, 12);
-  }
-  module.exports = { decrypt, encrypt, _salter };
-});
-
-// ../../node_modules/adm-zip/methods/index.js
-var require_methods2 = __commonJS((exports) => {
-  exports.Deflater = require_deflater();
-  exports.Inflater = require_inflater();
-  exports.ZipCrypto = require_zipcrypto();
-});
-
-// ../../node_modules/adm-zip/zipEntry.js
-var require_zipEntry = __commonJS((exports, module) => {
-  var Utils = require_util12();
-  var Headers2 = require_headers();
-  var Constants = Utils.Constants;
-  var Methods = require_methods2();
-  module.exports = function(options, input) {
-    var _centralHeader = new Headers2.EntryHeader, _entryName = Buffer.alloc(0), _comment = Buffer.alloc(0), _isDirectory = false, uncompressedData = null, _extra = Buffer.alloc(0), _extralocal = Buffer.alloc(0), _efs = true;
-    const opts = options;
-    const decoder = typeof opts.decoder === "object" ? opts.decoder : Utils.decoder;
-    _efs = decoder.hasOwnProperty("efs") ? decoder.efs : false;
-    function getCompressedDataFromZip() {
-      if (!input || !(input instanceof Uint8Array)) {
-        return Buffer.alloc(0);
-      }
-      _extralocal = _centralHeader.loadLocalHeaderFromBinary(input);
-      return input.slice(_centralHeader.realDataOffset, _centralHeader.realDataOffset + _centralHeader.compressedSize);
-    }
-    function crc32OK(data) {
-      if (!_centralHeader.flags_desc) {
-        if (Utils.crc32(data) !== _centralHeader.localHeader.crc) {
-          return false;
-        }
-      } else {
-        const descriptor = {};
-        const dataEndOffset = _centralHeader.realDataOffset + _centralHeader.compressedSize;
-        if (input.readUInt32LE(dataEndOffset) == Constants.LOCSIG || input.readUInt32LE(dataEndOffset) == Constants.CENSIG) {
-          throw Utils.Errors.DESCRIPTOR_NOT_EXIST();
-        }
-        if (input.readUInt32LE(dataEndOffset) == Constants.EXTSIG) {
-          descriptor.crc = input.readUInt32LE(dataEndOffset + Constants.EXTCRC);
-          descriptor.compressedSize = input.readUInt32LE(dataEndOffset + Constants.EXTSIZ);
-          descriptor.size = input.readUInt32LE(dataEndOffset + Constants.EXTLEN);
-        } else if (input.readUInt16LE(dataEndOffset + 12) === 19280) {
-          descriptor.crc = input.readUInt32LE(dataEndOffset + Constants.EXTCRC - 4);
-          descriptor.compressedSize = input.readUInt32LE(dataEndOffset + Constants.EXTSIZ - 4);
-          descriptor.size = input.readUInt32LE(dataEndOffset + Constants.EXTLEN - 4);
-        } else {
-          throw Utils.Errors.DESCRIPTOR_UNKNOWN();
-        }
-        if (descriptor.compressedSize !== _centralHeader.compressedSize || descriptor.size !== _centralHeader.size || descriptor.crc !== _centralHeader.crc) {
-          throw Utils.Errors.DESCRIPTOR_FAULTY();
-        }
-        if (Utils.crc32(data) !== descriptor.crc) {
-          return false;
-        }
+    if (options == null)
+      options = {};
+    if (options.autoClose == null)
+      options.autoClose = true;
+    if (options.lazyEntries == null)
+      options.lazyEntries = false;
+    if (options.decodeStrings == null)
+      options.decodeStrings = true;
+    var decodeStrings = !!options.decodeStrings;
+    if (options.validateEntrySizes == null)
+      options.validateEntrySizes = true;
+    if (options.strictFileNames == null)
+      options.strictFileNames = false;
+    if (callback == null)
+      callback = defaultCallback;
+    if (typeof totalSize !== "number")
+      throw new Error("expected totalSize parameter to be a number");
+    if (totalSize > Number.MAX_SAFE_INTEGER) {
+      throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double.");
+    }
+    reader.ref();
+    var eocdrWithoutCommentSize = 22;
+    var maxCommentSize = 65535;
+    var bufferSize = Math.min(eocdrWithoutCommentSize + maxCommentSize, totalSize);
+    var buffer = newBuffer(bufferSize);
+    var bufferReadStart = totalSize - buffer.length;
+    readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) {
+      if (err)
+        return callback(err);
+      for (var i = bufferSize - eocdrWithoutCommentSize;i >= 0; i -= 1) {
+        if (buffer.readUInt32LE(i) !== 101010256)
+          continue;
+        var eocdrBuffer = buffer.slice(i);
+        var diskNumber = eocdrBuffer.readUInt16LE(4);
+        if (diskNumber !== 0) {
+          return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
+        }
+        var entryCount = eocdrBuffer.readUInt16LE(10);
+        var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16);
+        var commentLength = eocdrBuffer.readUInt16LE(20);
+        var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize;
+        if (commentLength !== expectedCommentLength) {
+          return callback(new Error("invalid comment length. expected: " + expectedCommentLength + ". found: " + commentLength));
+        }
+        var comment = decodeStrings ? decodeBuffer(eocdrBuffer, 22, eocdrBuffer.length, false) : eocdrBuffer.slice(22);
+        if (!(entryCount === 65535 || centralDirectoryOffset === 4294967295)) {
+          return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
+        }
+        var zip64EocdlBuffer = newBuffer(20);
+        var zip64EocdlOffset = bufferReadStart + i - zip64EocdlBuffer.length;
+        readAndAssertNoEof(reader, zip64EocdlBuffer, 0, zip64EocdlBuffer.length, zip64EocdlOffset, function(err2) {
+          if (err2)
+            return callback(err2);
+          if (zip64EocdlBuffer.readUInt32LE(0) !== 117853008) {
+            return callback(new Error("invalid zip64 end of central directory locator signature"));
+          }
+          var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8);
+          var zip64EocdrBuffer = newBuffer(56);
+          readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err3) {
+            if (err3)
+              return callback(err3);
+            if (zip64EocdrBuffer.readUInt32LE(0) !== 101075792) {
+              return callback(new Error("invalid zip64 end of central directory record signature"));
+            }
+            entryCount = readUInt64LE(zip64EocdrBuffer, 32);
+            centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48);
+            return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
+          });
+        });
+        return;
       }
-      return true;
+      callback(new Error("end of central directory record signature not found"));
+    });
+  }
+  util5.inherits(ZipFile, EventEmitter3);
+  function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
+    var self2 = this;
+    EventEmitter3.call(self2);
+    self2.reader = reader;
+    self2.reader.on("error", function(err) {
+      emitError(self2, err);
+    });
+    self2.reader.once("close", function() {
+      self2.emit("close");
+    });
+    self2.readEntryCursor = centralDirectoryOffset;
+    self2.fileSize = fileSize;
+    self2.entryCount = entryCount;
+    self2.comment = comment;
+    self2.entriesRead = 0;
+    self2.autoClose = !!autoClose;
+    self2.lazyEntries = !!lazyEntries;
+    self2.decodeStrings = !!decodeStrings;
+    self2.validateEntrySizes = !!validateEntrySizes;
+    self2.strictFileNames = !!strictFileNames;
+    self2.isOpen = true;
+    self2.emittedError = false;
+    if (!self2.lazyEntries)
+      self2._readEntry();
+  }
+  ZipFile.prototype.close = function() {
+    if (!this.isOpen)
+      return;
+    this.isOpen = false;
+    this.reader.unref();
+  };
+  function emitErrorAndAutoClose(self2, err) {
+    if (self2.autoClose)
+      self2.close();
+    emitError(self2, err);
+  }
+  function emitError(self2, err) {
+    if (self2.emittedError)
+      return;
+    self2.emittedError = true;
+    self2.emit("error", err);
+  }
+  ZipFile.prototype.readEntry = function() {
+    if (!this.lazyEntries)
+      throw new Error("readEntry() called without lazyEntries:true");
+    this._readEntry();
+  };
+  ZipFile.prototype._readEntry = function() {
+    var self2 = this;
+    if (self2.entryCount === self2.entriesRead) {
+      setImmediate(function() {
+        if (self2.autoClose)
+          self2.close();
+        if (self2.emittedError)
+          return;
+        self2.emit("end");
+      });
+      return;
     }
-    function decompress(async, callback, pass) {
-      if (typeof callback === "undefined" && typeof async === "string") {
-        pass = async;
-        async = undefined;
-      }
-      if (_isDirectory) {
-        if (async && callback) {
-          callback(Buffer.alloc(0), Utils.Errors.DIRECTORY_CONTENT_ERROR());
-        }
-        return Buffer.alloc(0);
-      }
-      var compressedData = getCompressedDataFromZip();
-      if (compressedData.length === 0) {
-        if (async && callback)
-          callback(compressedData);
-        return compressedData;
-      }
-      if (_centralHeader.encrypted) {
-        if (typeof pass !== "string" && !Buffer.isBuffer(pass)) {
-          throw Utils.Errors.INVALID_PASS_PARAM();
-        }
-        compressedData = Methods.ZipCrypto.decrypt(compressedData, _centralHeader, pass);
-      }
-      var data = Buffer.alloc(_centralHeader.size);
-      switch (_centralHeader.method) {
-        case Utils.Constants.STORED:
-          compressedData.copy(data);
-          if (!crc32OK(data)) {
-            if (async && callback)
-              callback(data, Utils.Errors.BAD_CRC());
-            throw Utils.Errors.BAD_CRC();
-          } else {
-            if (async && callback)
-              callback(data);
-            return data;
-          }
-        case Utils.Constants.DEFLATED:
-          var inflater = new Methods.Inflater(compressedData, _centralHeader.size);
-          if (!async) {
-            const result = inflater.inflate(data);
-            result.copy(data, 0);
-            if (!crc32OK(data)) {
-              throw Utils.Errors.BAD_CRC(`"${decoder.decode(_entryName)}"`);
-            }
-            return data;
-          } else {
-            inflater.inflateAsync(function(result) {
-              result.copy(result, 0);
-              if (callback) {
-                if (!crc32OK(result)) {
-                  callback(result, Utils.Errors.BAD_CRC());
-                } else {
-                  callback(result);
-                }
-              }
-            });
+    if (self2.emittedError)
+      return;
+    var buffer = newBuffer(46);
+    readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, self2.readEntryCursor, function(err) {
+      if (err)
+        return emitErrorAndAutoClose(self2, err);
+      if (self2.emittedError)
+        return;
+      var entry = new Entry;
+      var signature = buffer.readUInt32LE(0);
+      if (signature !== 33639248)
+        return emitErrorAndAutoClose(self2, new Error("invalid central directory file header signature: 0x" + signature.toString(16)));
+      entry.versionMadeBy = buffer.readUInt16LE(4);
+      entry.versionNeededToExtract = buffer.readUInt16LE(6);
+      entry.generalPurposeBitFlag = buffer.readUInt16LE(8);
+      entry.compressionMethod = buffer.readUInt16LE(10);
+      entry.lastModFileTime = buffer.readUInt16LE(12);
+      entry.lastModFileDate = buffer.readUInt16LE(14);
+      entry.crc32 = buffer.readUInt32LE(16);
+      entry.compressedSize = buffer.readUInt32LE(20);
+      entry.uncompressedSize = buffer.readUInt32LE(24);
+      entry.fileNameLength = buffer.readUInt16LE(28);
+      entry.extraFieldLength = buffer.readUInt16LE(30);
+      entry.fileCommentLength = buffer.readUInt16LE(32);
+      entry.internalFileAttributes = buffer.readUInt16LE(36);
+      entry.externalFileAttributes = buffer.readUInt32LE(38);
+      entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42);
+      if (entry.generalPurposeBitFlag & 64)
+        return emitErrorAndAutoClose(self2, new Error("strong encryption is not supported"));
+      self2.readEntryCursor += 46;
+      buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
+      readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, self2.readEntryCursor, function(err2) {
+        if (err2)
+          return emitErrorAndAutoClose(self2, err2);
+        if (self2.emittedError)
+          return;
+        var isUtf8 = (entry.generalPurposeBitFlag & 2048) !== 0;
+        entry.fileName = self2.decodeStrings ? decodeBuffer(buffer, 0, entry.fileNameLength, isUtf8) : buffer.slice(0, entry.fileNameLength);
+        var fileCommentStart = entry.fileNameLength + entry.extraFieldLength;
+        var extraFieldBuffer = buffer.slice(entry.fileNameLength, fileCommentStart);
+        entry.extraFields = [];
+        var i = 0;
+        while (i < extraFieldBuffer.length - 3) {
+          var headerId = extraFieldBuffer.readUInt16LE(i + 0);
+          var dataSize = extraFieldBuffer.readUInt16LE(i + 2);
+          var dataStart = i + 4;
+          var dataEnd = dataStart + dataSize;
+          if (dataEnd > extraFieldBuffer.length)
+            return emitErrorAndAutoClose(self2, new Error("extra field length exceeds extra field buffer size"));
+          var dataBuffer = newBuffer(dataSize);
+          extraFieldBuffer.copy(dataBuffer, 0, dataStart, dataEnd);
+          entry.extraFields.push({
+            id: headerId,
+            data: dataBuffer
+          });
+          i = dataEnd;
+        }
+        entry.fileComment = self2.decodeStrings ? decodeBuffer(buffer, fileCommentStart, fileCommentStart + entry.fileCommentLength, isUtf8) : buffer.slice(fileCommentStart, fileCommentStart + entry.fileCommentLength);
+        entry.comment = entry.fileComment;
+        self2.readEntryCursor += buffer.length;
+        self2.entriesRead += 1;
+        if (entry.uncompressedSize === 4294967295 || entry.compressedSize === 4294967295 || entry.relativeOffsetOfLocalHeader === 4294967295) {
+          var zip64EiefBuffer = null;
+          for (var i = 0;i < entry.extraFields.length; i++) {
+            var extraField = entry.extraFields[i];
+            if (extraField.id === 1) {
+              zip64EiefBuffer = extraField.data;
+              break;
+            }
           }
-          break;
-        default:
-          if (async && callback)
-            callback(Buffer.alloc(0), Utils.Errors.UNKNOWN_METHOD());
-          throw Utils.Errors.UNKNOWN_METHOD();
-      }
-    }
-    function compress(async, callback) {
-      if ((!uncompressedData || !uncompressedData.length) && Buffer.isBuffer(input)) {
-        if (async && callback)
-          callback(getCompressedDataFromZip());
-        return getCompressedDataFromZip();
-      }
-      if (uncompressedData.length && !_isDirectory) {
-        var compressedData;
-        switch (_centralHeader.method) {
-          case Utils.Constants.STORED:
-            _centralHeader.compressedSize = _centralHeader.size;
-            compressedData = Buffer.alloc(uncompressedData.length);
-            uncompressedData.copy(compressedData);
-            if (async && callback)
-              callback(compressedData);
-            return compressedData;
-          default:
-          case Utils.Constants.DEFLATED:
-            var deflater = new Methods.Deflater(uncompressedData);
-            if (!async) {
-              var deflated = deflater.deflate();
-              _centralHeader.compressedSize = deflated.length;
-              return deflated;
-            } else {
-              deflater.deflateAsync(function(data) {
-                compressedData = Buffer.alloc(data.length);
-                _centralHeader.compressedSize = data.length;
-                data.copy(compressedData);
-                callback && callback(compressedData);
-              });
+          if (zip64EiefBuffer == null) {
+            return emitErrorAndAutoClose(self2, new Error("expected zip64 extended information extra field"));
+          }
+          var index = 0;
+          if (entry.uncompressedSize === 4294967295) {
+            if (index + 8 > zip64EiefBuffer.length) {
+              return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include uncompressed size"));
             }
-            deflater = null;
-            break;
+            entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
+            index += 8;
+          }
+          if (entry.compressedSize === 4294967295) {
+            if (index + 8 > zip64EiefBuffer.length) {
+              return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include compressed size"));
+            }
+            entry.compressedSize = readUInt64LE(zip64EiefBuffer, index);
+            index += 8;
+          }
+          if (entry.relativeOffsetOfLocalHeader === 4294967295) {
+            if (index + 8 > zip64EiefBuffer.length) {
+              return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include relative header offset"));
+            }
+            entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
+            index += 8;
+          }
         }
-      } else if (async && callback) {
-        callback(Buffer.alloc(0));
-      } else {
-        return Buffer.alloc(0);
-      }
-    }
-    function readUInt64LE(buffer, offset) {
-      return (buffer.readUInt32LE(offset + 4) << 4) + buffer.readUInt32LE(offset);
-    }
-    function parseExtra(data) {
-      try {
-        var offset = 0;
-        var signature, size, part;
-        while (offset + 4 < data.length) {
-          signature = data.readUInt16LE(offset);
-          offset += 2;
-          size = data.readUInt16LE(offset);
-          offset += 2;
-          part = data.slice(offset, offset + size);
-          offset += size;
-          if (Constants.ID_ZIP64 === signature) {
-            parseZip64ExtendedInformation(part);
+        if (self2.decodeStrings) {
+          for (var i = 0;i < entry.extraFields.length; i++) {
+            var extraField = entry.extraFields[i];
+            if (extraField.id === 28789) {
+              if (extraField.data.length < 6) {
+                continue;
+              }
+              if (extraField.data.readUInt8(0) !== 1) {
+                continue;
+              }
+              var oldNameCrc32 = extraField.data.readUInt32LE(1);
+              if (crc32.unsigned(buffer.slice(0, entry.fileNameLength)) !== oldNameCrc32) {
+                continue;
+              }
+              entry.fileName = decodeBuffer(extraField.data, 5, extraField.data.length, true);
+              break;
+            }
           }
         }
-      } catch (error) {
-        throw Utils.Errors.EXTRA_FIELD_PARSE_ERROR();
-      }
-    }
-    function parseZip64ExtendedInformation(data) {
-      var size, compressedSize, offset, diskNumStart;
-      if (data.length >= Constants.EF_ZIP64_SCOMP) {
-        size = readUInt64LE(data, Constants.EF_ZIP64_SUNCOMP);
-        if (_centralHeader.size === Constants.EF_ZIP64_OR_32) {
-          _centralHeader.size = size;
+        if (self2.validateEntrySizes && entry.compressionMethod === 0) {
+          var expectedCompressedSize = entry.uncompressedSize;
+          if (entry.isEncrypted()) {
+            expectedCompressedSize += 12;
+          }
+          if (entry.compressedSize !== expectedCompressedSize) {
+            var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize;
+            return emitErrorAndAutoClose(self2, new Error(msg));
+          }
         }
-      }
-      if (data.length >= Constants.EF_ZIP64_RHO) {
-        compressedSize = readUInt64LE(data, Constants.EF_ZIP64_SCOMP);
-        if (_centralHeader.compressedSize === Constants.EF_ZIP64_OR_32) {
-          _centralHeader.compressedSize = compressedSize;
+        if (self2.decodeStrings) {
+          if (!self2.strictFileNames) {
+            entry.fileName = entry.fileName.replace(/\\/g, "/");
+          }
+          var errorMessage = validateFileName(entry.fileName, self2.validateFileNameOptions);
+          if (errorMessage != null)
+            return emitErrorAndAutoClose(self2, new Error(errorMessage));
         }
-      }
-      if (data.length >= Constants.EF_ZIP64_DSN) {
-        offset = readUInt64LE(data, Constants.EF_ZIP64_RHO);
-        if (_centralHeader.offset === Constants.EF_ZIP64_OR_32) {
-          _centralHeader.offset = offset;
+        self2.emit("entry", entry);
+        if (!self2.lazyEntries)
+          self2._readEntry();
+      });
+    });
+  };
+  ZipFile.prototype.openReadStream = function(entry, options, callback) {
+    var self2 = this;
+    var relativeStart = 0;
+    var relativeEnd = entry.compressedSize;
+    if (callback == null) {
+      callback = options;
+      options = {};
+    } else {
+      if (options.decrypt != null) {
+        if (!entry.isEncrypted()) {
+          throw new Error("options.decrypt can only be specified for encrypted entries");
         }
-      }
-      if (data.length >= Constants.EF_ZIP64_DSN + 4) {
-        diskNumStart = data.readUInt32LE(Constants.EF_ZIP64_DSN);
-        if (_centralHeader.diskNumStart === Constants.EF_ZIP64_OR_16) {
-          _centralHeader.diskNumStart = diskNumStart;
+        if (options.decrypt !== false)
+          throw new Error("invalid options.decrypt value: " + options.decrypt);
+        if (entry.isCompressed()) {
+          if (options.decompress !== false)
+            throw new Error("entry is encrypted and compressed, and options.decompress !== false");
         }
       }
-    }
-    return {
-      get entryName() {
-        return decoder.decode(_entryName);
-      },
-      get rawEntryName() {
-        return _entryName;
-      },
-      set entryName(val) {
-        _entryName = Utils.toBuffer(val, decoder.encode);
-        var lastChar = _entryName[_entryName.length - 1];
-        _isDirectory = lastChar === 47 || lastChar === 92;
-        _centralHeader.fileNameLength = _entryName.length;
-      },
-      get efs() {
-        if (typeof _efs === "function") {
-          return _efs(this.entryName);
-        } else {
-          return _efs;
-        }
-      },
-      get extra() {
-        return _extra;
-      },
-      set extra(val) {
-        _extra = val;
-        _centralHeader.extraLength = val.length;
-        parseExtra(val);
-      },
-      get comment() {
-        return decoder.decode(_comment);
-      },
-      set comment(val) {
-        _comment = Utils.toBuffer(val, decoder.encode);
-        _centralHeader.commentLength = _comment.length;
-        if (_comment.length > 65535)
-          throw Utils.Errors.COMMENT_TOO_LONG();
-      },
-      get name() {
-        var n = decoder.decode(_entryName);
-        return _isDirectory ? n.substr(n.length - 1).split("/").pop() : n.split("/").pop();
-      },
-      get isDirectory() {
-        return _isDirectory;
-      },
-      getCompressedData: function() {
-        return compress(false, null);
-      },
-      getCompressedDataAsync: function(callback) {
-        compress(true, callback);
-      },
-      setData: function(value) {
-        uncompressedData = Utils.toBuffer(value, Utils.decoder.encode);
-        if (!_isDirectory && uncompressedData.length) {
-          _centralHeader.size = uncompressedData.length;
-          _centralHeader.method = Utils.Constants.DEFLATED;
-          _centralHeader.crc = Utils.crc32(value);
-          _centralHeader.changed = true;
-        } else {
-          _centralHeader.method = Utils.Constants.STORED;
-        }
-      },
-      getData: function(pass) {
-        if (_centralHeader.changed) {
-          return uncompressedData;
-        } else {
-          return decompress(false, null, pass);
+      if (options.decompress != null) {
+        if (!entry.isCompressed()) {
+          throw new Error("options.decompress can only be specified for compressed entries");
         }
-      },
-      getDataAsync: function(callback, pass) {
-        if (_centralHeader.changed) {
-          callback(uncompressedData);
-        } else {
-          decompress(true, callback, pass);
+        if (!(options.decompress === false || options.decompress === true)) {
+          throw new Error("invalid options.decompress value: " + options.decompress);
         }
-      },
-      set attr(attr) {
-        _centralHeader.attr = attr;
-      },
-      get attr() {
-        return _centralHeader.attr;
-      },
-      set header(data) {
-        _centralHeader.loadFromBinary(data);
-      },
-      get header() {
-        return _centralHeader;
-      },
-      packCentralHeader: function() {
-        _centralHeader.flags_efs = this.efs;
-        _centralHeader.extraLength = _extra.length;
-        var header = _centralHeader.centralHeaderToBinary();
-        var addpos = Utils.Constants.CENHDR;
-        _entryName.copy(header, addpos);
-        addpos += _entryName.length;
-        _extra.copy(header, addpos);
-        addpos += _centralHeader.extraLength;
-        _comment.copy(header, addpos);
-        return header;
-      },
-      packLocalHeader: function() {
-        let addpos = 0;
-        _centralHeader.flags_efs = this.efs;
-        _centralHeader.extraLocalLength = _extralocal.length;
-        const localHeaderBuf = _centralHeader.localHeaderToBinary();
-        const localHeader = Buffer.alloc(localHeaderBuf.length + _entryName.length + _centralHeader.extraLocalLength);
-        localHeaderBuf.copy(localHeader, addpos);
-        addpos += localHeaderBuf.length;
-        _entryName.copy(localHeader, addpos);
-        addpos += _entryName.length;
-        _extralocal.copy(localHeader, addpos);
-        addpos += _extralocal.length;
-        return localHeader;
-      },
-      toJSON: function() {
-        const bytes = function(nr) {
-          return "<" + (nr && nr.length + " bytes buffer" || "null") + ">";
-        };
-        return {
-          entryName: this.entryName,
-          name: this.name,
-          comment: this.comment,
-          isDirectory: this.isDirectory,
-          header: _centralHeader.toJSON(),
-          compressedData: bytes(input),
-          data: bytes(uncompressedData)
-        };
-      },
-      toString: function() {
-        return JSON.stringify(this.toJSON(), null, "\t");
       }
-    };
-  };
-});
-
-// ../../node_modules/adm-zip/zipFile.js
-var require_zipFile = __commonJS((exports, module) => {
-  var ZipEntry = require_zipEntry();
-  var Headers2 = require_headers();
-  var Utils = require_util12();
-  module.exports = function(inBuffer, options) {
-    var entryList = [], entryTable = {}, _comment = Buffer.alloc(0), mainHeader = new Headers2.MainHeader, loadedEntries = false;
-    var password = null;
-    const temporary = new Set;
-    const opts = options;
-    const { noSort, decoder } = opts;
-    if (inBuffer) {
-      readMainHeader(opts.readEntries);
-    } else {
-      loadedEntries = true;
-    }
-    function makeTemporaryFolders() {
-      const foldersList = new Set;
-      for (const elem of Object.keys(entryTable)) {
-        const elements = elem.split("/");
-        elements.pop();
-        if (!elements.length)
-          continue;
-        for (let i = 0;i < elements.length; i++) {
-          const sub = elements.slice(0, i + 1).join("/") + "/";
-          foldersList.add(sub);
-        }
-      }
-      for (const elem of foldersList) {
-        if (!(elem in entryTable)) {
-          const tempfolder = new ZipEntry(opts);
-          tempfolder.entryName = elem;
-          tempfolder.attr = 16;
-          tempfolder.temporary = true;
-          entryList.push(tempfolder);
-          entryTable[tempfolder.entryName] = tempfolder;
-          temporary.add(tempfolder);
-        }
-      }
-    }
-    function readEntries() {
-      loadedEntries = true;
-      entryTable = {};
-      if (mainHeader.diskEntries > (inBuffer.length - mainHeader.offset) / Utils.Constants.CENHDR) {
-        throw Utils.Errors.DISK_ENTRY_TOO_LARGE();
-      }
-      entryList = new Array(mainHeader.diskEntries);
-      var index = mainHeader.offset;
-      for (var i = 0;i < entryList.length; i++) {
-        var tmp = index, entry = new ZipEntry(opts, inBuffer);
-        entry.header = inBuffer.slice(tmp, tmp += Utils.Constants.CENHDR);
-        entry.entryName = inBuffer.slice(tmp, tmp += entry.header.fileNameLength);
-        if (entry.header.extraLength) {
-          entry.extra = inBuffer.slice(tmp, tmp += entry.header.extraLength);
-        }
-        if (entry.header.commentLength)
-          entry.comment = inBuffer.slice(tmp, tmp + entry.header.commentLength);
-        index += entry.header.centralHeaderSize;
-        entryList[i] = entry;
-        entryTable[entry.entryName] = entry;
-      }
-      temporary.clear();
-      makeTemporaryFolders();
-    }
-    function readMainHeader(readNow) {
-      var i = inBuffer.length - Utils.Constants.ENDHDR, max = Math.max(0, i - 65535), n = max, endStart = inBuffer.length, endOffset = -1, commentEnd = 0;
-      const trailingSpace = typeof opts.trailingSpace === "boolean" ? opts.trailingSpace : false;
-      if (trailingSpace)
-        max = 0;
-      for (i;i >= n; i--) {
-        if (inBuffer[i] !== 80)
-          continue;
-        if (inBuffer.readUInt32LE(i) === Utils.Constants.ENDSIG) {
-          endOffset = i;
-          commentEnd = i;
-          endStart = i + Utils.Constants.ENDHDR;
-          n = i - Utils.Constants.END64HDR;
-          continue;
-        }
-        if (inBuffer.readUInt32LE(i) === Utils.Constants.END64SIG) {
-          n = max;
-          continue;
+      if (options.start != null || options.end != null) {
+        if (entry.isCompressed() && options.decompress !== false) {
+          throw new Error("start/end range not allowed for compressed entry without options.decompress === false");
         }
-        if (inBuffer.readUInt32LE(i) === Utils.Constants.ZIP64SIG) {
-          endOffset = i;
-          endStart = i + Utils.readBigUInt64LE(inBuffer, i + Utils.Constants.ZIP64SIZE) + Utils.Constants.ZIP64LEAD;
-          break;
+        if (entry.isEncrypted() && options.decrypt !== false) {
+          throw new Error("start/end range not allowed for encrypted entry without options.decrypt === false");
         }
       }
-      if (endOffset == -1)
-        throw Utils.Errors.INVALID_FORMAT();
-      mainHeader.loadFromBinary(inBuffer.slice(endOffset, endStart));
-      if (mainHeader.commentLength) {
-        _comment = inBuffer.slice(commentEnd + Utils.Constants.ENDHDR);
+      if (options.start != null) {
+        relativeStart = options.start;
+        if (relativeStart < 0)
+          throw new Error("options.start < 0");
+        if (relativeStart > entry.compressedSize)
+          throw new Error("options.start > entry.compressedSize");
       }
-      if (readNow)
-        readEntries();
-    }
-    function sortEntries() {
-      if (entryList.length > 1 && !noSort) {
-        entryList.sort((a, b) => a.entryName.toLowerCase().localeCompare(b.entryName.toLowerCase()));
+      if (options.end != null) {
+        relativeEnd = options.end;
+        if (relativeEnd < 0)
+          throw new Error("options.end < 0");
+        if (relativeEnd > entry.compressedSize)
+          throw new Error("options.end > entry.compressedSize");
+        if (relativeEnd < relativeStart)
+          throw new Error("options.end < options.start");
       }
     }
-    return {
-      get entries() {
-        if (!loadedEntries) {
-          readEntries();
-        }
-        return entryList.filter((e) => !temporary.has(e));
-      },
-      get comment() {
-        return decoder.decode(_comment);
-      },
-      set comment(val) {
-        _comment = Utils.toBuffer(val, decoder.encode);
-        mainHeader.commentLength = _comment.length;
-      },
-      getEntryCount: function() {
-        if (!loadedEntries) {
-          return mainHeader.diskEntries;
-        }
-        return entryList.length;
-      },
-      forEach: function(callback) {
-        this.entries.forEach(callback);
-      },
-      getEntry: function(entryName) {
-        if (!loadedEntries) {
-          readEntries();
-        }
-        return entryTable[entryName] || null;
-      },
-      setEntry: function(entry) {
-        if (!loadedEntries) {
-          readEntries();
-        }
-        entryList.push(entry);
-        entryTable[entry.entryName] = entry;
-        mainHeader.totalEntries = entryList.length;
-      },
-      deleteFile: function(entryName, withsubfolders = true) {
-        if (!loadedEntries) {
-          readEntries();
-        }
-        const entry = entryTable[entryName];
-        const list = this.getEntryChildren(entry, withsubfolders).map((child) => child.entryName);
-        list.forEach(this.deleteEntry);
-      },
-      deleteEntry: function(entryName) {
-        if (!loadedEntries) {
-          readEntries();
-        }
-        const entry = entryTable[entryName];
-        const index = entryList.indexOf(entry);
-        if (index >= 0) {
-          entryList.splice(index, 1);
-          delete entryTable[entryName];
-          mainHeader.totalEntries = entryList.length;
-        }
-      },
-      getEntryChildren: function(entry, subfolders = true) {
-        if (!loadedEntries) {
-          readEntries();
+    if (!self2.isOpen)
+      return callback(new Error("closed"));
+    if (entry.isEncrypted()) {
+      if (options.decrypt !== false)
+        return callback(new Error("entry is encrypted, and options.decrypt !== false"));
+    }
+    self2.reader.ref();
+    var buffer = newBuffer(30);
+    readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) {
+      try {
+        if (err)
+          return callback(err);
+        var signature = buffer.readUInt32LE(0);
+        if (signature !== 67324752) {
+          return callback(new Error("invalid local file header signature: 0x" + signature.toString(16)));
+        }
+        var fileNameLength = buffer.readUInt16LE(26);
+        var extraFieldLength = buffer.readUInt16LE(28);
+        var localFileHeaderEnd = entry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength;
+        var decompress;
+        if (entry.compressionMethod === 0) {
+          decompress = false;
+        } else if (entry.compressionMethod === 8) {
+          decompress = options.decompress != null ? options.decompress : true;
+        } else {
+          return callback(new Error("unsupported compression method: " + entry.compressionMethod));
         }
-        if (typeof entry === "object") {
-          if (entry.isDirectory && subfolders) {
-            const list = [];
-            const name = entry.entryName;
-            for (const zipEntry of entryList) {
-              if (zipEntry.entryName.startsWith(name)) {
-                list.push(zipEntry);
-              }
-            }
-            return list;
-          } else {
-            return [entry];
+        var fileDataStart = localFileHeaderEnd;
+        var fileDataEnd = fileDataStart + entry.compressedSize;
+        if (entry.compressedSize !== 0) {
+          if (fileDataEnd > self2.fileSize) {
+            return callback(new Error("file data overflows file bounds: " + fileDataStart + " + " + entry.compressedSize + " > " + self2.fileSize));
           }
         }
-        return [];
-      },
-      getChildCount: function(entry) {
-        if (entry && entry.isDirectory) {
-          const list = this.getEntryChildren(entry);
-          return list.includes(entry) ? list.length - 1 : list.length;
-        }
-        return 0;
-      },
-      compressToBuffer: function() {
-        if (!loadedEntries) {
-          readEntries();
-        }
-        sortEntries();
-        const dataBlock = [];
-        const headerBlocks = [];
-        let totalSize = 0;
-        let dindex = 0;
-        mainHeader.size = 0;
-        mainHeader.offset = 0;
-        let totalEntries = 0;
-        for (const entry of this.entries) {
-          const compressedData = entry.getCompressedData();
-          entry.header.offset = dindex;
-          const localHeader = entry.packLocalHeader();
-          const dataLength = localHeader.length + compressedData.length;
-          dindex += dataLength;
-          dataBlock.push(localHeader);
-          dataBlock.push(compressedData);
-          const centralHeader = entry.packCentralHeader();
-          headerBlocks.push(centralHeader);
-          mainHeader.size += centralHeader.length;
-          totalSize += dataLength + centralHeader.length;
-          totalEntries++;
-        }
-        totalSize += mainHeader.mainHeaderSize;
-        mainHeader.offset = dindex;
-        mainHeader.totalEntries = totalEntries;
-        dindex = 0;
-        const outBuffer = Buffer.alloc(totalSize);
-        for (const content of dataBlock) {
-          content.copy(outBuffer, dindex);
-          dindex += content.length;
-        }
-        for (const content of headerBlocks) {
-          content.copy(outBuffer, dindex);
-          dindex += content.length;
-        }
-        const mh = mainHeader.toBinary();
-        if (_comment) {
-          _comment.copy(mh, Utils.Constants.ENDHDR);
-        }
-        mh.copy(outBuffer, dindex);
-        inBuffer = outBuffer;
-        loadedEntries = false;
-        return outBuffer;
-      },
-      toAsyncBuffer: function(onSuccess, onFail, onItemStart, onItemEnd) {
-        try {
-          if (!loadedEntries) {
-            readEntries();
-          }
-          sortEntries();
-          const dataBlock = [];
-          const centralHeaders = [];
-          let totalSize = 0;
-          let dindex = 0;
-          let totalEntries = 0;
-          mainHeader.size = 0;
-          mainHeader.offset = 0;
-          const compress2Buffer = function(entryLists) {
-            if (entryLists.length > 0) {
-              const entry = entryLists.shift();
-              const name = entry.entryName + entry.extra.toString();
-              if (onItemStart)
-                onItemStart(name);
-              entry.getCompressedDataAsync(function(compressedData) {
-                if (onItemEnd)
-                  onItemEnd(name);
-                entry.header.offset = dindex;
-                const localHeader = entry.packLocalHeader();
-                const dataLength = localHeader.length + compressedData.length;
-                dindex += dataLength;
-                dataBlock.push(localHeader);
-                dataBlock.push(compressedData);
-                const centalHeader = entry.packCentralHeader();
-                centralHeaders.push(centalHeader);
-                mainHeader.size += centalHeader.length;
-                totalSize += dataLength + centalHeader.length;
-                totalEntries++;
-                compress2Buffer(entryLists);
-              });
-            } else {
-              totalSize += mainHeader.mainHeaderSize;
-              mainHeader.offset = dindex;
-              mainHeader.totalEntries = totalEntries;
-              dindex = 0;
-              const outBuffer = Buffer.alloc(totalSize);
-              dataBlock.forEach(function(content) {
-                content.copy(outBuffer, dindex);
-                dindex += content.length;
-              });
-              centralHeaders.forEach(function(content) {
-                content.copy(outBuffer, dindex);
-                dindex += content.length;
+        var readStream2 = self2.reader.createReadStream({
+          start: fileDataStart + relativeStart,
+          end: fileDataStart + relativeEnd
+        });
+        var endpointStream = readStream2;
+        if (decompress) {
+          var destroyed = false;
+          var inflateFilter = zlib2.createInflateRaw();
+          readStream2.on("error", function(err2) {
+            setImmediate(function() {
+              if (!destroyed)
+                inflateFilter.emit("error", err2);
+            });
+          });
+          readStream2.pipe(inflateFilter);
+          if (self2.validateEntrySizes) {
+            endpointStream = new AssertByteCountStream(entry.uncompressedSize);
+            inflateFilter.on("error", function(err2) {
+              setImmediate(function() {
+                if (!destroyed)
+                  endpointStream.emit("error", err2);
               });
-              const mh = mainHeader.toBinary();
-              if (_comment) {
-                _comment.copy(mh, Utils.Constants.ENDHDR);
-              }
-              mh.copy(outBuffer, dindex);
-              inBuffer = outBuffer;
-              loadedEntries = false;
-              onSuccess(outBuffer);
-            }
+            });
+            inflateFilter.pipe(endpointStream);
+          } else {
+            endpointStream = inflateFilter;
+          }
+          endpointStream.destroy = function() {
+            destroyed = true;
+            if (inflateFilter !== endpointStream)
+              inflateFilter.unpipe(endpointStream);
+            readStream2.unpipe(inflateFilter);
+            readStream2.destroy();
           };
-          compress2Buffer(Array.from(this.entries));
-        } catch (e) {
-          onFail(e);
-        }
-      }
-    };
-  };
-});
-
-// ../../node_modules/adm-zip/adm-zip.js
-var require_adm_zip = __commonJS((exports, module) => {
-  var Utils = require_util12();
-  var pth = __require("path");
-  var ZipEntry = require_zipEntry();
-  var ZipFile = require_zipFile();
-  var get_Bool = (...val) => Utils.findLast(val, (c) => typeof c === "boolean");
-  var get_Str = (...val) => Utils.findLast(val, (c) => typeof c === "string");
-  var get_Fun = (...val) => Utils.findLast(val, (c) => typeof c === "function");
-  var defaultOptions2 = {
-    noSort: false,
-    readEntries: false,
-    method: Utils.Constants.NONE,
-    fs: null
-  };
-  module.exports = function(input, options) {
-    let inBuffer = null;
-    const opts = Object.assign(Object.create(null), defaultOptions2);
-    if (input && typeof input === "object") {
-      if (!(input instanceof Uint8Array)) {
-        Object.assign(opts, input);
-        input = opts.input ? opts.input : undefined;
-        if (opts.input)
-          delete opts.input;
-      }
-      if (Buffer.isBuffer(input)) {
-        inBuffer = input;
-        opts.method = Utils.Constants.BUFFER;
-        input = undefined;
-      }
-    }
-    Object.assign(opts, options);
-    const filetools = new Utils(opts);
-    if (typeof opts.decoder !== "object" || typeof opts.decoder.encode !== "function" || typeof opts.decoder.decode !== "function") {
-      opts.decoder = Utils.decoder;
-    }
-    if (input && typeof input === "string") {
-      if (filetools.fs.existsSync(input)) {
-        opts.method = Utils.Constants.FILE;
-        opts.filename = input;
-        inBuffer = filetools.fs.readFileSync(input);
-      } else {
-        throw Utils.Errors.INVALID_FILENAME();
-      }
-    }
-    const _zip = new ZipFile(inBuffer, opts);
-    const { canonical, sanitize, zipnamefix } = Utils;
-    function getEntry(entry) {
-      if (entry && _zip) {
-        var item;
-        if (typeof entry === "string")
-          item = _zip.getEntry(pth.posix.normalize(entry));
-        if (typeof entry === "object" && typeof entry.entryName !== "undefined" && typeof entry.header !== "undefined")
-          item = _zip.getEntry(entry.entryName);
-        if (item) {
-          return item;
         }
+        callback(null, endpointStream);
+      } finally {
+        self2.reader.unref();
       }
-      return null;
+    });
+  };
+  function Entry() {}
+  Entry.prototype.getLastModDate = function() {
+    return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime);
+  };
+  Entry.prototype.isEncrypted = function() {
+    return (this.generalPurposeBitFlag & 1) !== 0;
+  };
+  Entry.prototype.isCompressed = function() {
+    return this.compressionMethod === 8;
+  };
+  function dosDateTimeToDate(date, time) {
+    var day = date & 31;
+    var month = (date >> 5 & 15) - 1;
+    var year = (date >> 9 & 127) + 1980;
+    var millisecond = 0;
+    var second = (time & 31) * 2;
+    var minute = time >> 5 & 63;
+    var hour = time >> 11 & 31;
+    return new Date(year, month, day, hour, minute, second, millisecond);
+  }
+  function validateFileName(fileName) {
+    if (fileName.indexOf("\\") !== -1) {
+      return "invalid characters in fileName: " + fileName;
     }
-    function fixPath(zipPath) {
-      const { join: join3, normalize: normalize2, sep } = pth.posix;
-      return join3(".", normalize2(sep + zipPath.split("\\").join(sep) + sep));
+    if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) {
+      return "absolute path: " + fileName;
     }
-    function filenameFilter(filterfn) {
-      if (filterfn instanceof RegExp) {
-        return function(rx) {
-          return function(filename) {
-            return rx.test(filename);
-          };
-        }(filterfn);
-      } else if (typeof filterfn !== "function") {
-        return () => true;
+    if (fileName.split("/").indexOf("..") !== -1) {
+      return "invalid relative path: " + fileName;
+    }
+    return null;
+  }
+  function readAndAssertNoEof(reader, buffer, offset, length, position, callback) {
+    if (length === 0) {
+      return setImmediate(function() {
+        callback(null, newBuffer(0));
+      });
+    }
+    reader.read(buffer, offset, length, position, function(err, bytesRead) {
+      if (err)
+        return callback(err);
+      if (bytesRead < length) {
+        return callback(new Error("unexpected EOF"));
       }
-      return filterfn;
+      callback();
+    });
+  }
+  util5.inherits(AssertByteCountStream, Transform);
+  function AssertByteCountStream(byteCount) {
+    Transform.call(this);
+    this.actualByteCount = 0;
+    this.expectedByteCount = byteCount;
+  }
+  AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) {
+    this.actualByteCount += chunk.length;
+    if (this.actualByteCount > this.expectedByteCount) {
+      var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount;
+      return cb(new Error(msg));
+    }
+    cb(null, chunk);
+  };
+  AssertByteCountStream.prototype._flush = function(cb) {
+    if (this.actualByteCount < this.expectedByteCount) {
+      var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount;
+      return cb(new Error(msg));
+    }
+    cb();
+  };
+  util5.inherits(RandomAccessReader, EventEmitter3);
+  function RandomAccessReader() {
+    EventEmitter3.call(this);
+    this.refCount = 0;
+  }
+  RandomAccessReader.prototype.ref = function() {
+    this.refCount += 1;
+  };
+  RandomAccessReader.prototype.unref = function() {
+    var self2 = this;
+    self2.refCount -= 1;
+    if (self2.refCount > 0)
+      return;
+    if (self2.refCount < 0)
+      throw new Error("invalid unref");
+    self2.close(onCloseDone);
+    function onCloseDone(err) {
+      if (err)
+        return self2.emit("error", err);
+      self2.emit("close");
+    }
+  };
+  RandomAccessReader.prototype.createReadStream = function(options) {
+    var start = options.start;
+    var end = options.end;
+    if (start === end) {
+      var emptyStream = new PassThrough;
+      setImmediate(function() {
+        emptyStream.end();
+      });
+      return emptyStream;
     }
-    const relativePath = (local, entry) => {
-      let lastChar = entry.slice(-1);
-      lastChar = lastChar === filetools.sep ? filetools.sep : "";
-      return pth.relative(local, entry) + lastChar;
+    var stream4 = this._readStreamForRange(start, end);
+    var destroyed = false;
+    var refUnrefFilter = new RefUnrefFilter(this);
+    stream4.on("error", function(err) {
+      setImmediate(function() {
+        if (!destroyed)
+          refUnrefFilter.emit("error", err);
+      });
+    });
+    refUnrefFilter.destroy = function() {
+      stream4.unpipe(refUnrefFilter);
+      refUnrefFilter.unref();
+      stream4.destroy();
     };
-    return {
-      readFile: function(entry, pass) {
-        var item = getEntry(entry);
-        return item && item.getData(pass) || null;
-      },
-      childCount: function(entry) {
-        const item = getEntry(entry);
-        if (item) {
-          return _zip.getChildCount(item);
-        }
-      },
-      readFileAsync: function(entry, callback) {
-        var item = getEntry(entry);
-        if (item) {
-          item.getDataAsync(callback);
-        } else {
-          callback(null, "getEntry failed for:" + entry);
-        }
-      },
-      readAsText: function(entry, encoding) {
-        var item = getEntry(entry);
-        if (item) {
-          var data = item.getData();
-          if (data && data.length) {
-            return data.toString(encoding || "utf8");
-          }
-        }
-        return "";
-      },
-      readAsTextAsync: function(entry, callback, encoding) {
-        var item = getEntry(entry);
-        if (item) {
-          item.getDataAsync(function(data, err) {
-            if (err) {
-              callback(data, err);
-              return;
-            }
-            if (data && data.length) {
-              callback(data.toString(encoding || "utf8"));
-            } else {
-              callback("");
-            }
-          });
-        } else {
-          callback("");
-        }
-      },
-      deleteFile: function(entry, withsubfolders = true) {
-        var item = getEntry(entry);
-        if (item) {
-          _zip.deleteFile(item.entryName, withsubfolders);
-        }
-      },
-      deleteEntry: function(entry) {
-        var item = getEntry(entry);
-        if (item) {
-          _zip.deleteEntry(item.entryName);
-        }
-      },
-      addZipComment: function(comment) {
-        _zip.comment = comment;
-      },
-      getZipComment: function() {
-        return _zip.comment || "";
-      },
-      addZipEntryComment: function(entry, comment) {
-        var item = getEntry(entry);
-        if (item) {
-          item.comment = comment;
-        }
-      },
-      getZipEntryComment: function(entry) {
-        var item = getEntry(entry);
-        if (item) {
-          return item.comment || "";
-        }
-        return "";
-      },
-      updateFile: function(entry, content) {
-        var item = getEntry(entry);
-        if (item) {
-          item.setData(content);
-        }
-      },
-      addLocalFile: function(localPath2, zipPath, zipName, comment) {
-        if (filetools.fs.existsSync(localPath2)) {
-          zipPath = zipPath ? fixPath(zipPath) : "";
-          const p = pth.win32.basename(pth.win32.normalize(localPath2));
-          zipPath += zipName ? zipName : p;
-          const _attr = filetools.fs.statSync(localPath2);
-          const data = _attr.isFile() ? filetools.fs.readFileSync(localPath2) : Buffer.alloc(0);
-          if (_attr.isDirectory())
-            zipPath += filetools.sep;
-          this.addFile(zipPath, data, comment, _attr);
-        } else {
-          throw Utils.Errors.FILE_NOT_FOUND(localPath2);
-        }
-      },
-      addLocalFileAsync: function(options2, callback) {
-        options2 = typeof options2 === "object" ? options2 : { localPath: options2 };
-        const localPath2 = pth.resolve(options2.localPath);
-        const { comment } = options2;
-        let { zipPath, zipName } = options2;
-        const self2 = this;
-        filetools.fs.stat(localPath2, function(err, stats) {
-          if (err)
-            return callback(err, false);
-          zipPath = zipPath ? fixPath(zipPath) : "";
-          const p = pth.win32.basename(pth.win32.normalize(localPath2));
-          zipPath += zipName ? zipName : p;
-          if (stats.isFile()) {
-            filetools.fs.readFile(localPath2, function(err2, data) {
-              if (err2)
-                return callback(err2, false);
-              self2.addFile(zipPath, data, comment, stats);
-              return setImmediate(callback, undefined, true);
-            });
-          } else if (stats.isDirectory()) {
-            zipPath += filetools.sep;
-            self2.addFile(zipPath, Buffer.alloc(0), comment, stats);
-            return setImmediate(callback, undefined, true);
-          }
-        });
-      },
-      addLocalFolder: function(localPath2, zipPath, filter2) {
-        filter2 = filenameFilter(filter2);
-        zipPath = zipPath ? fixPath(zipPath) : "";
-        localPath2 = pth.normalize(localPath2);
-        if (filetools.fs.existsSync(localPath2)) {
-          const items = filetools.findFiles(localPath2);
-          const self2 = this;
-          if (items.length) {
-            for (const filepath of items) {
-              const p = pth.join(zipPath, relativePath(localPath2, filepath));
-              if (filter2(p)) {
-                self2.addLocalFile(filepath, pth.dirname(p));
-              }
-            }
-          }
-        } else {
-          throw Utils.Errors.FILE_NOT_FOUND(localPath2);
-        }
-      },
-      addLocalFolderAsync: function(localPath2, callback, zipPath, filter2) {
-        filter2 = filenameFilter(filter2);
-        zipPath = zipPath ? fixPath(zipPath) : "";
-        localPath2 = pth.normalize(localPath2);
-        var self2 = this;
-        filetools.fs.open(localPath2, "r", function(err) {
-          if (err && err.code === "ENOENT") {
-            callback(undefined, Utils.Errors.FILE_NOT_FOUND(localPath2));
-          } else if (err) {
-            callback(undefined, err);
-          } else {
-            var items = filetools.findFiles(localPath2);
-            var i = -1;
-            var next = function() {
-              i += 1;
-              if (i < items.length) {
-                var filepath = items[i];
-                var p = relativePath(localPath2, filepath).split("\\").join("/");
-                p = p.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^\x20-\x7E]/g, "");
-                if (filter2(p)) {
-                  filetools.fs.stat(filepath, function(er0, stats) {
-                    if (er0)
-                      callback(undefined, er0);
-                    if (stats.isFile()) {
-                      filetools.fs.readFile(filepath, function(er1, data) {
-                        if (er1) {
-                          callback(undefined, er1);
-                        } else {
-                          self2.addFile(zipPath + p, data, "", stats);
-                          next();
-                        }
-                      });
-                    } else {
-                      self2.addFile(zipPath + p + "/", Buffer.alloc(0), "", stats);
-                      next();
-                    }
-                  });
-                } else {
-                  process.nextTick(() => {
-                    next();
-                  });
-                }
-              } else {
-                callback(true, undefined);
-              }
-            };
-            next();
-          }
+    var byteCounter = new AssertByteCountStream(end - start);
+    refUnrefFilter.on("error", function(err) {
+      setImmediate(function() {
+        if (!destroyed)
+          byteCounter.emit("error", err);
+      });
+    });
+    byteCounter.destroy = function() {
+      destroyed = true;
+      refUnrefFilter.unpipe(byteCounter);
+      refUnrefFilter.destroy();
+    };
+    return stream4.pipe(refUnrefFilter).pipe(byteCounter);
+  };
+  RandomAccessReader.prototype._readStreamForRange = function(start, end) {
+    throw new Error("not implemented");
+  };
+  RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) {
+    var readStream2 = this.createReadStream({ start: position, end: position + length });
+    var writeStream = new Writable;
+    var written = 0;
+    writeStream._write = function(chunk, encoding, cb) {
+      chunk.copy(buffer, offset + written, 0, chunk.length);
+      written += chunk.length;
+      cb();
+    };
+    writeStream.on("finish", callback);
+    readStream2.on("error", function(error) {
+      callback(error);
+    });
+    readStream2.pipe(writeStream);
+  };
+  RandomAccessReader.prototype.close = function(callback) {
+    setImmediate(callback);
+  };
+  util5.inherits(RefUnrefFilter, PassThrough);
+  function RefUnrefFilter(context) {
+    PassThrough.call(this);
+    this.context = context;
+    this.context.ref();
+    this.unreffedYet = false;
+  }
+  RefUnrefFilter.prototype._flush = function(cb) {
+    this.unref();
+    cb();
+  };
+  RefUnrefFilter.prototype.unref = function(cb) {
+    if (this.unreffedYet)
+      return;
+    this.unreffedYet = true;
+    this.context.unref();
+  };
+  var cp437 = "\x00☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ";
+  function decodeBuffer(buffer, start, end, isUtf8) {
+    if (isUtf8) {
+      return buffer.toString("utf8", start, end);
+    } else {
+      var result = "";
+      for (var i = start;i < end; i++) {
+        result += cp437[buffer[i]];
+      }
+      return result;
+    }
+  }
+  function readUInt64LE(buffer, offset) {
+    var lower32 = buffer.readUInt32LE(offset);
+    var upper32 = buffer.readUInt32LE(offset + 4);
+    return upper32 * 4294967296 + lower32;
+  }
+  var newBuffer;
+  if (typeof Buffer.allocUnsafe === "function") {
+    newBuffer = function(len) {
+      return Buffer.allocUnsafe(len);
+    };
+  } else {
+    newBuffer = function(len) {
+      return new Buffer(len);
+    };
+  }
+  function defaultCallback(err) {
+    if (err)
+      throw err;
+  }
+});
+
+// ../../node_modules/extract-zip/index.js
+var require_extract_zip = __commonJS((exports, module) => {
+  var debug = require_src5()("extract-zip");
+  var { createWriteStream, promises: fs2 } = __require("fs");
+  var getStream = require_get_stream();
+  var path3 = __require("path");
+  var { promisify } = __require("util");
+  var stream4 = __require("stream");
+  var yauzl = require_yauzl();
+  var openZip = promisify(yauzl.open);
+  var pipeline = promisify(stream4.pipeline);
+
+  class Extractor {
+    constructor(zipPath, opts) {
+      this.zipPath = zipPath;
+      this.opts = opts;
+    }
+    async extract() {
+      debug("opening", this.zipPath, "with opts", this.opts);
+      this.zipfile = await openZip(this.zipPath, { lazyEntries: true });
+      this.canceled = false;
+      return new Promise((resolve3, reject) => {
+        this.zipfile.on("error", (err) => {
+          this.canceled = true;
+          reject(err);
         });
-      },
-      addLocalFolderAsync2: function(options2, callback) {
-        const self2 = this;
-        options2 = typeof options2 === "object" ? options2 : { localPath: options2 };
-        localPath = pth.resolve(fixPath(options2.localPath));
-        let { zipPath, filter: filter2, namefix } = options2;
-        if (filter2 instanceof RegExp) {
-          filter2 = function(rx) {
-            return function(filename) {
-              return rx.test(filename);
-            };
-          }(filter2);
-        } else if (typeof filter2 !== "function") {
-          filter2 = function() {
-            return true;
-          };
-        }
-        zipPath = zipPath ? fixPath(zipPath) : "";
-        if (namefix == "latin1") {
-          namefix = (str) => str.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^\x20-\x7E]/g, "");
-        }
-        if (typeof namefix !== "function")
-          namefix = (str) => str;
-        const relPathFix = (entry) => pth.join(zipPath, namefix(relativePath(localPath, entry)));
-        const fileNameFix = (entry) => pth.win32.basename(pth.win32.normalize(namefix(entry)));
-        filetools.fs.open(localPath, "r", function(err) {
-          if (err && err.code === "ENOENT") {
-            callback(undefined, Utils.Errors.FILE_NOT_FOUND(localPath));
-          } else if (err) {
-            callback(undefined, err);
-          } else {
-            filetools.findFilesAsync(localPath, function(err2, fileEntries) {
-              if (err2)
-                return callback(err2);
-              fileEntries = fileEntries.filter((dir) => filter2(relPathFix(dir)));
-              if (!fileEntries.length)
-                callback(undefined, false);
-              setImmediate(fileEntries.reverse().reduce(function(next, entry) {
-                return function(err3, done) {
-                  if (err3 || done === false)
-                    return setImmediate(next, err3, false);
-                  self2.addLocalFileAsync({
-                    localPath: entry,
-                    zipPath: pth.dirname(relPathFix(entry)),
-                    zipName: fileNameFix(entry)
-                  }, next);
-                };
-              }, callback));
-            });
+        this.zipfile.readEntry();
+        this.zipfile.on("close", () => {
+          if (!this.canceled) {
+            debug("zip extraction complete");
+            resolve3();
           }
         });
-      },
-      addLocalFolderPromise: function(localPath2, props) {
-        return new Promise((resolve3, reject) => {
-          this.addLocalFolderAsync2(Object.assign({ localPath: localPath2 }, props), (err, done) => {
-            if (err)
-              reject(err);
-            if (done)
-              resolve3(this);
-          });
-        });
-      },
-      addFile: function(entryName, content, comment, attr) {
-        entryName = zipnamefix(entryName);
-        let entry = getEntry(entryName);
-        const update = entry != null;
-        if (!update) {
-          entry = new ZipEntry(opts);
-          entry.entryName = entryName;
-        }
-        entry.comment = comment || "";
-        const isStat = typeof attr === "object" && attr instanceof filetools.fs.Stats;
-        if (isStat) {
-          entry.header.time = attr.mtime;
-        }
-        var fileattr = entry.isDirectory ? 16 : 0;
-        let unix = entry.isDirectory ? 16384 : 32768;
-        if (isStat) {
-          unix |= 4095 & attr.mode;
-        } else if (typeof attr === "number") {
-          unix |= 4095 & attr;
-        } else {
-          unix |= entry.isDirectory ? 493 : 420;
-        }
-        fileattr = (fileattr | unix << 16) >>> 0;
-        entry.attr = fileattr;
-        entry.setData(content);
-        if (!update)
-          _zip.setEntry(entry);
-        return entry;
-      },
-      getEntries: function(password) {
-        _zip.password = password;
-        return _zip ? _zip.entries : [];
-      },
-      getEntry: function(name) {
-        return getEntry(name);
-      },
-      getEntryCount: function() {
-        return _zip.getEntryCount();
-      },
-      forEach: function(callback) {
-        return _zip.forEach(callback);
-      },
-      extractEntryTo: function(entry, targetPath, maintainEntryPath, overwrite, keepOriginalPermission, outFileName) {
-        overwrite = get_Bool(false, overwrite);
-        keepOriginalPermission = get_Bool(false, keepOriginalPermission);
-        maintainEntryPath = get_Bool(true, maintainEntryPath);
-        outFileName = get_Str(keepOriginalPermission, outFileName);
-        var item = getEntry(entry);
-        if (!item) {
-          throw Utils.Errors.NO_ENTRY();
-        }
-        var entryName = canonical(item.entryName);
-        var target = sanitize(targetPath, outFileName && !item.isDirectory ? outFileName : maintainEntryPath ? entryName : pth.basename(entryName));
-        if (item.isDirectory) {
-          var children = _zip.getEntryChildren(item);
-          children.forEach(function(child) {
-            if (child.isDirectory)
-              return;
-            var content2 = child.getData();
-            if (!content2) {
-              throw Utils.Errors.CANT_EXTRACT_FILE();
-            }
-            var name = canonical(child.entryName);
-            var childName = sanitize(targetPath, maintainEntryPath ? name : pth.basename(name));
-            const fileAttr2 = keepOriginalPermission ? child.header.fileAttr : undefined;
-            filetools.writeFileTo(childName, content2, overwrite, fileAttr2);
-          });
-          return true;
-        }
-        var content = item.getData(_zip.password);
-        if (!content)
-          throw Utils.Errors.CANT_EXTRACT_FILE();
-        if (filetools.fs.existsSync(target) && !overwrite) {
-          throw Utils.Errors.CANT_OVERRIDE();
-        }
-        const fileAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
-        filetools.writeFileTo(target, content, overwrite, fileAttr);
-        return true;
-      },
-      test: function(pass) {
-        if (!_zip) {
-          return false;
-        }
-        for (var entry in _zip.entries) {
-          try {
-            if (entry.isDirectory) {
-              continue;
-            }
-            var content = _zip.entries[entry].getData(pass);
-            if (!content) {
-              return false;
-            }
-          } catch (err) {
-            return false;
-          }
-        }
-        return true;
-      },
-      extractAllTo: function(targetPath, overwrite, keepOriginalPermission, pass) {
-        keepOriginalPermission = get_Bool(false, keepOriginalPermission);
-        pass = get_Str(keepOriginalPermission, pass);
-        overwrite = get_Bool(false, overwrite);
-        if (!_zip)
-          throw Utils.Errors.NO_ZIP();
-        _zip.entries.forEach(function(entry) {
-          var entryName = sanitize(targetPath, canonical(entry.entryName));
-          if (entry.isDirectory) {
-            filetools.makeDir(entryName);
+        this.zipfile.on("entry", async (entry) => {
+          if (this.canceled) {
+            debug("skipping entry", entry.fileName, { cancelled: this.canceled });
             return;
           }
-          var content = entry.getData(pass);
-          if (!content) {
-            throw Utils.Errors.CANT_EXTRACT_FILE();
+          debug("zipfile entry", entry.fileName);
+          if (entry.fileName.startsWith("__MACOSX/")) {
+            this.zipfile.readEntry();
+            return;
           }
-          const fileAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
-          filetools.writeFileTo(entryName, content, overwrite, fileAttr);
+          const destDir = path3.dirname(path3.join(this.opts.dir, entry.fileName));
           try {
-            filetools.fs.utimesSync(entryName, entry.header.time, entry.header.time);
+            await fs2.mkdir(destDir, { recursive: true });
+            const canonicalDestDir = await fs2.realpath(destDir);
+            const relativeDestDir = path3.relative(this.opts.dir, canonicalDestDir);
+            if (relativeDestDir.split(path3.sep).includes("..")) {
+              throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
+            }
+            await this.extractEntry(entry);
+            debug("finished processing", entry.fileName);
+            this.zipfile.readEntry();
           } catch (err) {
-            throw Utils.Errors.CANT_EXTRACT_FILE();
+            this.canceled = true;
+            this.zipfile.close();
+            reject(err);
           }
         });
-      },
-      extractAllToAsync: function(targetPath, overwrite, keepOriginalPermission, callback) {
-        callback = get_Fun(overwrite, keepOriginalPermission, callback);
-        keepOriginalPermission = get_Bool(false, keepOriginalPermission);
-        overwrite = get_Bool(false, overwrite);
-        if (!callback) {
-          return new Promise((resolve3, reject) => {
-            this.extractAllToAsync(targetPath, overwrite, keepOriginalPermission, function(err) {
-              if (err) {
-                reject(err);
-              } else {
-                resolve3(this);
-              }
-            });
-          });
-        }
-        if (!_zip) {
-          callback(Utils.Errors.NO_ZIP());
-          return;
-        }
-        targetPath = pth.resolve(targetPath);
-        const getPath = (entry) => sanitize(targetPath, pth.normalize(canonical(entry.entryName)));
-        const getError = (msg, file) => new Error(msg + ': "' + file + '"');
-        const dirEntries = [];
-        const fileEntries = [];
-        _zip.entries.forEach((e) => {
-          if (e.isDirectory) {
-            dirEntries.push(e);
-          } else {
-            fileEntries.push(e);
+      });
+    }
+    async extractEntry(entry) {
+      if (this.canceled) {
+        debug("skipping entry extraction", entry.fileName, { cancelled: this.canceled });
+        return;
+      }
+      if (this.opts.onEntry) {
+        this.opts.onEntry(entry, this.zipfile);
+      }
+      const dest = path3.join(this.opts.dir, entry.fileName);
+      const mode = entry.externalFileAttributes >> 16 & 65535;
+      const IFMT = 61440;
+      const IFDIR = 16384;
+      const IFLNK = 40960;
+      const symlink = (mode & IFMT) === IFLNK;
+      let isDir = (mode & IFMT) === IFDIR;
+      if (!isDir && entry.fileName.endsWith("/")) {
+        isDir = true;
+      }
+      const madeBy = entry.versionMadeBy >> 8;
+      if (!isDir)
+        isDir = madeBy === 0 && entry.externalFileAttributes === 16;
+      debug("extracting entry", { filename: entry.fileName, isDir, isSymlink: symlink });
+      const procMode = this.getExtractedMode(mode, isDir) & 511;
+      const destDir = isDir ? dest : path3.dirname(dest);
+      const mkdirOptions = { recursive: true };
+      if (isDir) {
+        mkdirOptions.mode = procMode;
+      }
+      debug("mkdir", { dir: destDir, ...mkdirOptions });
+      await fs2.mkdir(destDir, mkdirOptions);
+      if (isDir)
+        return;
+      debug("opening read stream", dest);
+      const readStream2 = await promisify(this.zipfile.openReadStream.bind(this.zipfile))(entry);
+      if (symlink) {
+        const link = await getStream(readStream2);
+        debug("creating symlink", link, dest);
+        await fs2.symlink(link, dest);
+      } else {
+        await pipeline(readStream2, createWriteStream(dest, { mode: procMode }));
+      }
+    }
+    getExtractedMode(entryMode, isDir) {
+      let mode = entryMode;
+      if (mode === 0) {
+        if (isDir) {
+          if (this.opts.defaultDirMode) {
+            mode = parseInt(this.opts.defaultDirMode, 10);
           }
-        });
-        for (const entry of dirEntries) {
-          const dirPath = getPath(entry);
-          const dirAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
-          try {
-            filetools.makeDir(dirPath);
-            if (dirAttr)
-              filetools.fs.chmodSync(dirPath, dirAttr);
-            filetools.fs.utimesSync(dirPath, entry.header.time, entry.header.time);
-          } catch (er) {
-            callback(getError("Unable to create folder", dirPath));
+          if (!mode) {
+            mode = 493;
           }
-        }
-        fileEntries.reverse().reduce(function(next, entry) {
-          return function(err) {
-            if (err) {
-              next(err);
-            } else {
-              const entryName = pth.normalize(canonical(entry.entryName));
-              const filePath = sanitize(targetPath, entryName);
-              entry.getDataAsync(function(content, err_1) {
-                if (err_1) {
-                  next(err_1);
-                } else if (!content) {
-                  next(Utils.Errors.CANT_EXTRACT_FILE());
-                } else {
-                  const fileAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
-                  filetools.writeFileToAsync(filePath, content, overwrite, fileAttr, function(succ) {
-                    if (!succ) {
-                      next(getError("Unable to write file", filePath));
-                    }
-                    filetools.fs.utimes(filePath, entry.header.time, entry.header.time, function(err_2) {
-                      if (err_2) {
-                        next(getError("Unable to set times", filePath));
-                      } else {
-                        next();
-                      }
-                    });
-                  });
-                }
-              });
-            }
-          };
-        }, callback)();
-      },
-      writeZip: function(targetFileName, callback) {
-        if (arguments.length === 1) {
-          if (typeof targetFileName === "function") {
-            callback = targetFileName;
-            targetFileName = "";
+        } else {
+          if (this.opts.defaultFileMode) {
+            mode = parseInt(this.opts.defaultFileMode, 10);
+          }
+          if (!mode) {
+            mode = 420;
           }
         }
-        if (!targetFileName && opts.filename) {
-          targetFileName = opts.filename;
-        }
-        if (!targetFileName)
-          return;
-        var zipData = _zip.compressToBuffer();
-        if (zipData) {
-          var ok = filetools.writeFileTo(targetFileName, zipData, true);
-          if (typeof callback === "function")
-            callback(!ok ? new Error("failed") : null, "");
-        }
-      },
-      writeZipPromise: function(targetFileName, props) {
-        const { overwrite, perm } = Object.assign({ overwrite: true }, props);
-        return new Promise((resolve3, reject) => {
-          if (!targetFileName && opts.filename)
-            targetFileName = opts.filename;
-          if (!targetFileName)
-            reject("ADM-ZIP: ZIP File Name Missing");
-          this.toBufferPromise().then((zipData) => {
-            const ret = (done) => done ? resolve3(done) : reject("ADM-ZIP: Wasn't able to write zip file");
-            filetools.writeFileToAsync(targetFileName, zipData, overwrite, perm, ret);
-          }, reject);
-        });
-      },
-      toBufferPromise: function() {
-        return new Promise((resolve3, reject) => {
-          _zip.toAsyncBuffer(resolve3, reject);
-        });
-      },
-      toBuffer: function(onSuccess, onFail, onItemStart, onItemEnd) {
-        if (typeof onSuccess === "function") {
-          _zip.toAsyncBuffer(onSuccess, onFail, onItemStart, onItemEnd);
-          return null;
-        }
-        return _zip.compressToBuffer();
       }
-    };
+      return mode;
+    }
+  }
+  module.exports = async function(zipPath, opts) {
+    debug("creating target directory", opts.dir);
+    if (!path3.isAbsolute(opts.dir)) {
+      throw new Error("Target directory is expected to be absolute");
+    }
+    await fs2.mkdir(opts.dir, { recursive: true });
+    opts.dir = await fs2.realpath(opts.dir);
+    return new Extractor(zipPath, opts).extract();
   };
 });
 
@@ -200771,7 +200116,7 @@ var require_uri_all = __commonJS((exports, module) => {
       target.fragment = relative4.fragment;
       return target;
     }
-    function resolve4(baseURI, relativeURI, options) {
+    function resolve5(baseURI, relativeURI, options) {
       var schemelessOptions = assign({ scheme: "null" }, options);
       return serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
     }
@@ -201039,7 +200384,7 @@ var require_uri_all = __commonJS((exports, module) => {
     exports2.removeDotSegments = removeDotSegments;
     exports2.serialize = serialize;
     exports2.resolveComponents = resolveComponents;
-    exports2.resolve = resolve4;
+    exports2.resolve = resolve5;
     exports2.normalize = normalize2;
     exports2.equal = equal;
     exports2.escapeComponent = escapeComponent;
@@ -201108,7 +200453,7 @@ var require_ucs2length = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/util.js
-var require_util13 = __commonJS((exports, module) => {
+var require_util12 = __commonJS((exports, module) => {
   module.exports = {
     copy,
     checkDataType,
@@ -201312,7 +200657,7 @@ var require_util13 = __commonJS((exports, module) => {
 
 // ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/schema_obj.js
 var require_schema_obj = __commonJS((exports, module) => {
-  var util5 = require_util13();
+  var util5 = require_util12();
   module.exports = SchemaObject;
   function SchemaObject(obj) {
     util5.copy(obj, this);
@@ -201402,23 +200747,23 @@ var require_json_schema_traverse = __commonJS((exports, module) => {
 var require_resolve2 = __commonJS((exports, module) => {
   var URI = require_uri_all();
   var equal = require_fast_deep_equal();
-  var util5 = require_util13();
+  var util5 = require_util12();
   var SchemaObject = require_schema_obj();
   var traverse = require_json_schema_traverse();
-  module.exports = resolve4;
-  resolve4.normalizeId = normalizeId;
-  resolve4.fullPath = getFullPath;
-  resolve4.url = resolveUrl;
-  resolve4.ids = resolveIds;
-  resolve4.inlineRef = inlineRef;
-  resolve4.schema = resolveSchema;
-  function resolve4(compile, root, ref) {
+  module.exports = resolve5;
+  resolve5.normalizeId = normalizeId;
+  resolve5.fullPath = getFullPath;
+  resolve5.url = resolveUrl;
+  resolve5.ids = resolveIds;
+  resolve5.inlineRef = inlineRef;
+  resolve5.schema = resolveSchema;
+  function resolve5(compile, root, ref) {
     var refVal = this._refs[ref];
     if (typeof refVal == "string") {
       if (this._refs[refVal])
         refVal = this._refs[refVal];
       else
-        return resolve4.call(this, compile, root, refVal);
+        return resolve5.call(this, compile, root, refVal);
     }
     refVal = refVal || this._schemas[ref];
     if (refVal instanceof SchemaObject) {
@@ -201641,7 +200986,7 @@ var require_resolve2 = __commonJS((exports, module) => {
 
 // ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/error_classes.js
 var require_error_classes = __commonJS((exports, module) => {
-  var resolve4 = require_resolve2();
+  var resolve5 = require_resolve2();
   module.exports = {
     Validation: errorSubclass(ValidationError),
     MissingRef: errorSubclass(MissingRefError)
@@ -201656,8 +201001,8 @@ var require_error_classes = __commonJS((exports, module) => {
   };
   function MissingRefError(baseId, ref, message) {
     this.message = message || MissingRefError.message(baseId, ref);
-    this.missingRef = resolve4.url(baseId, ref);
-    this.missingSchema = resolve4.normalizeId(resolve4.fullPath(this.missingRef));
+    this.missingRef = resolve5.url(baseId, ref);
+    this.missingSchema = resolve5.normalizeId(resolve5.fullPath(this.missingRef));
   }
   function errorSubclass(Subclass) {
     Subclass.prototype = Object.create(Error.prototype);
@@ -202199,8 +201544,8 @@ var require_validate4 = __commonJS((exports, module) => {
 
 // ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/index.js
 var require_compile2 = __commonJS((exports, module) => {
-  var resolve4 = require_resolve2();
-  var util5 = require_util13();
+  var resolve5 = require_resolve2();
+  var util5 = require_util12();
   var errorClasses = require_error_classes();
   var stableStringify = require_fast_json_stable_stringify();
   var validateGenerator = require_validate4();
@@ -202259,7 +201604,7 @@ var require_compile2 = __commonJS((exports, module) => {
         RULES,
         validate: validateGenerator,
         util: util5,
-        resolve: resolve4,
+        resolve: resolve5,
         resolveRef,
         usePattern,
         useDefault,
@@ -202298,7 +201643,7 @@ var require_compile2 = __commonJS((exports, module) => {
       return validate;
     }
     function resolveRef(baseId2, ref, isRoot) {
-      ref = resolve4.url(baseId2, ref);
+      ref = resolve5.url(baseId2, ref);
       var refIndex = refs[ref];
       var _refVal, refCode;
       if (refIndex !== undefined) {
@@ -202315,11 +201660,11 @@ var require_compile2 = __commonJS((exports, module) => {
         }
       }
       refCode = addLocalRef(ref);
-      var v2 = resolve4.call(self2, localCompile, root, ref);
+      var v2 = resolve5.call(self2, localCompile, root, ref);
       if (v2 === undefined) {
         var localSchema = localRefs && localRefs[ref];
         if (localSchema) {
-          v2 = resolve4.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self2, localSchema, root, localRefs, baseId2);
+          v2 = resolve5.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self2, localSchema, root, localRefs, baseId2);
         }
       }
       if (v2 === undefined) {
@@ -202484,7 +201829,7 @@ var require_cache = __commonJS((exports, module) => {
 
 // ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/formats.js
 var require_formats2 = __commonJS((exports, module) => {
-  var util5 = require_util13();
+  var util5 = require_util12();
   var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
   var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
   var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
@@ -205080,7 +204425,7 @@ var require_dotjs = __commonJS((exports, module) => {
 // ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/rules.js
 var require_rules = __commonJS((exports, module) => {
   var ruleModules = require_dotjs();
-  var toHash = require_util13().toHash;
+  var toHash = require_util12().toHash;
   module.exports = function rules() {
     var RULES = [
       {
@@ -205836,14 +205181,14 @@ var require_data2 = __commonJS((exports, module) => {
 // ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/ajv.js
 var require_ajv = __commonJS((exports, module) => {
   var compileSchema = require_compile2();
-  var resolve4 = require_resolve2();
+  var resolve5 = require_resolve2();
   var Cache = require_cache();
   var SchemaObject = require_schema_obj();
   var stableStringify = require_fast_json_stable_stringify();
   var formats = require_formats2();
   var rules = require_rules();
   var $dataMetaSchema = require_data();
-  var util5 = require_util13();
+  var util5 = require_util12();
   module.exports = Ajv;
   Ajv.prototype.validate = validate;
   Ajv.prototype.compile = compile;
@@ -205928,7 +205273,7 @@ var require_ajv = __commonJS((exports, module) => {
     var id = this._getId(schema);
     if (id !== undefined && typeof id != "string")
       throw new Error("schema id must be string");
-    key = resolve4.normalizeId(key || id);
+    key = resolve5.normalizeId(key || id);
     checkUnique(this, key);
     this._schemas[key] = this._addSchema(schema, _skipValidation, _meta, true);
     return this;
@@ -205974,7 +205319,7 @@ var require_ajv = __commonJS((exports, module) => {
     }
   }
   function _getSchemaFragment(self2, ref) {
-    var res = resolve4.schema.call(self2, { schema: {} }, ref);
+    var res = resolve5.schema.call(self2, { schema: {} }, ref);
     if (res) {
       var { schema, root, baseId } = res;
       var v = compileSchema.call(self2, schema, root, undefined, baseId);
@@ -205990,7 +205335,7 @@ var require_ajv = __commonJS((exports, module) => {
     }
   }
   function _getSchemaObj(self2, keyRef) {
-    keyRef = resolve4.normalizeId(keyRef);
+    keyRef = resolve5.normalizeId(keyRef);
     return self2._schemas[keyRef] || self2._refs[keyRef] || self2._fragments[keyRef];
   }
   function removeSchema(schemaKeyRef) {
@@ -206018,7 +205363,7 @@ var require_ajv = __commonJS((exports, module) => {
         this._cache.del(cacheKey);
         var id = this._getId(schemaKeyRef);
         if (id) {
-          id = resolve4.normalizeId(id);
+          id = resolve5.normalizeId(id);
           delete this._schemas[id];
           delete this._refs[id];
         }
@@ -206043,14 +205388,14 @@ var require_ajv = __commonJS((exports, module) => {
     if (cached)
       return cached;
     shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false;
-    var id = resolve4.normalizeId(this._getId(schema));
+    var id = resolve5.normalizeId(this._getId(schema));
     if (id && shouldAddSchema)
       checkUnique(this, id);
     var willValidate = this._opts.validateSchema !== false && !skipValidation;
     var recursiveMeta;
-    if (willValidate && !(recursiveMeta = id && id == resolve4.normalizeId(schema.$schema)))
+    if (willValidate && !(recursiveMeta = id && id == resolve5.normalizeId(schema.$schema)))
       this.validateSchema(schema, true);
-    var localRefs = resolve4.ids.call(this, schema);
+    var localRefs = resolve5.ids.call(this, schema);
     var schemaObj = new SchemaObject({
       id,
       schema,
@@ -206212,7 +205557,7 @@ var require_ajv = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/handlebars/dist/cjs/handlebars/utils.js
-var require_utils75 = __commonJS((exports) => {
+var require_utils74 = __commonJS((exports) => {
   exports.__esModule = true;
   exports.extend = extend2;
   exports.indexOf = indexOf;
@@ -206355,7 +205700,7 @@ var require_exception = __commonJS((exports, module) => {
 // ../../node_modules/handlebars/dist/cjs/handlebars/helpers/block-helper-missing.js
 var require_block_helper_missing = __commonJS((exports, module) => {
   exports.__esModule = true;
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   exports.default = function(instance) {
     instance.registerHelper("blockHelperMissing", function(context, options) {
       var { inverse, fn } = options;
@@ -206391,7 +205736,7 @@ var require_each = __commonJS((exports, module) => {
   function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : { default: obj };
   }
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   var _exception = require_exception();
   var _exception2 = _interopRequireDefault(_exception);
   exports.default = function(instance) {
@@ -206492,7 +205837,7 @@ var require_if2 = __commonJS((exports, module) => {
   function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : { default: obj };
   }
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   var _exception = require_exception();
   var _exception2 = _interopRequireDefault(_exception);
   exports.default = function(instance) {
@@ -206565,7 +205910,7 @@ var require_with = __commonJS((exports, module) => {
   function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : { default: obj };
   }
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   var _exception = require_exception();
   var _exception2 = _interopRequireDefault(_exception);
   exports.default = function(instance) {
@@ -206639,7 +205984,7 @@ var require_helpers2 = __commonJS((exports) => {
 // ../../node_modules/handlebars/dist/cjs/handlebars/decorators/inline.js
 var require_inline = __commonJS((exports, module) => {
   exports.__esModule = true;
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   exports.default = function(instance) {
     instance.registerDecorator("inline", function(fn, props, container, options) {
       var ret = fn;
@@ -206677,7 +206022,7 @@ var require_decorators = __commonJS((exports) => {
 // ../../node_modules/handlebars/dist/cjs/handlebars/logger.js
 var require_logger4 = __commonJS((exports, module) => {
   exports.__esModule = true;
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   var logger2 = {
     methodMap: ["debug", "info", "warn", "error"],
     level: "info",
@@ -206714,7 +206059,7 @@ var require_logger4 = __commonJS((exports, module) => {
 var require_create_new_lookup_object = __commonJS((exports) => {
   exports.__esModule = true;
   exports.createNewLookupObject = createNewLookupObject;
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   function createNewLookupObject() {
     for (var _len = arguments.length, sources = Array(_len), _key = 0;_key < _len; _key++) {
       sources[_key] = arguments[_key];
@@ -206794,7 +206139,7 @@ var require_base = __commonJS((exports) => {
   function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : { default: obj };
   }
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   var _exception = require_exception();
   var _exception2 = _interopRequireDefault(_exception);
   var _helpers = require_helpers2();
@@ -206937,7 +206282,7 @@ var require_runtime = __commonJS((exports) => {
       return newObj;
     }
   }
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   var Utils = _interopRequireWildcard(_utils);
   var _exception = require_exception();
   var _exception2 = _interopRequireDefault(_exception);
@@ -207269,7 +206614,7 @@ var require_handlebars_runtime = __commonJS((exports, module) => {
   var _handlebarsSafeString2 = _interopRequireDefault(_handlebarsSafeString);
   var _handlebarsException = require_exception();
   var _handlebarsException2 = _interopRequireDefault(_handlebarsException);
-  var _handlebarsUtils = require_utils75();
+  var _handlebarsUtils = require_utils74();
   var Utils = _interopRequireWildcard(_handlebarsUtils);
   var _handlebarsRuntime = require_runtime();
   var runtime = _interopRequireWildcard(_handlebarsRuntime);
@@ -208505,7 +207850,7 @@ var require_base2 = __commonJS((exports) => {
   var _whitespaceControl2 = _interopRequireDefault(_whitespaceControl);
   var _helpers = require_helpers3();
   var Helpers = _interopRequireWildcard(_helpers);
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   exports.parser = _parser2["default"];
   var yy = {};
   _utils.extend(yy, Helpers);
@@ -208538,7 +207883,7 @@ var require_compiler = __commonJS((exports) => {
   }
   var _exception = require_exception();
   var _exception2 = _interopRequireDefault(_exception);
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   var _ast = require_ast();
   var _ast2 = _interopRequireDefault(_ast);
   var slice = [].slice;
@@ -209036,7 +208381,7 @@ var require_base64_vlq = __commonJS((exports) => {
 });
 
 // ../../node_modules/source-map/lib/util.js
-var require_util14 = __commonJS((exports) => {
+var require_util13 = __commonJS((exports) => {
   function getArg(aArgs, aName, aDefaultValue) {
     if (aName in aArgs) {
       return aArgs[aName];
@@ -209336,7 +208681,7 @@ var require_util14 = __commonJS((exports) => {
 
 // ../../node_modules/source-map/lib/array-set.js
 var require_array_set = __commonJS((exports) => {
-  var util5 = require_util14();
+  var util5 = require_util13();
   var has = Object.prototype.hasOwnProperty;
   var hasNativeMap = typeof Map !== "undefined";
   function ArraySet() {
@@ -209404,7 +208749,7 @@ var require_array_set = __commonJS((exports) => {
 
 // ../../node_modules/source-map/lib/mapping-list.js
 var require_mapping_list = __commonJS((exports) => {
-  var util5 = require_util14();
+  var util5 = require_util13();
   function generatedPositionAfter(mappingA, mappingB) {
     var lineA = mappingA.generatedLine;
     var lineB = mappingB.generatedLine;
@@ -209442,7 +208787,7 @@ var require_mapping_list = __commonJS((exports) => {
 // ../../node_modules/source-map/lib/source-map-generator.js
 var require_source_map_generator = __commonJS((exports) => {
   var base64VLQ = require_base64_vlq();
-  var util5 = require_util14();
+  var util5 = require_util13();
   var ArraySet = require_array_set().ArraySet;
   var MappingList = require_mapping_list().MappingList;
   function SourceMapGenerator(aArgs) {
@@ -209791,7 +209136,7 @@ var require_quick_sort = __commonJS((exports) => {
 
 // ../../node_modules/source-map/lib/source-map-consumer.js
 var require_source_map_consumer = __commonJS((exports) => {
-  var util5 = require_util14();
+  var util5 = require_util13();
   var binarySearch = require_binary_search();
   var ArraySet = require_array_set().ArraySet;
   var base64VLQ = require_base64_vlq();
@@ -210361,7 +209706,7 @@ var require_source_map_consumer = __commonJS((exports) => {
 // ../../node_modules/source-map/lib/source-node.js
 var require_source_node = __commonJS((exports) => {
   var SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
-  var util5 = require_util14();
+  var util5 = require_util13();
   var REGEX_NEWLINE = /(\r?\n)/;
   var NEWLINE_CODE = 10;
   var isSourceNode = "$$$isSourceNode$$$";
@@ -210622,7 +209967,7 @@ var require_source_map = __commonJS((exports) => {
 // ../../node_modules/handlebars/dist/cjs/handlebars/compiler/code-gen.js
 var require_code_gen = __commonJS((exports, module) => {
   exports.__esModule = true;
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   var SourceNode = undefined;
   try {
     if (typeof define !== "function" || !define.amd) {
@@ -210761,7 +210106,7 @@ var require_javascript_compiler = __commonJS((exports, module) => {
   var _base = require_base();
   var _exception = require_exception();
   var _exception2 = _interopRequireDefault(_exception);
-  var _utils = require_utils75();
+  var _utils = require_utils74();
   var _codeGen = require_code_gen();
   var _codeGen2 = _interopRequireDefault(_codeGen);
   function Literal(value) {
@@ -224909,7 +224254,6 @@ import path11 from "path";
 
 // src/service/environment_store.ts
 var import_client_s32 = __toESM(require_dist_cjs75(), 1);
-var import_adm_zip = __toESM(require_adm_zip(), 1);
 import { Storage } from "@google-cloud/storage";
 
 // ../../node_modules/async-mutex/index.mjs
@@ -225121,6 +224465,7 @@ class Mutex {
 }
 
 // src/service/environment_store.ts
+var import_extract_zip = __toESM(require_extract_zip(), 1);
 import crypto5 from "crypto";
 import * as fs7 from "fs";
 import * as path10 from "path";
@@ -228509,11 +227854,11 @@ var require_git = __commonJS2({
     Git2.prototype.stashList = function(options) {
       return this._runTask(stashListTask2(trailingOptionsArgument2(arguments) || {}, filterArray2(options) && options || []), trailingFunctionArgument2(arguments));
     };
-    function createCloneTask(api, task, repoPath, localPath2) {
+    function createCloneTask(api, task, repoPath, localPath) {
       if (typeof repoPath !== "string") {
         return configurationErrorTask2(`git.${api}() requires a string 'repoPath'`);
       }
-      return task(repoPath, filterType2(localPath2, filterString2), getTrailingOptions2(arguments));
+      return task(repoPath, filterType2(localPath, filterString2), getTrailingOptions2(arguments));
     }
     Git2.prototype.clone = function() {
       return this._runTask(createCloneTask("clone", cloneTask2, ...arguments), trailingFunctionArgument2(arguments));
@@ -231688,35 +231033,35 @@ class SchemaWorkerPool {
         }
         this.workerCurrentId.delete(index);
       }
-      logger.error("SchemaWorkerPool: worker errored, respawning", {
+      logger.error("SchemaWorkerPool: worker errored", {
         workerIndex: index,
         error: err
       });
-      if (!this.stopped) {
-        this.workers[index] = this.spawn(index);
-        this.drain();
-      }
     });
     worker.on("exit", (code) => {
       if (this.stopped)
         return;
+      const inFlightId = this.workerCurrentId.get(index);
+      if (inFlightId !== undefined) {
+        const req = this.inFlight.get(inFlightId);
+        if (req) {
+          this.inFlight.delete(inFlightId);
+          req.reject(new Error(`SchemaWorker exited with code ${code}`));
+        }
+        this.workerCurrentId.delete(index);
+      }
       if (code !== 0) {
         logger.warn("SchemaWorkerPool: worker exited unexpectedly", {
           workerIndex: index,
           code
         });
-        const inFlightId = this.workerCurrentId.get(index);
-        if (inFlightId !== undefined) {
-          const req = this.inFlight.get(inFlightId);
-          if (req) {
-            this.inFlight.delete(inFlightId);
-            req.reject(new Error(`SchemaWorker exited with code ${code}`));
-          }
-          this.workerCurrentId.delete(index);
-        }
-        this.workers[index] = this.spawn(index);
-        this.drain();
+      } else {
+        logger.info("SchemaWorkerPool: worker exited cleanly, respawning", {
+          workerIndex: index
+        });
       }
+      this.workers[index] = this.spawn(index);
+      this.drain();
     });
     return slot;
   }
@@ -233121,6 +232466,7 @@ class EnvironmentStore {
     return newEnvironment;
   }
   async unzipEnvironment(absoluteEnvironmentPath) {
+    const startedAt = Date.now();
     logger.info(`Detected zip file at "${absoluteEnvironmentPath}". Unzipping...`);
     const unzippedEnvironmentPath = absoluteEnvironmentPath.replace(".zip", "");
     await fs7.promises.rm(unzippedEnvironmentPath, {
@@ -233128,8 +232474,17 @@ class EnvironmentStore {
       force: true
     });
     await fs7.promises.mkdir(unzippedEnvironmentPath, { recursive: true });
-    const zip = new import_adm_zip.default(absoluteEnvironmentPath);
-    zip.extractAllTo(unzippedEnvironmentPath, true);
+    let entryCount = 0;
+    let totalUncompressedBytes = 0;
+    await import_extract_zip.default(absoluteEnvironmentPath, {
+      dir: path10.resolve(unzippedEnvironmentPath),
+      onEntry: (entry) => {
+        entryCount += 1;
+        totalUncompressedBytes += entry.uncompressedSize ?? 0;
+      }
+    });
+    const mib = (totalUncompressedBytes / (1024 * 1024)).toFixed(1);
+    logger.info(`Unzipped "${absoluteEnvironmentPath}" -> "${unzippedEnvironmentPath}" ` + `(${entryCount} entries, ${mib} MiB uncompressed) in ` + `${formatDuration(Date.now() - startedAt)}`);
     return unzippedEnvironmentPath;
   }
   async updateEnvironment(environment) {
@@ -233459,9 +232814,9 @@ class EnvironmentStore {
       }
       const file = fs7.createWriteStream(zipFilePath);
       item.Body.transformToWebStream().pipeTo(Writable.toWeb(file));
-      await new Promise((resolve4, reject) => {
+      await new Promise((resolve5, reject) => {
         file.on("error", reject);
-        file.on("finish", resolve4);
+        file.on("finish", resolve5);
       });
       await this.unzipEnvironment(zipFilePath);
       logger.info(`Downloaded S3 zip file ${s3Path} to ${absoluteDirPath}`);
@@ -233499,9 +232854,9 @@ class EnvironmentStore {
       }
       const file = fs7.createWriteStream(absoluteFilePath);
       item.Body.transformToWebStream().pipeTo(Writable.toWeb(file));
-      await new Promise((resolve4, reject) => {
+      await new Promise((resolve5, reject) => {
         file.on("error", reject);
-        file.on("finish", resolve4);
+        file.on("finish", resolve5);
       });
     }));
     logger.info(`Downloaded S3 directory ${s3Path} to ${absoluteDirPath}`);
@@ -233534,14 +232889,14 @@ class EnvironmentStore {
     });
     await fs7.promises.mkdir(absoluteDirPath, { recursive: true });
     const repoUrl = `https://github.com/${owner}/${repoName}`;
-    await new Promise((resolve4, reject) => {
+    await new Promise((resolve5, reject) => {
       esm_default2().clone(repoUrl, absoluteDirPath, {}, (err) => {
         if (err) {
           const errorData = this.extractErrorDataFromError(err);
           logger.error(`Failed to clone GitHub repository "${repoUrl}"`, errorData);
           reject(err);
         }
-        resolve4();
+        resolve5();
       });
     });
     if (!cleanPackagePath) {
@@ -233937,7 +233292,7 @@ class Protocol {
   }
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken } = options !== null && options !== undefined ? options : {};
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       var _a2, _b, _c, _d, _e, _f;
       if (!this._transport) {
         reject(new Error("Not connected"));
@@ -233988,7 +233343,7 @@ class Protocol {
         }
         try {
           const result = resultSchema.parse(response.result);
-          resolve4(result);
+          resolve5(result);
         } catch (error) {
           reject(error);
         }