@vercel/go 2.3.11 → 2.4.0

package/dist/index.js

@@ -113,6 +113,124 @@ function retry(fn, opts) {
 module.exports = retry;
 
 
+/***/ }),
+
+/***/ 7938:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var Buffer = __webpack_require__(4293).Buffer;
+
+var CRC_TABLE = [
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
+  0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
+  0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
+  0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+  0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
+  0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+  0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
+  0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+  0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
+  0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
+  0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
+  0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
+  0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
+  0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
+  0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+  0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
+  0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+  0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
+  0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+  0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
+  0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
+  0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
+  0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
+  0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
+  0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
+  0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+  0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
+  0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+  0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
+  0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+  0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
+  0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
+  0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
+  0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
+  0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
+  0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
+  0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+  0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
+  0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+  0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
+  0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+  0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
+  0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
+  0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
+  0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
+  0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
+  0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
+  0x2d02ef8d
+];
+
+if (typeof Int32Array !== 'undefined') {
+  CRC_TABLE = new Int32Array(CRC_TABLE);
+}
+
+function ensureBuffer(input) {
+  if (Buffer.isBuffer(input)) {
+    return input;
+  }
+
+  var hasNewBufferAPI =
+      typeof Buffer.alloc === "function" &&
+      typeof Buffer.from === "function";
+
+  if (typeof input === "number") {
+    return hasNewBufferAPI ? Buffer.alloc(input) : new Buffer(input);
+  }
+  else if (typeof input === "string") {
+    return hasNewBufferAPI ? Buffer.from(input) : new Buffer(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 (Buffer.isBuffer(previous)) {
+    previous = previous.readUInt32BE(0);
+  }
+  var crc = ~~previous ^ -1;
+  for (var n = 0; n < buf.length; n++) {
+    crc = CRC_TABLE[(crc ^ buf[n]) & 0xff] ^ (crc >>> 8);
+  }
+  return (crc ^ -1);
+}
+
+function crc32() {
+  return bufferizeInt(_crc32.apply(null, arguments));
+}
+crc32.signed = function () {
+  return _crc32.apply(null, arguments);
+};
+crc32.unsigned = function () {
+  return _crc32.apply(null, arguments) >>> 0;
+};
+
+module.exports = crc32;
+
+
 /***/ }),
 
 /***/ 899:
@@ -875,6 +993,241 @@ var eos = function(stream, opts, callback) {
 module.exports = eos;
 
 
+/***/ }),
+
+/***/ 7052:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+(function () {
+
+  var events = __webpack_require__(8614);
+  var util = __webpack_require__(1669);
+
+  function intercept(type, interceptor) {
+    var m;
+
+    if (typeof interceptor !== 'function') {
+      throw new TypeError('interceptor must be a function');
+    }
+
+    this.emit('newInterceptor', type, interceptor);
+
+    if (!this._interceptors[type]) {
+      this._interceptors[type] = [interceptor];
+    } else {
+      this._interceptors[type].push(interceptor);
+    }
+
+    // Check for listener leak
+    if (!this._interceptors[type].warned) {
+      if (typeof this._maxInterceptors !== 'undefined') {
+        m = this._maxInterceptors;
+      } else {
+        m = EventEmitter.defaultMaxInterceptors;
+      }
+
+      if (m && m > 0 && this._interceptors[type].length > m) {
+        this._interceptors[type].warned = true;
+        console.error('(node) warning: possible events-intercept EventEmitter memory ' +
+          'leak detected. %d interceptors added. ' +
+          'Use emitter.setMaxInterceptors(n) to increase limit.',
+          this._interceptors[type].length);
+        console.trace();
+      }
+    }
+
+    return this;
+  }
+
+  function emitFactory(superCall) {
+    return function (type) {
+      var completed,
+        interceptor,
+        _this = this;
+
+      function next(err) {
+        var trueArgs;
+        if (err) {
+          _this.emit('error', err);
+        } else if (completed === interceptor.length) {
+          return superCall.apply(_this, [type].concat(Array.prototype.slice.call(arguments).slice(1)));
+        } else {
+          trueArgs = Array.prototype.slice.call(arguments).slice(1).concat([next]);
+          completed += 1;
+          return interceptor[completed - 1].apply(_this, trueArgs);
+        }
+      }
+
+      if (!_this._interceptors) {
+        _this._interceptors = {};
+      }
+
+      interceptor = _this._interceptors[type];
+
+      if (!interceptor) {
+
+        //Just pass through
+        return superCall.apply(_this, arguments);
+
+      } else {
+
+        completed = 0;
+        return next.apply(_this, [null].concat(Array.prototype.slice.call(arguments).slice(1)));
+
+      }
+    };
+  }
+
+  function interceptors(type) {
+    var ret;
+
+    if (!this._interceptors || !this._interceptors[type]) {
+      ret = [];
+    } else {
+      ret = this._interceptors[type].slice();
+    }
+
+    return ret;
+  }
+
+  function removeInterceptor(type, interceptor) {
+    var list, position, length, i;
+
+    if (typeof interceptor !== 'function') {
+      throw new TypeError('interceptor must be a function');
+    }
+
+    if (!this._interceptors || !this._interceptors[type]) {
+      return this;
+    }
+
+    list = this._interceptors[type];
+    length = list.length;
+    position = -1;
+
+    for (i = length - 1; i >= 0; i--) {
+      if (list[i] === interceptor) {
+        position = i;
+        break;
+      }
+    }
+
+    if (position < 0) {
+      return this;
+    }
+
+    if (length === 1) {
+      delete this._interceptors[type];
+    } else {
+      list.splice(position, 1);
+    }
+
+    this.emit('removeInterceptor', type, interceptor);
+
+    return this;
+  }
+
+  function listenersFactory(superCall) {
+    return function (type) {
+      var superListeners = superCall.call(this, type);
+      var fakeFunctionIndex;
+      var tempSuperListeners = superListeners.slice();
+      if (type === 'newListener' || type === 'removeListener') {
+        fakeFunctionIndex = superListeners.indexOf(fakeFunction);
+        if (fakeFunctionIndex !== -1) {
+          tempSuperListeners.splice(fakeFunctionIndex, 1);
+        }
+        return tempSuperListeners;
+      }
+      return superListeners;
+    };
+  }
+
+  function fakeFunction() {}
+
+  function fixListeners(emitter) {
+    emitter.on('newListener', fakeFunction);
+    emitter.on('removeListener', fakeFunction);
+  }
+
+  function setMaxInterceptors(n) {
+    if (typeof n !== 'number' || n < 0 || isNaN(n)) {
+      throw new TypeError('n must be a positive number');
+    }
+    this._maxInterceptors = n;
+    return this;
+  }
+
+  function removeAllInterceptors(type) {
+    var key, theseInterceptors, length, i;
+
+    if (!this._interceptors || Object.getOwnPropertyNames(this._interceptors).length === 0) {
+      return this;
+    }
+
+    if (arguments.length === 0) {
+
+      for (key in this._interceptors) {
+        if (this._interceptors.hasOwnProperty(key) && key !== 'removeInterceptor') {
+          this.removeAllInterceptors(key);
+        }
+      }
+      this.removeAllInterceptors('removeInterceptor');
+      this._interceptors = {};
+
+    } else if (this._interceptors[type]) {
+      theseInterceptors = this._interceptors[type];
+      length = theseInterceptors.length;
+
+      // LIFO order
+      for (i = length - 1; i >= 0; i--) {
+        this.removeInterceptor(type, theseInterceptors[i]);
+      }
+
+      delete this._interceptors[type];
+    }
+
+    return this;
+  }
+
+  function EventEmitter() {
+    events.EventEmitter.call(this);
+    fixListeners(this);
+  }
+
+  util.inherits(EventEmitter, events.EventEmitter);
+
+  EventEmitter.prototype.intercept = intercept;
+  EventEmitter.prototype.emit = emitFactory(EventEmitter.super_.prototype.emit);
+  EventEmitter.prototype.interceptors = interceptors;
+  EventEmitter.prototype.removeInterceptor = removeInterceptor;
+  EventEmitter.prototype.removeAllInterceptors = removeAllInterceptors;
+  EventEmitter.prototype.setMaxInterceptors = setMaxInterceptors;
+  EventEmitter.prototype.listeners = listenersFactory(EventEmitter.super_.prototype.listeners);
+  EventEmitter.defaultMaxInterceptors = 10;
+
+  function monkeyPatch(emitter) {
+    var oldEmit = emitter.emit;
+    var oldListeners = emitter.listeners;
+
+    emitter.emit = emitFactory(oldEmit);
+    emitter.intercept = intercept;
+    emitter.interceptors = interceptors;
+    emitter.removeInterceptor = removeInterceptor;
+    emitter.removeAllInterceptors = removeAllInterceptors;
+    emitter.setMaxInterceptors = setMaxInterceptors;
+    emitter.listeners = listenersFactory(oldListeners);
+    fixListeners(emitter);
+  }
+
+  module.exports = {
+    EventEmitter: EventEmitter,
+    patch: monkeyPatch
+  };
+
+})();
+
+
 /***/ }),
 
 /***/ 389:
@@ -1340,6 +1693,309 @@ module.exports = opts => {
 };
 
 
+/***/ }),
+
+/***/ 402:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+var fs = __webpack_require__(5747);
+var util = __webpack_require__(1669);
+var stream = __webpack_require__(2413);
+var Readable = stream.Readable;
+var Writable = stream.Writable;
+var PassThrough = stream.PassThrough;
+var Pend = __webpack_require__(1059);
+var EventEmitter = __webpack_require__(8614).EventEmitter;
+
+exports.createFromBuffer = createFromBuffer;
+exports.createFromFd = createFromFd;
+exports.BufferSlicer = BufferSlicer;
+exports.FdSlicer = FdSlicer;
+
+util.inherits(FdSlicer, EventEmitter);
+function FdSlicer(fd, options) {
+  options = options || {};
+  EventEmitter.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 self = this;
+  self.pend.go(function(cb) {
+    fs.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer) {
+      cb();
+      callback(err, bytesRead, buffer);
+    });
+  });
+};
+
+FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
+  var self = this;
+  self.pend.go(function(cb) {
+    fs.write(self.fd, buffer, offset, length, position, function(err, written, buffer) {
+      cb();
+      callback(err, written, buffer);
+    });
+  });
+};
+
+FdSlicer.prototype.createReadStream = function(options) {
+  return new ReadStream(this, options);
+};
+
+FdSlicer.prototype.createWriteStream = function(options) {
+  return new WriteStream(this, options);
+};
+
+FdSlicer.prototype.ref = function() {
+  this.refCount += 1;
+};
+
+FdSlicer.prototype.unref = function() {
+  var self = this;
+  self.refCount -= 1;
+
+  if (self.refCount > 0) return;
+  if (self.refCount < 0) throw new Error("invalid unref");
+
+  if (self.autoClose) {
+    fs.close(self.fd, onCloseDone);
+  }
+
+  function onCloseDone(err) {
+    if (err) {
+      self.emit('error', err);
+    } else {
+      self.emit('close');
+    }
+  }
+};
+
+util.inherits(ReadStream, Readable);
+function ReadStream(context, options) {
+  options = options || {};
+  Readable.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 self = this;
+  if (self.destroyed) return;
+
+  var toRead = Math.min(self._readableState.highWaterMark, n);
+  if (self.endOffset != null) {
+    toRead = Math.min(toRead, self.endOffset - self.pos);
+  }
+  if (toRead <= 0) {
+    self.destroyed = true;
+    self.push(null);
+    self.context.unref();
+    return;
+  }
+  self.context.pend.go(function(cb) {
+    if (self.destroyed) return cb();
+    var buffer = new Buffer(toRead);
+    fs.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+      if (err) {
+        self.destroy(err);
+      } else if (bytesRead === 0) {
+        self.destroyed = true;
+        self.push(null);
+        self.context.unref();
+      } else {
+        self.pos += bytesRead;
+        self.push(buffer.slice(0, bytesRead));
+      }
+      cb();
+    });
+  });
+};
+
+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();
+};
+
+util.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 self = this;
+  if (self.destroyed) return;
+
+  if (self.pos + buffer.length > self.endOffset) {
+    var err = new Error("maximum file length exceeded");
+    err.code = 'ETOOBIG';
+    self.destroy();
+    callback(err);
+    return;
+  }
+  self.context.pend.go(function(cb) {
+    if (self.destroyed) return cb();
+    fs.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err, bytes) {
+      if (err) {
+        self.destroy();
+        cb();
+        callback(err);
+      } else {
+        self.bytesWritten += bytes;
+        self.pos += bytes;
+        self.emit('progress');
+        cb();
+        callback();
+      }
+    });
+  });
+};
+
+WriteStream.prototype.destroy = function() {
+  if (this.destroyed) return;
+  this.destroyed = true;
+  this.context.unref();
+};
+
+util.inherits(BufferSlicer, EventEmitter);
+function BufferSlicer(buffer, options) {
+  EventEmitter.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);
+  });
+};
+
+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 readStream = new PassThrough(options);
+  readStream.destroyed = false;
+  readStream.start = options.start || 0;
+  readStream.endOffset = options.end;
+  // by the time this function returns, we'll be done.
+  readStream.pos = readStream.endOffset || this.buffer.length;
+
+  // respect the maxChunkSize option to slice up the chunk into smaller pieces.
+  var entireSlice = this.buffer.slice(readStream.start, readStream.pos);
+  var offset = 0;
+  while (true) {
+    var nextOffset = offset + this.maxChunkSize;
+    if (nextOffset >= entireSlice.length) {
+      // last chunk
+      if (offset < entireSlice.length) {
+        readStream.write(entireSlice.slice(offset, entireSlice.length));
+      }
+      break;
+    }
+    readStream.write(entireSlice.slice(offset, nextOffset));
+    offset = nextOffset;
+  }
+
+  readStream.end();
+  readStream.destroy = function() {
+    readStream.destroyed = true;
+  };
+  return readStream;
+};
+
+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);
+}
+
+
 /***/ }),
 
 /***/ 3838:
@@ -11208,51 +11864,189 @@ function onceStrict (fn) {
 
 /***/ }),
 
-/***/ 6472:
-/***/ ((module) => {
+/***/ 9801:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
+/* eslint-env es6, node */
+// # spell-checker:ignore HomeDrive HomePath LocalAppData UserProfile WinDir
 
-module.exports = (promise, onFinally) => {
-	onFinally = onFinally || (() => {});
-
-	return promise.then(
-		val => new Promise(resolve => {
-			resolve(onFinally());
-		}).then(() => val),
-		err => new Promise(resolve => {
-			resolve(onFinally());
-		}).then(() => {
-			throw err;
-		})
-	);
-};
 
+const os = __webpack_require__(2087);
+const paths = __webpack_require__(5622);
 
-/***/ }),
+const isWinOS = /^win/i.test(process.platform);
 
-/***/ 2658:
-/***/ ((module) => {
+function normalize_path(path) {
+	return paths.normalize(paths.join(path, '.'));
+}
 
-"use strict";
+const base = () => {
+	const { env } = process;
 
-module.exports = opts => {
-	opts = opts || {};
+	const object = {};
 
-	const env = opts.env || process.env;
-	const platform = opts.platform || process.platform;
+	object.home = () => normalize_path(os.homedir ? os.homedir() : env.HOME);
 
-	if (platform !== 'win32') {
-		return 'PATH';
-	}
+	object.temp = () => normalize_path(os.tmpdir ? os.tmpdir() : env.TMPDIR || env.TEMP || env.TMP);
 
-	return Object.keys(env).find(x => x.toUpperCase() === 'PATH') || 'Path';
+	return object;
 };
 
+const windows = () => {
+	const { env } = process;
 
-/***/ }),
+	const object = {};
 
-/***/ 8140:
+	object.home = () =>
+		normalize_path(
+			os.homedir
+				? os.homedir()
+				: env.USERPROFILE || paths.join(env.HOMEDRIVE, env.HOMEPATH) || env.HOME
+		);
+
+	object.temp = () =>
+		normalize_path(
+			os.tmpdir
+				? os.tmpdir()
+				: env.TEMP ||
+						env.TMP ||
+						paths.join(env.LOCALAPPDATA || env.SystemRoot || env.windir, 'Temp')
+		);
+
+	return object;
+};
+
+class _OSPaths {
+	constructor() {
+		const OSPaths = function () {
+			return new _OSPaths();
+		};
+
+		this._fn = OSPaths;
+
+		// Connect to platform-specific API functions by extension
+		const extension = isWinOS ? windows() : base();
+		Object.keys(extension).forEach((key) => {
+			this._fn[key] = extension[key];
+		});
+
+		return this._fn;
+	}
+}
+
+module.exports = new _OSPaths();
+
+
+/***/ }),
+
+/***/ 6472:
+/***/ ((module) => {
+
+"use strict";
+
+module.exports = (promise, onFinally) => {
+	onFinally = onFinally || (() => {});
+
+	return promise.then(
+		val => new Promise(resolve => {
+			resolve(onFinally());
+		}).then(() => val),
+		err => new Promise(resolve => {
+			resolve(onFinally());
+		}).then(() => {
+			throw err;
+		})
+	);
+};
+
+
+/***/ }),
+
+/***/ 2658:
+/***/ ((module) => {
+
+"use strict";
+
+module.exports = opts => {
+	opts = opts || {};
+
+	const env = opts.env || process.env;
+	const platform = opts.platform || process.platform;
+
+	if (platform !== 'win32') {
+		return 'PATH';
+	}
+
+	return Object.keys(env).find(x => x.toUpperCase() === 'PATH') || 'Path';
+};
+
+
+/***/ }),
+
+/***/ 1059:
+/***/ ((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);
+  }
+};
+
+Pend.prototype.wait = function(cb) {
+  if (this.pending === 0) {
+    cb(this.error);
+  } else {
+    this.listeners.push(cb);
+  }
+};
+
+Pend.prototype.hold = function() {
+  return pendHold(this);
+};
+
+function pendHold(self) {
+  self.pending += 1;
+  var called = false;
+  return onCb;
+  function onCb(err) {
+    if (called) throw new Error("callback called twice");
+    called = true;
+    self.error = self.error || err;
+    self.pending -= 1;
+    if (self.waiting.length > 0 && self.pending < self.max) {
+      pendGo(self, self.waiting.shift());
+    } else if (self.pending === 0) {
+      var listeners = self.listeners;
+      self.listeners = [];
+      listeners.forEach(cbListener);
+    }
+  }
+  function cbListener(listener) {
+    listener(self.error);
+  }
+}
+
+function pendGo(self, fn) {
+  fn(pendHold(self));
+}
+
+
+/***/ }),
+
+/***/ 8140:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 var once = __webpack_require__(1924)
@@ -19627,6 +20421,336 @@ function wrappy (fn, cb) {
 }
 
 
+/***/ }),
+
+/***/ 4925:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// # spell-checker:ignore macos APPDATA LOCALAPPDATA
+/* eslint-env es6, node */
+
+
+const path = __webpack_require__(5622);
+const os = __webpack_require__(2087);
+const xdg = __webpack_require__(5442);
+
+const isWinOS = /^win/i.test(process.platform);
+
+function _normalizeOptions(options, isolated) {
+	options = options || {};
+	if (typeof options !== 'object') {
+		options = {isolated: options};
+	}
+
+	options.isolated = ((options.isolated === undefined) || (options.isolated === null)) ? isolated : options.isolated;
+	if (typeof options.isolated !== 'boolean') {
+		throw new TypeError(`Expected boolean for "isolated" argument, got ${typeof options.isolated}`);
+	}
+
+	return options;
+}
+
+const base = (name, isolated) => {
+	const object = {};
+
+	object.cache = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		return path.join(xdg.cache(), options.isolated ? name : '');
+	};
+
+	object.config = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		return path.join(xdg.config(), options.isolated ? name : '');
+	};
+
+	object.data = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		return path.join(xdg.data(), options.isolated ? name : '');
+	};
+
+	object.runtime = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		return xdg.runtime() ? path.join(xdg.runtime(), options.isolated ? name : '') : undefined;
+	};
+
+	object.state = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		return path.join(xdg.state(), options.isolated ? name : '');
+	};
+
+	object.configDirs = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		return (xdg.configDirs()).map(s => path.join(s, options.isolated ? name : ''));
+	};
+
+	object.dataDirs = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		return (xdg.dataDirs()).map(s => path.join(s, options.isolated ? name : ''));
+	};
+
+	return object;
+};
+
+const windows = (name, isolated) => {
+	const {env} = process;
+	const homedir = os.homedir();
+	const tmpdir = os.tmpdir();
+
+	// # ref: <https://www.thewindowsclub.com/local-localnow-roaming-folders-windows-10> @@ <http://archive.is/tDEPl>
+	const appData = env.APPDATA || path.join(homedir || tmpdir, 'AppData', 'Roaming'); // APPDATA == "AppData/Roaming" contains data which may follow user between machines
+	const localAppData = env.LOCALAPPDATA || path.join(homedir || tmpdir, 'AppData', 'Local'); // LOCALAPPDATA == "AppData/Local" contains local-machine-only user data
+
+	const object = {};
+
+	// Locations for data/config/cache/state are invented (Windows doesn't have a popular convention)
+
+	object.cache = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		return (!options.isolated || env.XDG_CACHE_HOME) ?
+			path.join(xdg.cache(), options.isolated ? name : '') :
+			path.join(localAppData, options.isolated ? name : '', 'Cache');
+	};
+
+	object.config = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		const config = (!options.isolated || env.XDG_CONFIG_HOME) ?
+			path.join(xdg.config(), options.isolated ? name : '') :
+			path.join(appData, options.isolated ? name : '', 'Config');
+		return config;
+	};
+
+	object.data = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		const data = (!options.isolated || env.XDG_DATA_HOME) ?
+			path.join(xdg.data(), options.isolated ? name : '') :
+			path.join(appData, options.isolated ? name : '', 'Data');
+		return data;
+	};
+
+	object.runtime = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		return xdg.runtime() ? path.join(xdg.runtime(), options.isolated ? name : '') : undefined;
+	};
+
+	object.state = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		return (!options.isolated || env.XDG_STATE_HOME) ?
+			path.join(xdg.state(), options.isolated ? name : '') :
+			path.join(localAppData, options.isolated ? name : '', 'State');
+	};
+
+	object.configDirs = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		const dirs = [object.config(options)];
+		if (env.XDG_CONFIG_DIRS) {
+			dirs.push(...env.XDG_CONFIG_DIRS.split(path.delimiter).map(s => path.join(s, options.isolated ? name : '')));
+		}
+
+		return dirs;
+	};
+
+	object.dataDirs = (options = {isolated: null}) => {
+		options = _normalizeOptions(options, isolated);
+		const dirs = [object.data(options)];
+		if (env.XDG_DATA_DIRS) {
+			dirs.push(...env.XDG_DATA_DIRS.split(path.delimiter).map(s => path.join(s, options.isolated ? name : '')));
+		}
+
+		return dirs;
+	};
+
+	return object;
+};
+
+class _XDGAppPaths {
+	constructor(options = {name: null, suffix: null, isolated: true}) {
+		const XDGAppPaths = function (options = {name: null, suffix: null, isolated: true}) {
+			return new _XDGAppPaths(options);
+		};
+
+		this._fn = XDGAppPaths;
+
+		options = options || {};
+		if (typeof options !== 'object') {
+			options = {name: options};
+		}
+
+		let name = options.name || '';
+		if (typeof name !== 'string') {
+			throw new TypeError(`Expected string for "name" argument, got ${typeof name}`);
+		}
+
+		const suffix = options.suffix || '';
+		if (typeof suffix !== 'string') {
+			throw new TypeError(`Expected string for "suffix" argument, got ${typeof suffix}`);
+		}
+
+		const isolated = ((options.isolated === undefined) || (options.isolated === null)) ? true : options.isolated;
+		if (typeof isolated !== 'boolean') {
+			throw new TypeError(`Expected boolean for "isolated" argument, got ${typeof isolated}`);
+		}
+
+		if (!name) {
+			// Find a suitable application name (ref: <https://stackoverflow.com/a/46110961/43774>)
+			name = path.parse(process.pkg ? process.execPath : (require.main ? require.main.filename : process.argv[0])).name;
+		}
+
+		if (suffix) {
+			name += suffix;
+		}
+
+		this._fn.$name = () => name;
+		this._fn.$isolated = () => isolated;
+
+		// Connect to platform-specific API functions by extension
+		const extension = isWinOS ? windows(name, isolated) : base(name, isolated);
+		Object.keys(extension).forEach(key => {
+			this._fn[key] = extension[key];
+		});
+
+		return this._fn;
+	}
+}
+
+module.exports = new _XDGAppPaths();
+
+
+/***/ }),
+
+/***/ 5442:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// # spell-checker:ignore macos APPDATA LOCALAPPDATA
+/* eslint-env es6, node */
+
+
+const path = __webpack_require__(5622);
+
+const osPaths = __webpack_require__(9801);
+
+// XDG references
+// # ref: <https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html> @@ <https://archive.is/aAhtw>
+// # ref: <https://specifications.freedesktop.org/basedir-spec/latest/ar01s03.html> @@ <https://archive.is/7N0TN>
+// # ref: <https://wiki.archlinux.org/index.php/XDG_Base_Directory> @@ <https://archive.is/VdO9n>
+// # ref: <https://wiki.debian.org/XDGBaseDirectorySpecification#state> @@ <http://archive.is/pahId>
+// # ref: <https://ploum.net/207-modify-your-application-to-use-xdg-folders> @@ <https://archive.is/f43Gk>
+
+const linux = () => {
+	const object = {};
+
+	object.cache = () =>
+		process.env.XDG_CACHE_HOME || path.join(osPaths.home() || osPaths.temp(), '.cache');
+	object.config = () =>
+		process.env.XDG_CONFIG_HOME || path.join(osPaths.home() || osPaths.temp(), '.config');
+	object.data = () =>
+		process.env.XDG_DATA_HOME || path.join(osPaths.home() || osPaths.temp(), '.local', 'share');
+	object.runtime = () => process.env.XDG_RUNTIME_DIR || undefined;
+	object.state = () =>
+		process.env.XDG_STATE_HOME || path.join(osPaths.home() || osPaths.temp(), '.local', 'state');
+
+	return object;
+};
+
+const macos = () => {
+	const object = {};
+
+	object.cache = () =>
+		process.env.XDG_CACHE_HOME ||
+		path.join(path.join(osPaths.home() || osPaths.temp(), 'Library'), 'Caches');
+	object.config = () =>
+		process.env.XDG_CONFIG_HOME ||
+		path.join(path.join(osPaths.home() || osPaths.temp(), 'Library'), 'Preferences');
+	object.data = () =>
+		process.env.XDG_DATA_HOME ||
+		path.join(path.join(osPaths.home() || osPaths.temp(), 'Library'), 'Application Support');
+	object.runtime = () => process.env.XDG_RUNTIME_DIR || undefined;
+	object.state = () =>
+		process.env.XDG_STATE_HOME ||
+		path.join(path.join(osPaths.home() || osPaths.temp(), 'Library'), 'State');
+
+	return object;
+};
+
+const windows = () => {
+	const object = {};
+	// # ref: <https://www.thewindowsclub.com/local-localnow-roaming-folders-windows-10> @@ <http://archive.is/tDEPl>
+	// Locations for cache/config/data/state are invented (Windows doesn't have a popular convention)
+
+	object.cache = () => {
+		const localAppData =
+			process.env.LOCALAPPDATA || path.join(osPaths.home() || osPaths.temp(), 'AppData', 'Local'); // "AppData/Local" contains local-machine-only user data
+		return process.env.XDG_CACHE_HOME || path.join(localAppData, 'xdg.cache');
+	};
+
+	object.config = () => {
+		const appData =
+			process.env.APPDATA || path.join(osPaths.home() || osPaths.temp(), 'AppData', 'Roaming'); // "AppData/Roaming" contains data which may follow user between machines
+		return process.env.XDG_CONFIG_HOME || path.join(appData, 'xdg.config');
+	};
+
+	object.data = () => {
+		const appData =
+			process.env.APPDATA || path.join(osPaths.home() || osPaths.temp(), 'AppData', 'Roaming'); // "AppData/Roaming" contains data which may follow user between machines
+		return process.env.XDG_DATA_HOME || path.join(appData, 'xdg.data');
+	};
+
+	object.runtime = () => process.env.XDG_RUNTIME_DIR || undefined;
+
+	object.state = () => {
+		const localAppData =
+			process.env.LOCALAPPDATA || path.join(osPaths.home() || osPaths.temp(), 'AppData', 'Local'); // "AppData/Local" contains local-machine-only user data
+		return process.env.XDG_STATE_HOME || path.join(localAppData, 'xdg.state');
+	};
+
+	return object;
+};
+
+const _XDGPortable = () => {
+	const XDGPortable = function () {
+		return _XDGPortable();
+	};
+
+	let extension = {};
+	if (/^darwin$/i.test(process.platform)) {
+		extension = macos();
+	} else if (/^win/i.test(process.platform)) {
+		extension = windows();
+	} else {
+		extension = linux();
+	}
+
+	extension.configDirs = () => {
+		const dirs = [];
+		dirs.push(extension.config());
+		if (process.env.XDG_CONFIG_DIRS) {
+			dirs.push(...process.env.XDG_CONFIG_DIRS.split(path.delimiter));
+		}
+
+		return dirs;
+	};
+
+	extension.dataDirs = () => {
+		const dirs = [];
+		dirs.push(extension.data());
+		if (process.env.XDG_DATA_DIRS) {
+			dirs.push(...process.env.XDG_DATA_DIRS.split(path.delimiter));
+		}
+
+		return dirs;
+	};
+
+	Object.keys(extension).forEach((key) => {
+		XDGPortable[key] = extension[key];
+	});
+
+	return XDGPortable;
+};
+
+module.exports = _XDGPortable();
+
+
 /***/ }),
 
 /***/ 194:
@@ -20079,75 +21203,1512 @@ try {
 
 /***/ }),
 
-/***/ 3097:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 5011:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
+/* --------------------
+ * yauzl-clone module
+ * Clone yauzl module so it can be modified without affecting original
+ * ------------------*/
 
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.downloadGo = exports.createGo = exports.getAnalyzedEntrypoint = exports.OUT_EXTENSION = exports.cacheDir = void 0;
-const tar_1 = __importDefault(__webpack_require__(6758));
-const execa_1 = __importDefault(__webpack_require__(389));
-const node_fetch_1 = __importDefault(__webpack_require__(779));
-const fs_extra_1 = __webpack_require__(7692);
-const path_1 = __webpack_require__(5622);
-const string_argv_1 = __importDefault(__webpack_require__(2534));
-const build_utils_1 = __webpack_require__(3445);
-const versionMap = new Map([
-    ['1.19', '1.19.5'],
-    ['1.18', '1.18.1'],
-    ['1.17', '1.17.3'],
-    ['1.16', '1.16.10'],
-    ['1.15', '1.15.8'],
-    ['1.14', '1.14.15'],
-    ['1.13', '1.13.15'],
-]);
-const archMap = new Map([
-    ['x64', 'amd64'],
-    ['x86', '386'],
-]);
-const platformMap = new Map([['win32', 'windows']]);
-exports.cacheDir = path_1.join('.vercel', 'cache', 'golang');
-const getGoDir = (workPath) => path_1.join(workPath, exports.cacheDir);
-const GO_FLAGS = process.platform === 'win32' ? [] : ['-ldflags', '-s -w'];
-const GO_MIN_VERSION = 13;
-const getPlatform = (p) => platformMap.get(p) || p;
-const getArch = (a) => archMap.get(a) || a;
-const getGoUrl = (version, platform, arch) => {
-    const goArch = getArch(arch);
-    const goPlatform = getPlatform(platform);
-    const ext = platform === 'win32' ? 'zip' : 'tar.gz';
-    return `https://dl.google.com/go/go${version}.${goPlatform}-${goArch}.${ext}`;
+
+
+// Modules
+const util = __webpack_require__(1669),
+	eventsIntercept = __webpack_require__(7052);
+
+// Exports
+module.exports = {
+	clone,
+	patch,
+	patchAll
 };
-exports.OUT_EXTENSION = process.platform === 'win32' ? '.exe' : '';
-async function getAnalyzedEntrypoint(workPath, filePath, modulePath) {
-    build_utils_1.debug('Analyzing entrypoint %o with modulePath %o', filePath, modulePath);
-    const bin = path_1.join(__dirname, `analyze${exports.OUT_EXTENSION}`);
-    const isAnalyzeExist = await fs_extra_1.pathExists(bin);
-    if (!isAnalyzeExist) {
-        const src = __webpack_require__.ab + "analyze.go";
-        const go = await downloadGo(workPath, modulePath);
-        await go.build(__webpack_require__.ab + "analyze.go", bin);
-    }
-    const args = [`-modpath=${modulePath}`, filePath];
-    const analyzed = await execa_1.default.stdout(bin, args);
-    build_utils_1.debug('Analyzed entrypoint %o', analyzed);
+
+/**
+ * yauzlClone.clone( yauzl [, options] )
+ *
+ * Clone `yauzl` object and optionally subclass `yauzl.ZipFile` + `yauzl.Entry`
+ * @param {Object} yauzl - yauzl module object
+ * @param {Object} [options] - options object
+ * @param {boolean} [options.clone=true] - If true, creates clone of `yauzl` object
+ * @param {boolean} [options.subclassZipFile=false] - If true, creates subclass of
+ *   `yauzl.ZipFile` and saves to `yauzl` object
+ * @param {boolean} [options.subclassEntry=false] - If true, creates subclass of
+ *   `yauzl.Entry` and saves to `yauzl` object
+ * @param {boolean} [options.eventsIntercept=false] - If true, patches prototype of
+ *   `yauzl.ZipFile` to support event interception using events-intercept module
+ * @returns {Object} - Cloned yauzl module object
+ *
+ * If ZipFile is subclassed, all access methods (`.open()`, `.fromFd()` etc) are
+ * patched to callback with an instance of the ZipFile subclass.
+ *
+ * If Entry is subclassed, emitted 'entry' events are intercepted and re-emitted
+ * so entries are instance of the entry subclass.
+ */
+function clone(yauzl, options) {
+	// Conform options
+	options = Object.assign({
+		clone: true,
+		subclassZipFile: false,
+		subclassEntry: false,
+		eventsIntercept: false
+	}, options);
+	if (options.subclassEntry) options.eventsIntercept = true;
+
+	// Clone main object
+	if (options.clone) yauzl = Object.assign({}, yauzl);
+
+	// Subclass ZipFile
+	if (options.subclassZipFile) {
+		// Subclass ZipFile
+		const original = yauzl.ZipFile;
+		yauzl.ZipFile = function ZipFile() {
+			original.apply(this, arguments);
+		};
+		util.inherits(yauzl.ZipFile, original);
+
+		// Patch access methods to callback with instance of ZipFile subclass
+		patchAll(yauzl, original => zipFilePatcher(original, yauzl.ZipFile));
+	}
+
+	// Patch ZipFile prototype with events-intercept methods
+	if (options.eventsIntercept) {
+		const ZipFileProto = yauzl.ZipFile.prototype;
+		if (!ZipFileProto.intercept) {
+			eventsIntercept.patch(ZipFileProto);
+			['_events', '_eventsCount', '_interceptors'].forEach(key => delete ZipFileProto[key]);
+		}
+	}
+
+	// Subclass Entry
+	if (options.subclassEntry) {
+		// Subclass Entry
+		const original = yauzl.Entry;
+		yauzl.Entry = function Entry() {
+			original.apply(this, arguments);
+		};
+		util.inherits(yauzl.Entry, original);
+
+		// Patch access methods to add 'entry' event interceptor
+		// which re-emits instances of Entry subclass
+		patchAll(yauzl, original => entryPatcher(original, yauzl.Entry));
+	}
+
+	// Return cloned copy of yauzl
+	return yauzl;
+}
+
+/**
+ * yauzlClone.patchAll( yauzl, fn )
+ *
+ * Patch all access methods with patcher function `fn`
+ * @param {Object} yauzl - yauzl module object
+ * @param {Function} fn - Patcher function
+ * @returns {undefined}
+ *
+ * Patcher function will be called with arguments `(original)` which is original
+ * method (see below for complications)
+ */
+function patchAll(yauzl, fn) {
+	patch(yauzl, 'open', fn);
+	patch(yauzl, 'fromFd', fn);
+	patch(yauzl, 'fromBuffer', fn);
+	patch(yauzl, 'fromRandomAccessReader', fn);
+}
+
+/**
+ * yauzlClone.patch( yauzl, fnName, fn )
+ *
+ * Patch access method with patcher function `fn`
+ * @param {Object} yauzl - yauzl module object
+ * @param {String} fnName - Name of method to patch
+ * @param {Function} fn - Patcher function
+ * @returns {Function} - Patched function
+ *
+ * Patcher function will be called with arguments `(original)` which is original
+ * method.
+ *
+ * EXCEPT: Arguments are conformed so they're the same for all 4 access methods.
+ * This involves adding a dummy extra argument to `.open()`, `.fromFd()` and
+ * `.fromBuffer()`.
+ * Rationale is to make it easier to use the same patching function for all 4
+ * methods so no need to conform arguments in the patching function.
+ *
+ * e.g.:
+ * patchMethod(yauzl, 'open', function(original) {
+ *   return function(path, _, options, callback) {
+ *     original.call(path, _, options, function(err, zipFile) {
+ *       // Do something to modify zipFile
+ *       callback(err, zipFile);
+ *     });
+ *   });
+ * });
+ */
+function patch(yauzl, methodName, fn) {
+	// Convert original function to function which takes 4 arguments
+	// i.e. open(path, options, cb) -> open(path, _, options, cb)
+	// So same shimming function can be used on all 4 methods.
+	const original = yauzl[methodName];
+	if (methodName == 'fromRandomAccessReader') {
+		const shimmed = fn(original);
+
+		yauzl.fromRandomAccessReader = function(reader, totalSize, options, callback) {
+			if (typeof options == 'function') {
+				callback = options;
+				options = {};
+			} else if (!options) {
+				options = {};
+			}
+
+			return shimmed.call(this, reader, totalSize, options, callback);
+		};
+	} else {
+		const shimmed = fn(function(path, unused, options, callback) { // jshint ignore:line
+			return original.call(this, path, options, callback);
+		});
+
+		yauzl[methodName] = function(path, options, callback) {
+			if (typeof options == 'function') {
+				callback = options;
+				options = {};
+			} else if (!options) {
+				options = {};
+			}
+
+			return shimmed.call(this, path, null, options, callback);
+		};
+	}
+
+	// Return shimmed function
+	return yauzl[methodName];
+}
+
+/**
+ * Patcher to make all access methods callback with instance of ZipFile subclass
+ * (rather than original yauzl.ZipFile class)
+ */
+function zipFilePatcher(original, ZipFile) {
+	return function(path, totalSize, options, callback) {
+		// Set `lazyEntries` option to prevent `._readEntry()` being called on
+		// internal zipFile object. Needs to be called on subclass instance instead.
+		const {lazyEntries} = options,
+			hasLazyEntries = options.hasOwnProperty('lazyEntries');
+		if (!lazyEntries) options.lazyEntries = true;
+
+		// Call original method
+		return original.call(this, path, totalSize, options, function(err, zipFile) {
+			if (err) return callback(err);
+
+			// Convert to instance of subclass
+			const zipFileInternal = zipFile;
+			zipFile = Object.assign(Object.create(ZipFile.prototype), zipFile);
+
+			// Forward events from internal ZipFile to exposed one
+			zipFileInternal.emit = zipFile.emit.bind(zipFile);
+
+			// If lazyEntries option was modified, restore to previous setting
+			// and call `._readEntry()` on subclass instance
+			if (!lazyEntries) {
+				if (hasLazyEntries) {
+					options.lazyEntries = lazyEntries;
+				} else {
+					delete options.lazyEntries;
+				}
+
+				zipFile.lazyEntries = false;
+				zipFileInternal.lazyEntries = false;
+
+				zipFile._readEntry();
+			}
+
+			// Callback with subclass instance
+			callback(null, zipFile);
+		});
+	};
+}
+
+/**
+ * Patcher to make all access methods attach event interceptor to zipFiles
+ * which intercept 'entry' events and re-emit entries from Entry subclass
+ */
+function entryPatcher(original, Entry) {
+	return function(path, totalSize, options, callback) {
+		return original.call(this, path, totalSize, options, function(err, zipFile) {
+			if (err) return callback(err);
+
+			zipFile.intercept('entry', function(entry, cb) {
+				entry = Object.assign(Object.create(Entry.prototype), entry);
+				cb(null, entry);
+			});
+
+			callback(null, zipFile);
+		});
+	};
+}
+
+
+/***/ }),
+
+/***/ 7542:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+/* --------------------
+ * yauzl-promise module
+ * ------------------*/
+
+
+
+// Modules
+const yauzlOriginal = __webpack_require__(2277),
+	cloner = __webpack_require__(5011);
+
+// Imports
+const NativePromise = __webpack_require__(612),
+	promisify = __webpack_require__(9384);
+
+// Exports
+function use(Promise, yauzl, options) {
+	// Conform options
+	options = Object.assign({clone: true}, options);
+
+	// Use defaults if not provided
+	if (!Promise) Promise = NativePromise;
+	if (!yauzl) yauzl = yauzlOriginal;
+
+	// Clone yauzl unless `options.clone` false
+	if (options.clone) {
+		yauzl = cloner.clone(yauzl, {subclassZipFile: true, subclassEntry: true});
+	} else {
+		// Patch ZipFile prototype with events-intercept methods
+		cloner.clone(yauzl, {clone: false, eventsIntercept: true});
+	}
+
+	// Add promisfied methods
+	if (Promise) {
+		promisify(yauzl, Promise);
+	} else {
+		yauzl = {};
+	}
+
+	// Add `use` methods
+	yauzl.use = use;
+	yauzl.usePromise = function(Promise) {
+		return use(Promise, null);
+	};
+	yauzl.useYauzl = function(yauzl, options) {
+		return use(null, yauzl, options);
+	};
+
+	// Return yauzl object
+	return yauzl;
+}
+
+module.exports = use();
+
+
+/***/ }),
+
+/***/ 612:
+/***/ ((module) => {
+
+"use strict";
+/* --------------------
+ * yauzl-promise module
+ * Return native Promise
+ * ------------------*/
+
+
+
+// Exports
+let NativePromise;
+try {
+	NativePromise = Promise;
+} catch(e) {}
+
+module.exports = NativePromise;
+
+
+/***/ }),
+
+/***/ 9384:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+/* --------------------
+ * yauzl-promise module
+ * Promisify yauzl
+ * ------------------*/
+
+
+
+// Modules
+const cloner = __webpack_require__(5011);
+
+// Constants
+const STATE = Symbol(),
+	STORED_ERROR = Symbol();
+
+// Exports
+module.exports = (yauzl, Promise) => {
+	const {ZipFile, Entry} = yauzl;
+
+	// Promisify open + from... methods
+	promisifyMethod(yauzl, Promise, 'open');
+	promisifyMethod(yauzl, Promise, 'fromFd');
+	promisifyMethod(yauzl, Promise, 'fromBuffer');
+	promisifyMethod(yauzl, Promise, 'fromRandomAccessReader');
+
+	// Promisify `close` method
+	promisifyClose(ZipFile, Promise);
+
+	// Promisify ZipFile `readEntry` method
+	promisifyReadEntry(ZipFile, Promise);
+
+	// Add ZipFile `readEntries` + `walkEntries` methods
+	ZipFile.prototype.readEntries = readEntries;
+	addWalkEntriesMethod(ZipFile, Promise);
+
+	// Promisify ZipFile `openReadStream` method
+	promisifyOpenReadStream(ZipFile, Promise);
+
+	// Add Entry `openReadStream` method
+	Entry.prototype.openReadStream = entryOpenReadStream;
+
+	// Add reference to Entry to ZipFile (used by `readEntries`)
+	ZipFile.Entry = Entry;
+};
+
+/*
+ * Promisify open/from... method
+ */
+function promisifyMethod(yauzl, Promise, fnName) {
+	const fromBuffer = fnName == 'fromBuffer';
+
+	cloner.patch(yauzl, fnName, original => {
+		return function(path, totalSize, options) {
+			return new Promise((resolve, reject) => {
+				options = Object.assign({}, options, {lazyEntries: true, autoClose: false});
+
+				original(path, totalSize, options, (err, zipFile) => {
+					if (err) return reject(err);
+					opened(zipFile, resolve, fromBuffer, yauzl);
+				});
+			});
+		};
+	});
+}
+
+function opened(zipFile, resolve, fromBuffer, yauzl) {
+	// For `.fromBuffer()` calls, adapt `reader` to emit close event
+	if (fromBuffer) {
+		zipFile.reader.unref = yauzl.RandomAccessReader.prototype.unref;
+		zipFile.reader.close = cb => cb();
+	}
+
+	// Init
+	clearState(zipFile);
+	clearError(zipFile);
+
+	// Intercept events
+	zipFile.intercept('entry', emittedEntry);
+	zipFile.intercept('end', emittedEnd);
+	zipFile.intercept('close', emittedClose);
+	zipFile.intercept('error', emittedError);
+
+	// Resolve promise with zip object
+	resolve(zipFile);
+}
+
+/*
+ * Error event handler
+ */
+function emittedError(err) {
+	// jshint validthis:true
+	// If operation in progress, reject its promise
+	const state = getState(this);
+	if (state) {
+		clearState(this);
+		return state.reject(err);
+	}
+
+	// Store error to be returned on next call to
+	// `.readEntry()`, `.close()` or `.openReadStream()`.
+	if (!getError(this)) setError(this, err);
+}
+
+function rejectWithStoredError(zipFile, reject) {
+	const err = getError(zipFile);
+	clearError(zipFile);
+	reject(err);
+}
+
+/*
+ * Promisify ZipFile `close` method
+ */
+function promisifyClose(ZipFile, Promise) {
+	const close = ZipFile.prototype.close;
+
+	ZipFile.prototype.close = function() {
+		return new Promise((resolve, reject) => {
+			if (getError(this)) return rejectWithStoredError(this, reject);
+			if (!this.isOpen) return resolve();
+			if (getState(this)) return reject(new Error('Previous operation has not completed yet'));
+
+			setState(this, {action: 'close', resolve, reject});
+			close.call(this);
+		});
+	};
+}
+
+function emittedClose() {
+	// jshint validthis:true
+	// If not closing, emit error
+	const state = getState(this);
+	if (!state || state.action != 'close') return this.emit('error', new Error('Unexpected \'close\' event emitted'));
+
+	clearState(this);
+
+	// Resolve promise
+	state.resolve();
+}
+
+/*
+ * Promisify ZipFile `readEntry` method
+ */
+function promisifyReadEntry(ZipFile, Promise) {
+	const readEntry = ZipFile.prototype.readEntry;
+
+	ZipFile.prototype.readEntry = function() {
+		return new Promise((resolve, reject) => {
+			if (getError(this)) return rejectWithStoredError(this, reject);
+			if (!this.isOpen) return reject(new Error('ZipFile is not open'));
+			if (getState(this)) return reject(new Error('Previous operation has not completed yet'));
+
+			setState(this, {action: 'read', resolve, reject});
+			readEntry.call(this);
+		});
+	};
+}
+
+function emittedEntry(entry) {
+	// jshint validthis:true
+	// If not reading, emit error
+	const state = getState(this);
+	if (!state || state.action != 'read') return this.emit('error', new Error(`Unexpected '${entry ? 'entry' : 'end'}' event emitted`));
+
+	clearState(this);
+
+	// Set reference to zipFile on entry (used by `entry.openReadStream()`)
+	if (entry) entry.zipFile = this;
+
+	// Resolve promise with entry
+	state.resolve(entry);
+}
+
+function emittedEnd() {
+	// jshint validthis:true
+	emittedEntry.call(this, null);
+}
+
+/*
+ * Functions to access state
+ */
+function getState(zipFile) {
+	return zipFile[STATE];
+}
+
+function setState(zipFile, state) {
+	zipFile[STATE] = state;
+}
+
+function clearState(zipFile) {
+	zipFile[STATE] = undefined;
+}
+
+function getError(zipFile) {
+	return zipFile[STORED_ERROR];
+}
+
+function setError(zipFile, state) {
+	zipFile[STORED_ERROR] = state;
+}
+
+function clearError(zipFile) {
+	zipFile[STORED_ERROR] = undefined;
+}
+
+/*
+ * Read all ZipFile entries
+ * Reads all entries and returns a promise which resolves with an array of entries
+ * `options.max` limits number returned (default 100)
+ * `options.max` can be set to `0` for no limit
+ */
+function readEntries(numEntries) {
+	// jshint validthis:true
+	const entries = [];
+	return this.walkEntries(entry => {
+		entries.push(entry);
+	}, numEntries).then(() => {
+		return entries;
+	});
+}
+
+/*
+ * Walk all ZipFile entries
+ * Walks through each entry and calls `fn` with each.
+ * Returns a promise which resolves when all have been read.
+ */
+function addWalkEntriesMethod(ZipFile, Promise) {
+	ZipFile.prototype.walkEntries = function(callback, numEntries) {
+		callback = wrapFunctionToReturnPromise(callback, Promise);
+
+		return new Promise((resolve, reject) => {
+			walkNextEntry(this, callback, numEntries, 0, err => {
+				if (err) return reject(err);
+				resolve();
+			});
+		});
+	};
+}
+
+function walkNextEntry(zipFile, fn, numEntries, count, cb) {
+	if (numEntries && count == numEntries) return cb();
+
+	zipFile.readEntry().then(entry => {
+		if (!entry) return cb();
+
+		return fn(entry).then(() => {
+			walkNextEntry(zipFile, fn, numEntries, count + 1, cb);
+		});
+	}).catch(err => {
+		cb(err);
+	});
+}
+
+/*
+ * Promisify ZipFile `openReadStream` method
+ */
+function promisifyOpenReadStream(ZipFile, Promise) {
+	const openReadStream = ZipFile.prototype.openReadStream;
+	ZipFile.prototype.openReadStream = function(entry, options) {
+		return new Promise((resolve, reject) => {
+			if (getError(this)) return rejectWithStoredError(this, reject);
+			openReadStream.call(this, entry, options || {}, (err, stream) => {
+				if (err) return reject(err);
+				resolve(stream);
+			});
+		});
+	};
+}
+
+/*
+ * Entry `openReadStream` method
+ */
+function entryOpenReadStream(options) {
+	// jshint validthis:true
+	return this.zipFile.openReadStream(this, options);
+}
+
+/*
+ * Utility functions
+ */
+function wrapFunctionToReturnPromise(fn, Promise) {
+	return function() {
+		try {
+			const result = fn.apply(this, arguments);
+			if (result instanceof Promise) return result;
+			return Promise.resolve(result);
+		} catch (err) {
+			return new Promise((resolve, reject) => { // jshint ignore:line
+				reject(err);
+			});
+		}
+	};
+}
+
+
+/***/ }),
+
+/***/ 2277:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+var fs = __webpack_require__(5747);
+var zlib = __webpack_require__(8761);
+var fd_slicer = __webpack_require__(402);
+var crc32 = __webpack_require__(7938);
+var util = __webpack_require__(1669);
+var EventEmitter = __webpack_require__(8614).EventEmitter;
+var Transform = __webpack_require__(2413).Transform;
+var PassThrough = __webpack_require__(2413).PassThrough;
+var Writable = __webpack_require__(2413).Writable;
+
+exports.open = open;
+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 open(path, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = null;
+  }
+  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;
+  fs.open(path, "r", function(err, fd) {
+    if (err) return callback(err);
+    fromFd(fd, options, function(err, zipfile) {
+      if (err) fs.close(fd, defaultCallback);
+      callback(err, zipfile);
+    });
+  });
+}
+
+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;
+  fs.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 fromBuffer(buffer, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = null;
+  }
+  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;
+  // limit the max chunk size. see https://github.com/thejoshwolfe/yauzl/issues/87
+  var reader = fd_slicer.createFromBuffer(buffer, {maxChunkSize: 0x10000});
+  fromRandomAccessReader(reader, buffer.length, options, callback);
+}
+
+function fromRandomAccessReader(reader, totalSize, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = null;
+  }
+  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.");
+  }
+
+  // the matching unref() call is in zipfile.close()
+  reader.ref();
+
+  // eocdr means End of Central Directory Record.
+  // search backwards for the eocdr signature.
+  // the last field of the eocdr is a variable-length comment.
+  // the comment size is encoded in a 2-byte field in the eocdr, which we can't find without trudging backwards through the comment to find it.
+  // as a consequence of this design decision, it's possible to have ambiguous zip file metadata if a coherent eocdr was in the comment.
+  // we search backwards for a eocdr signature, and hope that whoever made the zip file was smart enough to forbid the eocdr signature in the comment.
+  var eocdrWithoutCommentSize = 22;
+  var maxCommentSize = 0xffff; // 2-byte size
+  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) !== 0x06054b50) continue;
+      // found eocdr
+      var eocdrBuffer = buffer.slice(i);
+
+      // 0 - End of central directory signature = 0x06054b50
+      // 4 - Number of this disk
+      var diskNumber = eocdrBuffer.readUInt16LE(4);
+      if (diskNumber !== 0) {
+        return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
+      }
+      // 6 - Disk where central directory starts
+      // 8 - Number of central directory records on this disk
+      // 10 - Total number of central directory records
+      var entryCount = eocdrBuffer.readUInt16LE(10);
+      // 12 - Size of central directory (bytes)
+      // 16 - Offset of start of central directory, relative to start of archive
+      var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16);
+      // 20 - Comment length
+      var commentLength = eocdrBuffer.readUInt16LE(20);
+      var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize;
+      if (commentLength !== expectedCommentLength) {
+        return callback(new Error("invalid comment length. expected: " + expectedCommentLength + ". found: " + commentLength));
+      }
+      // 22 - Comment
+      // the encoding is always cp437.
+      var comment = decodeStrings ? decodeBuffer(eocdrBuffer, 22, eocdrBuffer.length, false)
+                                  : eocdrBuffer.slice(22);
+
+      if (!(entryCount === 0xffff || centralDirectoryOffset === 0xffffffff)) {
+        return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
+      }
+
+      // ZIP64 format
+
+      // ZIP64 Zip64 end of central directory locator
+      var zip64EocdlBuffer = newBuffer(20);
+      var zip64EocdlOffset = bufferReadStart + i - zip64EocdlBuffer.length;
+      readAndAssertNoEof(reader, zip64EocdlBuffer, 0, zip64EocdlBuffer.length, zip64EocdlOffset, function(err) {
+        if (err) return callback(err);
+
+        // 0 - zip64 end of central dir locator signature = 0x07064b50
+        if (zip64EocdlBuffer.readUInt32LE(0) !== 0x07064b50) {
+          return callback(new Error("invalid zip64 end of central directory locator signature"));
+        }
+        // 4 - number of the disk with the start of the zip64 end of central directory
+        // 8 - relative offset of the zip64 end of central directory record
+        var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8);
+        // 16 - total number of disks
+
+        // ZIP64 end of central directory record
+        var zip64EocdrBuffer = newBuffer(56);
+        readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err) {
+          if (err) return callback(err);
+
+          // 0 - zip64 end of central dir signature                           4 bytes  (0x06064b50)
+          if (zip64EocdrBuffer.readUInt32LE(0) !== 0x06064b50) {
+            return callback(new Error("invalid zip64 end of central directory record signature"));
+          }
+          // 4 - size of zip64 end of central directory record                8 bytes
+          // 12 - version made by                                             2 bytes
+          // 14 - version needed to extract                                   2 bytes
+          // 16 - number of this disk                                         4 bytes
+          // 20 - number of the disk with the start of the central directory  4 bytes
+          // 24 - total number of entries in the central directory on this disk         8 bytes
+          // 32 - total number of entries in the central directory            8 bytes
+          entryCount = readUInt64LE(zip64EocdrBuffer, 32);
+          // 40 - size of the central directory                               8 bytes
+          // 48 - offset of start of central directory with respect to the starting disk number     8 bytes
+          centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48);
+          // 56 - zip64 extensible data sector                                (variable size)
+          return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
+        });
+      });
+      return;
+    }
+    callback(new Error("end of central directory record signature not found"));
+  });
+}
+
+util.inherits(ZipFile, EventEmitter);
+function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
+  var self = this;
+  EventEmitter.call(self);
+  self.reader = reader;
+  // forward close events
+  self.reader.on("error", function(err) {
+    // error closing the fd
+    emitError(self, err);
+  });
+  self.reader.once("close", function() {
+    self.emit("close");
+  });
+  self.readEntryCursor = centralDirectoryOffset;
+  self.fileSize = fileSize;
+  self.entryCount = entryCount;
+  self.comment = comment;
+  self.entriesRead = 0;
+  self.autoClose = !!autoClose;
+  self.lazyEntries = !!lazyEntries;
+  self.decodeStrings = !!decodeStrings;
+  self.validateEntrySizes = !!validateEntrySizes;
+  self.strictFileNames = !!strictFileNames;
+  self.isOpen = true;
+  self.emittedError = false;
+
+  if (!self.lazyEntries) self._readEntry();
+}
+ZipFile.prototype.close = function() {
+  if (!this.isOpen) return;
+  this.isOpen = false;
+  this.reader.unref();
+};
+
+function emitErrorAndAutoClose(self, err) {
+  if (self.autoClose) self.close();
+  emitError(self, err);
+}
+function emitError(self, err) {
+  if (self.emittedError) return;
+  self.emittedError = true;
+  self.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 self = this;
+  if (self.entryCount === self.entriesRead) {
+    // done with metadata
+    setImmediate(function() {
+      if (self.autoClose) self.close();
+      if (self.emittedError) return;
+      self.emit("end");
+    });
+    return;
+  }
+  if (self.emittedError) return;
+  var buffer = newBuffer(46);
+  readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
+    if (err) return emitErrorAndAutoClose(self, err);
+    if (self.emittedError) return;
+    var entry = new Entry();
+    // 0 - Central directory file header signature
+    var signature = buffer.readUInt32LE(0);
+    if (signature !== 0x02014b50) return emitErrorAndAutoClose(self, new Error("invalid central directory file header signature: 0x" + signature.toString(16)));
+    // 4 - Version made by
+    entry.versionMadeBy = buffer.readUInt16LE(4);
+    // 6 - Version needed to extract (minimum)
+    entry.versionNeededToExtract = buffer.readUInt16LE(6);
+    // 8 - General purpose bit flag
+    entry.generalPurposeBitFlag = buffer.readUInt16LE(8);
+    // 10 - Compression method
+    entry.compressionMethod = buffer.readUInt16LE(10);
+    // 12 - File last modification time
+    entry.lastModFileTime = buffer.readUInt16LE(12);
+    // 14 - File last modification date
+    entry.lastModFileDate = buffer.readUInt16LE(14);
+    // 16 - CRC-32
+    entry.crc32 = buffer.readUInt32LE(16);
+    // 20 - Compressed size
+    entry.compressedSize = buffer.readUInt32LE(20);
+    // 24 - Uncompressed size
+    entry.uncompressedSize = buffer.readUInt32LE(24);
+    // 28 - File name length (n)
+    entry.fileNameLength = buffer.readUInt16LE(28);
+    // 30 - Extra field length (m)
+    entry.extraFieldLength = buffer.readUInt16LE(30);
+    // 32 - File comment length (k)
+    entry.fileCommentLength = buffer.readUInt16LE(32);
+    // 34 - Disk number where file starts
+    // 36 - Internal file attributes
+    entry.internalFileAttributes = buffer.readUInt16LE(36);
+    // 38 - External file attributes
+    entry.externalFileAttributes = buffer.readUInt32LE(38);
+    // 42 - Relative offset of local file header
+    entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42);
+
+    if (entry.generalPurposeBitFlag & 0x40) return emitErrorAndAutoClose(self, new Error("strong encryption is not supported"));
+
+    self.readEntryCursor += 46;
+
+    buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
+    readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
+      if (err) return emitErrorAndAutoClose(self, err);
+      if (self.emittedError) return;
+      // 46 - File name
+      var isUtf8 = (entry.generalPurposeBitFlag & 0x800) !== 0;
+      entry.fileName = self.decodeStrings ? decodeBuffer(buffer, 0, entry.fileNameLength, isUtf8)
+                                          : buffer.slice(0, entry.fileNameLength);
+
+      // 46+n - Extra field
+      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(self, 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;
+      }
+
+      // 46+n+m - File comment
+      entry.fileComment = self.decodeStrings ? decodeBuffer(buffer, fileCommentStart, fileCommentStart + entry.fileCommentLength, isUtf8)
+                                             : buffer.slice(fileCommentStart, fileCommentStart + entry.fileCommentLength);
+      // compatibility hack for https://github.com/thejoshwolfe/yauzl/issues/47
+      entry.comment = entry.fileComment;
+
+      self.readEntryCursor += buffer.length;
+      self.entriesRead += 1;
+
+      if (entry.uncompressedSize            === 0xffffffff ||
+          entry.compressedSize              === 0xffffffff ||
+          entry.relativeOffsetOfLocalHeader === 0xffffffff) {
+        // ZIP64 format
+        // find the Zip64 Extended Information Extra Field
+        var zip64EiefBuffer = null;
+        for (var i = 0; i < entry.extraFields.length; i++) {
+          var extraField = entry.extraFields[i];
+          if (extraField.id === 0x0001) {
+            zip64EiefBuffer = extraField.data;
+            break;
+          }
+        }
+        if (zip64EiefBuffer == null) {
+          return emitErrorAndAutoClose(self, new Error("expected zip64 extended information extra field"));
+        }
+        var index = 0;
+        // 0 - Original Size          8 bytes
+        if (entry.uncompressedSize === 0xffffffff) {
+          if (index + 8 > zip64EiefBuffer.length) {
+            return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include uncompressed size"));
+          }
+          entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
+          index += 8;
+        }
+        // 8 - Compressed Size        8 bytes
+        if (entry.compressedSize === 0xffffffff) {
+          if (index + 8 > zip64EiefBuffer.length) {
+            return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include compressed size"));
+          }
+          entry.compressedSize = readUInt64LE(zip64EiefBuffer, index);
+          index += 8;
+        }
+        // 16 - Relative Header Offset 8 bytes
+        if (entry.relativeOffsetOfLocalHeader === 0xffffffff) {
+          if (index + 8 > zip64EiefBuffer.length) {
+            return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include relative header offset"));
+          }
+          entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
+          index += 8;
+        }
+        // 24 - Disk Start Number      4 bytes
+      }
+
+      // check for Info-ZIP Unicode Path Extra Field (0x7075)
+      // see https://github.com/thejoshwolfe/yauzl/issues/33
+      if (self.decodeStrings) {
+        for (var i = 0; i < entry.extraFields.length; i++) {
+          var extraField = entry.extraFields[i];
+          if (extraField.id === 0x7075) {
+            if (extraField.data.length < 6) {
+              // too short to be meaningful
+              continue;
+            }
+            // Version       1 byte      version of this extra field, currently 1
+            if (extraField.data.readUInt8(0) !== 1) {
+              // > Changes may not be backward compatible so this extra
+              // > field should not be used if the version is not recognized.
+              continue;
+            }
+            // NameCRC32     4 bytes     File Name Field CRC32 Checksum
+            var oldNameCrc32 = extraField.data.readUInt32LE(1);
+            if (crc32.unsigned(buffer.slice(0, entry.fileNameLength)) !== oldNameCrc32) {
+              // > If the CRC check fails, this UTF-8 Path Extra Field should be
+              // > ignored and the File Name field in the header should be used instead.
+              continue;
+            }
+            // UnicodeName   Variable    UTF-8 version of the entry File Name
+            entry.fileName = decodeBuffer(extraField.data, 5, extraField.data.length, true);
+            break;
+          }
+        }
+      }
+
+      // validate file size
+      if (self.validateEntrySizes && entry.compressionMethod === 0) {
+        var expectedCompressedSize = entry.uncompressedSize;
+        if (entry.isEncrypted()) {
+          // traditional encryption prefixes the file data with a header
+          expectedCompressedSize += 12;
+        }
+        if (entry.compressedSize !== expectedCompressedSize) {
+          var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize;
+          return emitErrorAndAutoClose(self, new Error(msg));
+        }
+      }
+
+      if (self.decodeStrings) {
+        if (!self.strictFileNames) {
+          // allow backslash
+          entry.fileName = entry.fileName.replace(/\\/g, "/");
+        }
+        var errorMessage = validateFileName(entry.fileName, self.validateFileNameOptions);
+        if (errorMessage != null) return emitErrorAndAutoClose(self, new Error(errorMessage));
+      }
+      self.emit("entry", entry);
+
+      if (!self.lazyEntries) self._readEntry();
+    });
+  });
+};
+
+ZipFile.prototype.openReadStream = function(entry, options, callback) {
+  var self = this;
+  // parameter validation
+  var relativeStart = 0;
+  var relativeEnd = entry.compressedSize;
+  if (callback == null) {
+    callback = options;
+    options = {};
+  } else {
+    // validate options that the caller has no excuse to get wrong
+    if (options.decrypt != null) {
+      if (!entry.isEncrypted()) {
+        throw new Error("options.decrypt can only be specified for encrypted entries");
+      }
+      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");
+      }
+    }
+    if (options.decompress != null) {
+      if (!entry.isCompressed()) {
+        throw new Error("options.decompress can only be specified for compressed entries");
+      }
+      if (!(options.decompress === false || options.decompress === true)) {
+        throw new Error("invalid options.decompress value: " + options.decompress);
+      }
+    }
+    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 (entry.isEncrypted() && options.decrypt !== false) {
+        throw new Error("start/end range not allowed for encrypted entry without options.decrypt === false");
+      }
+    }
+    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 (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");
+    }
+  }
+  // any further errors can either be caused by the zipfile,
+  // or were introduced in a minor version of yauzl,
+  // so should be passed to the client rather than thrown.
+  if (!self.isOpen) return callback(new Error("closed"));
+  if (entry.isEncrypted()) {
+    if (options.decrypt !== false) return callback(new Error("entry is encrypted, and options.decrypt !== false"));
+  }
+  // make sure we don't lose the fd before we open the actual read stream
+  self.reader.ref();
+  var buffer = newBuffer(30);
+  readAndAssertNoEof(self.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) {
+    try {
+      if (err) return callback(err);
+      // 0 - Local file header signature = 0x04034b50
+      var signature = buffer.readUInt32LE(0);
+      if (signature !== 0x04034b50) {
+        return callback(new Error("invalid local file header signature: 0x" + signature.toString(16)));
+      }
+      // all this should be redundant
+      // 4 - Version needed to extract (minimum)
+      // 6 - General purpose bit flag
+      // 8 - Compression method
+      // 10 - File last modification time
+      // 12 - File last modification date
+      // 14 - CRC-32
+      // 18 - Compressed size
+      // 22 - Uncompressed size
+      // 26 - File name length (n)
+      var fileNameLength = buffer.readUInt16LE(26);
+      // 28 - Extra field length (m)
+      var extraFieldLength = buffer.readUInt16LE(28);
+      // 30 - File name
+      // 30+n - Extra field
+      var localFileHeaderEnd = entry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength;
+      var decompress;
+      if (entry.compressionMethod === 0) {
+        // 0 - The file is stored (no compression)
+        decompress = false;
+      } else if (entry.compressionMethod === 8) {
+        // 8 - The file is Deflated
+        decompress = options.decompress != null ? options.decompress : true;
+      } else {
+        return callback(new Error("unsupported compression method: " + entry.compressionMethod));
+      }
+      var fileDataStart = localFileHeaderEnd;
+      var fileDataEnd = fileDataStart + entry.compressedSize;
+      if (entry.compressedSize !== 0) {
+        // bounds check now, because the read streams will probably not complain loud enough.
+        // since we're dealing with an unsigned offset plus an unsigned size,
+        // we only have 1 thing to check for.
+        if (fileDataEnd > self.fileSize) {
+          return callback(new Error("file data overflows file bounds: " +
+              fileDataStart + " + " + entry.compressedSize + " > " + self.fileSize));
+        }
+      }
+      var readStream = self.reader.createReadStream({
+        start: fileDataStart + relativeStart,
+        end: fileDataStart + relativeEnd,
+      });
+      var endpointStream = readStream;
+      if (decompress) {
+        var destroyed = false;
+        var inflateFilter = zlib.createInflateRaw();
+        readStream.on("error", function(err) {
+          // setImmediate here because errors can be emitted during the first call to pipe()
+          setImmediate(function() {
+            if (!destroyed) inflateFilter.emit("error", err);
+          });
+        });
+        readStream.pipe(inflateFilter);
+
+        if (self.validateEntrySizes) {
+          endpointStream = new AssertByteCountStream(entry.uncompressedSize);
+          inflateFilter.on("error", function(err) {
+            // forward zlib errors to the client-visible stream
+            setImmediate(function() {
+              if (!destroyed) endpointStream.emit("error", err);
+            });
+          });
+          inflateFilter.pipe(endpointStream);
+        } else {
+          // the zlib filter is the client-visible stream
+          endpointStream = inflateFilter;
+        }
+        // this is part of yauzl's API, so implement this function on the client-visible stream
+        endpointStream.destroy = function() {
+          destroyed = true;
+          if (inflateFilter !== endpointStream) inflateFilter.unpipe(endpointStream);
+          readStream.unpipe(inflateFilter);
+          // TODO: the inflateFilter may cause a memory leak. see Issue #27.
+          readStream.destroy();
+        };
+      }
+      callback(null, endpointStream);
+    } finally {
+      self.reader.unref();
+    }
+  });
+};
+
+function Entry() {
+}
+Entry.prototype.getLastModDate = function() {
+  return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime);
+};
+Entry.prototype.isEncrypted = function() {
+  return (this.generalPurposeBitFlag & 0x1) !== 0;
+};
+Entry.prototype.isCompressed = function() {
+  return this.compressionMethod === 8;
+};
+
+function dosDateTimeToDate(date, time) {
+  var day = date & 0x1f; // 1-31
+  var month = (date >> 5 & 0xf) - 1; // 1-12, 0-11
+  var year = (date >> 9 & 0x7f) + 1980; // 0-128, 1980-2108
+
+  var millisecond = 0;
+  var second = (time & 0x1f) * 2; // 0-29, 0-58 (even numbers)
+  var minute = time >> 5 & 0x3f; // 0-59
+  var hour = time >> 11 & 0x1f; // 0-23
+
+  return new Date(year, month, day, hour, minute, second, millisecond);
+}
+
+function validateFileName(fileName) {
+  if (fileName.indexOf("\\") !== -1) {
+    return "invalid characters in fileName: " + fileName;
+  }
+  if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) {
+    return "absolute path: " + fileName;
+  }
+  if (fileName.split("/").indexOf("..") !== -1) {
+    return "invalid relative path: " + fileName;
+  }
+  // all good
+  return null;
+}
+
+function readAndAssertNoEof(reader, buffer, offset, length, position, callback) {
+  if (length === 0) {
+    // fs.read will throw an out-of-bounds error if you try to read 0 bytes from a 0 byte file
+    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"));
+    }
+    callback();
+  });
+}
+
+util.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();
+};
+
+util.inherits(RandomAccessReader, EventEmitter);
+function RandomAccessReader() {
+  EventEmitter.call(this);
+  this.refCount = 0;
+}
+RandomAccessReader.prototype.ref = function() {
+  this.refCount += 1;
+};
+RandomAccessReader.prototype.unref = function() {
+  var self = this;
+  self.refCount -= 1;
+
+  if (self.refCount > 0) return;
+  if (self.refCount < 0) throw new Error("invalid unref");
+
+  self.close(onCloseDone);
+
+  function onCloseDone(err) {
+    if (err) return self.emit('error', err);
+    self.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;
+  }
+  var stream = this._readStreamForRange(start, end);
+
+  var destroyed = false;
+  var refUnrefFilter = new RefUnrefFilter(this);
+  stream.on("error", function(err) {
+    setImmediate(function() {
+      if (!destroyed) refUnrefFilter.emit("error", err);
+    });
+  });
+  refUnrefFilter.destroy = function() {
+    stream.unpipe(refUnrefFilter);
+    refUnrefFilter.unref();
+    stream.destroy();
+  };
+
+  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 stream.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 readStream = 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);
+  readStream.on("error", function(error) {
+    callback(error);
+  });
+  readStream.pipe(writeStream);
+};
+RandomAccessReader.prototype.close = function(callback) {
+  setImmediate(callback);
+};
+
+util.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 = '\u0000☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !"#$%&\'()*+,-./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) {
+  // there is no native function for this, because we can't actually store 64-bit integers precisely.
+  // after 53 bits, JavaScript's Number type (IEEE 754 double) can't store individual integers anymore.
+  // but since 53 bits is a whole lot more than 32 bits, we do our best anyway.
+  var lower32 = buffer.readUInt32LE(offset);
+  var upper32 = buffer.readUInt32LE(offset + 4);
+  // we can't use bitshifting here, because JavaScript bitshifting only works on 32-bit integers.
+  return upper32 * 0x100000000 + lower32;
+  // as long as we're bounds checking the result of this function against the total file size,
+  // we'll catch any overflow errors, because we already made sure the total file size was within reason.
+}
+
+// Node 10 deprecated new Buffer().
+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;
+}
+
+
+/***/ }),
+
+/***/ 3097:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createGo = exports.getAnalyzedEntrypoint = exports.OUT_EXTENSION = exports.goGlobalCachePath = exports.cacheDir = void 0;
+const tar_1 = __importDefault(__webpack_require__(6758));
+const execa_1 = __importDefault(__webpack_require__(389));
+const node_fetch_1 = __importDefault(__webpack_require__(779));
+const fs_extra_1 = __webpack_require__(7692);
+const path_1 = __webpack_require__(5622);
+const string_argv_1 = __importDefault(__webpack_require__(2534));
+const build_utils_1 = __webpack_require__(3445);
+const stream_1 = __webpack_require__(2413);
+const util_1 = __webpack_require__(1669);
+const os_1 = __webpack_require__(2087);
+const yauzl_promise_1 = __importDefault(__webpack_require__(7542));
+const xdg_app_paths_1 = __importDefault(__webpack_require__(4925));
+const streamPipeline = util_1.promisify(stream_1.pipeline);
+const versionMap = new Map([
+    ['1.20', '1.20.1'],
+    ['1.19', '1.19.6'],
+    ['1.18', '1.18.10'],
+    ['1.17', '1.17.13'],
+    ['1.16', '1.16.15'],
+    ['1.15', '1.15.15'],
+    ['1.14', '1.14.15'],
+    ['1.13', '1.13.15'],
+]);
+const archMap = new Map([
+    ['x64', 'amd64'],
+    ['x86', '386'],
+]);
+const platformMap = new Map([['win32', 'windows']]);
+exports.cacheDir = path_1.join('.vercel', 'cache', 'golang');
+const GO_FLAGS = process.platform === 'win32' ? [] : ['-ldflags', '-s -w'];
+const GO_MIN_VERSION = 13;
+const getPlatform = (p) => platformMap.get(p) || p;
+const getArch = (a) => archMap.get(a) || a;
+function getGoUrl(version) {
+    const { arch, platform } = process;
+    const goArch = getArch(arch);
+    const goPlatform = getPlatform(platform);
+    const ext = platform === 'win32' ? 'zip' : 'tar.gz';
+    const filename = `go${version}.${goPlatform}-${goArch}.${ext}`;
+    return {
+        filename,
+        url: `https://dl.google.com/go/${filename}`,
+    };
+}
+exports.goGlobalCachePath = path_1.join(xdg_app_paths_1.default('com.vercel.cli').cache(), 'golang');
+exports.OUT_EXTENSION = process.platform === 'win32' ? '.exe' : '';
+async function getAnalyzedEntrypoint(workPath, filePath, modulePath) {
+    const bin = path_1.join(__dirname, `analyze${exports.OUT_EXTENSION}`);
+    const isAnalyzeExist = await fs_extra_1.pathExists(bin);
+    if (!isAnalyzeExist) {
+        build_utils_1.debug(`Building analyze bin: ${bin}`);
+        const src = __webpack_require__.ab + "analyze.go";
+        const go = await createGo({
+            modulePath,
+            workPath,
+        });
+        await go.build(__webpack_require__.ab + "analyze.go", bin);
+    }
+    build_utils_1.debug(`Analyzing entrypoint ${filePath} with modulePath ${modulePath}`);
+    const args = [`-modpath=${modulePath}`, filePath];
+    const analyzed = await execa_1.default.stdout(bin, args);
+    build_utils_1.debug(`Analyzed entrypoint ${analyzed}`);
     return analyzed;
 }
 exports.getAnalyzedEntrypoint = getAnalyzedEntrypoint;
-// Creates a `$GOPATH` directory tree, as per `go help gopath` instructions.
-// Without this, `go` won't recognize the `$GOPATH`.
-function createGoPathTree(goPath, platform, arch) {
-    const tuple = `${getPlatform(platform)}_${getArch(arch)}`;
-    build_utils_1.debug('Creating GOPATH directory structure for %o (%s)', goPath, tuple);
-    return Promise.all([
-        fs_extra_1.mkdirp(path_1.join(goPath, 'bin')),
-        fs_extra_1.mkdirp(path_1.join(goPath, 'pkg', tuple)),
-    ]);
-}
 class GoWrapper {
     constructor(env, opts = {}) {
         if (!opts.cwd) {
@@ -20158,8 +22719,10 @@ class GoWrapper {
     }
     execute(...args) {
         const { opts, env } = this;
-        build_utils_1.debug('Exec %o', `go ${args.join(' ')}`);
-        return execa_1.default('go', args, { stdio: 'pipe', ...opts, env });
+        build_utils_1.debug(`Exec: go ${args
+            .map(a => (a.includes(' ') ? `"${a}"` : a))
+            .join(' ')} CWD=${opts.cwd}`);
+        return execa_1.default('go', args, { stdio: 'inherit', ...opts, env });
     }
     mod() {
         return this.execute('mod', 'tidy');
@@ -20167,16 +22730,16 @@ class GoWrapper {
     get(src) {
         const args = ['get'];
         if (src) {
-            build_utils_1.debug('Fetching `go` dependencies for file %o', src);
+            build_utils_1.debug(`Fetching 'go' dependencies for file ${src}`);
             args.push(src);
         }
         else {
-            build_utils_1.debug('Fetching `go` dependencies for cwd %o', this.opts.cwd);
+            build_utils_1.debug(`Fetching 'go' dependencies for cwd ${this.opts.cwd}`);
         }
         return this.execute(...args);
     }
     build(src, dest) {
-        build_utils_1.debug('Building optimized `go` binary %o -> %o', src, dest);
+        build_utils_1.debug(`Building optimized 'go' binary ${src} -> ${dest}`);
         const sources = Array.isArray(src) ? src : [src];
         const flags = process.env.GO_BUILD_FLAGS
             ? string_argv_1.default(process.env.GO_BUILD_FLAGS)
@@ -20184,59 +22747,184 @@ class GoWrapper {
         return this.execute('build', ...flags, '-o', dest, ...sources);
     }
 }
-async function createGo(workPath, goPath, platform = process.platform, arch = process.arch, opts = {}, goMod = false) {
-    const binPath = path_1.join(getGoDir(workPath), 'bin');
-    build_utils_1.debug(`Adding ${binPath} to PATH`);
-    const path = `${binPath}${path_1.delimiter}${process.env.PATH}`;
-    const env = {
-        ...process.env,
-        PATH: path,
-        GOPATH: goPath,
-        ...opts.env,
-    };
-    if (goMod) {
+/**
+ * Initializes a `GoWrapper` instance.
+ *
+ * This function determines the Go version to use by first looking in the
+ * `go.mod`, if exists, otherwise uses the latest version from the version
+ * map.
+ *
+ * Next it will attempt to find the desired Go version by checking the
+ * following locations:
+ *   1. The "local" project cache directory (e.g. `.vercel/cache/golang`)
+ *   2. The "global" cache directory (e.g. `~/.cache/com.vercel.com/golang`)
+ *   3. The system PATH
+ *
+ * If the Go version is not found, it's downloaded and installed in the
+ * global cache directory so it can be shared across projects. When using
+ * Linux or macOS, it creates a symlink from the global cache to the local
+ * cache directory so that `prepareCache` will persist it.
+ *
+ * @param modulePath The path possibly containing a `go.mod` file
+ * @param opts `execa` options (`cwd`, `env`, `stdio`, etc)
+ * @param workPath The path to the project to be built
+ * @returns An initialized `GoWrapper` instance
+ */
+async function createGo({ modulePath, opts = {}, workPath, }) {
+    // parse the `go.mod`, if exists
+    let goPreferredVersion;
+    if (modulePath) {
+        goPreferredVersion = await parseGoModVersion(modulePath);
+    }
+    // default to newest (first) supported go version
+    const goSelectedVersion = goPreferredVersion || Array.from(versionMap.values())[0];
+    const env = build_utils_1.cloneEnv(process.env, opts.env);
+    const { PATH } = env;
+    const { platform } = process;
+    const goGlobalCacheDir = path_1.join(exports.goGlobalCachePath, `${goSelectedVersion}_${platform}_${process.arch}`);
+    const goCacheDir = path_1.join(workPath, exports.cacheDir);
+    if (goPreferredVersion) {
+        build_utils_1.debug(`Preferred go version ${goPreferredVersion} (from go.mod)`);
         env.GO111MODULE = 'on';
     }
-    await createGoPathTree(goPath, platform, arch);
+    else {
+        build_utils_1.debug(`Preferred go version ${goSelectedVersion} (latest from version map)`);
+    }
+    const setGoEnv = async (goDir) => {
+        if (platform !== 'win32' && goDir === goGlobalCacheDir) {
+            build_utils_1.debug(`Symlinking ${goDir} -> ${goCacheDir}`);
+            await fs_extra_1.remove(goCacheDir);
+            await fs_extra_1.mkdirp(path_1.dirname(goCacheDir));
+            await fs_extra_1.symlink(goDir, goCacheDir);
+            goDir = goCacheDir;
+        }
+        env.GOROOT = goDir || undefined;
+        env.PATH = goDir ? `${path_1.join(goDir, 'bin')}${path_1.delimiter}${PATH}` : PATH;
+    };
+    // try each of these Go directories looking for the version we need
+    const goDirs = {
+        'local cache': goCacheDir,
+        'global cache': goGlobalCacheDir,
+        'system PATH': null,
+    };
+    for (const [label, goDir] of Object.entries(goDirs)) {
+        try {
+            const goBinDir = goDir && path_1.join(goDir, 'bin');
+            if (goBinDir && !(await fs_extra_1.pathExists(goBinDir))) {
+                build_utils_1.debug(`Go not found in ${label}`);
+                continue;
+            }
+            env.GOROOT = goDir || undefined;
+            env.PATH = goBinDir || PATH;
+            const { stdout } = await execa_1.default('go', ['version'], { env });
+            const { minor, short, version } = parseGoVersionString(stdout);
+            if (minor < GO_MIN_VERSION) {
+                build_utils_1.debug(`Found go ${version} in ${label}, but version is unsupported`);
+            }
+            if (version === goSelectedVersion || short === goSelectedVersion) {
+                console.log(`Selected go ${version} (from ${label})`);
+                await setGoEnv(goDir);
+                return new GoWrapper(env, opts);
+            }
+            else {
+                build_utils_1.debug(`Found go ${version} in ${label}, but need ${goSelectedVersion}`);
+            }
+        }
+        catch {
+            build_utils_1.debug(`Go not found in ${label}`);
+        }
+    }
+    // we need to download and cache the desired `go` version
+    await download({
+        dest: goGlobalCacheDir,
+        version: goSelectedVersion,
+    });
+    await setGoEnv(goGlobalCacheDir);
     return new GoWrapper(env, opts);
 }
 exports.createGo = createGo;
-async function downloadGo(workPath, modulePath) {
-    const dir = getGoDir(workPath);
-    const { platform, arch } = process;
-    const version = await parseGoVersion(modulePath);
-    // Check if `go` is already installed in user's `$PATH`
-    const { failed, stdout } = await execa_1.default('go', ['version'], { reject: false });
-    if (!failed && parseInt(stdout.split('.')[1]) >= GO_MIN_VERSION) {
-        build_utils_1.debug('Using system installed version of `go`: %o', stdout.trim());
-        return createGo(workPath, dir, platform, arch);
-    }
-    // Check `go` bin in cacheDir
-    const isGoExist = await fs_extra_1.pathExists(path_1.join(dir, 'bin'));
-    if (!isGoExist) {
-        build_utils_1.debug('Installing `go` v%s to %o for %s %s', version, dir, platform, arch);
-        const url = getGoUrl(version, platform, arch);
-        build_utils_1.debug('Downloading `go` URL: %o', url);
-        const res = await node_fetch_1.default(url);
-        if (!res.ok) {
-            throw new Error(`Failed to download: ${url} (${res.status})`);
+/**
+ * Download and installs the Go distribution.
+ *
+ * @param dest The directory to install Go into. If directory exists, it is
+ * first deleted before installing.
+ * @param version The Go version to download
+ */
+async function download({ dest, version }) {
+    const { filename, url } = getGoUrl(version);
+    console.log(`Downloading go: ${url}`);
+    const res = await node_fetch_1.default(url);
+    if (!res.ok) {
+        throw new Error(`Failed to download: ${url} (${res.status})`);
+    }
+    build_utils_1.debug(`Installing go ${version} to ${dest}`);
+    await fs_extra_1.remove(dest);
+    await fs_extra_1.mkdirp(dest);
+    if (/\.zip$/.test(filename)) {
+        const zipFile = path_1.join(os_1.tmpdir(), filename);
+        try {
+            await streamPipeline(res.body, fs_extra_1.createWriteStream(zipFile));
+            const zip = await yauzl_promise_1.default.open(zipFile);
+            let entry = await zip.readEntry();
+            while (entry) {
+                const fileName = entry.fileName.split('/').slice(1).join('/');
+                if (fileName) {
+                    const destPath = path_1.join(dest, fileName);
+                    if (/\/$/.test(fileName)) {
+                        await fs_extra_1.mkdirp(destPath);
+                    }
+                    else {
+                        const [entryStream] = await Promise.all([
+                            entry.openReadStream(),
+                            fs_extra_1.mkdirp(path_1.dirname(destPath)),
+                        ]);
+                        const out = fs_extra_1.createWriteStream(destPath);
+                        await streamPipeline(entryStream, out);
+                    }
+                }
+                entry = await zip.readEntry();
+            }
         }
-        // TODO: use a zip extractor when `ext === "zip"`
-        await fs_extra_1.mkdirp(dir);
-        await new Promise((resolve, reject) => {
-            res.body
-                .on('error', reject)
-                .pipe(tar_1.default.extract({ cwd: dir, strip: 1 }))
-                .on('error', reject)
-                .on('finish', resolve);
-        });
+        finally {
+            await fs_extra_1.remove(zipFile);
+        }
+        return;
     }
-    return createGo(workPath, dir, platform, arch);
+    await new Promise((resolve, reject) => {
+        res.body
+            .on('error', reject)
+            .pipe(tar_1.default.extract({ cwd: dest, strip: 1 }))
+            .on('error', reject)
+            .on('finish', resolve);
+    });
+}
+const goVersionRegExp = /(\d+)\.(\d+)(?:\.(\d+))?/;
+/**
+ * Parses the raw output from `go version` and returns the version parts.
+ *
+ * @param goVersionOutput The output from `go version`
+ */
+function parseGoVersionString(goVersionOutput) {
+    const matches = goVersionOutput.match(goVersionRegExp) || [];
+    const major = parseInt(matches[1], 10);
+    const minor = parseInt(matches[2], 10);
+    const patch = parseInt(matches[3] || '0', 10);
+    return {
+        version: `${major}.${minor}.${patch}`,
+        short: `${major}.${minor}`,
+        major,
+        minor,
+        patch,
+    };
 }
-exports.downloadGo = downloadGo;
-async function parseGoVersion(modulePath) {
-    // default to newest (first)
-    let version = Array.from(versionMap.values())[0];
+/**
+ * Attempts to parse the preferred Go version from the `go.mod` file.
+ *
+ * @param modulePath The directory containing the `go.mod` file
+ * @returns
+ */
+async function parseGoModVersion(modulePath) {
+    let version;
     const file = path_1.join(modulePath, 'go.mod');
     try {
         const content = await fs_extra_1.readFile(file, 'utf8');
@@ -20259,7 +22947,6 @@ async function parseGoVersion(modulePath) {
             throw err;
         }
     }
-    build_utils_1.debug(`Selected Go version ${version}`);
     return version;
 }
 
@@ -20354,7 +23041,7 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
             entrypoint = renamedEntrypoint;
         }
         const entrypointAbsolute = path_1.join(workPath, entrypoint);
-        const entrypointArr = entrypoint.split(path_1.sep);
+        const entrypointArr = entrypoint.split(path_1.posix.sep);
         build_utils_1.debug(`Parsing AST for "${entrypoint}"`);
         let analyzed;
         try {
@@ -20365,14 +23052,14 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
             analyzed = await go_helpers_1.getAnalyzedEntrypoint(workPath, entrypointAbsolute, path_1.dirname(goModAbsPath));
         }
         catch (err) {
-            console.log(`Failed to parse AST for "${entrypoint}"`);
+            console.error(`Failed to parse AST for "${entrypoint}"`);
             throw err;
         }
         if (!analyzed) {
             const err = new Error(`Could not find an exported function in "${entrypoint}"
   Learn more: https://vercel.com/docs/runtimes#official-runtimes/go
         `);
-            console.log(err.message);
+            console.error(err.message);
             throw err;
         }
         const parsedAnalyzed = JSON.parse(analyzed);
@@ -20464,11 +23151,18 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
         // in order to allow the user to have `main.go`,
         // we need our `main.go` to be called something else
         const mainGoFileName = 'main__vc__go__.go';
-        if (packageName !== 'main') {
-            const go = await go_helpers_1.createGo(workPath, goPath, process.platform, process.arch, {
+        const go = await go_helpers_1.createGo({
+            modulePath: goModPath,
+            opts: {
                 cwd: entrypointDirname,
-                stdio: 'inherit',
-            }, true);
+                env: {
+                    GOARCH: 'amd64',
+                    GOOS: 'linux',
+                },
+            },
+            workPath,
+        });
+        if (packageName !== 'main') {
             if (!isGoModExist) {
                 try {
                     const defaultGoModContent = `module ${packageName}`;
@@ -20484,7 +23178,7 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
                     });
                 }
                 catch (err) {
-                    console.log(`Failed to create default go.mod for ${packageName}`);
+                    console.error(`Failed to create default go.mod for ${packageName}`);
                     throw err;
                 }
             }
@@ -20549,7 +23243,7 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
                 }
             }
             catch (err) {
-                console.log('Failed to move entry to package folder');
+                console.error('Failed to move entry to package folder');
                 throw err;
             }
             let baseGoModPath = '';
@@ -20568,7 +23262,7 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
                 await go.mod();
             }
             catch (err) {
-                console.log('failed to `go mod tidy`');
+                console.error('failed to `go mod tidy`');
                 throw err;
             }
             build_utils_1.debug('Running `go build`...');
@@ -20578,7 +23272,7 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
                 await go.build(src, destPath);
             }
             catch (err) {
-                console.log('failed to `go build`');
+                console.error('failed to `go build`');
                 throw err;
             }
         }
@@ -20586,9 +23280,6 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
             // legacy mode
             // we need `main.go` in the same dir as the entrypoint,
             // otherwise `go build` will refuse to build
-            const go = await go_helpers_1.createGo(workPath, goPath, process.platform, process.arch, {
-                cwd: entrypointDirname,
-            }, false);
             const originalMainGoContents = await fs_extra_1.readFile(__webpack_require__.ab + "main.go", 'utf8');
             const mainGoContents = originalMainGoContents
                 .replace('"__VC_HANDLER_PACKAGE_NAME"', '')
@@ -20607,7 +23298,7 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
                 await go.get();
             }
             catch (err) {
-                console.log('Failed to `go get`');
+                console.error('Failed to `go get`');
                 throw err;
             }
             build_utils_1.debug('Running `go build`...');
@@ -20620,7 +23311,7 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
                 await go.build(src, destPath);
             }
             catch (err) {
-                console.log('failed to `go build`');
+                console.error('failed to `go build`');
                 throw err;
             }
         }
@@ -20644,7 +23335,9 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
             await cleanupFileSystem(undoFileActions, undoDirectoryCreation, undoFunctionRenames);
         }
         catch (error) {
-            console.log(`Build cleanup failed: ${error.message}`);
+            if (error instanceof Error) {
+                console.error(`Build cleanup failed: ${error.message}`);
+            }
             build_utils_1.debug('Cleanup Error: ' + error);
         }
     }
@@ -20734,6 +23427,10 @@ async function copyDevServer(functionName, dest) {
     const patched = data.replace('__HANDLER_FUNC_NAME', functionName);
     await fs_extra_1.writeFile(path_1.join(dest, 'vercel-dev-server-main.go'), patched);
 }
+async function writeDefaultGoMod(entrypointDirname, packageName) {
+    const defaultGoModContent = `module ${packageName}`;
+    await fs_extra_1.writeFile(path_1.join(entrypointDirname, 'go.mod'), defaultGoModContent, 'utf-8');
+}
 async function startDevServer(opts) {
     const { entrypoint, workPath, meta = {} } = opts;
     const { devCacheDir = path_1.join(workPath, '.vercel', 'cache') } = meta;
@@ -20760,18 +23457,27 @@ Learn more: https://vercel.com/docs/runtimes#official-runtimes/go`);
     await Promise.all([
         copyEntrypoint(entrypointWithExt, tmpPackage),
         copyDevServer(analyzed.functionName, tmpPackage),
+        goModAbsPathDir ? null : writeDefaultGoMod(tmp, analyzed.packageName),
     ]);
     const portFile = path_1.join(TMP, `vercel-dev-port-${Math.random().toString(32).substring(2)}`);
     const env = build_utils_1.cloneEnv(process.env, meta.env, {
         VERCEL_DEV_PORT_FILE: portFile,
     });
     const executable = `./vercel-dev-server-go${process.platform === 'win32' ? '.exe' : ''}`;
-    build_utils_1.debug(`SPAWNING go build -o ${executable} ./... CWD=${tmp}`);
-    child_process_1.execFileSync('go', ['build', '-o', executable, './...'], {
-        cwd: tmp,
-        env,
-        stdio: 'inherit',
+    // Note: We must run `go build`, then manually spawn the dev server instead
+    // of spawning `go run`. See https://github.com/vercel/vercel/pull/8718 for
+    // more info.
+    // build the dev server
+    const go = await go_helpers_1.createGo({
+        modulePath: goModAbsPathDir,
+        opts: {
+            cwd: tmp,
+            env,
+        },
+        workPath,
     });
+    await go.build('./...', executable);
+    // run the dev server
     build_utils_1.debug(`SPAWNING ${executable} CWD=${tmp}`);
     const child = child_process_1.spawn(executable, [], {
         cwd: tmp,
@@ -20833,7 +23539,7 @@ async function waitForPortFile_(opts) {
         try {
             const port = Number(await fs_extra_1.readFile(opts.portFile, 'ascii'));
             async_retry_1.default(() => fs_extra_1.remove(opts.portFile)).catch((err) => {
-                console.error('Could not delete port file: %j: %s', opts.portFile, err);
+                console.error(`Could not delete port file: ${opts.portFile}: ${err}`);
             });
             return { port };
         }
@@ -20845,6 +23551,24 @@ async function waitForPortFile_(opts) {
     }
 }
 async function prepareCache({ workPath, }) {
+    // When building the project for the first time, there won't be a cache and
+    // `createGo()` will have downloaded Go to the global cache directory, then
+    // symlinked it to the local `cacheDir`.
+    //
+    // If we detect the `cacheDir` is a symlink, unlink it, then move the global
+    // cache directory into the local cache directory so that it can be
+    // persisted.
+    //
+    // On the next build, the local cache will be restored and `createGo()` will
+    // use it unless the preferred Go version changed in the `go.mod`.
+    const goCacheDir = path_1.join(workPath, go_helpers_1.cacheDir);
+    const stat = await fs_extra_1.lstat(goCacheDir);
+    if (stat.isSymbolicLink()) {
+        const goGlobalCacheDir = await fs_extra_1.readlink(goCacheDir);
+        build_utils_1.debug(`Preparing cache by moving ${goGlobalCacheDir} -> ${goCacheDir}`);
+        await fs_extra_1.unlink(goCacheDir);
+        await fs_extra_1.move(goGlobalCacheDir, goCacheDir);
+    }
     const cache = await build_utils_1.glob(`${go_helpers_1.cacheDir}/**`, workPath);
     return cache;
 }