@mcp-s/skills 1.0.5 → 1.3.1

package/dist/_chunks/libs/unzipper.mjs

@@ -0,0 +1,945 @@
+import { n as __require, t as __commonJSMin } from "../rolldown-runtime.mjs";
+import { n as require_readable, t as require_duplexer2 } from "./duplexer2.mjs";
+import { n as require_graceful_fs, t as require_lib } from "./fs-extra.mjs";
+import { t as require_Int64 } from "./node-int64.mjs";
+import { t as require_bluebird } from "./bluebird.mjs";
+var require_PullStream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Stream$7 = __require("stream");
+	const util$2 = __require("util");
+	const strFunction = "function";
+	function PullStream() {
+		if (!(this instanceof PullStream)) return new PullStream();
+		Stream$7.Duplex.call(this, {
+			decodeStrings: false,
+			objectMode: true
+		});
+		this.buffer = Buffer.from("");
+		const self = this;
+		self.on("finish", function() {
+			self.finished = true;
+			self.emit("chunk", false);
+		});
+	}
+	util$2.inherits(PullStream, Stream$7.Duplex);
+	PullStream.prototype._write = function(chunk, e, cb) {
+		this.buffer = Buffer.concat([this.buffer, chunk]);
+		this.cb = cb;
+		this.emit("chunk");
+	};
+	PullStream.prototype.stream = function(eof, includeEof) {
+		const p = Stream$7.PassThrough();
+		let done;
+		const self = this;
+		function cb() {
+			if (typeof self.cb === strFunction) {
+				const callback = self.cb;
+				self.cb = void 0;
+				return callback();
+			}
+		}
+		function pull() {
+			let packet;
+			if (self.buffer && self.buffer.length) {
+				if (typeof eof === "number") {
+					packet = self.buffer.slice(0, eof);
+					self.buffer = self.buffer.slice(eof);
+					eof -= packet.length;
+					done = done || !eof;
+				} else {
+					let match = self.buffer.indexOf(eof);
+					if (match !== -1) {
+						self.match = match;
+						if (includeEof) match = match + eof.length;
+						packet = self.buffer.slice(0, match);
+						self.buffer = self.buffer.slice(match);
+						done = true;
+					} else {
+						const len = self.buffer.length - eof.length;
+						if (len <= 0) cb();
+						else {
+							packet = self.buffer.slice(0, len);
+							self.buffer = self.buffer.slice(len);
+						}
+					}
+				}
+				if (packet) p.write(packet, function() {
+					if (self.buffer.length === 0 || eof.length && self.buffer.length <= eof.length) cb();
+				});
+			}
+			if (!done) {
+				if (self.finished) {
+					self.removeListener("chunk", pull);
+					self.emit("error", /* @__PURE__ */ new Error("FILE_ENDED"));
+					return;
+				}
+			} else {
+				self.removeListener("chunk", pull);
+				p.end();
+			}
+		}
+		self.on("chunk", pull);
+		pull();
+		return p;
+	};
+	PullStream.prototype.pull = function(eof, includeEof) {
+		if (eof === 0) return Promise.resolve("");
+		if (!isNaN(eof) && this.buffer.length > eof) {
+			const data = this.buffer.slice(0, eof);
+			this.buffer = this.buffer.slice(eof);
+			return Promise.resolve(data);
+		}
+		let buffer = Buffer.from("");
+		const self = this;
+		const concatStream = new Stream$7.Transform();
+		concatStream._transform = function(d, e, cb) {
+			buffer = Buffer.concat([buffer, d]);
+			cb();
+		};
+		let rejectHandler;
+		let pullStreamRejectHandler;
+		return new Promise(function(resolve, reject) {
+			rejectHandler = reject;
+			pullStreamRejectHandler = function(e) {
+				self.__emittedError = e;
+				reject(e);
+			};
+			if (self.finished) return reject(/* @__PURE__ */ new Error("FILE_ENDED"));
+			self.once("error", pullStreamRejectHandler);
+			self.stream(eof, includeEof).on("error", reject).pipe(concatStream).on("finish", function() {
+				resolve(buffer);
+			}).on("error", reject);
+		}).finally(function() {
+			self.removeListener("error", rejectHandler);
+			self.removeListener("error", pullStreamRejectHandler);
+		});
+	};
+	PullStream.prototype._read = function() {};
+	module.exports = PullStream;
+}));
+var require_NoopStream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Stream$6 = __require("stream");
+	const util$1 = __require("util");
+	function NoopStream() {
+		if (!(this instanceof NoopStream)) return new NoopStream();
+		Stream$6.Transform.call(this);
+	}
+	util$1.inherits(NoopStream, Stream$6.Transform);
+	NoopStream.prototype._transform = function(d, e, cb) {
+		cb();
+	};
+	module.exports = NoopStream;
+}));
+var require_BufferStream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Stream$5 = __require("stream");
+	module.exports = function(entry) {
+		return new Promise(function(resolve, reject) {
+			const chunks = [];
+			const bufferStream = Stream$5.Transform().on("finish", function() {
+				resolve(Buffer.concat(chunks));
+			}).on("error", reject);
+			bufferStream._transform = function(d, e, cb) {
+				chunks.push(d);
+				cb();
+			};
+			entry.on("error", reject).pipe(bufferStream);
+		});
+	};
+}));
+var require_parseBuffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const parseUIntLE = function(buffer, offset, size) {
+		let result;
+		switch (size) {
+			case 1:
+				result = buffer.readUInt8(offset);
+				break;
+			case 2:
+				result = buffer.readUInt16LE(offset);
+				break;
+			case 4:
+				result = buffer.readUInt32LE(offset);
+				break;
+			case 8:
+				result = Number(buffer.readBigUInt64LE(offset));
+				break;
+			default: throw new Error("Unsupported UInt LE size!");
+		}
+		return result;
+	};
+	const parse = function(buffer, format) {
+		const result = {};
+		let offset = 0;
+		for (const [key, size] of format) {
+			if (buffer.length >= offset + size) result[key] = parseUIntLE(buffer, offset, size);
+			else result[key] = null;
+			offset += size;
+		}
+		return result;
+	};
+	module.exports = { parse };
+}));
+var require_parseExtraField = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const parseBuffer = require_parseBuffer();
+	module.exports = function(extraField, vars) {
+		let extra;
+		while (!extra && extraField && extraField.length) {
+			const candidateExtra = parseBuffer.parse(extraField, [["signature", 2], ["partSize", 2]]);
+			if (candidateExtra.signature === 1) {
+				const fieldsToExpect = [];
+				if (vars.uncompressedSize === 4294967295) fieldsToExpect.push(["uncompressedSize", 8]);
+				if (vars.compressedSize === 4294967295) fieldsToExpect.push(["compressedSize", 8]);
+				if (vars.offsetToLocalFileHeader === 4294967295) fieldsToExpect.push(["offsetToLocalFileHeader", 8]);
+				extra = parseBuffer.parse(extraField.slice(4), fieldsToExpect);
+			} else extraField = extraField.slice(candidateExtra.partSize + 4);
+		}
+		extra = extra || {};
+		if (vars.compressedSize === 4294967295) vars.compressedSize = extra.compressedSize;
+		if (vars.uncompressedSize === 4294967295) vars.uncompressedSize = extra.uncompressedSize;
+		if (vars.offsetToLocalFileHeader === 4294967295) vars.offsetToLocalFileHeader = extra.offsetToLocalFileHeader;
+		return extra;
+	};
+}));
+var require_parseDateTime = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function parseDateTime(date, time) {
+		const day = date & 31;
+		const month = date >> 5 & 15;
+		const year = (date >> 9 & 127) + 1980;
+		const seconds = time ? (time & 31) * 2 : 0;
+		const minutes = time ? time >> 5 & 63 : 0;
+		const hours = time ? time >> 11 : 0;
+		return new Date(Date.UTC(year, month - 1, day, hours, minutes, seconds));
+	};
+}));
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const util = __require("util");
+	const zlib$1 = __require("zlib");
+	const Stream$4 = __require("stream");
+	const PullStream = require_PullStream();
+	const NoopStream = require_NoopStream();
+	const BufferStream = require_BufferStream();
+	const parseExtraField = require_parseExtraField();
+	const parseDateTime = require_parseDateTime();
+	const pipeline = Stream$4.pipeline;
+	const parseBuffer = require_parseBuffer();
+	const endDirectorySignature = Buffer.alloc(4);
+	endDirectorySignature.writeUInt32LE(101010256, 0);
+	function Parse(opts) {
+		if (!(this instanceof Parse)) return new Parse(opts);
+		const self = this;
+		self._opts = opts || { verbose: false };
+		PullStream.call(self, self._opts);
+		self.on("finish", function() {
+			self.emit("end");
+			self.emit("close");
+		});
+		self._readRecord().catch(function(e) {
+			if (!self.__emittedError || self.__emittedError !== e) self.emit("error", e);
+		});
+	}
+	util.inherits(Parse, PullStream);
+	Parse.prototype._readRecord = function() {
+		const self = this;
+		return self.pull(4).then(function(data) {
+			if (data.length === 0) return;
+			const signature = data.readUInt32LE(0);
+			if (signature === 875721283) return self._readCrxHeader();
+			if (signature === 67324752) return self._readFile();
+			else if (signature === 33639248) {
+				self.reachedCD = true;
+				return self._readCentralDirectoryFileHeader();
+			} else if (signature === 101010256) return self._readEndOfCentralDirectoryRecord();
+			else if (self.reachedCD) return self.pull(endDirectorySignature, true).then(function() {
+				return self._readEndOfCentralDirectoryRecord();
+			});
+			else self.emit("error", /* @__PURE__ */ new Error("invalid signature: 0x" + signature.toString(16)));
+		}).then((function(loop) {
+			if (loop) return self._readRecord();
+		}));
+	};
+	Parse.prototype._readCrxHeader = function() {
+		const self = this;
+		return self.pull(12).then(function(data) {
+			self.crxHeader = parseBuffer.parse(data, [
+				["version", 4],
+				["pubKeyLength", 4],
+				["signatureLength", 4]
+			]);
+			return self.pull(self.crxHeader.pubKeyLength + self.crxHeader.signatureLength);
+		}).then(function(data) {
+			self.crxHeader.publicKey = data.slice(0, self.crxHeader.pubKeyLength);
+			self.crxHeader.signature = data.slice(self.crxHeader.pubKeyLength);
+			self.emit("crx-header", self.crxHeader);
+			return true;
+		});
+	};
+	Parse.prototype._readFile = function() {
+		const self = this;
+		return self.pull(26).then(function(data) {
+			const vars = parseBuffer.parse(data, [
+				["versionsNeededToExtract", 2],
+				["flags", 2],
+				["compressionMethod", 2],
+				["lastModifiedTime", 2],
+				["lastModifiedDate", 2],
+				["crc32", 4],
+				["compressedSize", 4],
+				["uncompressedSize", 4],
+				["fileNameLength", 2],
+				["extraFieldLength", 2]
+			]);
+			vars.lastModifiedDateTime = parseDateTime(vars.lastModifiedDate, vars.lastModifiedTime);
+			if (self.crxHeader) vars.crxHeader = self.crxHeader;
+			return self.pull(vars.fileNameLength).then(function(fileNameBuffer) {
+				const fileName = fileNameBuffer.toString("utf8");
+				const entry = Stream$4.PassThrough();
+				let __autodraining = false;
+				entry.autodrain = function() {
+					__autodraining = true;
+					const draining = entry.pipe(NoopStream());
+					draining.promise = function() {
+						return new Promise(function(resolve, reject) {
+							draining.on("finish", resolve);
+							draining.on("error", reject);
+						});
+					};
+					return draining;
+				};
+				entry.buffer = function() {
+					return BufferStream(entry);
+				};
+				entry.path = fileName;
+				entry.props = {};
+				entry.props.path = fileName;
+				entry.props.pathBuffer = fileNameBuffer;
+				entry.props.flags = { "isUnicode": (vars.flags & 2048) != 0 };
+				entry.type = vars.uncompressedSize === 0 && /[/\\]$/.test(fileName) ? "Directory" : "File";
+				if (self._opts.verbose) {
+					if (entry.type === "Directory") console.log("   creating:", fileName);
+					else if (entry.type === "File") if (vars.compressionMethod === 0) console.log(" extracting:", fileName);
+					else console.log("  inflating:", fileName);
+				}
+				return self.pull(vars.extraFieldLength).then(function(extraField) {
+					const extra = parseExtraField(extraField, vars);
+					entry.vars = vars;
+					entry.extra = extra;
+					if (self._opts.forceStream) self.push(entry);
+					else {
+						self.emit("entry", entry);
+						if (self._readableState.pipesCount || self._readableState.pipes && self._readableState.pipes.length) self.push(entry);
+					}
+					if (self._opts.verbose) console.log({
+						filename: fileName,
+						vars,
+						extra
+					});
+					const fileSizeKnown = !(vars.flags & 8) || vars.compressedSize > 0;
+					let eof;
+					entry.__autodraining = __autodraining;
+					const inflater = vars.compressionMethod && !__autodraining ? zlib$1.createInflateRaw() : Stream$4.PassThrough();
+					if (fileSizeKnown) {
+						entry.size = vars.uncompressedSize;
+						eof = vars.compressedSize;
+					} else {
+						eof = Buffer.alloc(4);
+						eof.writeUInt32LE(134695760, 0);
+					}
+					return new Promise(function(resolve, reject) {
+						pipeline(self.stream(eof), inflater, entry, function(err) {
+							if (err) return reject(err);
+							return fileSizeKnown ? resolve(fileSizeKnown) : self._processDataDescriptor(entry).then(resolve).catch(reject);
+						});
+					});
+				});
+			});
+		});
+	};
+	Parse.prototype._processDataDescriptor = function(entry) {
+		return this.pull(16).then(function(data) {
+			entry.size = parseBuffer.parse(data, [
+				["dataDescriptorSignature", 4],
+				["crc32", 4],
+				["compressedSize", 4],
+				["uncompressedSize", 4]
+			]).uncompressedSize;
+			return true;
+		});
+	};
+	Parse.prototype._readCentralDirectoryFileHeader = function() {
+		const self = this;
+		return self.pull(42).then(function(data) {
+			const vars = parseBuffer.parse(data, [
+				["versionMadeBy", 2],
+				["versionsNeededToExtract", 2],
+				["flags", 2],
+				["compressionMethod", 2],
+				["lastModifiedTime", 2],
+				["lastModifiedDate", 2],
+				["crc32", 4],
+				["compressedSize", 4],
+				["uncompressedSize", 4],
+				["fileNameLength", 2],
+				["extraFieldLength", 2],
+				["fileCommentLength", 2],
+				["diskNumber", 2],
+				["internalFileAttributes", 2],
+				["externalFileAttributes", 4],
+				["offsetToLocalFileHeader", 4]
+			]);
+			return self.pull(vars.fileNameLength).then(function(fileName) {
+				vars.fileName = fileName.toString("utf8");
+				return self.pull(vars.extraFieldLength);
+			}).then(function() {
+				return self.pull(vars.fileCommentLength);
+			}).then(function() {
+				return true;
+			});
+		});
+	};
+	Parse.prototype._readEndOfCentralDirectoryRecord = function() {
+		const self = this;
+		return self.pull(18).then(function(data) {
+			const vars = parseBuffer.parse(data, [
+				["diskNumber", 2],
+				["diskStart", 2],
+				["numberOfRecordsOnDisk", 2],
+				["numberOfRecords", 2],
+				["sizeOfCentralDirectory", 4],
+				["offsetToStartOfCentralDirectory", 4],
+				["commentLength", 2]
+			]);
+			return self.pull(vars.commentLength).then(function() {
+				self.end();
+				self.push(null);
+			});
+		});
+	};
+	Parse.prototype.promise = function() {
+		const self = this;
+		return new Promise(function(resolve, reject) {
+			self.on("finish", resolve);
+			self.on("error", reject);
+		});
+	};
+	module.exports = Parse;
+}));
+var require_parseOne = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Stream$3 = __require("stream");
+	const Parse = require_parse();
+	const duplexer2 = require_duplexer2();
+	const BufferStream = require_BufferStream();
+	function parseOne(match, opts) {
+		const inStream = Stream$3.PassThrough({ objectMode: true });
+		const outStream = Stream$3.PassThrough();
+		const transform = Stream$3.Transform({ objectMode: true });
+		const re = match instanceof RegExp ? match : match && new RegExp(match);
+		let found;
+		transform._transform = function(entry, e, cb) {
+			if (found || re && !re.exec(entry.path)) {
+				entry.autodrain();
+				return cb();
+			} else {
+				found = true;
+				out.emit("entry", entry);
+				entry.on("error", function(e) {
+					outStream.emit("error", e);
+				});
+				entry.pipe(outStream).on("error", function(err) {
+					cb(err);
+				}).on("finish", function(d) {
+					cb(null, d);
+				});
+			}
+		};
+		inStream.pipe(Parse(opts)).on("error", function(err) {
+			outStream.emit("error", err);
+		}).pipe(transform).on("error", Object).on("finish", function() {
+			if (!found) outStream.emit("error", /* @__PURE__ */ new Error("PATTERN_NOT_FOUND"));
+			else outStream.end();
+		});
+		const out = duplexer2(inStream, outStream);
+		out.buffer = function() {
+			return BufferStream(outStream);
+		};
+		return out;
+	}
+	module.exports = parseOne;
+}));
+var require_extract = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = Extract;
+	const Parse = require_parse();
+	const fs = require_lib();
+	const path$1 = __require("path");
+	const stream = __require("stream");
+	const duplexer2 = require_duplexer2();
+	function Extract(opts) {
+		opts.path = path$1.resolve(path$1.normalize(opts.path));
+		const parser = new Parse(opts);
+		const outStream = new stream.Writable({ objectMode: true });
+		outStream._write = async function(entry, encoding, cb) {
+			const extractPath = path$1.join(opts.path, entry.path.replace(/\\/g, "/"));
+			if (extractPath.indexOf(opts.path) != 0) return cb();
+			if (entry.type == "Directory") {
+				await fs.ensureDir(extractPath);
+				return cb();
+			}
+			await fs.ensureDir(path$1.dirname(extractPath));
+			const writer = opts.getWriter ? opts.getWriter({ path: extractPath }) : fs.createWriteStream(extractPath);
+			entry.pipe(writer).on("error", cb).on("close", cb);
+		};
+		const extract = duplexer2(parser, outStream);
+		parser.once("crx-header", function(crxHeader) {
+			extract.crxHeader = crxHeader;
+		});
+		parser.pipe(outStream).on("finish", function() {
+			extract.emit("close");
+		});
+		extract.promise = function() {
+			return new Promise(function(resolve, reject) {
+				extract.on("close", resolve);
+				extract.on("error", reject);
+			});
+		};
+		return extract;
+	}
+}));
+var require_Decrypt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Int64 = require_Int64();
+	let Stream$2 = __require("stream");
+	if (!Stream$2.Writable || !Stream$2.Writable.prototype.destroy) Stream$2 = require_readable();
+	let table;
+	function generateTable() {
+		const poly = 3988292384;
+		let c, n, k;
+		table = [];
+		for (n = 0; n < 256; n++) {
+			c = n;
+			for (k = 0; k < 8; k++) c = c & 1 ? poly ^ c >>> 1 : c = c >>> 1;
+			table[n] = c >>> 0;
+		}
+	}
+	function crc(ch, crc) {
+		if (!table) generateTable();
+		if (ch.charCodeAt) ch = ch.charCodeAt(0);
+		return (crc.readUInt32BE() >> 8 & 16777215 ^ table[(crc.readUInt32BE() ^ ch >>> 0) & 255]) >>> 0;
+	}
+	function multiply(a, b) {
+		const ah = a >> 16 & 65535;
+		const al = a & 65535;
+		const bh = b >> 16 & 65535;
+		const bl = b & 65535;
+		return ((ah * bl + al * bh & 65535) << 16 >>> 0) + al * bl;
+	}
+	function Decrypt() {
+		if (!(this instanceof Decrypt)) return new Decrypt();
+		this.key0 = Buffer.allocUnsafe(4);
+		this.key1 = Buffer.allocUnsafe(4);
+		this.key2 = Buffer.allocUnsafe(4);
+		this.key0.writeUInt32BE(305419896, 0);
+		this.key1.writeUInt32BE(591751049, 0);
+		this.key2.writeUInt32BE(878082192, 0);
+	}
+	Decrypt.prototype.update = function(h) {
+		this.key0.writeUInt32BE(crc(h, this.key0));
+		this.key1.writeUInt32BE((this.key0.readUInt32BE() & 255) + this.key1.readUInt32BE() >>> 0);
+		const x = new Int64(multiply(this.key1.readUInt32BE(), 134775813) + 1 & 4294967295);
+		const b = Buffer.alloc(8);
+		x.copy(b, 0);
+		b.copy(this.key1, 0, 4, 8);
+		this.key2.writeUInt32BE(crc((this.key1.readUInt32BE() >> 24 & 255) >>> 0, this.key2));
+	};
+	Decrypt.prototype.decryptByte = function(c) {
+		const k = (this.key2.readUInt32BE() | 2) >>> 0;
+		c = c ^ multiply(k, k ^ 1) >> 8 & 255;
+		this.update(c);
+		return c;
+	};
+	Decrypt.prototype.stream = function() {
+		const stream = Stream$2.Transform(), self = this;
+		stream._transform = function(d, e, cb) {
+			for (let i = 0; i < d.length; i++) d[i] = self.decryptByte(d[i]);
+			this.push(d);
+			cb();
+		};
+		return stream;
+	};
+	module.exports = Decrypt;
+}));
+var require_unzip$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Decrypt = require_Decrypt();
+	const PullStream = require_PullStream();
+	const Stream$1 = __require("stream");
+	const zlib = __require("zlib");
+	const parseExtraField = require_parseExtraField();
+	const parseDateTime = require_parseDateTime();
+	const parseBuffer = require_parseBuffer();
+	module.exports = function unzip(source, offset, _password, directoryVars, length) {
+		const file = PullStream(), entry = Stream$1.PassThrough();
+		const req = source.stream(offset, length);
+		req.pipe(file).on("error", function(e) {
+			entry.emit("error", e);
+		});
+		entry.vars = file.pull(30).then(function(data) {
+			let vars = parseBuffer.parse(data, [
+				["signature", 4],
+				["versionsNeededToExtract", 2],
+				["flags", 2],
+				["compressionMethod", 2],
+				["lastModifiedTime", 2],
+				["lastModifiedDate", 2],
+				["crc32", 4],
+				["compressedSize", 4],
+				["uncompressedSize", 4],
+				["fileNameLength", 2],
+				["extraFieldLength", 2]
+			]);
+			vars.lastModifiedDateTime = parseDateTime(vars.lastModifiedDate, vars.lastModifiedTime);
+			return file.pull(vars.fileNameLength).then(function(fileName) {
+				vars.fileName = fileName.toString("utf8");
+				return file.pull(vars.extraFieldLength);
+			}).then(function(extraField) {
+				let checkEncryption;
+				vars.extra = parseExtraField(extraField, vars);
+				if (directoryVars && directoryVars.compressedSize) vars = directoryVars;
+				if (vars.flags & 1) checkEncryption = file.pull(12).then(function(header) {
+					if (!_password) throw new Error("MISSING_PASSWORD");
+					const decrypt = Decrypt();
+					String(_password).split("").forEach(function(d) {
+						decrypt.update(d);
+					});
+					for (let i = 0; i < header.length; i++) header[i] = decrypt.decryptByte(header[i]);
+					vars.decrypt = decrypt;
+					vars.compressedSize -= 12;
+					const check = vars.flags & 8 ? vars.lastModifiedTime >> 8 & 255 : vars.crc32 >> 24 & 255;
+					if (header[11] !== check) throw new Error("BAD_PASSWORD");
+					return vars;
+				});
+				return Promise.resolve(checkEncryption).then(function() {
+					entry.emit("vars", vars);
+					return vars;
+				});
+			});
+		});
+		entry.vars.then(function(vars) {
+			const fileSizeKnown = !(vars.flags & 8) || vars.compressedSize > 0;
+			let eof;
+			const inflater = vars.compressionMethod ? zlib.createInflateRaw() : Stream$1.PassThrough();
+			if (fileSizeKnown) {
+				entry.size = vars.uncompressedSize;
+				eof = vars.compressedSize;
+			} else {
+				eof = Buffer.alloc(4);
+				eof.writeUInt32LE(134695760, 0);
+			}
+			let stream = file.stream(eof);
+			if (vars.decrypt) stream = stream.pipe(vars.decrypt.stream());
+			stream.pipe(inflater).on("error", function(err) {
+				entry.emit("error", err);
+			}).pipe(entry).on("finish", function() {
+				if (req.destroy) req.destroy();
+				else if (req.abort) req.abort();
+				else if (req.close) req.close();
+				else if (req.push) req.push();
+				else console.log("warning - unable to close stream");
+			});
+		}).catch(function(e) {
+			entry.emit("error", e);
+		});
+		return entry;
+	};
+}));
+var require_directory = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const PullStream = require_PullStream();
+	const unzip = require_unzip$1();
+	const BufferStream = require_BufferStream();
+	const parseExtraField = require_parseExtraField();
+	const path = __require("path");
+	const fs = require_lib();
+	const parseDateTime = require_parseDateTime();
+	const parseBuffer = require_parseBuffer();
+	const Bluebird = require_bluebird();
+	const signature = Buffer.alloc(4);
+	signature.writeUInt32LE(101010256, 0);
+	function getCrxHeader(source) {
+		const sourceStream = source.stream(0).pipe(PullStream());
+		return sourceStream.pull(4).then(function(data) {
+			if (data.readUInt32LE(0) === 875721283) {
+				let crxHeader;
+				return sourceStream.pull(12).then(function(data) {
+					crxHeader = parseBuffer.parse(data, [
+						["version", 4],
+						["pubKeyLength", 4],
+						["signatureLength", 4]
+					]);
+				}).then(function() {
+					return sourceStream.pull(crxHeader.pubKeyLength + crxHeader.signatureLength);
+				}).then(function(data) {
+					crxHeader.publicKey = data.slice(0, crxHeader.pubKeyLength);
+					crxHeader.signature = data.slice(crxHeader.pubKeyLength);
+					crxHeader.size = 16 + crxHeader.pubKeyLength + crxHeader.signatureLength;
+					return crxHeader;
+				});
+			}
+		});
+	}
+	function getZip64CentralDirectory(source, zip64CDL) {
+		const d64loc = parseBuffer.parse(zip64CDL, [
+			["signature", 4],
+			["diskNumber", 4],
+			["offsetToStartOfCentralDirectory", 8],
+			["numberOfDisks", 4]
+		]);
+		if (d64loc.signature != 117853008) throw new Error("invalid zip64 end of central dir locator signature (0x07064b50): 0x" + d64loc.signature.toString(16));
+		const dir64 = PullStream();
+		source.stream(d64loc.offsetToStartOfCentralDirectory).pipe(dir64);
+		return dir64.pull(56);
+	}
+	function parseZip64DirRecord(dir64record) {
+		const vars = parseBuffer.parse(dir64record, [
+			["signature", 4],
+			["sizeOfCentralDirectory", 8],
+			["version", 2],
+			["versionsNeededToExtract", 2],
+			["diskNumber", 4],
+			["diskStart", 4],
+			["numberOfRecordsOnDisk", 8],
+			["numberOfRecords", 8],
+			["sizeOfCentralDirectory", 8],
+			["offsetToStartOfCentralDirectory", 8]
+		]);
+		if (vars.signature != 101075792) throw new Error("invalid zip64 end of central dir locator signature (0x06064b50): 0x0" + vars.signature.toString(16));
+		return vars;
+	}
+	module.exports = function centralDirectory(source, options) {
+		const endDir = PullStream();
+		const records = PullStream();
+		const tailSize = options && options.tailSize || 80;
+		let sourceSize, crxHeader, startOffset, vars;
+		if (options && options.crx) crxHeader = getCrxHeader(source);
+		return source.size().then(function(size) {
+			sourceSize = size;
+			source.stream(Math.max(0, size - tailSize)).on("error", function(error) {
+				endDir.emit("error", error);
+			}).pipe(endDir);
+			return endDir.pull(signature);
+		}).then(function() {
+			return Bluebird.props({
+				directory: endDir.pull(22),
+				crxHeader
+			});
+		}).then(function(d) {
+			const data = d.directory;
+			startOffset = d.crxHeader && d.crxHeader.size || 0;
+			vars = parseBuffer.parse(data, [
+				["signature", 4],
+				["diskNumber", 2],
+				["diskStart", 2],
+				["numberOfRecordsOnDisk", 2],
+				["numberOfRecords", 2],
+				["sizeOfCentralDirectory", 4],
+				["offsetToStartOfCentralDirectory", 4],
+				["commentLength", 2]
+			]);
+			if (vars.diskNumber == 65535 || vars.numberOfRecords == 65535 || vars.offsetToStartOfCentralDirectory == 4294967295) {
+				const zip64CDLSize = 20;
+				const zip64CDLOffset = sourceSize - (tailSize - endDir.match + zip64CDLSize);
+				const zip64CDLStream = PullStream();
+				source.stream(zip64CDLOffset).pipe(zip64CDLStream);
+				return zip64CDLStream.pull(zip64CDLSize).then(function(d) {
+					return getZip64CentralDirectory(source, d);
+				}).then(function(dir64record) {
+					vars = parseZip64DirRecord(dir64record);
+				});
+			} else vars.offsetToStartOfCentralDirectory += startOffset;
+		}).then(function() {
+			if (vars.commentLength) return endDir.pull(vars.commentLength).then(function(comment) {
+				vars.comment = comment.toString("utf8");
+			});
+		}).then(function() {
+			source.stream(vars.offsetToStartOfCentralDirectory).pipe(records);
+			vars.extract = function(opts) {
+				if (!opts || !opts.path) throw new Error("PATH_MISSING");
+				opts.path = path.resolve(path.normalize(opts.path));
+				return vars.files.then(function(files) {
+					return Bluebird.map(files, async function(entry) {
+						const extractPath = path.join(opts.path, entry.path);
+						if (extractPath.indexOf(opts.path) != 0) return;
+						if (entry.type == "Directory") {
+							await fs.ensureDir(extractPath);
+							return;
+						}
+						await fs.ensureDir(path.dirname(extractPath));
+						const writer = opts.getWriter ? opts.getWriter({ path: extractPath }) : fs.createWriteStream(extractPath);
+						return new Promise(function(resolve, reject) {
+							entry.stream(opts.password).on("error", reject).pipe(writer).on("close", resolve).on("error", reject);
+						});
+					}, { concurrency: opts.concurrency > 1 ? opts.concurrency : 1 });
+				});
+			};
+			vars.files = Bluebird.mapSeries(Array(vars.numberOfRecords), function() {
+				return records.pull(46).then(function(data) {
+					const vars = parseBuffer.parse(data, [
+						["signature", 4],
+						["versionMadeBy", 2],
+						["versionsNeededToExtract", 2],
+						["flags", 2],
+						["compressionMethod", 2],
+						["lastModifiedTime", 2],
+						["lastModifiedDate", 2],
+						["crc32", 4],
+						["compressedSize", 4],
+						["uncompressedSize", 4],
+						["fileNameLength", 2],
+						["extraFieldLength", 2],
+						["fileCommentLength", 2],
+						["diskNumber", 2],
+						["internalFileAttributes", 2],
+						["externalFileAttributes", 4],
+						["offsetToLocalFileHeader", 4]
+					]);
+					vars.offsetToLocalFileHeader += startOffset;
+					vars.lastModifiedDateTime = parseDateTime(vars.lastModifiedDate, vars.lastModifiedTime);
+					return records.pull(vars.fileNameLength).then(function(fileNameBuffer) {
+						vars.pathBuffer = fileNameBuffer;
+						vars.path = fileNameBuffer.toString("utf8");
+						vars.isUnicode = (vars.flags & 2048) != 0;
+						return records.pull(vars.extraFieldLength);
+					}).then(function(extraField) {
+						vars.extra = parseExtraField(extraField, vars);
+						return records.pull(vars.fileCommentLength);
+					}).then(function(comment) {
+						vars.comment = comment;
+						vars.type = vars.uncompressedSize === 0 && /[/\\]$/.test(vars.path) ? "Directory" : "File";
+						const padding = options && options.padding || 1e3;
+						vars.stream = function(_password) {
+							const totalSize = 30 + padding + (vars.extraFieldLength || 0) + (vars.fileNameLength || 0) + vars.compressedSize;
+							return unzip(source, vars.offsetToLocalFileHeader, _password, vars, totalSize);
+						};
+						vars.buffer = function(_password) {
+							return BufferStream(vars.stream(_password));
+						};
+						return vars;
+					});
+				});
+			});
+			return Bluebird.props(vars);
+		});
+	};
+}));
+var require_Open = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_graceful_fs();
+	const directory = require_directory();
+	const Stream = __require("stream");
+	module.exports = {
+		buffer: function(buffer, options) {
+			return directory({
+				stream: function(offset, length) {
+					const stream = Stream.PassThrough();
+					const end = length ? offset + length : void 0;
+					stream.end(buffer.slice(offset, end));
+					return stream;
+				},
+				size: function() {
+					return Promise.resolve(buffer.length);
+				}
+			}, options);
+		},
+		file: function(filename, options) {
+			return directory({
+				stream: function(start, length) {
+					const end = length ? start + length : void 0;
+					return fs.createReadStream(filename, {
+						start,
+						end
+					});
+				},
+				size: function() {
+					return new Promise(function(resolve, reject) {
+						fs.stat(filename, function(err, d) {
+							if (err) reject(err);
+							else resolve(d.size);
+						});
+					});
+				}
+			}, options);
+		},
+		url: function(request, params, options) {
+			if (typeof params === "string") params = { url: params };
+			if (!params.url) throw "URL missing";
+			params.headers = params.headers || {};
+			return directory({
+				stream: function(offset, length) {
+					const options = Object.create(params);
+					const end = length ? offset + length : "";
+					options.headers = Object.create(params.headers);
+					options.headers.range = "bytes=" + offset + "-" + end;
+					return request(options);
+				},
+				size: function() {
+					return new Promise(function(resolve, reject) {
+						const req = request(params);
+						req.on("response", function(d) {
+							req.abort();
+							if (!d.headers["content-length"]) reject(/* @__PURE__ */ new Error("Missing content length header"));
+							else resolve(d.headers["content-length"]);
+						}).on("error", reject);
+					});
+				}
+			}, options);
+		},
+		s3: function(client, params, options) {
+			return directory({
+				size: function() {
+					return new Promise(function(resolve, reject) {
+						client.headObject(params, function(err, d) {
+							if (err) reject(err);
+							else resolve(d.ContentLength);
+						});
+					});
+				},
+				stream: function(offset, length) {
+					const d = {};
+					for (const key in params) d[key] = params[key];
+					const end = length ? offset + length : "";
+					d.Range = "bytes=" + offset + "-" + end;
+					return client.getObject(d).createReadStream();
+				}
+			}, options);
+		},
+		s3_v3: function(client, params, options) {
+			const { GetObjectCommand, HeadObjectCommand } = __require("@aws-sdk/client-s3");
+			return directory({
+				size: async () => {
+					const head = await client.send(new HeadObjectCommand({
+						Bucket: params.Bucket,
+						Key: params.Key
+					}));
+					if (!head.ContentLength) return 0;
+					return head.ContentLength;
+				},
+				stream: (offset, length) => {
+					const stream = Stream.PassThrough();
+					const end = length ? offset + length : "";
+					client.send(new GetObjectCommand({
+						Bucket: params.Bucket,
+						Key: params.Key,
+						Range: `bytes=${offset}-${end}`
+					})).then((response) => {
+						response.Body.pipe(stream);
+					}).catch((error) => {
+						stream.emit("error", error);
+					});
+					return stream;
+				}
+			}, options);
+		},
+		custom: function(source, options) {
+			return directory(source, options);
+		}
+	};
+}));
+var require_unzip = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.Parse = require_parse();
+	exports.ParseOne = require_parseOne();
+	exports.Extract = require_extract();
+	exports.Open = require_Open();
+}));
+export { require_unzip as t };