Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.
TypeScript automationchromechromiume2e-testingelectronend-to-end-testingfirefoxjavascriptplaywrighttesttest-automationtestingtesting-toolswebwebkit
fix(yauzl): vendor yauzl with destroy-lifecycle fix (#40747)
Pavel Feldmanc17e0b45c12f
diff --git a/package-lock.json b/package-lock.jsonindex 57606e7c09..9c13db4841 100644--- a/package-lock.json+++ b/package-lock.json@@ -66,7 +66,6 @@"@types/source-map-support": "^0.5.4","@types/ws": "8.2.2","@types/xml2js": "^0.4.9",- "@types/yauzl": "^2.10.3","@types/yazl": "^2.4.2","@typescript-eslint/eslint-plugin": "^8.59.0","@typescript-eslint/parser": "^8.59.0",@@ -121,7 +120,6 @@"ws": "8.17.1","xml2js": "^0.5.0","yaml": "^2.8.3",- "yauzl": "3.2.1","yazl": "2.5.1","zod": "^4.3.6","zod-to-json-schema": "^3.25.1"@@ -2821,6 +2819,7 @@"resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz","integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==","dev": true,+ "optional": true,"dependencies": {"@types/node": "*"}@@ -9507,20 +9506,6 @@"node": ">=10"}},- "node_modules/yauzl": {- "version": "3.2.1",- "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-3.2.1.tgz",- "integrity": "sha512-k1isifdbpNSFEHFJ1ZY4YDewv0IH9FR61lDetaRMD3j2ae3bIXGV+7c+LHCqtQGofSd8PIyV4X6+dHMAnSr60A==",- "dev": true,- "license": "MIT",- "dependencies": {- "buffer-crc32": "~0.2.3",- "pend": "~1.2.0"- },- "engines": {- "node": ">=12"- }- },"node_modules/yazl": {"version": "2.5.1","resolved": "https://registry.npmjs.org/yazl/-/yazl-2.5.1.tgz",diff --git a/package.json b/package.jsonindex 13888383a2..eb3dfa4382 100644--- a/package.json+++ b/package.json@@ -107,7 +107,6 @@"@types/source-map-support": "^0.5.4","@types/ws": "8.2.2","@types/xml2js": "^0.4.9",- "@types/yauzl": "^2.10.3","@types/yazl": "^2.4.2","@typescript-eslint/eslint-plugin": "^8.59.0","@typescript-eslint/parser": "^8.59.0",@@ -162,7 +161,6 @@"ws": "8.17.1","xml2js": "^0.5.0","yaml": "^2.8.3",- "yauzl": "3.2.1","yazl": "2.5.1","zod": "^4.3.6","zod-to-json-schema": "^3.25.1"diff --git a/packages/playwright-core/src/server/DEPS.list b/packages/playwright-core/src/server/DEPS.listindex f9cf05a0b3..b6267405e2 100644--- a/packages/playwright-core/src/server/DEPS.list+++ b/packages/playwright-core/src/server/DEPS.list@@ -16,7 +16,6 @@ node_modules/pngjsnode_modules/proxy-from-envnode_modules/wsnode_modules/yaml-node_modules/yauzlnode_modules/yazl[devtoolsController.ts]diff --git a/packages/playwright-core/src/server/localUtils.ts b/packages/playwright-core/src/server/localUtils.tsindex 2ba65b226e..e52eb66cf0 100644--- a/packages/playwright-core/src/server/localUtils.ts+++ b/packages/playwright-core/src/server/localUtils.ts@@ -18,8 +18,8 @@ import fs from 'fs';import os from 'os';import path from 'path';-import * as yauzl from 'yauzl';import * as yazl from 'yazl';+import * as yauzl from '@utils/third_party/yauzl';import { ManualPromise } from '@isomorphic/manualPromise';import { serializeClientSideCallMetadata } from '@isomorphic/trace/traceUtils';import { assert } from '@isomorphic/assert';diff --git a/packages/playwright-core/src/utilsBundle.ts b/packages/playwright-core/src/utilsBundle.tsindex af57d4cf10..d6a69b083d 100644--- a/packages/playwright-core/src/utilsBundle.ts+++ b/packages/playwright-core/src/utilsBundle.ts@@ -81,7 +81,6 @@ import * as getEastAsianWidthLibrary from 'get-east-asian-width';export const getEastAsianWidth = getEastAsianWidthLibrary;export * as yazl from 'yazl';-export * as yauzl from 'yauzl';// @ts-expect-error untyped vendored moduleimport * as gracefulFsLibrary from 'graceful-fs';diff --git a/packages/playwright/src/worker/DEPS.list b/packages/playwright/src/worker/DEPS.listindex 72ccc32a73..40fc65671b 100644--- a/packages/playwright/src/worker/DEPS.list+++ b/packages/playwright/src/worker/DEPS.list@@ -6,5 +6,4 @@../util.ts../matchers/**node_modules/colors/safe-node_modules/yauzlnode_modules/yazldiff --git a/packages/playwright/src/worker/testTracing.ts b/packages/playwright/src/worker/testTracing.tsindex 27132bc7fd..ccf66ee5fb 100644--- a/packages/playwright/src/worker/testTracing.ts+++ b/packages/playwright/src/worker/testTracing.ts@@ -18,7 +18,7 @@ import fs from 'fs';import path from 'path';import * as yazl from 'yazl';-import * as yauzl from 'yauzl';+import * as yauzl from '@utils/third_party/yauzl';import { ManualPromise } from '@isomorphic/manualPromise';import { monotonicTime } from '@isomorphic/time';import { calculateSha1, createGuid } from '@utils/crypto';diff --git a/packages/utils/DEPS.list b/packages/utils/DEPS.listindex 0834f57c8e..aa25a66a8a 100644--- a/packages/utils/DEPS.list+++ b/packages/utils/DEPS.list@@ -10,7 +10,6 @@ node_modules/pngjsnode_modules/proxy-from-envnode_modules/socks-proxy-agentnode_modules/ws-node_modules/yauzlnode_modules/yazl[comparators.ts]diff --git a/packages/utils/third_party/extractZip.ts b/packages/utils/third_party/extractZip.tsindex 1dc0d27253..0e8bb41181 100644--- a/packages/utils/third_party/extractZip.ts+++ b/packages/utils/third_party/extractZip.ts@@ -31,12 +31,12 @@ import { promisify } from 'util';import debugPkg from 'debug';import getStream from 'get-stream';-import yauzl from 'yauzl';-import type { Entry, ZipFile } from 'yauzl';+import yauzl from './yauzl';+import type { Entry, Options as YauzlOptions, ZipFile } from './yauzl';const debug = debugPkg('extract-zip');-const openZip = promisify<string, yauzl.Options, ZipFile>(yauzl.open);+const openZip = promisify<string, YauzlOptions, ZipFile>(yauzl.open);const pipeline = promisify(stream.pipeline);export interface Options {diff --git a/packages/utils/third_party/yauzl/LICENSE b/packages/utils/third_party/yauzl/LICENSEnew file mode 100644index 0000000000..65412d42ed--- /dev/null+++ b/packages/utils/third_party/yauzl/LICENSE@@ -0,0 +1,134 @@+This directory contains code vendored from several MIT-licensed projects.++================================================================================+yauzl (https://github.com/thejoshwolfe/yauzl)+================================================================================++The MIT License (MIT)++Copyright (c) 2014 Josh Wolfe++Permission is hereby granted, free of charge, to any person obtaining a copy+of this software and associated documentation files (the "Software"), to deal+in the Software without restriction, including without limitation the rights+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+copies of the Software, and to permit persons to whom the Software is+furnished to do so, subject to the following conditions:++The above copyright notice and this permission notice shall be included in all+copies or substantial portions of the Software.++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+SOFTWARE.++================================================================================+node-fd-slicer (https://github.com/andrewrk/node-fd-slicer) — embedded as+fd-slicer.js, with additional fix from https://github.com/thejoshwolfe/yauzl/pull/168+================================================================================++The MIT License (Expat)++Copyright (c) 2014 Andrew Kelley++Permission is hereby granted, free of charge, to any person+obtaining a copy of this software and associated documentation files+(the "Software"), to deal in the Software without restriction,+including without limitation the rights to use, copy, modify, merge,+publish, distribute, sublicense, and/or sell copies of the Software,+and to permit persons to whom the Software is furnished to do so,+subject to the following conditions:++The above copyright notice and this permission notice shall be+included in all copies or substantial portions of the Software.++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+SOFTWARE.++================================================================================+pend (https://github.com/andrewrk/node-pend)+================================================================================++The MIT License (Expat)++Copyright (c) 2014 Andrew Kelley++Permission is hereby granted, free of charge, to any person+obtaining a copy of this software and associated documentation files+(the "Software"), to deal in the Software without restriction,+including without limitation the rights to use, copy, modify, merge,+publish, distribute, sublicense, and/or sell copies of the Software,+and to permit persons to whom the Software is furnished to do so,+subject to the following conditions:++The above copyright notice and this permission notice shall be+included in all copies or substantial portions of the Software.++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+SOFTWARE.++================================================================================+buffer-crc32 (https://github.com/brianloveswords/buffer-crc32)+================================================================================++The MIT License++Copyright (c) 2013 Brian J. Brennan++Permission is hereby granted, free of charge, to any person obtaining a copy+of this software and associated documentation files (the "Software"), to deal in+the Software without restriction, including without limitation the rights to use,+copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the+Software, and to permit persons to whom the Software is furnished to do so,+subject to the following conditions:++The above copyright notice and this permission notice shall be included in all+copies or substantial portions of the Software.++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.++================================================================================+DefinitelyTyped @types/yauzl — basis for index.d.ts+================================================================================++MIT License++Copyright (c) Microsoft Corporation.++Permission is hereby granted, free of charge, to any person obtaining a copy+of this software and associated documentation files (the "Software"), to deal+in the Software without restriction, including without limitation the rights+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+copies of the Software, and to permit persons to whom the Software is+furnished to do so, subject to the following conditions:++The above copyright notice and this permission notice shall be included in all+copies or substantial portions of the Software.++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+SOFTWARE.diff --git a/packages/utils/third_party/yauzl/buffer-crc32.js b/packages/utils/third_party/yauzl/buffer-crc32.jsnew file mode 100644index 0000000000..534590d76a--- /dev/null+++ b/packages/utils/third_party/yauzl/buffer-crc32.js@@ -0,0 +1,114 @@+// Vendored from https://github.com/brianloveswords/buffer-crc32 at v0.2.13 under the MIT License.+// See LICENSE for the full text.++var Buffer = require('buffer').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;diff --git a/packages/utils/third_party/yauzl/fd-slicer.js b/packages/utils/third_party/yauzl/fd-slicer.jsnew file mode 100644index 0000000000..2888ea474f--- /dev/null+++ b/packages/utils/third_party/yauzl/fd-slicer.js@@ -0,0 +1,330 @@+// This was adapted from https://github.com/andrewrk/node-fd-slicer by Andrew Kelley under the MIT License.+// Originally vendored from https://github.com/thejoshwolfe/yauzl at 3.2.1.+// Modified to apply the destroy() lifecycle fix from+// https://github.com/thejoshwolfe/yauzl/pull/168 (HoJeong Go) so async iteration+// over `openReadStream` properly emits 'close' on modern Node.+var fs = require('fs');+var util = require('util');+var stream = require('stream');+var Readable = stream.Readable;+var Writable = stream.Writable;+var PassThrough = stream.PassThrough;+var Pend = require('./pend');+var EventEmitter = require('events').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 = Buffer.allocUnsafe(toRead);+ fs.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {+ if (self._destroyed) return cb();+ 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 (err == null && !this.readableEnded) {+ err = new Error("stream destroyed");+ }+ return Readable.prototype.destroy.call(this, err);+};++ReadStream.prototype._destroy = function(err, cb) {+ if (!this._destroyed) {+ this._destroyed = true;+ this.context.unref();+ }+ cb(err);+};++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(err, cb) {+ if (!this._destroyed) {+ this._destroyed = true;+ this.context.unref();+ }+ cb(err);+};++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) {+ if (!(0 <= offset && offset <= buffer.length)) throw new RangeError("offset outside buffer: 0 <= " + offset + " <= " + buffer.length);+ if (position < 0) throw new RangeError("position is negative: " + position);+ if (offset + length > buffer.length) {+ // The caller's buffer can't hold all the bytes they're trying to read.+ // Clamp the length instead of giving an error.+ // The callback will be informed of fewer than expected bytes written.+ length = buffer.length - offset;+ }+ if (position + length > this.buffer.length) {+ // Clamp any attempt to read past the end of the source buffer.+ length = this.buffer.length - position;+ }+ if (length <= 0) {+ // After any clamping, we're fully out of bounds or otherwise have nothing to do.+ // This isn't an error; it's just zero bytes written.+ setImmediate(function() {+ callback(null, 0);+ });+ return;+ }+ this.buffer.copy(buffer, offset, position, position + length);+ setImmediate(function() {+ callback(null, length);+ });+};++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(err, cb) {+ readStream._destroyed = true;+ PassThrough.prototype._destroy.call(readStream, err, cb);+ };+ 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(err, cb) {+ writeStream._destroyed = true;+ cb(err);+ };+ 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);+}diff --git a/packages/utils/third_party/yauzl/index.d.ts b/packages/utils/third_party/yauzl/index.d.tsnew file mode 100644index 0000000000..0b49b62f0d--- /dev/null+++ b/packages/utils/third_party/yauzl/index.d.ts@@ -0,0 +1,124 @@+// Adapted from https://www.npmjs.com/package/@types/yauzl (DefinitelyTyped, MIT).+/// <reference types="node" />++import { EventEmitter } from 'events';+import { Readable } from 'stream';++export abstract class RandomAccessReader extends EventEmitter {+ _readStreamForRange(start: number, end: number): void;+ createReadStream(options: { start: number; end: number }): void;+ read(buffer: Buffer, offset: number, length: number, position: number, callback: (err: Error | null) => void): void;+ close(callback: (err: Error | null) => void): void;+}++export class Entry {+ comment: string;+ compressedSize: number;+ compressionMethod: number;+ crc32: number;+ externalFileAttributes: number;+ extraFieldLength: number;+ extraFields: Array<{ id: number; data: Buffer }>;+ fileCommentLength: number;+ fileName: string;+ fileNameLength: number;+ generalPurposeBitFlag: number;+ internalFileAttributes: number;+ lastModFileDate: number;+ lastModFileTime: number;+ relativeOffsetOfLocalHeader: number;+ uncompressedSize: number;+ versionMadeBy: number;+ versionNeededToExtract: number;++ getLastModDate(): Date;+ isEncrypted(): boolean;+ isCompressed(): boolean;+}++export interface ZipFileOptions {+ decompress: boolean | null;+ decrypt: boolean | null;+ start: number | null;+ end: number | null;+}++export class ZipFile extends EventEmitter {+ autoClose: boolean;+ comment: string;+ decodeStrings: boolean;+ emittedError: boolean;+ entriesRead: number;+ entryCount: number;+ fileSize: number;+ isOpen: boolean;+ lazyEntries: boolean;+ readEntryCursor: boolean;+ validateEntrySizes: boolean;++ constructor(+ reader: RandomAccessReader,+ centralDirectoryOffset: number,+ fileSize: number,+ entryCount: number,+ comment: string,+ autoClose: boolean,+ lazyEntries: boolean,+ decodeStrings: boolean,+ validateEntrySizes: boolean,+ );++ openReadStream(+ entry: Entry,+ options: ZipFileOptions,+ callback: (err: Error | null, stream: Readable) => void,+ ): void;+ openReadStream(entry: Entry, callback: (err: Error | null, stream: Readable) => void): void;+ close(): void;+ readEntry(): void;+}++export interface Options {+ autoClose?: boolean | undefined;+ lazyEntries?: boolean | undefined;+ decodeStrings?: boolean | undefined;+ validateEntrySizes?: boolean | undefined;+ strictFileNames?: boolean | undefined;+}++export function open(path: string, options: Options, callback?: (err: Error | null, zipfile: ZipFile) => void): void;+export function open(path: string, callback?: (err: Error | null, zipfile: ZipFile) => void): void;+export function fromFd(fd: number, options: Options, callback?: (err: Error | null, zipfile: ZipFile) => void): void;+export function fromFd(fd: number, callback?: (err: Error | null, zipfile: ZipFile) => void): void;+export function fromBuffer(+ buffer: Buffer,+ options: Options,+ callback?: (err: Error | null, zipfile: ZipFile) => void,+): void;+export function fromBuffer(buffer: Buffer, callback?: (err: Error | null, zipfile: ZipFile) => void): void;+export function fromRandomAccessReader(+ reader: RandomAccessReader,+ totalSize: number,+ options: Options,+ callback: (err: Error | null, zipfile: ZipFile) => void,+): void;+export function fromRandomAccessReader(+ reader: RandomAccessReader,+ totalSize: number,+ callback: (err: Error | null, zipfile: ZipFile) => void,+): void;+export function dosDateTimeToDate(date: number, time: number): Date;+export function validateFileName(fileName: string): string | null;++declare const yauzl: {+ open: typeof open;+ fromFd: typeof fromFd;+ fromBuffer: typeof fromBuffer;+ fromRandomAccessReader: typeof fromRandomAccessReader;+ dosDateTimeToDate: typeof dosDateTimeToDate;+ validateFileName: typeof validateFileName;+ ZipFile: typeof ZipFile;+ Entry: typeof Entry;+ RandomAccessReader: typeof RandomAccessReader;+};+export default yauzl;diff --git a/packages/utils/third_party/yauzl/index.js b/packages/utils/third_party/yauzl/index.jsnew file mode 100644index 0000000000..3661c76540--- /dev/null+++ b/packages/utils/third_party/yauzl/index.js@@ -0,0 +1,951 @@+// Vendored from https://github.com/thejoshwolfe/yauzl at v3.2.1 under the MIT License.+// See LICENSE for the full text.+//+// Local modifications:+// - require('./fd-slicer'): unchanged path; fd-slicer.js carries the fix from+// https://github.com/thejoshwolfe/yauzl/pull/168.+// - require('buffer-crc32'): rewritten to ./buffer-crc32 (inlined sibling).++var fs = require("fs");+var zlib = require("zlib");+var fd_slicer = require("./fd-slicer");+var crc32 = require("./buffer-crc32");+var util = require("util");+var EventEmitter = require("events").EventEmitter;+var Transform = require("stream").Transform;+var PassThrough = require("stream").PassThrough;+var Writable = require("stream").Writable;++exports.open = open;+exports.fromFd = fromFd;+exports.fromBuffer = fromBuffer;+exports.fromRandomAccessReader = fromRandomAccessReader;+exports.dosDateTimeToDate = dosDateTimeToDate;+exports.getFileNameLowLevel = getFileNameLowLevel;+exports.validateFileName = validateFileName;+exports.parseExtraFields = parseExtraFields;+exports.ZipFile = ZipFile;+exports.Entry = Entry;+exports.LocalFileHeader = LocalFileHeader;+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 zip64EocdlSize = 20; // Zip64 end of central directory locator+ var maxCommentSize = 0xffff; // 2-byte size+ var bufferSize = Math.min(zip64EocdlSize + 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.subarray(i);++ // 0 - End of central directory signature = 0x06054b50+ // 4 - Number of this disk+ var diskNumber = eocdrBuffer.readUInt16LE(4);+ // 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 + ". Are there extra bytes at the end of the file? Or is the end of central dir signature `PK☺☻` in the comment?"));+ }+ // 22 - Comment+ // the encoding is always cp437.+ var comment = decodeStrings ? decodeBuffer(eocdrBuffer.subarray(22), false)+ : eocdrBuffer.subarray(22);++ // Look for a Zip64 end of central directory locator+ if (i - zip64EocdlSize >= 0 && buffer.readUInt32LE(i - zip64EocdlSize) === 0x07064b50) {+ // ZIP64 format+ var zip64EocdlBuffer = buffer.subarray(i - zip64EocdlSize, i - zip64EocdlSize + zip64EocdlSize);+ // 0 - zip64 end of central dir locator signature = 0x07064b50+ // 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);+ return 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+ diskNumber = zip64EocdrBuffer.readUInt32LE(16);+ if (diskNumber !== 0) {+ // Check this only after zip64 overrides. See #118.+ return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));+ }+ // 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));+ });+ }++ // Not ZIP64 format+ if (diskNumber !== 0) {+ return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));+ }+ return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));++ }++ // Not a zip file.+ callback(new Error("End of central directory record signature not found. Either not a zip file, or file is truncated."));+ });+}++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+ entry.fileNameRaw = buffer.subarray(0, entry.fileNameLength);+ // 46+n - Extra field+ var fileCommentStart = entry.fileNameLength + entry.extraFieldLength;+ entry.extraFieldRaw = buffer.subarray(entry.fileNameLength, fileCommentStart);+ // 46+n+m - File comment+ entry.fileCommentRaw = buffer.subarray(fileCommentStart, fileCommentStart + entry.fileCommentLength);++ // Parse the extra fields, which we need for processing other fields.+ try {+ entry.extraFields = parseExtraFields(entry.extraFieldRaw);+ } catch (err) {+ return emitErrorAndAutoClose(self, err);+ }++ // Interpret strings according to bit flags, extra fields, and options.+ if (self.decodeStrings) {+ var isUtf8 = (entry.generalPurposeBitFlag & 0x800) !== 0;+ entry.fileComment = decodeBuffer(entry.fileCommentRaw, isUtf8);+ entry.fileName = getFileNameLowLevel(entry.generalPurposeBitFlag, entry.fileNameRaw, entry.extraFields, self.strictFileNames);+ var errorMessage = validateFileName(entry.fileName);+ if (errorMessage != null) return emitErrorAndAutoClose(self, new Error(errorMessage));+ } else {+ entry.fileComment = entry.fileCommentRaw;+ entry.fileName = entry.fileNameRaw;+ }+ // Maintain API compatibility. See https://github.com/thejoshwolfe/yauzl/issues/47+ entry.comment = entry.fileComment;++ self.readEntryCursor += buffer.length;+ self.entriesRead += 1;++ // Check for the Zip64 Extended Information Extra Field.+ for (var i = 0; i < entry.extraFields.length; i++) {+ var extraField = entry.extraFields[i];+ if (extraField.id !== 0x0001) continue;+ // Found it.++ var zip64EiefBuffer = extraField.data;+ 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++ 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));+ }+ }++ 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 = null;+ }+ if (options == null) {+ 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"));+ }+ 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));+ }++ self.readLocalFileHeader(entry, {minimal: true}, function(err, localFileHeader) {+ if (err) return callback(err);+ self.openReadStreamLowLevel(+ localFileHeader.fileDataStart, entry.compressedSize,+ relativeStart, relativeEnd,+ decompress, entry.uncompressedSize,+ callback);+ });+};++ZipFile.prototype.openReadStreamLowLevel = function(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize, callback) {+ var self = this;++ var fileDataEnd = fileDataStart + compressedSize;+ 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(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+ installDestroyFn(endpointStream, 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);+};++ZipFile.prototype.readLocalFileHeader = function(entry, options, callback) {+ var self = this;+ if (callback == null) {+ callback = options;+ options = null;+ }+ if (options == null) options = {};++ 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)));+ }++ var fileNameLength = buffer.readUInt16LE(26);+ var extraFieldLength = buffer.readUInt16LE(28);+ var fileDataStart = entry.relativeOffsetOfLocalHeader + 30 + fileNameLength + extraFieldLength;+ // We now have enough information to do this bounds check.+ if (fileDataStart + entry.compressedSize > self.fileSize) {+ return callback(new Error("file data overflows file bounds: " ++ fileDataStart + " + " + entry.compressedSize + " > " + self.fileSize));+ }++ if (options.minimal) {+ return callback(null, {fileDataStart: fileDataStart});+ }++ var localFileHeader = new LocalFileHeader();+ localFileHeader.fileDataStart = fileDataStart;++ // 4 - Version needed to extract (minimum)+ localFileHeader.versionNeededToExtract = buffer.readUInt16LE(4);+ // 6 - General purpose bit flag+ localFileHeader.generalPurposeBitFlag = buffer.readUInt16LE(6);+ // 8 - Compression method+ localFileHeader.compressionMethod = buffer.readUInt16LE(8);+ // 10 - File last modification time+ localFileHeader.lastModFileTime = buffer.readUInt16LE(10);+ // 12 - File last modification date+ localFileHeader.lastModFileDate = buffer.readUInt16LE(12);+ // 14 - CRC-32+ localFileHeader.crc32 = buffer.readUInt32LE(14);+ // 18 - Compressed size+ localFileHeader.compressedSize = buffer.readUInt32LE(18);+ // 22 - Uncompressed size+ localFileHeader.uncompressedSize = buffer.readUInt32LE(22);+ // 26 - File name length (n)+ localFileHeader.fileNameLength = fileNameLength;+ // 28 - Extra field length (m)+ localFileHeader.extraFieldLength = extraFieldLength;+ // 30 - File name+ // 30+n - Extra field++ buffer = newBuffer(fileNameLength + extraFieldLength);+ self.reader.ref();+ readAndAssertNoEof(self.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader + 30, function(err) {+ try {+ if (err) return callback(err);+ localFileHeader.fileName = buffer.subarray(0, fileNameLength);+ localFileHeader.extraField = buffer.subarray(fileNameLength);+ return callback(null, localFileHeader);+ } finally {+ self.reader.unref();+ }+ });+ } finally {+ self.reader.unref();+ }+ });+};++function Entry() {+}+Entry.prototype.getLastModDate = function(options) {+ if (options == null) options = {};++ if (!options.forceDosFormat) {+ // Check extended fields.+ for (var i = 0; i < this.extraFields.length; i++) {+ var extraField = this.extraFields[i];+ if (extraField.id === 0x5455) {+ // Info-ZIP "universal timestamp" extended field (`0x5455` aka `"UT"`).+ // See the Info-ZIP source code unix/unix.c:set_extra_field() and zipfile.c:ef_scan_ut_time().+ var data = extraField.data;+ if (data.length < 5) continue; // Too short.+ // The flags define which of the three fields are present: mtime, atime, ctime.+ // We only care about mtime.+ // Also, ctime is never included in practice.+ // And also, atime is only included in the local file header for some reason+ // despite the flags lying about its inclusion in the central header.+ var flags = data[0];+ var HAS_MTIME = 1;+ if (!(flags & HAS_MTIME)) continue; // This will realistically never happen.+ // Although the positions of all of the fields shift around depending on the presence of other fields,+ // mtime is always first if present, and that's the only one we care about.+ var posixTimestamp = data.readInt32LE(1);+ return new Date(posixTimestamp * 1000);+ } else if (extraField.id === 0x000a) {+ var data = extraField.data;+ if (data.length !== 32) continue; // The length is always the same.+ // 4 bytes reserved+ // 2 bytes Tag+ if (data.readUInt16LE(4) !== 1) continue; // Tag1 is actually the only defined Tag.+ // 2 bytes Size+ if (data.readUInt16LE(6) !== 24) continue; // Size is always 24.+ // 8 bytes Mtime+ var hundredNanoSecondsSince1601 = data.readUInt32LE(8) + 4294967296 * data.readInt32LE(12);+ // Convert from NTFS to POSIX milliseconds.+ // The big number below is the milliseconds between year 1601 and year 1970+ // (i.e. the negative POSIX timestamp of 1601-01-01 00:00:00Z)+ var millisecondsSince1970 = hundredNanoSecondsSince1601 / 10000 - 11644473600000;+ // Note on numeric precision: JavaScript Number objects lose precision above Number.MAX_SAFE_INTEGER,+ // and NTFS timestamps are typically much bigger than that limit.+ // (MAX_SAFE_INTEGER would represent 1629-07-17T23:58:45.475Z.)+ // However, we're losing precision in the conversion from 100nanosecond units to millisecond units anyway,+ // and the time at which we also lose 1-millisecond precision is year 275760, the JavaScript Date limit (by design).+ // Up through the year 2057, this conversion only drops 4 bits of precision,+ // which is well under the 13-14 bits ratio between the milliseconds and 100nanoseconds.+ return new Date(millisecondsSince1970);+ }+ }+ }++ // Fallback to non-extended encoding.+ return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime, options.timezone);+};+Entry.prototype.isEncrypted = function() {+ return (this.generalPurposeBitFlag & 0x1) !== 0;+};+Entry.prototype.isCompressed = function() {+ return this.compressionMethod === 8;+};++function LocalFileHeader() {+}++function dosDateTimeToDate(date, time, timezone) {+ 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++ if (timezone == null || timezone === "local") {+ return new Date(year, month, day, hour, minute, second, millisecond);+ } else if (timezone === "UTC") {+ return new Date(Date.UTC(year, month, day, hour, minute, second, millisecond));+ } else {+ throw new Error("unrecognized options.timezone: " + options.timezone);+ }+}++function getFileNameLowLevel(generalPurposeBitFlag, fileNameBuffer, extraFields, strictFileNames) {+ var fileName = null;++ // check for Info-ZIP Unicode Path Extra Field (0x7075)+ // see https://github.com/thejoshwolfe/yauzl/issues/33+ for (var i = 0; i < extraFields.length; i++) {+ var extraField = 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(fileNameBuffer) !== 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+ fileName = decodeBuffer(extraField.data.subarray(5), true);+ break;+ }+ }++ if (fileName == null) {+ // The typical case.+ var isUtf8 = (generalPurposeBitFlag & 0x800) !== 0;+ fileName = decodeBuffer(fileNameBuffer, isUtf8);+ }++ if (!strictFileNames) {+ // Allow backslash.+ fileName = fileName.replace(/\\/g, "/");+ }+ return fileName;+}++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 parseExtraFields(extraFieldBuffer) {+ var 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) throw new Error("extra field length exceeds extra field buffer size");+ var dataBuffer = extraFieldBuffer.subarray(dataStart, dataEnd);+ extraFields.push({+ id: headerId,+ data: dataBuffer,+ });+ i = dataEnd;+ }+ return extraFields;+}++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) {+ if (options == null) 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);+ });+ });+ installDestroyFn(refUnrefFilter, 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);+ });+ });+ installDestroyFn(byteCounter, 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, isUtf8) {+ if (isUtf8) {+ return buffer.toString("utf8");+ } else {+ var result = "";+ for (var i = 0; i < buffer.length; 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.+ // As of 2020, Node has added support for BigInt, which obviates this whole function,+ // but yauzl hasn't been updated to depend on BigInt (yet?).+ 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);+ };+}++// Node 8 introduced a proper destroy() implementation on writable streams.+function installDestroyFn(stream, fn) {+ if (typeof stream.destroy === "function") {+ // New API.+ stream._destroy = function(err, cb) {+ fn();+ if (cb != null) cb(err);+ };+ } else {+ // Old API.+ stream.destroy = fn;+ }+}++function defaultCallback(err) {+ if (err) throw err;+}diff --git a/packages/utils/third_party/yauzl/pend.js b/packages/utils/third_party/yauzl/pend.jsnew file mode 100644index 0000000000..c278333e8e--- /dev/null+++ b/packages/utils/third_party/yauzl/pend.js@@ -0,0 +1,58 @@+// Vendored from https://github.com/andrewrk/node-pend at v1.2.0 under the MIT License.+// See LICENSE for the full text.++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));+}diff --git a/packages/utils/zipFile.ts b/packages/utils/zipFile.tsindex 9c59e5ae24..4b8209bab0 100644--- a/packages/utils/zipFile.ts+++ b/packages/utils/zipFile.ts@@ -14,8 +14,8 @@* limitations under the License.*/-import * as yauzl from 'yauzl';-import type { Entry, ZipFile as UnzipFile } from 'yauzl';+import * as yauzl from './third_party/yauzl';+import type { Entry, ZipFile as UnzipFile } from './third_party/yauzl';export class ZipFile {private _fileName: string;diff --git a/utils/build/utilsBundleMapping.js b/utils/build/utilsBundleMapping.jsindex 3020a6ea86..1ee21a049b 100644--- a/utils/build/utilsBundleMapping.js+++ b/utils/build/utilsBundleMapping.js@@ -33,7 +33,6 @@ const MAPPING = {'chokidar': { default: 'chokidar' },'get-east-asian-width': { namespace: 'getEastAsianWidth' },'yazl': { namespace: 'yazl' },- 'yauzl': { default: 'yauzl', namespace: 'yauzl' },'zod': { namespace: 'z' },'zod-to-json-schema': { named: { zodToJsonSchema: 'zodToJsonSchema' } },'@modelcontextprotocol/sdk/client/index.js': { named: { Client: 'Client' } },diff --git a/utils/protocol-types-generator/index.js b/utils/protocol-types-generator/index.jsindex 0219eb8960..992e45ece9 100644--- a/utils/protocol-types-generator/index.js+++ b/utils/protocol-types-generator/index.js@@ -1,7 +1,7 @@// @ts-checkconst path = require('path');const fs = require('fs');-const yauzl = require('yauzl');+const yauzl = require('../../packages/utils/third_party/yauzl');const vm = require('vm');const os = require('os');