138 function CompressedObject(compressedSize, uncompressedSize, crc32, compression, data) {  argument
143     this.compressedContent = data;
364     this._pako.push(utils.transformTo(ARRAY_TYPE, chunk.data), false);
397     this._pako.onData = function(data) {  argument
399             data : data,
780         this.bytesWritten += chunk.data.length;
783             data : chunk.data,  argument
806             data : record.fileRecord,
828             data : generateDataDescriptors(streamInfo),
835             data : record.fileRecord,
853             data : this.dirRecords[i],
862         data : dirEnd,
1100 module.exports = function (data, options) {
1110     if (nodejsUtils.isNode && nodejsUtils.isStream(data)) {
1114 …return utils.prepareContent("the loaded zip file", data, true, options.optimizedBinaryString, opti…
1115         .then(function (data) {  argument
1117             zipEntries.load(data);
1191                 data: chunk,
1256     helper.on("data", function (data, meta) {  argument
1257         if (!self.push(data)) {
1295     newBufferFrom: function(data, encoding) {  argument
1297             return Buffer.from(data, encoding);
1299             if (typeof data === "number") {
1304             return new Buffer(data, encoding);
1360 var fileAdd = function(name, data, originalOptions) {  argument
1362     var dataType = utils.getTypeOf(data),
1402     var isCompressedEmpty = (data instanceof CompressedObject) && data.uncompressedSize === 0;
1404     if (isCompressedEmpty || o.dir || !data || data.length === 0) {
1407         data = "";
1417     if (data instanceof CompressedObject || data instanceof GenericWorker) {
1418         zipObjectContent = data;
1419     } else if (nodejsUtils.isNode && nodejsUtils.isStream(data)) {
1420         zipObjectContent = new NodejsStreamInputAdapter(name, data);
1422 …  zipObjectContent = utils.prepareContent(name, data, o.binary, o.optimizedBinaryString, o.base64);
1558     file: function(name, data, o) {  argument
1577             fileAdd.call(this, name, data, o);
1741 function ArrayReader(data) {  argument
1742     DataReader.call(this, data);
1743     for(var i = 0; i < this.data.length; i++) {
1744         data[i] = data[i] & 0xFF;
1752     return this.data[this.zero + i];
1763 …if (this.data[i] === sig0 && this.data[i + 1] === sig1 && this.data[i + 2] === sig2 && this.data[i…
1778         data = this.readData(4);
1779     return sig0 === data[0] && sig1 === data[1] && sig2 === data[2] && sig3 === data[3];
1789     var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
1799 function DataReader(data) {  argument
1800     this.data = data; // type : see implementation
1801     this.length = data.length;
1918 function NodeBufferReader(data) {  argument
1919     Uint8ArrayReader.call(this, data);
1928     var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
1939 function StringReader(data) {  argument
1940     DataReader.call(this, data);
1947     return this.data.charCodeAt(this.zero + i);
1953     return this.data.lastIndexOf(sig) - this.zero;
1959     var data = this.readData(4);
1960     return sig === data;
1968     var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
1979 function Uint8ArrayReader(data) {  argument
1980     ArrayReader.call(this, data);
1992     var result = this.data.subarray(this.zero + this.index, this.zero + this.index + size);
2013 module.exports = function (data) {
2014     var type = utils.getTypeOf(data);
2017         return new StringReader(data);
2020         return new NodeBufferReader(data);
2023         return new Uint8ArrayReader(utils.transformTo("uint8array", data));
2025     return new ArrayReader(utils.transformTo("array", data));
2059         data : utils.transformTo(this.destType, chunk.data),
2086     this.streamInfo.crc32 = crc32(chunk.data, this.streamInfo.crc32 || 0);
2115         this.streamInfo[this.propName] = length + chunk.data.length;
2143     this.data = null;
2148     dataP.then(function (data) {  argument
2150         self.data = data;
2151         self.max = data && data.length || 0;
2152         self.type = utils.getTypeOf(data);
2168     this.data = null;
2211     var data = null, nextIndex = Math.min(this.max, this.index + size);
2218             data = this.data.substring(this.index, nextIndex);
2221             data = this.data.subarray(this.index, nextIndex);
2225             data = this.data.slice(this.index, nextIndex);
2230             data : data,
2591             .on("data", function (data, meta) {  argument
2592                 dataArray.push(data);
2672                 fn.call(self, chunk.data, chunk.meta);
2971     var data = utils.transformTo(support.uint8array ? "uint8array" : "array", chunk.data);
2976             var previousData = data;
2977             data = new Uint8Array(previousData.length + this.leftOver.length);
2978             data.set(this.leftOver, 0);
2979             data.set(previousData, this.leftOver.length);
2981             data = this.leftOver.concat(data);
2986     var nextBoundary = utf8border(data);
2987     var usableData = data;
2988     if (nextBoundary !== data.length) {
2990             usableData = data.subarray(0, nextBoundary);
2991             this.leftOver = data.subarray(nextBoundary, data.length);
2993             usableData = data.slice(0, nextBoundary);
2994             this.leftOver = data.slice(nextBoundary, data.length);
2999         data : exports.utf8decode(usableData),
3010             data : exports.utf8decode(this.leftOver),
3032         data : exports.utf8encode(chunk.data),
3490     var promise = external.Promise.resolve(inputData).then(function(data) {  argument
3493 …sBlob = support.blob && (data instanceof Blob || ["[object File]", "[object Blob]"].indexOf(Object…
3505                 reader.readAsArrayBuffer(data);
3508             return data;
3512     return promise.then(function(data) {  argument
3513         var dataType = exports.getTypeOf(data);
3523             data = exports.transformTo("uint8array", data);
3526                 data = base64.decode(data);
3533                     data = string2binary(data);
3537         return data;
3787     prepareReader: function(data) {
3788         this.reader = readerFor(data);
3794     load: function(data) {
3795         this.prepareReader(data);
4115 var ZipObject = function(name, data, options) {  argument
4123     this._data = data;
4250       element.data = (called = ++called % 2);
4817 Deflate.prototype.push = function (data, mode) {  argument
4827   if (typeof data === 'string') {
4829     strm.input = strings.string2buf(data);
4830   } else if (toString.call(data) === '[object ArrayBuffer]') {
4831     strm.input = new Uint8Array(data);
4833     strm.input = data;
5177 Inflate.prototype.push = function (data, mode) {  argument
5193   if (typeof data === 'string') {
5195     strm.input = strings.binstring2buf(data);
5196   } else if (toString.call(data) === '[object ArrayBuffer]') {
5197     strm.input = new Uint8Array(data);
5199     strm.input = data;
11494                 typeof event.data === "string" &&
11495                 event.data.indexOf(messagePrefix) === 0) {
11496                 runIfPresent(+event.data.slice(messagePrefix.length));
11514             var handle = event.data;