1 /*!
2
3 JSZip v3.2.1 - A JavaScript class for generating and reading zip files
4 <http://stuartk.com/jszip>
5
6 (c) 2009-2016 Stuart Knightley <stuart [at] stuartk.com>
7 Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/jszip/master/LICENSE.markdown.
8
9 JSZip uses the library pako released under the MIT license :
10 https://github.com/nodeca/pako/blob/master/LICENSE
11 */
12
13 (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.JSZip = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
14 'use strict';
15 var utils = require('./utils');
16 var support = require('./support');
17 // private property
18 var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
19
20
21 // public method for encoding
22 exports.encode = function(input) {
23 var output = [];
24 var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
25 var i = 0, len = input.length, remainingBytes = len;
26
27 var isArray = utils.getTypeOf(input) !== "string";
28 while (i < input.length) {
29 remainingBytes = len - i;
30
31 if (!isArray) {
32 chr1 = input.charCodeAt(i++);
33 chr2 = i < len ? input.charCodeAt(i++) : 0;
34 chr3 = i < len ? input.charCodeAt(i++) : 0;
35 } else {
36 chr1 = input[i++];
37 chr2 = i < len ? input[i++] : 0;
38 chr3 = i < len ? input[i++] : 0;
39 }
40
41 enc1 = chr1 >> 2;
42 enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
43 enc3 = remainingBytes > 1 ? (((chr2 & 15) << 2) | (chr3 >> 6)) : 64;
44 enc4 = remainingBytes > 2 ? (chr3 & 63) : 64;
45
46 output.push(_keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4));
47
48 }
49
50 return output.join("");
51 };
52
53 // public method for decoding
54 exports.decode = function(input) {
55 var chr1, chr2, chr3;
56 var enc1, enc2, enc3, enc4;
57 var i = 0, resultIndex = 0;
58
59 var dataUrlPrefix = "data:";
60
61 if (input.substr(0, dataUrlPrefix.length) === dataUrlPrefix) {
62 // This is a common error: people give a data url
63 // (data:image/png;base64,iVBOR...) with a {base64: true} and
64 // wonders why things don't work.
65 // We can detect that the string input looks like a data url but we
66 // *can't* be sure it is one: removing everything up to the comma would
67 // be too dangerous.
68 throw new Error("Invalid base64 input, it looks like a data url.");
69 }
70
71 input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
72
73 var totalLength = input.length * 3 / 4;
74 if(input.charAt(input.length - 1) === _keyStr.charAt(64)) {
75 totalLength--;
76 }
77 if(input.charAt(input.length - 2) === _keyStr.charAt(64)) {
78 totalLength--;
79 }
80 if (totalLength % 1 !== 0) {
81 // totalLength is not an integer, the length does not match a valid
82 // base64 content. That can happen if:
83 // - the input is not a base64 content
84 // - the input is *almost* a base64 content, with a extra chars at the
85 // beginning or at the end
86 // - the input uses a base64 variant (base64url for example)
87 throw new Error("Invalid base64 input, bad content length.");
88 }
89 var output;
90 if (support.uint8array) {
91 output = new Uint8Array(totalLength|0);
92 } else {
93 output = new Array(totalLength|0);
94 }
95
96 while (i < input.length) {
97
98 enc1 = _keyStr.indexOf(input.charAt(i++));
99 enc2 = _keyStr.indexOf(input.charAt(i++));
100 enc3 = _keyStr.indexOf(input.charAt(i++));
101 enc4 = _keyStr.indexOf(input.charAt(i++));
102
103 chr1 = (enc1 << 2) | (enc2 >> 4);
104 chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
105 chr3 = ((enc3 & 3) << 6) | enc4;
106
107 output[resultIndex++] = chr1;
108
109 if (enc3 !== 64) {
110 output[resultIndex++] = chr2;
111 }
112 if (enc4 !== 64) {
113 output[resultIndex++] = chr3;
114 }
115
116 }
117
118 return output;
119 };
120
121 },{"./support":30,"./utils":32}],2:[function(require,module,exports){
122 'use strict';
123
124 var external = require("./external");
125 var DataWorker = require('./stream/DataWorker');
126 var DataLengthProbe = require('./stream/DataLengthProbe');
127 var Crc32Probe = require('./stream/Crc32Probe');
128 var DataLengthProbe = require('./stream/DataLengthProbe');
129
130 /**
131 * Represent a compressed object, with everything needed to decompress it.
132 * @constructor
133 * @param {number} compressedSize the size of the data compressed.
134 * @param {number} uncompressedSize the size of the data after decompression.
135 * @param {number} crc32 the crc32 of the decompressed file.
136 * @param {object} compression the type of compression, see lib/compressions.js.
137 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the compressed data.
138 */
139 function CompressedObject(compressedSize, uncompressedSize, crc32, compression, data) {
140 this.compressedSize = compressedSize;
141 this.uncompressedSize = uncompressedSize;
142 this.crc32 = crc32;
143 this.compression = compression;
144 this.compressedContent = data;
145 }
146
147 CompressedObject.prototype = {
148 /**
149 * Create a worker to get the uncompressed content.
150 * @return {GenericWorker} the worker.
151 */
152 getContentWorker : function () {
153 var worker = new DataWorker(external.Promise.resolve(this.compressedContent))
154 .pipe(this.compression.uncompressWorker())
155 .pipe(new DataLengthProbe("data_length"));
156
157 var that = this;
158 worker.on("end", function () {
159 if(this.streamInfo['data_length'] !== that.uncompressedSize) {
160 throw new Error("Bug : uncompressed data size mismatch");
161 }
162 });
163 return worker;
164 },
165 /**
166 * Create a worker to get the compressed content.
167 * @return {GenericWorker} the worker.
168 */
169 getCompressedWorker : function () {
170 return new DataWorker(external.Promise.resolve(this.compressedContent))
171 .withStreamInfo("compressedSize", this.compressedSize)
172 .withStreamInfo("uncompressedSize", this.uncompressedSize)
173 .withStreamInfo("crc32", this.crc32)
174 .withStreamInfo("compression", this.compression)
175 ;
176 }
177 };
178
179 /**
180 * Chain the given worker with other workers to compress the content with the
181 * given compresion.
182 * @param {GenericWorker} uncompressedWorker the worker to pipe.
183 * @param {Object} compression the compression object.
184 * @param {Object} compressionOptions the options to use when compressing.
185 * @return {GenericWorker} the new worker compressing the content.
186 */
187 CompressedObject.createWorkerFrom = function (uncompressedWorker, compression, compressionOptions) {
188 return uncompressedWorker
189 .pipe(new Crc32Probe())
190 .pipe(new DataLengthProbe("uncompressedSize"))
191 .pipe(compression.compressWorker(compressionOptions))
192 .pipe(new DataLengthProbe("compressedSize"))
193 .withStreamInfo("compression", compression);
194 };
195
196 module.exports = CompressedObject;
197
198 },{"./external":6,"./stream/Crc32Probe":25,"./stream/DataLengthProbe":26,"./stream/DataWorker":27}],3:[function(require,module,exports){
199 'use strict';
200
201 var GenericWorker = require("./stream/GenericWorker");
202
203 exports.STORE = {
204 magic: "\x00\x00",
205 compressWorker : function (compressionOptions) {
206 return new GenericWorker("STORE compression");
207 },
208 uncompressWorker : function () {
209 return new GenericWorker("STORE decompression");
210 }
211 };
212 exports.DEFLATE = require('./flate');
213
214 },{"./flate":7,"./stream/GenericWorker":28}],4:[function(require,module,exports){
215 'use strict';
216
217 var utils = require('./utils');
218
219 /**
220 * The following functions come from pako, from pako/lib/zlib/crc32.js
221 * released under the MIT license, see pako https://github.com/nodeca/pako/
222 */
223
224 // Use ordinary array, since untyped makes no boost here
225 function makeTable() {
226 var c, table = [];
227
228 for(var n =0; n < 256; n++){
229 c = n;
230 for(var k =0; k < 8; k++){
231 c = ((c&1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
232 }
233 table[n] = c;
234 }
235
236 return table;
237 }
238
239 // Create table on load. Just 255 signed longs. Not a problem.
240 var crcTable = makeTable();
241
242
243 function crc32(crc, buf, len, pos) {
244 var t = crcTable, end = pos + len;
245
246 crc = crc ^ (-1);
247
248 for (var i = pos; i < end; i++ ) {
249 crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
250 }
251
252 return (crc ^ (-1)); // >>> 0;
253 }
254
255 // That's all for the pako functions.
256
257 /**
258 * Compute the crc32 of a string.
259 * This is almost the same as the function crc32, but for strings. Using the
260 * same function for the two use cases leads to horrible performances.
261 * @param {Number} crc the starting value of the crc.
262 * @param {String} str the string to use.
263 * @param {Number} len the length of the string.
264 * @param {Number} pos the starting position for the crc32 computation.
265 * @return {Number} the computed crc32.
266 */
267 function crc32str(crc, str, len, pos) {
268 var t = crcTable, end = pos + len;
269
270 crc = crc ^ (-1);
271
272 for (var i = pos; i < end; i++ ) {
273 crc = (crc >>> 8) ^ t[(crc ^ str.charCodeAt(i)) & 0xFF];
274 }
275
276 return (crc ^ (-1)); // >>> 0;
277 }
278
279 module.exports = function crc32wrapper(input, crc) {
280 if (typeof input === "undefined" || !input.length) {
281 return 0;
282 }
283
284 var isArray = utils.getTypeOf(input) !== "string";
285
286 if(isArray) {
287 return crc32(crc|0, input, input.length, 0);
288 } else {
289 return crc32str(crc|0, input, input.length, 0);
290 }
291 };
292
293 },{"./utils":32}],5:[function(require,module,exports){
294 'use strict';
295 exports.base64 = false;
296 exports.binary = false;
297 exports.dir = false;
298 exports.createFolders = true;
299 exports.date = null;
300 exports.compression = null;
301 exports.compressionOptions = null;
302 exports.comment = null;
303 exports.unixPermissions = null;
304 exports.dosPermissions = null;
305
306 },{}],6:[function(require,module,exports){
307 /* global Promise */
308 'use strict';
309
310 // load the global object first:
311 // - it should be better integrated in the system (unhandledRejection in node)
312 // - the environment may have a custom Promise implementation (see zone.js)
313 var ES6Promise = null;
314 if (typeof Promise !== "undefined") {
315 ES6Promise = Promise;
316 } else {
317 ES6Promise = require("lie");
318 }
319
320 /**
321 * Let the user use/change some implementations.
322 */
323 module.exports = {
324 Promise: ES6Promise
325 };
326
327 },{"lie":37}],7:[function(require,module,exports){
328 'use strict';
329 var USE_TYPEDARRAY = (typeof Uint8Array !== 'undefined') && (typeof Uint16Array !== 'undefined') && (typeof Uint32Array !== 'undefined');
330
331 var pako = require("pako");
332 var utils = require("./utils");
333 var GenericWorker = require("./stream/GenericWorker");
334
335 var ARRAY_TYPE = USE_TYPEDARRAY ? "uint8array" : "array";
336
337 exports.magic = "\x08\x00";
338
339 /**
340 * Create a worker that uses pako to inflate/deflate.
341 * @constructor
342 * @param {String} action the name of the pako function to call : either "Deflate" or "Inflate".
343 * @param {Object} options the options to use when (de)compressing.
344 */
345 function FlateWorker(action, options) {
346 GenericWorker.call(this, "FlateWorker/" + action);
347
348 this._pako = null;
349 this._pakoAction = action;
350 this._pakoOptions = options;
351 // the `meta` object from the last chunk received
352 // this allow this worker to pass around metadata
353 this.meta = {};
354 }
355
356 utils.inherits(FlateWorker, GenericWorker);
357
358 /**
359 * @see GenericWorker.processChunk
360 */
361 FlateWorker.prototype.processChunk = function (chunk) {
362 this.meta = chunk.meta;
363 if (this._pako === null) {
364 this._createPako();
365 }
366 this._pako.push(utils.transformTo(ARRAY_TYPE, chunk.data), false);
367 };
368
369 /**
370 * @see GenericWorker.flush
371 */
372 FlateWorker.prototype.flush = function () {
373 GenericWorker.prototype.flush.call(this);
374 if (this._pako === null) {
375 this._createPako();
376 }
377 this._pako.push([], true);
378 };
379 /**
380 * @see GenericWorker.cleanUp
381 */
382 FlateWorker.prototype.cleanUp = function () {
383 GenericWorker.prototype.cleanUp.call(this);
384 this._pako = null;
385 };
386
387 /**
388 * Create the _pako object.
389 * TODO: lazy-loading this object isn't the best solution but it's the
390 * quickest. The best solution is to lazy-load the worker list. See also the
391 * issue #446.
392 */
393 FlateWorker.prototype._createPako = function () {
394 this._pako = new pako[this._pakoAction]({
395 raw: true,
396 level: this._pakoOptions.level || -1 // default compression
397 });
398 var self = this;
399 this._pako.onData = function(data) {
400 self.push({
401 data : data,
402 meta : self.meta
403 });
404 };
405 };
406
407 exports.compressWorker = function (compressionOptions) {
408 return new FlateWorker("Deflate", compressionOptions);
409 };
410 exports.uncompressWorker = function () {
411 return new FlateWorker("Inflate", {});
412 };
413
414 },{"./stream/GenericWorker":28,"./utils":32,"pako":38}],8:[function(require,module,exports){
415 'use strict';
416
417 var utils = require('../utils');
418 var GenericWorker = require('../stream/GenericWorker');
419 var utf8 = require('../utf8');
420 var crc32 = require('../crc32');
421 var signature = require('../signature');
422
423 /**
424 * Transform an integer into a string in hexadecimal.
425 * @private
426 * @param {number} dec the number to convert.
427 * @param {number} bytes the number of bytes to generate.
428 * @returns {string} the result.
429 */
430 var decToHex = function(dec, bytes) {
431 var hex = "", i;
432 for (i = 0; i < bytes; i++) {
433 hex += String.fromCharCode(dec & 0xff);
434 dec = dec >>> 8;
435 }
436 return hex;
437 };
438
439 /**
440 * Generate the UNIX part of the external file attributes.
441 * @param {Object} unixPermissions the unix permissions or null.
442 * @param {Boolean} isDir true if the entry is a directory, false otherwise.
443 * @return {Number} a 32 bit integer.
444 *
445 * adapted from http://unix.stackexchange.com/questions/14705/the-zip-formats-external-file-attribute :
446 *
447 * TTTTsstrwxrwxrwx0000000000ADVSHR
448 * ^^^^____________________________ file type, see zipinfo.c (UNX_*)
449 * ^^^_________________________ setuid, setgid, sticky
450 * ^^^^^^^^^________________ permissions
451 * ^^^^^^^^^^______ not used ?
452 * ^^^^^^ DOS attribute bits : Archive, Directory, Volume label, System file, Hidden, Read only
453 */
454 var generateUnixExternalFileAttr = function (unixPermissions, isDir) {
455
456 var result = unixPermissions;
457 if (!unixPermissions) {
458 // I can't use octal values in strict mode, hence the hexa.
459 // 040775 => 0x41fd
460 // 0100664 => 0x81b4
461 result = isDir ? 0x41fd : 0x81b4;
462 }
463 return (result & 0xFFFF) << 16;
464 };
465
466 /**
467 * Generate the DOS part of the external file attributes.
468 * @param {Object} dosPermissions the dos permissions or null.
469 * @param {Boolean} isDir true if the entry is a directory, false otherwise.
470 * @return {Number} a 32 bit integer.
471 *
472 * Bit 0 Read-Only
473 * Bit 1 Hidden
474 * Bit 2 System
475 * Bit 3 Volume Label
476 * Bit 4 Directory
477 * Bit 5 Archive
478 */
479 var generateDosExternalFileAttr = function (dosPermissions, isDir) {
480
481 // the dir flag is already set for compatibility
482 return (dosPermissions || 0) & 0x3F;
483 };
484
485 /**
486 * Generate the various parts used in the construction of the final zip file.
487 * @param {Object} streamInfo the hash with informations about the compressed file.
488 * @param {Boolean} streamedContent is the content streamed ?
489 * @param {Boolean} streamingEnded is the stream finished ?
490 * @param {number} offset the current offset from the start of the zip file.
491 * @param {String} platform let's pretend we are this platform (change platform dependents fields)
492 * @param {Function} encodeFileName the function to encode the file name / comment.
493 * @return {Object} the zip parts.
494 */
495 var generateZipParts = function(streamInfo, streamedContent, streamingEnded, offset, platform, encodeFileName) {
496 var file = streamInfo['file'],
497 compression = streamInfo['compression'],
498 useCustomEncoding = encodeFileName !== utf8.utf8encode,
499 encodedFileName = utils.transformTo("string", encodeFileName(file.name)),
500 utfEncodedFileName = utils.transformTo("string", utf8.utf8encode(file.name)),
501 comment = file.comment,
502 encodedComment = utils.transformTo("string", encodeFileName(comment)),
503 utfEncodedComment = utils.transformTo("string", utf8.utf8encode(comment)),
504 useUTF8ForFileName = utfEncodedFileName.length !== file.name.length,
505 useUTF8ForComment = utfEncodedComment.length !== comment.length,
506 dosTime,
507 dosDate,
508 extraFields = "",
509 unicodePathExtraField = "",
510 unicodeCommentExtraField = "",
511 dir = file.dir,
512 date = file.date;
513
514
515 var dataInfo = {
516 crc32 : 0,
517 compressedSize : 0,
518 uncompressedSize : 0
519 };
520
521 // if the content is streamed, the sizes/crc32 are only available AFTER
522 // the end of the stream.
523 if (!streamedContent || streamingEnded) {
524 dataInfo.crc32 = streamInfo['crc32'];
525 dataInfo.compressedSize = streamInfo['compressedSize'];
526 dataInfo.uncompressedSize = streamInfo['uncompressedSize'];
527 }
528
529 var bitflag = 0;
530 if (streamedContent) {
531 // Bit 3: the sizes/crc32 are set to zero in the local header.
532 // The correct values are put in the data descriptor immediately
533 // following the compressed data.
534 bitflag |= 0x0008;
535 }
536 if (!useCustomEncoding && (useUTF8ForFileName || useUTF8ForComment)) {
537 // Bit 11: Language encoding flag (EFS).
538 bitflag |= 0x0800;
539 }
540
541
542 var extFileAttr = 0;
543 var versionMadeBy = 0;
544 if (dir) {
545 // dos or unix, we set the dos dir flag
546 extFileAttr |= 0x00010;
547 }
548 if(platform === "UNIX") {
549 versionMadeBy = 0x031E; // UNIX, version 3.0
550 extFileAttr |= generateUnixExternalFileAttr(file.unixPermissions, dir);
551 } else { // DOS or other, fallback to DOS
552 versionMadeBy = 0x0014; // DOS, version 2.0
553 extFileAttr |= generateDosExternalFileAttr(file.dosPermissions, dir);
554 }
555
556 // date
557 // @see http://www.delorie.com/djgpp/doc/rbinter/it/52/13.html
558 // @see http://www.delorie.com/djgpp/doc/rbinter/it/65/16.html
559 // @see http://www.delorie.com/djgpp/doc/rbinter/it/66/16.html
560
561 dosTime = date.getUTCHours();
562 dosTime = dosTime << 6;
563 dosTime = dosTime | date.getUTCMinutes();
564 dosTime = dosTime << 5;
565 dosTime = dosTime | date.getUTCSeconds() / 2;
566
567 dosDate = date.getUTCFullYear() - 1980;
568 dosDate = dosDate << 4;
569 dosDate = dosDate | (date.getUTCMonth() + 1);
570 dosDate = dosDate << 5;
571 dosDate = dosDate | date.getUTCDate();
572
573 if (useUTF8ForFileName) {
574 // set the unicode path extra field. unzip needs at least one extra
575 // field to correctly handle unicode path, so using the path is as good
576 // as any other information. This could improve the situation with
577 // other archive managers too.
578 // This field is usually used without the utf8 flag, with a non
579 // unicode path in the header (winrar, winzip). This helps (a bit)
580 // with the messy Windows' default compressed folders feature but
581 // breaks on p7zip which doesn't seek the unicode path extra field.
582 // So for now, UTF-8 everywhere !
583 unicodePathExtraField =
584 // Version
585 decToHex(1, 1) +
586 // NameCRC32
587 decToHex(crc32(encodedFileName), 4) +
588 // UnicodeName
589 utfEncodedFileName;
590
591 extraFields +=
592 // Info-ZIP Unicode Path Extra Field
593 "\x75\x70" +
594 // size
595 decToHex(unicodePathExtraField.length, 2) +
596 // content
597 unicodePathExtraField;
598 }
599
600 if(useUTF8ForComment) {
601
602 unicodeCommentExtraField =
603 // Version
604 decToHex(1, 1) +
605 // CommentCRC32
606 decToHex(crc32(encodedComment), 4) +
607 // UnicodeName
608 utfEncodedComment;
609
610 extraFields +=
611 // Info-ZIP Unicode Path Extra Field
612 "\x75\x63" +
613 // size
614 decToHex(unicodeCommentExtraField.length, 2) +
615 // content
616 unicodeCommentExtraField;
617 }
618
619 var header = "";
620
621 // version needed to extract
622 header += "\x0A\x00";
623 // general purpose bit flag
624 header += decToHex(bitflag, 2);
625 // compression method
626 header += compression.magic;
627 // last mod file time
628 header += decToHex(dosTime, 2);
629 // last mod file date
630 header += decToHex(dosDate, 2);
631 // crc-32
632 header += decToHex(dataInfo.crc32, 4);
633 // compressed size
634 header += decToHex(dataInfo.compressedSize, 4);
635 // uncompressed size
636 header += decToHex(dataInfo.uncompressedSize, 4);
637 // file name length
638 header += decToHex(encodedFileName.length, 2);
639 // extra field length
640 header += decToHex(extraFields.length, 2);
641
642
643 var fileRecord = signature.LOCAL_FILE_HEADER + header + encodedFileName + extraFields;
644
645 var dirRecord = signature.CENTRAL_FILE_HEADER +
646 // version made by (00: DOS)
647 decToHex(versionMadeBy, 2) +
648 // file header (common to file and central directory)
649 header +
650 // file comment length
651 decToHex(encodedComment.length, 2) +
652 // disk number start
653 "\x00\x00" +
654 // internal file attributes TODO
655 "\x00\x00" +
656 // external file attributes
657 decToHex(extFileAttr, 4) +
658 // relative offset of local header
659 decToHex(offset, 4) +
660 // file name
661 encodedFileName +
662 // extra field
663 extraFields +
664 // file comment
665 encodedComment;
666
667 return {
668 fileRecord: fileRecord,
669 dirRecord: dirRecord
670 };
671 };
672
673 /**
674 * Generate the EOCD record.
675 * @param {Number} entriesCount the number of entries in the zip file.
676 * @param {Number} centralDirLength the length (in bytes) of the central dir.
677 * @param {Number} localDirLength the length (in bytes) of the local dir.
678 * @param {String} comment the zip file comment as a binary string.
679 * @param {Function} encodeFileName the function to encode the comment.
680 * @return {String} the EOCD record.
681 */
682 var generateCentralDirectoryEnd = function (entriesCount, centralDirLength, localDirLength, comment, encodeFileName) {
683 var dirEnd = "";
684 var encodedComment = utils.transformTo("string", encodeFileName(comment));
685
686 // end of central dir signature
687 dirEnd = signature.CENTRAL_DIRECTORY_END +
688 // number of this disk
689 "\x00\x00" +
690 // number of the disk with the start of the central directory
691 "\x00\x00" +
692 // total number of entries in the central directory on this disk
693 decToHex(entriesCount, 2) +
694 // total number of entries in the central directory
695 decToHex(entriesCount, 2) +
696 // size of the central directory 4 bytes
697 decToHex(centralDirLength, 4) +
698 // offset of start of central directory with respect to the starting disk number
699 decToHex(localDirLength, 4) +
700 // .ZIP file comment length
701 decToHex(encodedComment.length, 2) +
702 // .ZIP file comment
703 encodedComment;
704
705 return dirEnd;
706 };
707
708 /**
709 * Generate data descriptors for a file entry.
710 * @param {Object} streamInfo the hash generated by a worker, containing informations
711 * on the file entry.
712 * @return {String} the data descriptors.
713 */
714 var generateDataDescriptors = function (streamInfo) {
715 var descriptor = "";
716 descriptor = signature.DATA_DESCRIPTOR +
717 // crc-32 4 bytes
718 decToHex(streamInfo['crc32'], 4) +
719 // compressed size 4 bytes
720 decToHex(streamInfo['compressedSize'], 4) +
721 // uncompressed size 4 bytes
722 decToHex(streamInfo['uncompressedSize'], 4);
723
724 return descriptor;
725 };
726
727
728 /**
729 * A worker to concatenate other workers to create a zip file.
730 * @param {Boolean} streamFiles `true` to stream the content of the files,
731 * `false` to accumulate it.
732 * @param {String} comment the comment to use.
733 * @param {String} platform the platform to use, "UNIX" or "DOS".
734 * @param {Function} encodeFileName the function to encode file names and comments.
735 */
736 function ZipFileWorker(streamFiles, comment, platform, encodeFileName) {
737 GenericWorker.call(this, "ZipFileWorker");
738 // The number of bytes written so far. This doesn't count accumulated chunks.
739 this.bytesWritten = 0;
740 // The comment of the zip file
741 this.zipComment = comment;
742 // The platform "generating" the zip file.
743 this.zipPlatform = platform;
744 // the function to encode file names and comments.
745 this.encodeFileName = encodeFileName;
746 // Should we stream the content of the files ?
747 this.streamFiles = streamFiles;
748 // If `streamFiles` is false, we will need to accumulate the content of the
749 // files to calculate sizes / crc32 (and write them *before* the content).
750 // This boolean indicates if we are accumulating chunks (it will change a lot
751 // during the lifetime of this worker).
752 this.accumulate = false;
753 // The buffer receiving chunks when accumulating content.
754 this.contentBuffer = [];
755 // The list of generated directory records.
756 this.dirRecords = [];
757 // The offset (in bytes) from the beginning of the zip file for the current source.
758 this.currentSourceOffset = 0;
759 // The total number of entries in this zip file.
760 this.entriesCount = 0;
761 // the name of the file currently being added, null when handling the end of the zip file.
762 // Used for the emited metadata.
763 this.currentFile = null;
764
765
766
767 this._sources = [];
768 }
769 utils.inherits(ZipFileWorker, GenericWorker);
770
771 /**
772 * @see GenericWorker.push
773 */
774 ZipFileWorker.prototype.push = function (chunk) {
775
776 var currentFilePercent = chunk.meta.percent || 0;
777 var entriesCount = this.entriesCount;
778 var remainingFiles = this._sources.length;
779
780 if(this.accumulate) {
781 this.contentBuffer.push(chunk);
782 } else {
783 this.bytesWritten += chunk.data.length;
784
785 GenericWorker.prototype.push.call(this, {
786 data : chunk.data,
787 meta : {
788 currentFile : this.currentFile,
789 percent : entriesCount ? (currentFilePercent + 100 * (entriesCount - remainingFiles - 1)) / entriesCount : 100
790 }
791 });
792 }
793 };
794
795 /**
796 * The worker started a new source (an other worker).
797 * @param {Object} streamInfo the streamInfo object from the new source.
798 */
799 ZipFileWorker.prototype.openedSource = function (streamInfo) {
800 this.currentSourceOffset = this.bytesWritten;
801 this.currentFile = streamInfo['file'].name;
802
803 var streamedContent = this.streamFiles && !streamInfo['file'].dir;
804
805 // don't stream folders (because they don't have any content)
806 if(streamedContent) {
807 var record = generateZipParts(streamInfo, streamedContent, false, this.currentSourceOffset, this.zipPlatform, this.encodeFileName);
808 this.push({
809 data : record.fileRecord,
810 meta : {percent:0}
811 });
812 } else {
813 // we need to wait for the whole file before pushing anything
814 this.accumulate = true;
815 }
816 };
817
818 /**
819 * The worker finished a source (an other worker).
820 * @param {Object} streamInfo the streamInfo object from the finished source.
821 */
822 ZipFileWorker.prototype.closedSource = function (streamInfo) {
823 this.accumulate = false;
824 var streamedContent = this.streamFiles && !streamInfo['file'].dir;
825 var record = generateZipParts(streamInfo, streamedContent, true, this.currentSourceOffset, this.zipPlatform, this.encodeFileName);
826
827 this.dirRecords.push(record.dirRecord);
828 if(streamedContent) {
829 // after the streamed file, we put data descriptors
830 this.push({
831 data : generateDataDescriptors(streamInfo),
832 meta : {percent:100}
833 });
834 } else {
835 // the content wasn't streamed, we need to push everything now
836 // first the file record, then the content
837 this.push({
838 data : record.fileRecord,
839 meta : {percent:0}
840 });
841 while(this.contentBuffer.length) {
842 this.push(this.contentBuffer.shift());
843 }
844 }
845 this.currentFile = null;
846 };
847
848 /**
849 * @see GenericWorker.flush
850 */
851 ZipFileWorker.prototype.flush = function () {
852
853 var localDirLength = this.bytesWritten;
854 for(var i = 0; i < this.dirRecords.length; i++) {
855 this.push({
856 data : this.dirRecords[i],
857 meta : {percent:100}
858 });
859 }
860 var centralDirLength = this.bytesWritten - localDirLength;
861
862 var dirEnd = generateCentralDirectoryEnd(this.dirRecords.length, centralDirLength, localDirLength, this.zipComment, this.encodeFileName);
863
864 this.push({
865 data : dirEnd,
866 meta : {percent:100}
867 });
868 };
869
870 /**
871 * Prepare the next source to be read.
872 */
873 ZipFileWorker.prototype.prepareNextSource = function () {
874 this.previous = this._sources.shift();
875 this.openedSource(this.previous.streamInfo);
876 if (this.isPaused) {
877 this.previous.pause();
878 } else {
879 this.previous.resume();
880 }
881 };
882
883 /**
884 * @see GenericWorker.registerPrevious
885 */
886 ZipFileWorker.prototype.registerPrevious = function (previous) {
887 this._sources.push(previous);
888 var self = this;
889
890 previous.on('data', function (chunk) {
891 self.processChunk(chunk);
892 });
893 previous.on('end', function () {
894 self.closedSource(self.previous.streamInfo);
895 if(self._sources.length) {
896 self.prepareNextSource();
897 } else {
898 self.end();
899 }
900 });
901 previous.on('error', function (e) {
902 self.error(e);
903 });
904 return this;
905 };
906
907 /**
908 * @see GenericWorker.resume
909 */
910 ZipFileWorker.prototype.resume = function () {
911 if(!GenericWorker.prototype.resume.call(this)) {
912 return false;
913 }
914
915 if (!this.previous && this._sources.length) {
916 this.prepareNextSource();
917 return true;
918 }
919 if (!this.previous && !this._sources.length && !this.generatedError) {
920 this.end();
921 return true;
922 }
923 };
924
925 /**
926 * @see GenericWorker.error
927 */
928 ZipFileWorker.prototype.error = function (e) {
929 var sources = this._sources;
930 if(!GenericWorker.prototype.error.call(this, e)) {
931 return false;
932 }
933 for(var i = 0; i < sources.length; i++) {
934 try {
935 sources[i].error(e);
936 } catch(e) {
937 // the `error` exploded, nothing to do
938 }
939 }
940 return true;
941 };
942
943 /**
944 * @see GenericWorker.lock
945 */
946 ZipFileWorker.prototype.lock = function () {
947 GenericWorker.prototype.lock.call(this);
948 var sources = this._sources;
949 for(var i = 0; i < sources.length; i++) {
950 sources[i].lock();
951 }
952 };
953
954 module.exports = ZipFileWorker;
955
956 },{"../crc32":4,"../signature":23,"../stream/GenericWorker":28,"../utf8":31,"../utils":32}],9:[function(require,module,exports){
957 'use strict';
958
959 var compressions = require('../compressions');
960 var ZipFileWorker = require('./ZipFileWorker');
961
962 /**
963 * Find the compression to use.
964 * @param {String} fileCompression the compression defined at the file level, if any.
965 * @param {String} zipCompression the compression defined at the load() level.
966 * @return {Object} the compression object to use.
967 */
968 var getCompression = function (fileCompression, zipCompression) {
969
970 var compressionName = fileCompression || zipCompression;
971 var compression = compressions[compressionName];
972 if (!compression) {
973 throw new Error(compressionName + " is not a valid compression method !");
974 }
975 return compression;
976 };
977
978 /**
979 * Create a worker to generate a zip file.
980 * @param {JSZip} zip the JSZip instance at the right root level.
981 * @param {Object} options to generate the zip file.
982 * @param {String} comment the comment to use.
983 */
984 exports.generateWorker = function (zip, options, comment) {
985
986 var zipFileWorker = new ZipFileWorker(options.streamFiles, comment, options.platform, options.encodeFileName);
987 var entriesCount = 0;
988 try {
989
990 zip.forEach(function (relativePath, file) {
991 entriesCount++;
992 var compression = getCompression(file.options.compression, options.compression);
993 var compressionOptions = file.options.compressionOptions || options.compressionOptions || {};
994 var dir = file.dir, date = file.date;
995
996 file._compressWorker(compression, compressionOptions)
997 .withStreamInfo("file", {
998 name : relativePath,
999 dir : dir,
1000 date : date,
1001 comment : file.comment || "",
1002 unixPermissions : file.unixPermissions,
1003 dosPermissions : file.dosPermissions
1004 })
1005 .pipe(zipFileWorker);
1006 });
1007 zipFileWorker.entriesCount = entriesCount;
1008 } catch (e) {
1009 zipFileWorker.error(e);
1010 }
1011
1012 return zipFileWorker;
1013 };
1014
1015 },{"../compressions":3,"./ZipFileWorker":8}],10:[function(require,module,exports){
1016 'use strict';
1017
1018 /**
1019 * Representation a of zip file in js
1020 * @constructor
1021 */
1022 function JSZip() {
1023 // if this constructor is used without `new`, it adds `new` before itself:
1024 if(!(this instanceof JSZip)) {
1025 return new JSZip();
1026 }
1027
1028 if(arguments.length) {
1029 throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");
1030 }
1031
1032 // object containing the files :
1033 // {
1034 // "folder/" : {...},
1035 // "folder/data.txt" : {...}
1036 // }
1037 this.files = {};
1038
1039 this.comment = null;
1040
1041 // Where we are in the hierarchy
1042 this.root = "";
1043 this.clone = function() {
1044 var newObj = new JSZip();
1045 for (var i in this) {
1046 if (typeof this[i] !== "function") {
1047 newObj[i] = this[i];
1048 }
1049 }
1050 return newObj;
1051 };
1052 }
1053 JSZip.prototype = require('./object');
1054 JSZip.prototype.loadAsync = require('./load');
1055 JSZip.support = require('./support');
1056 JSZip.defaults = require('./defaults');
1057
1058 // TODO find a better way to handle this version,
1059 // a require('package.json').version doesn't work with webpack, see #327
1060 JSZip.version = "3.2.0";
1061
1062 JSZip.loadAsync = function (content, options) {
1063 return new JSZip().loadAsync(content, options);
1064 };
1065
1066 JSZip.external = require("./external");
1067 module.exports = JSZip;
1068
1069 },{"./defaults":5,"./external":6,"./load":11,"./object":15,"./support":30}],11:[function(require,module,exports){
1070 'use strict';
1071 var utils = require('./utils');
1072 var external = require("./external");
1073 var utf8 = require('./utf8');
1074 var utils = require('./utils');
1075 var ZipEntries = require('./zipEntries');
1076 var Crc32Probe = require('./stream/Crc32Probe');
1077 var nodejsUtils = require("./nodejsUtils");
1078
1079 /**
1080 * Check the CRC32 of an entry.
1081 * @param {ZipEntry} zipEntry the zip entry to check.
1082 * @return {Promise} the result.
1083 */
1084 function checkEntryCRC32(zipEntry) {
1085 return new external.Promise(function (resolve, reject) {
1086 var worker = zipEntry.decompressed.getContentWorker().pipe(new Crc32Probe());
1087 worker.on("error", function (e) {
1088 reject(e);
1089 })
1090 .on("end", function () {
1091 if (worker.streamInfo.crc32 !== zipEntry.decompressed.crc32) {
1092 reject(new Error("Corrupted zip : CRC32 mismatch"));
1093 } else {
1094 resolve();
1095 }
1096 })
1097 .resume();
1098 });
1099 }
1100
1101 module.exports = function(data, options) {
1102 var zip = this;
1103 options = utils.extend(options || {}, {
1104 base64: false,
1105 checkCRC32: false,
1106 optimizedBinaryString: false,
1107 createFolders: false,
1108 decodeFileName: utf8.utf8decode
1109 });
1110
1111 if (nodejsUtils.isNode && nodejsUtils.isStream(data)) {
1112 return external.Promise.reject(new Error("JSZip can't accept a stream when loading a zip file."));
1113 }
1114
1115 return utils.prepareContent("the loaded zip file", data, true, options.optimizedBinaryString, options.base64)
1116 .then(function(data) {
1117 var zipEntries = new ZipEntries(options);
1118 zipEntries.load(data);
1119 return zipEntries;
1120 }).then(function checkCRC32(zipEntries) {
1121 var promises = [external.Promise.resolve(zipEntries)];
1122 var files = zipEntries.files;
1123 if (options.checkCRC32) {
1124 for (var i = 0; i < files.length; i++) {
1125 promises.push(checkEntryCRC32(files[i]));
1126 }
1127 }
1128 return external.Promise.all(promises);
1129 }).then(function addFiles(results) {
1130 var zipEntries = results.shift();
1131 var files = zipEntries.files;
1132 for (var i = 0; i < files.length; i++) {
1133 var input = files[i];
1134 zip.file(input.fileNameStr, input.decompressed, {
1135 binary: true,
1136 optimizedBinaryString: true,
1137 date: input.date,
1138 dir: input.dir,
1139 comment : input.fileCommentStr.length ? input.fileCommentStr : null,
1140 unixPermissions : input.unixPermissions,
1141 dosPermissions : input.dosPermissions,
1142 createFolders: options.createFolders
1143 });
1144 }
1145 if (zipEntries.zipComment.length) {
1146 zip.comment = zipEntries.zipComment;
1147 }
1148
1149 return zip;
1150 });
1151 };
1152
1153 },{"./external":6,"./nodejsUtils":14,"./stream/Crc32Probe":25,"./utf8":31,"./utils":32,"./zipEntries":33}],12:[function(require,module,exports){
1154 "use strict";
1155
1156 var utils = require('../utils');
1157 var GenericWorker = require('../stream/GenericWorker');
1158
1159 /**
1160 * A worker that use a nodejs stream as source.
1161 * @constructor
1162 * @param {String} filename the name of the file entry for this stream.
1163 * @param {Readable} stream the nodejs stream.
1164 */
1165 function NodejsStreamInputAdapter(filename, stream) {
1166 GenericWorker.call(this, "Nodejs stream input adapter for " + filename);
1167 this._upstreamEnded = false;
1168 this._bindStream(stream);
1169 }
1170
1171 utils.inherits(NodejsStreamInputAdapter, GenericWorker);
1172
1173 /**
1174 * Prepare the stream and bind the callbacks on it.
1175 * Do this ASAP on node 0.10 ! A lazy binding doesn't always work.
1176 * @param {Stream} stream the nodejs stream to use.
1177 */
1178 NodejsStreamInputAdapter.prototype._bindStream = function (stream) {
1179 var self = this;
1180 this._stream = stream;
1181 stream.pause();
1182 stream
1183 .on("data", function (chunk) {
1184 self.push({
1185 data: chunk,
1186 meta : {
1187 percent : 0
1188 }
1189 });
1190 })
1191 .on("error", function (e) {
1192 if(self.isPaused) {
1193 this.generatedError = e;
1194 } else {
1195 self.error(e);
1196 }
1197 })
1198 .on("end", function () {
1199 if(self.isPaused) {
1200 self._upstreamEnded = true;
1201 } else {
1202 self.end();
1203 }
1204 });
1205 };
1206 NodejsStreamInputAdapter.prototype.pause = function () {
1207 if(!GenericWorker.prototype.pause.call(this)) {
1208 return false;
1209 }
1210 this._stream.pause();
1211 return true;
1212 };
1213 NodejsStreamInputAdapter.prototype.resume = function () {
1214 if(!GenericWorker.prototype.resume.call(this)) {
1215 return false;
1216 }
1217
1218 if(this._upstreamEnded) {
1219 this.end();
1220 } else {
1221 this._stream.resume();
1222 }
1223
1224 return true;
1225 };
1226
1227 module.exports = NodejsStreamInputAdapter;
1228
1229 },{"../stream/GenericWorker":28,"../utils":32}],13:[function(require,module,exports){
1230 'use strict';
1231
1232 var Readable = require('readable-stream').Readable;
1233
1234 var utils = require('../utils');
1235 utils.inherits(NodejsStreamOutputAdapter, Readable);
1236
1237 /**
1238 * A nodejs stream using a worker as source.
1239 * @see the SourceWrapper in http://nodejs.org/api/stream.html
1240 * @constructor
1241 * @param {StreamHelper} helper the helper wrapping the worker
1242 * @param {Object} options the nodejs stream options
1243 * @param {Function} updateCb the update callback.
1244 */
1245 function NodejsStreamOutputAdapter(helper, options, updateCb) {
1246 Readable.call(this, options);
1247 this._helper = helper;
1248
1249 var self = this;
1250 helper.on("data", function (data, meta) {
1251 if (!self.push(data)) {
1252 self._helper.pause();
1253 }
1254 if(updateCb) {
1255 updateCb(meta);
1256 }
1257 })
1258 .on("error", function(e) {
1259 self.emit('error', e);
1260 })
1261 .on("end", function () {
1262 self.push(null);
1263 });
1264 }
1265
1266
1267 NodejsStreamOutputAdapter.prototype._read = function() {
1268 this._helper.resume();
1269 };
1270
1271 module.exports = NodejsStreamOutputAdapter;
1272
1273 },{"../utils":32,"readable-stream":16}],14:[function(require,module,exports){
1274 'use strict';
1275
1276 module.exports = {
1277 /**
1278 * True if this is running in Nodejs, will be undefined in a browser.
1279 * In a browser, browserify won't include this file and the whole module
1280 * will be resolved an empty object.
1281 */
1282 isNode : typeof Buffer !== "undefined",
1283 /**
1284 * Create a new nodejs Buffer from an existing content.
1285 * @param {Object} data the data to pass to the constructor.
1286 * @param {String} encoding the encoding to use.
1287 * @return {Buffer} a new Buffer.
1288 */
1289 newBufferFrom: function(data, encoding) {
1290 if (Buffer.from && Buffer.from !== Uint8Array.from) {
1291 return Buffer.from(data, encoding);
1292 } else {
1293 if (typeof data === "number") {
1294 // Safeguard for old Node.js versions. On newer versions,
1295 // Buffer.from(number) / Buffer(number, encoding) already throw.
1296 throw new Error("The \"data\" argument must not be a number");
1297 }
1298 return new Buffer(data, encoding);
1299 }
1300 },
1301 /**
1302 * Create a new nodejs Buffer with the specified size.
1303 * @param {Integer} size the size of the buffer.
1304 * @return {Buffer} a new Buffer.
1305 */
1306 allocBuffer: function (size) {
1307 if (Buffer.alloc) {
1308 return Buffer.alloc(size);
1309 } else {
1310 var buf = new Buffer(size);
1311 buf.fill(0);
1312 return buf;
1313 }
1314 },
1315 /**
1316 * Find out if an object is a Buffer.
1317 * @param {Object} b the object to test.
1318 * @return {Boolean} true if the object is a Buffer, false otherwise.
1319 */
1320 isBuffer : function(b){
1321 return Buffer.isBuffer(b);
1322 },
1323
1324 isStream : function (obj) {
1325 return obj &&
1326 typeof obj.on === "function" &&
1327 typeof obj.pause === "function" &&
1328 typeof obj.resume === "function";
1329 }
1330 };
1331
1332 },{}],15:[function(require,module,exports){
1333 'use strict';
1334 var utf8 = require('./utf8');
1335 var utils = require('./utils');
1336 var GenericWorker = require('./stream/GenericWorker');
1337 var StreamHelper = require('./stream/StreamHelper');
1338 var defaults = require('./defaults');
1339 var CompressedObject = require('./compressedObject');
1340 var ZipObject = require('./zipObject');
1341 var generate = require("./generate");
1342 var nodejsUtils = require("./nodejsUtils");
1343 var NodejsStreamInputAdapter = require("./nodejs/NodejsStreamInputAdapter");
1344
1345
1346 /**
1347 * Add a file in the current folder.
1348 * @private
1349 * @param {string} name the name of the file
1350 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data of the file
1351 * @param {Object} originalOptions the options of the file
1352 * @return {Object} the new file.
1353 */
1354 var fileAdd = function(name, data, originalOptions) {
1355 // be sure sub folders exist
1356 var dataType = utils.getTypeOf(data),
1357 parent;
1358
1359
1360 /*
1361 * Correct options.
1362 */
1363
1364 var o = utils.extend(originalOptions || {}, defaults);
1365 o.date = o.date || new Date();
1366 if (o.compression !== null) {
1367 o.compression = o.compression.toUpperCase();
1368 }
1369
1370 if (typeof o.unixPermissions === "string") {
1371 o.unixPermissions = parseInt(o.unixPermissions, 8);
1372 }
1373
1374 // UNX_IFDIR 0040000 see zipinfo.c
1375 if (o.unixPermissions && (o.unixPermissions & 0x4000)) {
1376 o.dir = true;
1377 }
1378 // Bit 4 Directory
1379 if (o.dosPermissions && (o.dosPermissions & 0x0010)) {
1380 o.dir = true;
1381 }
1382
1383 if (o.dir) {
1384 name = forceTrailingSlash(name);
1385 }
1386 if (o.createFolders && (parent = parentFolder(name))) {
1387 folderAdd.call(this, parent, true);
1388 }
1389
1390 var isUnicodeString = dataType === "string" && o.binary === false && o.base64 === false;
1391 if (!originalOptions || typeof originalOptions.binary === "undefined") {
1392 o.binary = !isUnicodeString;
1393 }
1394
1395
1396 var isCompressedEmpty = (data instanceof CompressedObject) && data.uncompressedSize === 0;
1397
1398 if (isCompressedEmpty || o.dir || !data || data.length === 0) {
1399 o.base64 = false;
1400 o.binary = true;
1401 data = "";
1402 o.compression = "STORE";
1403 dataType = "string";
1404 }
1405
1406 /*
1407 * Convert content to fit.
1408 */
1409
1410 var zipObjectContent = null;
1411 if (data instanceof CompressedObject || data instanceof GenericWorker) {
1412 zipObjectContent = data;
1413 } else if (nodejsUtils.isNode && nodejsUtils.isStream(data)) {
1414 zipObjectContent = new NodejsStreamInputAdapter(name, data);
1415 } else {
1416 zipObjectContent = utils.prepareContent(name, data, o.binary, o.optimizedBinaryString, o.base64);
1417 }
1418
1419 var object = new ZipObject(name, zipObjectContent, o);
1420 this.files[name] = object;
1421 /*
1422 TODO: we can't throw an exception because we have async promises
1423 (we can have a promise of a Date() for example) but returning a
1424 promise is useless because file(name, data) returns the JSZip
1425 object for chaining. Should we break that to allow the user
1426 to catch the error ?
1427
1428 return external.Promise.resolve(zipObjectContent)
1429 .then(function () {
1430 return object;
1431 });
1432 */
1433 };
1434
1435 /**
1436 * Find the parent folder of the path.
1437 * @private
1438 * @param {string} path the path to use
1439 * @return {string} the parent folder, or ""
1440 */
1441 var parentFolder = function (path) {
1442 if (path.slice(-1) === '/') {
1443 path = path.substring(0, path.length - 1);
1444 }
1445 var lastSlash = path.lastIndexOf('/');
1446 return (lastSlash > 0) ? path.substring(0, lastSlash) : "";
1447 };
1448
1449 /**
1450 * Returns the path with a slash at the end.
1451 * @private
1452 * @param {String} path the path to check.
1453 * @return {String} the path with a trailing slash.
1454 */
1455 var forceTrailingSlash = function(path) {
1456 // Check the name ends with a /
1457 if (path.slice(-1) !== "/") {
1458 path += "/"; // IE doesn't like substr(-1)
1459 }
1460 return path;
1461 };
1462
1463 /**
1464 * Add a (sub) folder in the current folder.
1465 * @private
1466 * @param {string} name the folder's name
1467 * @param {boolean=} [createFolders] If true, automatically create sub
1468 * folders. Defaults to false.
1469 * @return {Object} the new folder.
1470 */
1471 var folderAdd = function(name, createFolders) {
1472 createFolders = (typeof createFolders !== 'undefined') ? createFolders : defaults.createFolders;
1473
1474 name = forceTrailingSlash(name);
1475
1476 // Does this folder already exist?
1477 if (!this.files[name]) {
1478 fileAdd.call(this, name, null, {
1479 dir: true,
1480 createFolders: createFolders
1481 });
1482 }
1483 return this.files[name];
1484 };
1485
1486 /**
1487 * Cross-window, cross-Node-context regular expression detection
1488 * @param {Object} object Anything
1489 * @return {Boolean} true if the object is a regular expression,
1490 * false otherwise
1491 */
1492 function isRegExp(object) {
1493 return Object.prototype.toString.call(object) === "[object RegExp]";
1494 }
1495
1496 // return the actual prototype of JSZip
1497 var out = {
1498 /**
1499 * @see loadAsync
1500 */
1501 load: function() {
1502 throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
1503 },
1504
1505
1506 /**
1507 * Call a callback function for each entry at this folder level.
1508 * @param {Function} cb the callback function:
1509 * function (relativePath, file) {...}
1510 * It takes 2 arguments : the relative path and the file.
1511 */
1512 forEach: function(cb) {
1513 var filename, relativePath, file;
1514 for (filename in this.files) {
1515 if (!this.files.hasOwnProperty(filename)) {
1516 continue;
1517 }
1518 file = this.files[filename];
1519 relativePath = filename.slice(this.root.length, filename.length);
1520 if (relativePath && filename.slice(0, this.root.length) === this.root) { // the file is in the current root
1521 cb(relativePath, file); // TODO reverse the parameters ? need to be clean AND consistent with the filter search fn...
1522 }
1523 }
1524 },
1525
1526 /**
1527 * Filter nested files/folders with the specified function.
1528 * @param {Function} search the predicate to use :
1529 * function (relativePath, file) {...}
1530 * It takes 2 arguments : the relative path and the file.
1531 * @return {Array} An array of matching elements.
1532 */
1533 filter: function(search) {
1534 var result = [];
1535 this.forEach(function (relativePath, entry) {
1536 if (search(relativePath, entry)) { // the file matches the function
1537 result.push(entry);
1538 }
1539
1540 });
1541 return result;
1542 },
1543
1544 /**
1545 * Add a file to the zip file, or search a file.
1546 * @param {string|RegExp} name The name of the file to add (if data is defined),
1547 * the name of the file to find (if no data) or a regex to match files.
1548 * @param {String|ArrayBuffer|Uint8Array|Buffer} data The file data, either raw or base64 encoded
1549 * @param {Object} o File options
1550 * @return {JSZip|Object|Array} this JSZip object (when adding a file),
1551 * a file (when searching by string) or an array of files (when searching by regex).
1552 */
1553 file: function(name, data, o) {
1554 if (arguments.length === 1) {
1555 if (isRegExp(name)) {
1556 var regexp = name;
1557 return this.filter(function(relativePath, file) {
1558 return !file.dir && regexp.test(relativePath);
1559 });
1560 }
1561 else { // text
1562 var obj = this.files[this.root + name];
1563 if (obj && !obj.dir) {
1564 return obj;
1565 } else {
1566 return null;
1567 }
1568 }
1569 }
1570 else { // more than one argument : we have data !
1571 name = this.root + name;
1572 fileAdd.call(this, name, data, o);
1573 }
1574 return this;
1575 },
1576
1577 /**
1578 * Add a directory to the zip file, or search.
1579 * @param {String|RegExp} arg The name of the directory to add, or a regex to search folders.
1580 * @return {JSZip} an object with the new directory as the root, or an array containing matching folders.
1581 */
1582 folder: function(arg) {
1583 if (!arg) {
1584 return this;
1585 }
1586
1587 if (isRegExp(arg)) {
1588 return this.filter(function(relativePath, file) {
1589 return file.dir && arg.test(relativePath);
1590 });
1591 }
1592
1593 // else, name is a new folder
1594 var name = this.root + arg;
1595 var newFolder = folderAdd.call(this, name);
1596
1597 // Allow chaining by returning a new object with this folder as the root
1598 var ret = this.clone();
1599 ret.root = newFolder.name;
1600 return ret;
1601 },
1602
1603 /**
1604 * Delete a file, or a directory and all sub-files, from the zip
1605 * @param {string} name the name of the file to delete
1606 * @return {JSZip} this JSZip object
1607 */
1608 remove: function(name) {
1609 name = this.root + name;
1610 var file = this.files[name];
1611 if (!file) {
1612 // Look for any folders
1613 if (name.slice(-1) !== "/") {
1614 name += "/";
1615 }
1616 file = this.files[name];
1617 }
1618
1619 if (file && !file.dir) {
1620 // file
1621 delete this.files[name];
1622 } else {
1623 // maybe a folder, delete recursively
1624 var kids = this.filter(function(relativePath, file) {
1625 return file.name.slice(0, name.length) === name;
1626 });
1627 for (var i = 0; i < kids.length; i++) {
1628 delete this.files[kids[i].name];
1629 }
1630 }
1631
1632 return this;
1633 },
1634
1635 /**
1636 * Generate the complete zip file
1637 * @param {Object} options the options to generate the zip file :
1638 * - compression, "STORE" by default.
1639 * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
1640 * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the zip file
1641 */
1642 generate: function(options) {
1643 throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
1644 },
1645
1646 /**
1647 * Generate the complete zip file as an internal stream.
1648 * @param {Object} options the options to generate the zip file :
1649 * - compression, "STORE" by default.
1650 * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
1651 * @return {StreamHelper} the streamed zip file.
1652 */
1653 generateInternalStream: function(options) {
1654 var worker, opts = {};
1655 try {
1656 opts = utils.extend(options || {}, {
1657 streamFiles: false,
1658 compression: "STORE",
1659 compressionOptions : null,
1660 type: "",
1661 platform: "DOS",
1662 comment: null,
1663 mimeType: 'application/zip',
1664 encodeFileName: utf8.utf8encode
1665 });
1666
1667 opts.type = opts.type.toLowerCase();
1668 opts.compression = opts.compression.toUpperCase();
1669
1670 // "binarystring" is prefered but the internals use "string".
1671 if(opts.type === "binarystring") {
1672 opts.type = "string";
1673 }
1674
1675 if (!opts.type) {
1676 throw new Error("No output type specified.");
1677 }
1678
1679 utils.checkSupport(opts.type);
1680
1681 // accept nodejs `process.platform`
1682 if(
1683 opts.platform === 'darwin' ||
1684 opts.platform === 'freebsd' ||
1685 opts.platform === 'linux' ||
1686 opts.platform === 'sunos'
1687 ) {
1688 opts.platform = "UNIX";
1689 }
1690 if (opts.platform === 'win32') {
1691 opts.platform = "DOS";
1692 }
1693
1694 var comment = opts.comment || this.comment || "";
1695 worker = generate.generateWorker(this, opts, comment);
1696 } catch (e) {
1697 worker = new GenericWorker("error");
1698 worker.error(e);
1699 }
1700 return new StreamHelper(worker, opts.type || "string", opts.mimeType);
1701 },
1702 /**
1703 * Generate the complete zip file asynchronously.
1704 * @see generateInternalStream
1705 */
1706 generateAsync: function(options, onUpdate) {
1707 return this.generateInternalStream(options).accumulate(onUpdate);
1708 },
1709 /**
1710 * Generate the complete zip file asynchronously.
1711 * @see generateInternalStream
1712 */
1713 generateNodeStream: function(options, onUpdate) {
1714 options = options || {};
1715 if (!options.type) {
1716 options.type = "nodebuffer";
1717 }
1718 return this.generateInternalStream(options).toNodejsStream(onUpdate);
1719 }
1720 };
1721 module.exports = out;
1722
1723 },{"./compressedObject":2,"./defaults":5,"./generate":9,"./nodejs/NodejsStreamInputAdapter":12,"./nodejsUtils":14,"./stream/GenericWorker":28,"./stream/StreamHelper":29,"./utf8":31,"./utils":32,"./zipObject":35}],16:[function(require,module,exports){
1724 /*
1725 * This file is used by module bundlers (browserify/webpack/etc) when
1726 * including a stream implementation. We use "readable-stream" to get a
1727 * consistent behavior between nodejs versions but bundlers often have a shim
1728 * for "stream". Using this shim greatly improve the compatibility and greatly
1729 * reduce the final size of the bundle (only one stream implementation, not
1730 * two).
1731 */
1732 module.exports = require("stream");
1733
1734 },{"stream":undefined}],17:[function(require,module,exports){
1735 'use strict';
1736 var DataReader = require('./DataReader');
1737 var utils = require('../utils');
1738
1739 function ArrayReader(data) {
1740 DataReader.call(this, data);
1741 for(var i = 0; i < this.data.length; i++) {
1742 data[i] = data[i] & 0xFF;
1743 }
1744 }
1745 utils.inherits(ArrayReader, DataReader);
1746 /**
1747 * @see DataReader.byteAt
1748 */
1749 ArrayReader.prototype.byteAt = function(i) {
1750 return this.data[this.zero + i];
1751 };
1752 /**
1753 * @see DataReader.lastIndexOfSignature
1754 */
1755 ArrayReader.prototype.lastIndexOfSignature = function(sig) {
1756 var sig0 = sig.charCodeAt(0),
1757 sig1 = sig.charCodeAt(1),
1758 sig2 = sig.charCodeAt(2),
1759 sig3 = sig.charCodeAt(3);
1760 for (var i = this.length - 4; i >= 0; --i) {
1761 if (this.data[i] === sig0 && this.data[i + 1] === sig1 && this.data[i + 2] === sig2 && this.data[i + 3] === sig3) {
1762 return i - this.zero;
1763 }
1764 }
1765
1766 return -1;
1767 };
1768 /**
1769 * @see DataReader.readAndCheckSignature
1770 */
1771 ArrayReader.prototype.readAndCheckSignature = function (sig) {
1772 var sig0 = sig.charCodeAt(0),
1773 sig1 = sig.charCodeAt(1),
1774 sig2 = sig.charCodeAt(2),
1775 sig3 = sig.charCodeAt(3),
1776 data = this.readData(4);
1777 return sig0 === data[0] && sig1 === data[1] && sig2 === data[2] && sig3 === data[3];
1778 };
1779 /**
1780 * @see DataReader.readData
1781 */
1782 ArrayReader.prototype.readData = function(size) {
1783 this.checkOffset(size);
1784 if(size === 0) {
1785 return [];
1786 }
1787 var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
1788 this.index += size;
1789 return result;
1790 };
1791 module.exports = ArrayReader;
1792
1793 },{"../utils":32,"./DataReader":18}],18:[function(require,module,exports){
1794 'use strict';
1795 var utils = require('../utils');
1796
1797 function DataReader(data) {
1798 this.data = data; // type : see implementation
1799 this.length = data.length;
1800 this.index = 0;
1801 this.zero = 0;
1802 }
1803 DataReader.prototype = {
1804 /**
1805 * Check that the offset will not go too far.
1806 * @param {string} offset the additional offset to check.
1807 * @throws {Error} an Error if the offset is out of bounds.
1808 */
1809 checkOffset: function(offset) {
1810 this.checkIndex(this.index + offset);
1811 },
1812 /**
1813 * Check that the specified index will not be too far.
1814 * @param {string} newIndex the index to check.
1815 * @throws {Error} an Error if the index is out of bounds.
1816 */
1817 checkIndex: function(newIndex) {
1818 if (this.length < this.zero + newIndex || newIndex < 0) {
1819 throw new Error("End of data reached (data length = " + this.length + ", asked index = " + (newIndex) + "). Corrupted zip ?");
1820 }
1821 },
1822 /**
1823 * Change the index.
1824 * @param {number} newIndex The new index.
1825 * @throws {Error} if the new index is out of the data.
1826 */
1827 setIndex: function(newIndex) {
1828 this.checkIndex(newIndex);
1829 this.index = newIndex;
1830 },
1831 /**
1832 * Skip the next n bytes.
1833 * @param {number} n the number of bytes to skip.
1834 * @throws {Error} if the new index is out of the data.
1835 */
1836 skip: function(n) {
1837 this.setIndex(this.index + n);
1838 },
1839 /**
1840 * Get the byte at the specified index.
1841 * @param {number} i the index to use.
1842 * @return {number} a byte.
1843 */
1844 byteAt: function(i) {
1845 // see implementations
1846 },
1847 /**
1848 * Get the next number with a given byte size.
1849 * @param {number} size the number of bytes to read.
1850 * @return {number} the corresponding number.
1851 */
1852 readInt: function(size) {
1853 var result = 0,
1854 i;
1855 this.checkOffset(size);
1856 for (i = this.index + size - 1; i >= this.index; i--) {
1857 result = (result << 8) + this.byteAt(i);
1858 }
1859 this.index += size;
1860 return result;
1861 },
1862 /**
1863 * Get the next string with a given byte size.
1864 * @param {number} size the number of bytes to read.
1865 * @return {string} the corresponding string.
1866 */
1867 readString: function(size) {
1868 return utils.transformTo("string", this.readData(size));
1869 },
1870 /**
1871 * Get raw data without conversion, <size> bytes.
1872 * @param {number} size the number of bytes to read.
1873 * @return {Object} the raw data, implementation specific.
1874 */
1875 readData: function(size) {
1876 // see implementations
1877 },
1878 /**
1879 * Find the last occurence of a zip signature (4 bytes).
1880 * @param {string} sig the signature to find.
1881 * @return {number} the index of the last occurence, -1 if not found.
1882 */
1883 lastIndexOfSignature: function(sig) {
1884 // see implementations
1885 },
1886 /**
1887 * Read the signature (4 bytes) at the current position and compare it with sig.
1888 * @param {string} sig the expected signature
1889 * @return {boolean} true if the signature matches, false otherwise.
1890 */
1891 readAndCheckSignature: function(sig) {
1892 // see implementations
1893 },
1894 /**
1895 * Get the next date.
1896 * @return {Date} the date.
1897 */
1898 readDate: function() {
1899 var dostime = this.readInt(4);
1900 return new Date(Date.UTC(
1901 ((dostime >> 25) & 0x7f) + 1980, // year
1902 ((dostime >> 21) & 0x0f) - 1, // month
1903 (dostime >> 16) & 0x1f, // day
1904 (dostime >> 11) & 0x1f, // hour
1905 (dostime >> 5) & 0x3f, // minute
1906 (dostime & 0x1f) << 1)); // second
1907 }
1908 };
1909 module.exports = DataReader;
1910
1911 },{"../utils":32}],19:[function(require,module,exports){
1912 'use strict';
1913 var Uint8ArrayReader = require('./Uint8ArrayReader');
1914 var utils = require('../utils');
1915
1916 function NodeBufferReader(data) {
1917 Uint8ArrayReader.call(this, data);
1918 }
1919 utils.inherits(NodeBufferReader, Uint8ArrayReader);
1920
1921 /**
1922 * @see DataReader.readData
1923 */
1924 NodeBufferReader.prototype.readData = function(size) {
1925 this.checkOffset(size);
1926 var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
1927 this.index += size;
1928 return result;
1929 };
1930 module.exports = NodeBufferReader;
1931
1932 },{"../utils":32,"./Uint8ArrayReader":21}],20:[function(require,module,exports){
1933 'use strict';
1934 var DataReader = require('./DataReader');
1935 var utils = require('../utils');
1936
1937 function StringReader(data) {
1938 DataReader.call(this, data);
1939 }
1940 utils.inherits(StringReader, DataReader);
1941 /**
1942 * @see DataReader.byteAt
1943 */
1944 StringReader.prototype.byteAt = function(i) {
1945 return this.data.charCodeAt(this.zero + i);
1946 };
1947 /**
1948 * @see DataReader.lastIndexOfSignature
1949 */
1950 StringReader.prototype.lastIndexOfSignature = function(sig) {
1951 return this.data.lastIndexOf(sig) - this.zero;
1952 };
1953 /**
1954 * @see DataReader.readAndCheckSignature
1955 */
1956 StringReader.prototype.readAndCheckSignature = function (sig) {
1957 var data = this.readData(4);
1958 return sig === data;
1959 };
1960 /**
1961 * @see DataReader.readData
1962 */
1963 StringReader.prototype.readData = function(size) {
1964 this.checkOffset(size);
1965 // this will work because the constructor applied the "& 0xff" mask.
1966 var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
1967 this.index += size;
1968 return result;
1969 };
1970 module.exports = StringReader;
1971
1972 },{"../utils":32,"./DataReader":18}],21:[function(require,module,exports){
1973 'use strict';
1974 var ArrayReader = require('./ArrayReader');
1975 var utils = require('../utils');
1976
1977 function Uint8ArrayReader(data) {
1978 ArrayReader.call(this, data);
1979 }
1980 utils.inherits(Uint8ArrayReader, ArrayReader);
1981 /**
1982 * @see DataReader.readData
1983 */
1984 Uint8ArrayReader.prototype.readData = function(size) {
1985 this.checkOffset(size);
1986 if(size === 0) {
1987 // in IE10, when using subarray(idx, idx), we get the array [0x00] instead of [].
1988 return new Uint8Array(0);
1989 }
1990 var result = this.data.subarray(this.zero + this.index, this.zero + this.index + size);
1991 this.index += size;
1992 return result;
1993 };
1994 module.exports = Uint8ArrayReader;
1995
1996 },{"../utils":32,"./ArrayReader":17}],22:[function(require,module,exports){
1997 'use strict';
1998
1999 var utils = require('../utils');
2000 var support = require('../support');
2001 var ArrayReader = require('./ArrayReader');
2002 var StringReader = require('./StringReader');
2003 var NodeBufferReader = require('./NodeBufferReader');
2004 var Uint8ArrayReader = require('./Uint8ArrayReader');
2005
2006 /**
2007 * Create a reader adapted to the data.
2008 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data to read.
2009 * @return {DataReader} the data reader.
2010 */
2011 module.exports = function (data) {
2012 var type = utils.getTypeOf(data);
2013 utils.checkSupport(type);
2014 if (type === "string" && !support.uint8array) {
2015 return new StringReader(data);
2016 }
2017 if (type === "nodebuffer") {
2018 return new NodeBufferReader(data);
2019 }
2020 if (support.uint8array) {
2021 return new Uint8ArrayReader(utils.transformTo("uint8array", data));
2022 }
2023 return new ArrayReader(utils.transformTo("array", data));
2024 };
2025
2026 },{"../support":30,"../utils":32,"./ArrayReader":17,"./NodeBufferReader":19,"./StringReader":20,"./Uint8ArrayReader":21}],23:[function(require,module,exports){
2027 'use strict';
2028 exports.LOCAL_FILE_HEADER = "PK\x03\x04";
2029 exports.CENTRAL_FILE_HEADER = "PK\x01\x02";
2030 exports.CENTRAL_DIRECTORY_END = "PK\x05\x06";
2031 exports.ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x06\x07";
2032 exports.ZIP64_CENTRAL_DIRECTORY_END = "PK\x06\x06";
2033 exports.DATA_DESCRIPTOR = "PK\x07\x08";
2034
2035 },{}],24:[function(require,module,exports){
2036 'use strict';
2037
2038 var GenericWorker = require('./GenericWorker');
2039 var utils = require('../utils');
2040
2041 /**
2042 * A worker which convert chunks to a specified type.
2043 * @constructor
2044 * @param {String} destType the destination type.
2045 */
2046 function ConvertWorker(destType) {
2047 GenericWorker.call(this, "ConvertWorker to " + destType);
2048 this.destType = destType;
2049 }
2050 utils.inherits(ConvertWorker, GenericWorker);
2051
2052 /**
2053 * @see GenericWorker.processChunk
2054 */
2055 ConvertWorker.prototype.processChunk = function (chunk) {
2056 this.push({
2057 data : utils.transformTo(this.destType, chunk.data),
2058 meta : chunk.meta
2059 });
2060 };
2061 module.exports = ConvertWorker;
2062
2063 },{"../utils":32,"./GenericWorker":28}],25:[function(require,module,exports){
2064 'use strict';
2065
2066 var GenericWorker = require('./GenericWorker');
2067 var crc32 = require('../crc32');
2068 var utils = require('../utils');
2069
2070 /**
2071 * A worker which calculate the crc32 of the data flowing through.
2072 * @constructor
2073 */
2074 function Crc32Probe() {
2075 GenericWorker.call(this, "Crc32Probe");
2076 this.withStreamInfo("crc32", 0);
2077 }
2078 utils.inherits(Crc32Probe, GenericWorker);
2079
2080 /**
2081 * @see GenericWorker.processChunk
2082 */
2083 Crc32Probe.prototype.processChunk = function (chunk) {
2084 this.streamInfo.crc32 = crc32(chunk.data, this.streamInfo.crc32 || 0);
2085 this.push(chunk);
2086 };
2087 module.exports = Crc32Probe;
2088
2089 },{"../crc32":4,"../utils":32,"./GenericWorker":28}],26:[function(require,module,exports){
2090 'use strict';
2091
2092 var utils = require('../utils');
2093 var GenericWorker = require('./GenericWorker');
2094
2095 /**
2096 * A worker which calculate the total length of the data flowing through.
2097 * @constructor
2098 * @param {String} propName the name used to expose the length
2099 */
2100 function DataLengthProbe(propName) {
2101 GenericWorker.call(this, "DataLengthProbe for " + propName);
2102 this.propName = propName;
2103 this.withStreamInfo(propName, 0);
2104 }
2105 utils.inherits(DataLengthProbe, GenericWorker);
2106
2107 /**
2108 * @see GenericWorker.processChunk
2109 */
2110 DataLengthProbe.prototype.processChunk = function (chunk) {
2111 if(chunk) {
2112 var length = this.streamInfo[this.propName] || 0;
2113 this.streamInfo[this.propName] = length + chunk.data.length;
2114 }
2115 GenericWorker.prototype.processChunk.call(this, chunk);
2116 };
2117 module.exports = DataLengthProbe;
2118
2119
2120 },{"../utils":32,"./GenericWorker":28}],27:[function(require,module,exports){
2121 'use strict';
2122
2123 var utils = require('../utils');
2124 var GenericWorker = require('./GenericWorker');
2125
2126 // the size of the generated chunks
2127 // TODO expose this as a public variable
2128 var DEFAULT_BLOCK_SIZE = 16 * 1024;
2129
2130 /**
2131 * A worker that reads a content and emits chunks.
2132 * @constructor
2133 * @param {Promise} dataP the promise of the data to split
2134 */
2135 function DataWorker(dataP) {
2136 GenericWorker.call(this, "DataWorker");
2137 var self = this;
2138 this.dataIsReady = false;
2139 this.index = 0;
2140 this.max = 0;
2141 this.data = null;
2142 this.type = "";
2143
2144 this._tickScheduled = false;
2145
2146 dataP.then(function (data) {
2147 self.dataIsReady = true;
2148 self.data = data;
2149 self.max = data && data.length || 0;
2150 self.type = utils.getTypeOf(data);
2151 if(!self.isPaused) {
2152 self._tickAndRepeat();
2153 }
2154 }, function (e) {
2155 self.error(e);
2156 });
2157 }
2158
2159 utils.inherits(DataWorker, GenericWorker);
2160
2161 /**
2162 * @see GenericWorker.cleanUp
2163 */
2164 DataWorker.prototype.cleanUp = function () {
2165 GenericWorker.prototype.cleanUp.call(this);
2166 this.data = null;
2167 };
2168
2169 /**
2170 * @see GenericWorker.resume
2171 */
2172 DataWorker.prototype.resume = function () {
2173 if(!GenericWorker.prototype.resume.call(this)) {
2174 return false;
2175 }
2176
2177 if (!this._tickScheduled && this.dataIsReady) {
2178 this._tickScheduled = true;
2179 utils.delay(this._tickAndRepeat, [], this);
2180 }
2181 return true;
2182 };
2183
2184 /**
2185 * Trigger a tick a schedule an other call to this function.
2186 */
2187 DataWorker.prototype._tickAndRepeat = function() {
2188 this._tickScheduled = false;
2189 if(this.isPaused || this.isFinished) {
2190 return;
2191 }
2192 this._tick();
2193 if(!this.isFinished) {
2194 utils.delay(this._tickAndRepeat, [], this);
2195 this._tickScheduled = true;
2196 }
2197 };
2198
2199 /**
2200 * Read and push a chunk.
2201 */
2202 DataWorker.prototype._tick = function() {
2203
2204 if(this.isPaused || this.isFinished) {
2205 return false;
2206 }
2207
2208 var size = DEFAULT_BLOCK_SIZE;
2209 var data = null, nextIndex = Math.min(this.max, this.index + size);
2210 if (this.index >= this.max) {
2211 // EOF
2212 return this.end();
2213 } else {
2214 switch(this.type) {
2215 case "string":
2216 data = this.data.substring(this.index, nextIndex);
2217 break;
2218 case "uint8array":
2219 data = this.data.subarray(this.index, nextIndex);
2220 break;
2221 case "array":
2222 case "nodebuffer":
2223 data = this.data.slice(this.index, nextIndex);
2224 break;
2225 }
2226 this.index = nextIndex;
2227 return this.push({
2228 data : data,
2229 meta : {
2230 percent : this.max ? this.index / this.max * 100 : 0
2231 }
2232 });
2233 }
2234 };
2235
2236 module.exports = DataWorker;
2237
2238 },{"../utils":32,"./GenericWorker":28}],28:[function(require,module,exports){
2239 'use strict';
2240
2241 /**
2242 * A worker that does nothing but passing chunks to the next one. This is like
2243 * a nodejs stream but with some differences. On the good side :
2244 * - it works on IE 6-9 without any issue / polyfill
2245 * - it weights less than the full dependencies bundled with browserify
2246 * - it forwards errors (no need to declare an error handler EVERYWHERE)
2247 *
2248 * A chunk is an object with 2 attributes : `meta` and `data`. The former is an
2249 * object containing anything (`percent` for example), see each worker for more
2250 * details. The latter is the real data (String, Uint8Array, etc).
2251 *
2252 * @constructor
2253 * @param {String} name the name of the stream (mainly used for debugging purposes)
2254 */
2255 function GenericWorker(name) {
2256 // the name of the worker
2257 this.name = name || "default";
2258 // an object containing metadata about the workers chain
2259 this.streamInfo = {};
2260 // an error which happened when the worker was paused
2261 this.generatedError = null;
2262 // an object containing metadata to be merged by this worker into the general metadata
2263 this.extraStreamInfo = {};
2264 // true if the stream is paused (and should not do anything), false otherwise
2265 this.isPaused = true;
2266 // true if the stream is finished (and should not do anything), false otherwise
2267 this.isFinished = false;
2268 // true if the stream is locked to prevent further structure updates (pipe), false otherwise
2269 this.isLocked = false;
2270 // the event listeners
2271 this._listeners = {
2272 'data':[],
2273 'end':[],
2274 'error':[]
2275 };
2276 // the previous worker, if any
2277 this.previous = null;
2278 }
2279
2280 GenericWorker.prototype = {
2281 /**
2282 * Push a chunk to the next workers.
2283 * @param {Object} chunk the chunk to push
2284 */
2285 push : function (chunk) {
2286 this.emit("data", chunk);
2287 },
2288 /**
2289 * End the stream.
2290 * @return {Boolean} true if this call ended the worker, false otherwise.
2291 */
2292 end : function () {
2293 if (this.isFinished) {
2294 return false;
2295 }
2296
2297 this.flush();
2298 try {
2299 this.emit("end");
2300 this.cleanUp();
2301 this.isFinished = true;
2302 } catch (e) {
2303 this.emit("error", e);
2304 }
2305 return true;
2306 },
2307 /**
2308 * End the stream with an error.
2309 * @param {Error} e the error which caused the premature end.
2310 * @return {Boolean} true if this call ended the worker with an error, false otherwise.
2311 */
2312 error : function (e) {
2313 if (this.isFinished) {
2314 return false;
2315 }
2316
2317 if(this.isPaused) {
2318 this.generatedError = e;
2319 } else {
2320 this.isFinished = true;
2321
2322 this.emit("error", e);
2323
2324 // in the workers chain exploded in the middle of the chain,
2325 // the error event will go downward but we also need to notify
2326 // workers upward that there has been an error.
2327 if(this.previous) {
2328 this.previous.error(e);
2329 }
2330
2331 this.cleanUp();
2332 }
2333 return true;
2334 },
2335 /**
2336 * Add a callback on an event.
2337 * @param {String} name the name of the event (data, end, error)
2338 * @param {Function} listener the function to call when the event is triggered
2339 * @return {GenericWorker} the current object for chainability
2340 */
2341 on : function (name, listener) {
2342 this._listeners[name].push(listener);
2343 return this;
2344 },
2345 /**
2346 * Clean any references when a worker is ending.
2347 */
2348 cleanUp : function () {
2349 this.streamInfo = this.generatedError = this.extraStreamInfo = null;
2350 this._listeners = [];
2351 },
2352 /**
2353 * Trigger an event. This will call registered callback with the provided arg.
2354 * @param {String} name the name of the event (data, end, error)
2355 * @param {Object} arg the argument to call the callback with.
2356 */
2357 emit : function (name, arg) {
2358 if (this._listeners[name]) {
2359 for(var i = 0; i < this._listeners[name].length; i++) {
2360 this._listeners[name][i].call(this, arg);
2361 }
2362 }
2363 },
2364 /**
2365 * Chain a worker with an other.
2366 * @param {Worker} next the worker receiving events from the current one.
2367 * @return {worker} the next worker for chainability
2368 */
2369 pipe : function (next) {
2370 return next.registerPrevious(this);
2371 },
2372 /**
2373 * Same as `pipe` in the other direction.
2374 * Using an API with `pipe(next)` is very easy.
2375 * Implementing the API with the point of view of the next one registering
2376 * a source is easier, see the ZipFileWorker.
2377 * @param {Worker} previous the previous worker, sending events to this one
2378 * @return {Worker} the current worker for chainability
2379 */
2380 registerPrevious : function (previous) {
2381 if (this.isLocked) {
2382 throw new Error("The stream '" + this + "' has already been used.");
2383 }
2384
2385 // sharing the streamInfo...
2386 this.streamInfo = previous.streamInfo;
2387 // ... and adding our own bits
2388 this.mergeStreamInfo();
2389 this.previous = previous;
2390 var self = this;
2391 previous.on('data', function (chunk) {
2392 self.processChunk(chunk);
2393 });
2394 previous.on('end', function () {
2395 self.end();
2396 });
2397 previous.on('error', function (e) {
2398 self.error(e);
2399 });
2400 return this;
2401 },
2402 /**
2403 * Pause the stream so it doesn't send events anymore.
2404 * @return {Boolean} true if this call paused the worker, false otherwise.
2405 */
2406 pause : function () {
2407 if(this.isPaused || this.isFinished) {
2408 return false;
2409 }
2410 this.isPaused = true;
2411
2412 if(this.previous) {
2413 this.previous.pause();
2414 }
2415 return true;
2416 },
2417 /**
2418 * Resume a paused stream.
2419 * @return {Boolean} true if this call resumed the worker, false otherwise.
2420 */
2421 resume : function () {
2422 if(!this.isPaused || this.isFinished) {
2423 return false;
2424 }
2425 this.isPaused = false;
2426
2427 // if true, the worker tried to resume but failed
2428 var withError = false;
2429 if(this.generatedError) {
2430 this.error(this.generatedError);
2431 withError = true;
2432 }
2433 if(this.previous) {
2434 this.previous.resume();
2435 }
2436
2437 return !withError;
2438 },
2439 /**
2440 * Flush any remaining bytes as the stream is ending.
2441 */
2442 flush : function () {},
2443 /**
2444 * Process a chunk. This is usually the method overridden.
2445 * @param {Object} chunk the chunk to process.
2446 */
2447 processChunk : function(chunk) {
2448 this.push(chunk);
2449 },
2450 /**
2451 * Add a key/value to be added in the workers chain streamInfo once activated.
2452 * @param {String} key the key to use
2453 * @param {Object} value the associated value
2454 * @return {Worker} the current worker for chainability
2455 */
2456 withStreamInfo : function (key, value) {
2457 this.extraStreamInfo[key] = value;
2458 this.mergeStreamInfo();
2459 return this;
2460 },
2461 /**
2462 * Merge this worker's streamInfo into the chain's streamInfo.
2463 */
2464 mergeStreamInfo : function () {
2465 for(var key in this.extraStreamInfo) {
2466 if (!this.extraStreamInfo.hasOwnProperty(key)) {
2467 continue;
2468 }
2469 this.streamInfo[key] = this.extraStreamInfo[key];
2470 }
2471 },
2472
2473 /**
2474 * Lock the stream to prevent further updates on the workers chain.
2475 * After calling this method, all calls to pipe will fail.
2476 */
2477 lock: function () {
2478 if (this.isLocked) {
2479 throw new Error("The stream '" + this + "' has already been used.");
2480 }
2481 this.isLocked = true;
2482 if (this.previous) {
2483 this.previous.lock();
2484 }
2485 },
2486
2487 /**
2488 *
2489 * Pretty print the workers chain.
2490 */
2491 toString : function () {
2492 var me = "Worker " + this.name;
2493 if (this.previous) {
2494 return this.previous + " -> " + me;
2495 } else {
2496 return me;
2497 }
2498 }
2499 };
2500
2501 module.exports = GenericWorker;
2502
2503 },{}],29:[function(require,module,exports){
2504 'use strict';
2505
2506 var utils = require('../utils');
2507 var ConvertWorker = require('./ConvertWorker');
2508 var GenericWorker = require('./GenericWorker');
2509 var base64 = require('../base64');
2510 var support = require("../support");
2511 var external = require("../external");
2512
2513 var NodejsStreamOutputAdapter = null;
2514 if (support.nodestream) {
2515 try {
2516 NodejsStreamOutputAdapter = require('../nodejs/NodejsStreamOutputAdapter');
2517 } catch(e) {}
2518 }
2519
2520 /**
2521 * Apply the final transformation of the data. If the user wants a Blob for
2522 * example, it's easier to work with an U8intArray and finally do the
2523 * ArrayBuffer/Blob conversion.
2524 * @param {String} type the name of the final type
2525 * @param {String|Uint8Array|Buffer} content the content to transform
2526 * @param {String} mimeType the mime type of the content, if applicable.
2527 * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the content in the right format.
2528 */
2529 function transformZipOutput(type, content, mimeType) {
2530 switch(type) {
2531 case "blob" :
2532 return utils.newBlob(utils.transformTo("arraybuffer", content), mimeType);
2533 case "base64" :
2534 return base64.encode(content);
2535 default :
2536 return utils.transformTo(type, content);
2537 }
2538 }
2539
2540 /**
2541 * Concatenate an array of data of the given type.
2542 * @param {String} type the type of the data in the given array.
2543 * @param {Array} dataArray the array containing the data chunks to concatenate
2544 * @return {String|Uint8Array|Buffer} the concatenated data
2545 * @throws Error if the asked type is unsupported
2546 */
2547 function concat (type, dataArray) {
2548 var i, index = 0, res = null, totalLength = 0;
2549 for(i = 0; i < dataArray.length; i++) {
2550 totalLength += dataArray[i].length;
2551 }
2552 switch(type) {
2553 case "string":
2554 return dataArray.join("");
2555 case "array":
2556 return Array.prototype.concat.apply([], dataArray);
2557 case "uint8array":
2558 res = new Uint8Array(totalLength);
2559 for(i = 0; i < dataArray.length; i++) {
2560 res.set(dataArray[i], index);
2561 index += dataArray[i].length;
2562 }
2563 return res;
2564 case "nodebuffer":
2565 return Buffer.concat(dataArray);
2566 default:
2567 throw new Error("concat : unsupported type '" + type + "'");
2568 }
2569 }
2570
2571 /**
2572 * Listen a StreamHelper, accumulate its content and concatenate it into a
2573 * complete block.
2574 * @param {StreamHelper} helper the helper to use.
2575 * @param {Function} updateCallback a callback called on each update. Called
2576 * with one arg :
2577 * - the metadata linked to the update received.
2578 * @return Promise the promise for the accumulation.
2579 */
2580 function accumulate(helper, updateCallback) {
2581 return new external.Promise(function (resolve, reject){
2582 var dataArray = [];
2583 var chunkType = helper._internalType,
2584 resultType = helper._outputType,
2585 mimeType = helper._mimeType;
2586 helper
2587 .on('data', function (data, meta) {
2588 dataArray.push(data);
2589 if(updateCallback) {
2590 updateCallback(meta);
2591 }
2592 })
2593 .on('error', function(err) {
2594 dataArray = [];
2595 reject(err);
2596 })
2597 .on('end', function (){
2598 try {
2599 var result = transformZipOutput(resultType, concat(chunkType, dataArray), mimeType);
2600 resolve(result);
2601 } catch (e) {
2602 reject(e);
2603 }
2604 dataArray = [];
2605 })
2606 .resume();
2607 });
2608 }
2609
2610 /**
2611 * An helper to easily use workers outside of JSZip.
2612 * @constructor
2613 * @param {Worker} worker the worker to wrap
2614 * @param {String} outputType the type of data expected by the use
2615 * @param {String} mimeType the mime type of the content, if applicable.
2616 */
2617 function StreamHelper(worker, outputType, mimeType) {
2618 var internalType = outputType;
2619 switch(outputType) {
2620 case "blob":
2621 case "arraybuffer":
2622 internalType = "uint8array";
2623 break;
2624 case "base64":
2625 internalType = "string";
2626 break;
2627 }
2628
2629 try {
2630 // the type used internally
2631 this._internalType = internalType;
2632 // the type used to output results
2633 this._outputType = outputType;
2634 // the mime type
2635 this._mimeType = mimeType;
2636 utils.checkSupport(internalType);
2637 this._worker = worker.pipe(new ConvertWorker(internalType));
2638 // the last workers can be rewired without issues but we need to
2639 // prevent any updates on previous workers.
2640 worker.lock();
2641 } catch(e) {
2642 this._worker = new GenericWorker("error");
2643 this._worker.error(e);
2644 }
2645 }
2646
2647 StreamHelper.prototype = {
2648 /**
2649 * Listen a StreamHelper, accumulate its content and concatenate it into a
2650 * complete block.
2651 * @param {Function} updateCb the update callback.
2652 * @return Promise the promise for the accumulation.
2653 */
2654 accumulate : function (updateCb) {
2655 return accumulate(this, updateCb);
2656 },
2657 /**
2658 * Add a listener on an event triggered on a stream.
2659 * @param {String} evt the name of the event
2660 * @param {Function} fn the listener
2661 * @return {StreamHelper} the current helper.
2662 */
2663 on : function (evt, fn) {
2664 var self = this;
2665
2666 if(evt === "data") {
2667 this._worker.on(evt, function (chunk) {
2668 fn.call(self, chunk.data, chunk.meta);
2669 });
2670 } else {
2671 this._worker.on(evt, function () {
2672 utils.delay(fn, arguments, self);
2673 });
2674 }
2675 return this;
2676 },
2677 /**
2678 * Resume the flow of chunks.
2679 * @return {StreamHelper} the current helper.
2680 */
2681 resume : function () {
2682 utils.delay(this._worker.resume, [], this._worker);
2683 return this;
2684 },
2685 /**
2686 * Pause the flow of chunks.
2687 * @return {StreamHelper} the current helper.
2688 */
2689 pause : function () {
2690 this._worker.pause();
2691 return this;
2692 },
2693 /**
2694 * Return a nodejs stream for this helper.
2695 * @param {Function} updateCb the update callback.
2696 * @return {NodejsStreamOutputAdapter} the nodejs stream.
2697 */
2698 toNodejsStream : function (updateCb) {
2699 utils.checkSupport("nodestream");
2700 if (this._outputType !== "nodebuffer") {
2701 // an object stream containing blob/arraybuffer/uint8array/string
2702 // is strange and I don't know if it would be useful.
2703 // I you find this comment and have a good usecase, please open a
2704 // bug report !
2705 throw new Error(this._outputType + " is not supported by this method");
2706 }
2707
2708 return new NodejsStreamOutputAdapter(this, {
2709 objectMode : this._outputType !== "nodebuffer"
2710 }, updateCb);
2711 }
2712 };
2713
2714
2715 module.exports = StreamHelper;
2716
2717 },{"../base64":1,"../external":6,"../nodejs/NodejsStreamOutputAdapter":13,"../support":30,"../utils":32,"./ConvertWorker":24,"./GenericWorker":28}],30:[function(require,module,exports){
2718 'use strict';
2719
2720 exports.base64 = true;
2721 exports.array = true;
2722 exports.string = true;
2723 exports.arraybuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
2724 exports.nodebuffer = typeof Buffer !== "undefined";
2725 // contains true if JSZip can read/generate Uint8Array, false otherwise.
2726 exports.uint8array = typeof Uint8Array !== "undefined";
2727
2728 if (typeof ArrayBuffer === "undefined") {
2729 exports.blob = false;
2730 }
2731 else {
2732 var buffer = new ArrayBuffer(0);
2733 try {
2734 exports.blob = new Blob([buffer], {
2735 type: "application/zip"
2736 }).size === 0;
2737 }
2738 catch (e) {
2739 try {
2740 var Builder = self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder || self.MSBlobBuilder;
2741 var builder = new Builder();
2742 builder.append(buffer);
2743 exports.blob = builder.getBlob('application/zip').size === 0;
2744 }
2745 catch (e) {
2746 exports.blob = false;
2747 }
2748 }
2749 }
2750
2751 try {
2752 exports.nodestream = !!require('readable-stream').Readable;
2753 } catch(e) {
2754 exports.nodestream = false;
2755 }
2756
2757 },{"readable-stream":16}],31:[function(require,module,exports){
2758 'use strict';
2759
2760 var utils = require('./utils');
2761 var support = require('./support');
2762 var nodejsUtils = require('./nodejsUtils');
2763 var GenericWorker = require('./stream/GenericWorker');
2764
2765 /**
2766 * The following functions come from pako, from pako/lib/utils/strings
2767 * released under the MIT license, see pako https://github.com/nodeca/pako/
2768 */
2769
2770 // Table with utf8 lengths (calculated by first byte of sequence)
2771 // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
2772 // because max possible codepoint is 0x10ffff
2773 var _utf8len = new Array(256);
2774 for (var i=0; i<256; i++) {
2775 _utf8len[i] = (i >= 252 ? 6 : i >= 248 ? 5 : i >= 240 ? 4 : i >= 224 ? 3 : i >= 192 ? 2 : 1);
2776 }
2777 _utf8len[254]=_utf8len[254]=1; // Invalid sequence start
2778
2779 // convert string to array (typed, when possible)
2780 var string2buf = function (str) {
2781 var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
2782
2783 // count binary size
2784 for (m_pos = 0; m_pos < str_len; m_pos++) {
2785 c = str.charCodeAt(m_pos);
2786 if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) {
2787 c2 = str.charCodeAt(m_pos+1);
2788 if ((c2 & 0xfc00) === 0xdc00) {
2789 c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
2790 m_pos++;
2791 }
2792 }
2793 buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
2794 }
2795
2796 // allocate buffer
2797 if (support.uint8array) {
2798 buf = new Uint8Array(buf_len);
2799 } else {
2800 buf = new Array(buf_len);
2801 }
2802
2803 // convert
2804 for (i=0, m_pos = 0; i < buf_len; m_pos++) {
2805 c = str.charCodeAt(m_pos);
2806 if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) {
2807 c2 = str.charCodeAt(m_pos+1);
2808 if ((c2 & 0xfc00) === 0xdc00) {
2809 c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
2810 m_pos++;
2811 }
2812 }
2813 if (c < 0x80) {
2814 /* one byte */
2815 buf[i++] = c;
2816 } else if (c < 0x800) {
2817 /* two bytes */
2818 buf[i++] = 0xC0 | (c >>> 6);
2819 buf[i++] = 0x80 | (c & 0x3f);
2820 } else if (c < 0x10000) {
2821 /* three bytes */
2822 buf[i++] = 0xE0 | (c >>> 12);
2823 buf[i++] = 0x80 | (c >>> 6 & 0x3f);
2824 buf[i++] = 0x80 | (c & 0x3f);
2825 } else {
2826 /* four bytes */
2827 buf[i++] = 0xf0 | (c >>> 18);
2828 buf[i++] = 0x80 | (c >>> 12 & 0x3f);
2829 buf[i++] = 0x80 | (c >>> 6 & 0x3f);
2830 buf[i++] = 0x80 | (c & 0x3f);
2831 }
2832 }
2833
2834 return buf;
2835 };
2836
2837 // Calculate max possible position in utf8 buffer,
2838 // that will not break sequence. If that's not possible
2839 // - (very small limits) return max size as is.
2840 //
2841 // buf[] - utf8 bytes array
2842 // max - length limit (mandatory);
2843 var utf8border = function(buf, max) {
2844 var pos;
2845
2846 max = max || buf.length;
2847 if (max > buf.length) { max = buf.length; }
2848
2849 // go back from last position, until start of sequence found
2850 pos = max-1;
2851 while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }
2852
2853 // Fuckup - very small and broken sequence,
2854 // return max, because we should return something anyway.
2855 if (pos < 0) { return max; }
2856
2857 // If we came to start of buffer - that means vuffer is too small,
2858 // return max too.
2859 if (pos === 0) { return max; }
2860
2861 return (pos + _utf8len[buf[pos]] > max) ? pos : max;
2862 };
2863
2864 // convert array to string
2865 var buf2string = function (buf) {
2866 var str, i, out, c, c_len;
2867 var len = buf.length;
2868
2869 // Reserve max possible length (2 words per char)
2870 // NB: by unknown reasons, Array is significantly faster for
2871 // String.fromCharCode.apply than Uint16Array.
2872 var utf16buf = new Array(len*2);
2873
2874 for (out=0, i=0; i<len;) {
2875 c = buf[i++];
2876 // quick process ascii
2877 if (c < 0x80) { utf16buf[out++] = c; continue; }
2878
2879 c_len = _utf8len[c];
2880 // skip 5 & 6 byte codes
2881 if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len-1; continue; }
2882
2883 // apply mask on first byte
2884 c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
2885 // join the rest
2886 while (c_len > 1 && i < len) {
2887 c = (c << 6) | (buf[i++] & 0x3f);
2888 c_len--;
2889 }
2890
2891 // terminated by end of string?
2892 if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }
2893
2894 if (c < 0x10000) {
2895 utf16buf[out++] = c;
2896 } else {
2897 c -= 0x10000;
2898 utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);
2899 utf16buf[out++] = 0xdc00 | (c & 0x3ff);
2900 }
2901 }
2902
2903 // shrinkBuf(utf16buf, out)
2904 if (utf16buf.length !== out) {
2905 if(utf16buf.subarray) {
2906 utf16buf = utf16buf.subarray(0, out);
2907 } else {
2908 utf16buf.length = out;
2909 }
2910 }
2911
2912 // return String.fromCharCode.apply(null, utf16buf);
2913 return utils.applyFromCharCode(utf16buf);
2914 };
2915
2916
2917 // That's all for the pako functions.
2918
2919
2920 /**
2921 * Transform a javascript string into an array (typed if possible) of bytes,
2922 * UTF-8 encoded.
2923 * @param {String} str the string to encode
2924 * @return {Array|Uint8Array|Buffer} the UTF-8 encoded string.
2925 */
2926 exports.utf8encode = function utf8encode(str) {
2927 if (support.nodebuffer) {
2928 return nodejsUtils.newBufferFrom(str, "utf-8");
2929 }
2930
2931 return string2buf(str);
2932 };
2933
2934
2935 /**
2936 * Transform a bytes array (or a representation) representing an UTF-8 encoded
2937 * string into a javascript string.
2938 * @param {Array|Uint8Array|Buffer} buf the data de decode
2939 * @return {String} the decoded string.
2940 */
2941 exports.utf8decode = function utf8decode(buf) {
2942 if (support.nodebuffer) {
2943 return utils.transformTo("nodebuffer", buf).toString("utf-8");
2944 }
2945
2946 buf = utils.transformTo(support.uint8array ? "uint8array" : "array", buf);
2947
2948 return buf2string(buf);
2949 };
2950
2951 /**
2952 * A worker to decode utf8 encoded binary chunks into string chunks.
2953 * @constructor
2954 */
2955 function Utf8DecodeWorker() {
2956 GenericWorker.call(this, "utf-8 decode");
2957 // the last bytes if a chunk didn't end with a complete codepoint.
2958 this.leftOver = null;
2959 }
2960 utils.inherits(Utf8DecodeWorker, GenericWorker);
2961
2962 /**
2963 * @see GenericWorker.processChunk
2964 */
2965 Utf8DecodeWorker.prototype.processChunk = function (chunk) {
2966
2967 var data = utils.transformTo(support.uint8array ? "uint8array" : "array", chunk.data);
2968
2969 // 1st step, re-use what's left of the previous chunk
2970 if (this.leftOver && this.leftOver.length) {
2971 if(support.uint8array) {
2972 var previousData = data;
2973 data = new Uint8Array(previousData.length + this.leftOver.length);
2974 data.set(this.leftOver, 0);
2975 data.set(previousData, this.leftOver.length);
2976 } else {
2977 data = this.leftOver.concat(data);
2978 }
2979 this.leftOver = null;
2980 }
2981
2982 var nextBoundary = utf8border(data);
2983 var usableData = data;
2984 if (nextBoundary !== data.length) {
2985 if (support.uint8array) {
2986 usableData = data.subarray(0, nextBoundary);
2987 this.leftOver = data.subarray(nextBoundary, data.length);
2988 } else {
2989 usableData = data.slice(0, nextBoundary);
2990 this.leftOver = data.slice(nextBoundary, data.length);
2991 }
2992 }
2993
2994 this.push({
2995 data : exports.utf8decode(usableData),
2996 meta : chunk.meta
2997 });
2998 };
2999
3000 /**
3001 * @see GenericWorker.flush
3002 */
3003 Utf8DecodeWorker.prototype.flush = function () {
3004 if(this.leftOver && this.leftOver.length) {
3005 this.push({
3006 data : exports.utf8decode(this.leftOver),
3007 meta : {}
3008 });
3009 this.leftOver = null;
3010 }
3011 };
3012 exports.Utf8DecodeWorker = Utf8DecodeWorker;
3013
3014 /**
3015 * A worker to endcode string chunks into utf8 encoded binary chunks.
3016 * @constructor
3017 */
3018 function Utf8EncodeWorker() {
3019 GenericWorker.call(this, "utf-8 encode");
3020 }
3021 utils.inherits(Utf8EncodeWorker, GenericWorker);
3022
3023 /**
3024 * @see GenericWorker.processChunk
3025 */
3026 Utf8EncodeWorker.prototype.processChunk = function (chunk) {
3027 this.push({
3028 data : exports.utf8encode(chunk.data),
3029 meta : chunk.meta
3030 });
3031 };
3032 exports.Utf8EncodeWorker = Utf8EncodeWorker;
3033
3034 },{"./nodejsUtils":14,"./stream/GenericWorker":28,"./support":30,"./utils":32}],32:[function(require,module,exports){
3035 'use strict';
3036
3037 var support = require('./support');
3038 var base64 = require('./base64');
3039 var nodejsUtils = require('./nodejsUtils');
3040 var setImmediate = require('set-immediate-shim');
3041 var external = require("./external");
3042
3043
3044 /**
3045 * Convert a string that pass as a "binary string": it should represent a byte
3046 * array but may have > 255 char codes. Be sure to take only the first byte
3047 * and returns the byte array.
3048 * @param {String} str the string to transform.
3049 * @return {Array|Uint8Array} the string in a binary format.
3050 */
3051 function string2binary(str) {
3052 var result = null;
3053 if (support.uint8array) {
3054 result = new Uint8Array(str.length);
3055 } else {
3056 result = new Array(str.length);
3057 }
3058 return stringToArrayLike(str, result);
3059 }
3060
3061 /**
3062 * Create a new blob with the given content and the given type.
3063 * @param {String|ArrayBuffer} part the content to put in the blob. DO NOT use
3064 * an Uint8Array because the stock browser of android 4 won't accept it (it
3065 * will be silently converted to a string, "[object Uint8Array]").
3066 *
3067 * Use only ONE part to build the blob to avoid a memory leak in IE11 / Edge:
3068 * when a large amount of Array is used to create the Blob, the amount of
3069 * memory consumed is nearly 100 times the original data amount.
3070 *
3071 * @param {String} type the mime type of the blob.
3072 * @return {Blob} the created blob.
3073 */
3074 exports.newBlob = function(part, type) {
3075 exports.checkSupport("blob");
3076
3077 try {
3078 // Blob constructor
3079 return new Blob([part], {
3080 type: type
3081 });
3082 }
3083 catch (e) {
3084
3085 try {
3086 // deprecated, browser only, old way
3087 var Builder = self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder || self.MSBlobBuilder;
3088 var builder = new Builder();
3089 builder.append(part);
3090 return builder.getBlob(type);
3091 }
3092 catch (e) {
3093
3094 // well, fuck ?!
3095 throw new Error("Bug : can't construct the Blob.");
3096 }
3097 }
3098
3099
3100 };
3101 /**
3102 * The identity function.
3103 * @param {Object} input the input.
3104 * @return {Object} the same input.
3105 */
3106 function identity(input) {
3107 return input;
3108 }
3109
3110 /**
3111 * Fill in an array with a string.
3112 * @param {String} str the string to use.
3113 * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to fill in (will be mutated).
3114 * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated array.
3115 */
3116 function stringToArrayLike(str, array) {
3117 for (var i = 0; i < str.length; ++i) {
3118 array[i] = str.charCodeAt(i) & 0xFF;
3119 }
3120 return array;
3121 }
3122
3123 /**
3124 * An helper for the function arrayLikeToString.
3125 * This contains static informations and functions that
3126 * can be optimized by the browser JIT compiler.
3127 */
3128 var arrayToStringHelper = {
3129 /**
3130 * Transform an array of int into a string, chunk by chunk.
3131 * See the performances notes on arrayLikeToString.
3132 * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
3133 * @param {String} type the type of the array.
3134 * @param {Integer} chunk the chunk size.
3135 * @return {String} the resulting string.
3136 * @throws Error if the chunk is too big for the stack.
3137 */
3138 stringifyByChunk: function(array, type, chunk) {
3139 var result = [], k = 0, len = array.length;
3140 // shortcut
3141 if (len <= chunk) {
3142 return String.fromCharCode.apply(null, array);
3143 }
3144 while (k < len) {
3145 if (type === "array" || type === "nodebuffer") {
3146 result.push(String.fromCharCode.apply(null, array.slice(k, Math.min(k + chunk, len))));
3147 }
3148 else {
3149 result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len))));
3150 }
3151 k += chunk;
3152 }
3153 return result.join("");
3154 },
3155 /**
3156 * Call String.fromCharCode on every item in the array.
3157 * This is the naive implementation, which generate A LOT of intermediate string.
3158 * This should be used when everything else fail.
3159 * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
3160 * @return {String} the result.
3161 */
3162 stringifyByChar: function(array){
3163 var resultStr = "";
3164 for(var i = 0; i < array.length; i++) {
3165 resultStr += String.fromCharCode(array[i]);
3166 }
3167 return resultStr;
3168 },
3169 applyCanBeUsed : {
3170 /**
3171 * true if the browser accepts to use String.fromCharCode on Uint8Array
3172 */
3173 uint8array : (function () {
3174 try {
3175 return support.uint8array && String.fromCharCode.apply(null, new Uint8Array(1)).length === 1;
3176 } catch (e) {
3177 return false;
3178 }
3179 })(),
3180 /**
3181 * true if the browser accepts to use String.fromCharCode on nodejs Buffer.
3182 */
3183 nodebuffer : (function () {
3184 try {
3185 return support.nodebuffer && String.fromCharCode.apply(null, nodejsUtils.allocBuffer(1)).length === 1;
3186 } catch (e) {
3187 return false;
3188 }
3189 })()
3190 }
3191 };
3192
3193 /**
3194 * Transform an array-like object to a string.
3195 * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
3196 * @return {String} the result.
3197 */
3198 function arrayLikeToString(array) {
3199 // Performances notes :
3200 // --------------------
3201 // String.fromCharCode.apply(null, array) is the fastest, see
3202 // see http://jsperf.com/converting-a-uint8array-to-a-string/2
3203 // but the stack is limited (and we can get huge arrays !).
3204 //
3205 // result += String.fromCharCode(array[i]); generate too many strings !
3206 //
3207 // This code is inspired by http://jsperf.com/arraybuffer-to-string-apply-performance/2
3208 // TODO : we now have workers that split the work. Do we still need that ?
3209 var chunk = 65536,
3210 type = exports.getTypeOf(array),
3211 canUseApply = true;
3212 if (type === "uint8array") {
3213 canUseApply = arrayToStringHelper.applyCanBeUsed.uint8array;
3214 } else if (type === "nodebuffer") {
3215 canUseApply = arrayToStringHelper.applyCanBeUsed.nodebuffer;
3216 }
3217
3218 if (canUseApply) {
3219 while (chunk > 1) {
3220 try {
3221 return arrayToStringHelper.stringifyByChunk(array, type, chunk);
3222 } catch (e) {
3223 chunk = Math.floor(chunk / 2);
3224 }
3225 }
3226 }
3227
3228 // no apply or chunk error : slow and painful algorithm
3229 // default browser on android 4.*
3230 return arrayToStringHelper.stringifyByChar(array);
3231 }
3232
3233 exports.applyFromCharCode = arrayLikeToString;
3234
3235
3236 /**
3237 * Copy the data from an array-like to an other array-like.
3238 * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayFrom the origin array.
3239 * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayTo the destination array which will be mutated.
3240 * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated destination array.
3241 */
3242 function arrayLikeToArrayLike(arrayFrom, arrayTo) {
3243 for (var i = 0; i < arrayFrom.length; i++) {
3244 arrayTo[i] = arrayFrom[i];
3245 }
3246 return arrayTo;
3247 }
3248
3249 // a matrix containing functions to transform everything into everything.
3250 var transform = {};
3251
3252 // string to ?
3253 transform["string"] = {
3254 "string": identity,
3255 "array": function(input) {
3256 return stringToArrayLike(input, new Array(input.length));
3257 },
3258 "arraybuffer": function(input) {
3259 return transform["string"]["uint8array"](input).buffer;
3260 },
3261 "uint8array": function(input) {
3262 return stringToArrayLike(input, new Uint8Array(input.length));
3263 },
3264 "nodebuffer": function(input) {
3265 return stringToArrayLike(input, nodejsUtils.allocBuffer(input.length));
3266 }
3267 };
3268
3269 // array to ?
3270 transform["array"] = {
3271 "string": arrayLikeToString,
3272 "array": identity,
3273 "arraybuffer": function(input) {
3274 return (new Uint8Array(input)).buffer;
3275 },
3276 "uint8array": function(input) {
3277 return new Uint8Array(input);
3278 },
3279 "nodebuffer": function(input) {
3280 return nodejsUtils.newBufferFrom(input);
3281 }
3282 };
3283
3284 // arraybuffer to ?
3285 transform["arraybuffer"] = {
3286 "string": function(input) {
3287 return arrayLikeToString(new Uint8Array(input));
3288 },
3289 "array": function(input) {
3290 return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength));
3291 },
3292 "arraybuffer": identity,
3293 "uint8array": function(input) {
3294 return new Uint8Array(input);
3295 },
3296 "nodebuffer": function(input) {
3297 return nodejsUtils.newBufferFrom(new Uint8Array(input));
3298 }
3299 };
3300
3301 // uint8array to ?
3302 transform["uint8array"] = {
3303 "string": arrayLikeToString,
3304 "array": function(input) {
3305 return arrayLikeToArrayLike(input, new Array(input.length));
3306 },
3307 "arraybuffer": function(input) {
3308 return input.buffer;
3309 },
3310 "uint8array": identity,
3311 "nodebuffer": function(input) {
3312 return nodejsUtils.newBufferFrom(input);
3313 }
3314 };
3315
3316 // nodebuffer to ?
3317 transform["nodebuffer"] = {
3318 "string": arrayLikeToString,
3319 "array": function(input) {
3320 return arrayLikeToArrayLike(input, new Array(input.length));
3321 },
3322 "arraybuffer": function(input) {
3323 return transform["nodebuffer"]["uint8array"](input).buffer;
3324 },
3325 "uint8array": function(input) {
3326 return arrayLikeToArrayLike(input, new Uint8Array(input.length));
3327 },
3328 "nodebuffer": identity
3329 };
3330
3331 /**
3332 * Transform an input into any type.
3333 * The supported output type are : string, array, uint8array, arraybuffer, nodebuffer.
3334 * If no output type is specified, the unmodified input will be returned.
3335 * @param {String} outputType the output type.
3336 * @param {String|Array|ArrayBuffer|Uint8Array|Buffer} input the input to convert.
3337 * @throws {Error} an Error if the browser doesn't support the requested output type.
3338 */
3339 exports.transformTo = function(outputType, input) {
3340 if (!input) {
3341 // undefined, null, etc
3342 // an empty string won't harm.
3343 input = "";
3344 }
3345 if (!outputType) {
3346 return input;
3347 }
3348 exports.checkSupport(outputType);
3349 var inputType = exports.getTypeOf(input);
3350 var result = transform[inputType][outputType](input);
3351 return result;
3352 };
3353
3354 /**
3355 * Return the type of the input.
3356 * The type will be in a format valid for JSZip.utils.transformTo : string, array, uint8array, arraybuffer.
3357 * @param {Object} input the input to identify.
3358 * @return {String} the (lowercase) type of the input.
3359 */
3360 exports.getTypeOf = function(input) {
3361 if (typeof input === "string") {
3362 return "string";
3363 }
3364 if (Object.prototype.toString.call(input) === "[object Array]") {
3365 return "array";
3366 }
3367 if (support.nodebuffer && nodejsUtils.isBuffer(input)) {
3368 return "nodebuffer";
3369 }
3370 if (support.uint8array && input instanceof Uint8Array) {
3371 return "uint8array";
3372 }
3373 if (support.arraybuffer && input instanceof ArrayBuffer) {
3374 return "arraybuffer";
3375 }
3376 };
3377
3378 /**
3379 * Throw an exception if the type is not supported.
3380 * @param {String} type the type to check.
3381 * @throws {Error} an Error if the browser doesn't support the requested type.
3382 */
3383 exports.checkSupport = function(type) {
3384 var supported = support[type.toLowerCase()];
3385 if (!supported) {
3386 throw new Error(type + " is not supported by this platform");
3387 }
3388 };
3389
3390 exports.MAX_VALUE_16BITS = 65535;
3391 exports.MAX_VALUE_32BITS = -1; // well, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF" is parsed as -1
3392
3393 /**
3394 * Prettify a string read as binary.
3395 * @param {string} str the string to prettify.
3396 * @return {string} a pretty string.
3397 */
3398 exports.pretty = function(str) {
3399 var res = '',
3400 code, i;
3401 for (i = 0; i < (str || "").length; i++) {
3402 code = str.charCodeAt(i);
3403 res += '\\x' + (code < 16 ? "0" : "") + code.toString(16).toUpperCase();
3404 }
3405 return res;
3406 };
3407
3408 /**
3409 * Defer the call of a function.
3410 * @param {Function} callback the function to call asynchronously.
3411 * @param {Array} args the arguments to give to the callback.
3412 */
3413 exports.delay = function(callback, args, self) {
3414 setImmediate(function () {
3415 callback.apply(self || null, args || []);
3416 });
3417 };
3418
3419 /**
3420 * Extends a prototype with an other, without calling a constructor with
3421 * side effects. Inspired by nodejs' `utils.inherits`
3422 * @param {Function} ctor the constructor to augment
3423 * @param {Function} superCtor the parent constructor to use
3424 */
3425 exports.inherits = function (ctor, superCtor) {
3426 var Obj = function() {};
3427 Obj.prototype = superCtor.prototype;
3428 ctor.prototype = new Obj();
3429 };
3430
3431 /**
3432 * Merge the objects passed as parameters into a new one.
3433 * @private
3434 * @param {...Object} var_args All objects to merge.
3435 * @return {Object} a new object with the data of the others.
3436 */
3437 exports.extend = function() {
3438 var result = {}, i, attr;
3439 for (i = 0; i < arguments.length; i++) { // arguments is not enumerable in some browsers
3440 for (attr in arguments[i]) {
3441 if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") {
3442 result[attr] = arguments[i][attr];
3443 }
3444 }
3445 }
3446 return result;
3447 };
3448
3449 /**
3450 * Transform arbitrary content into a Promise.
3451 * @param {String} name a name for the content being processed.
3452 * @param {Object} inputData the content to process.
3453 * @param {Boolean} isBinary true if the content is not an unicode string
3454 * @param {Boolean} isOptimizedBinaryString true if the string content only has one byte per character.
3455 * @param {Boolean} isBase64 true if the string content is encoded with base64.
3456 * @return {Promise} a promise in a format usable by JSZip.
3457 */
3458 exports.prepareContent = function(name, inputData, isBinary, isOptimizedBinaryString, isBase64) {
3459
3460 // if inputData is already a promise, this flatten it.
3461 var promise = external.Promise.resolve(inputData).then(function(data) {
3462
3463
3464 var isBlob = support.blob && (data instanceof Blob || ['[object File]', '[object Blob]'].indexOf(Object.prototype.toString.call(data)) !== -1);
3465
3466 if (isBlob && typeof FileReader !== "undefined") {
3467 return new external.Promise(function (resolve, reject) {
3468 var reader = new FileReader();
3469
3470 reader.onload = function(e) {
3471 resolve(e.target.result);
3472 };
3473 reader.onerror = function(e) {
3474 reject(e.target.error);
3475 };
3476 reader.readAsArrayBuffer(data);
3477 });
3478 } else {
3479 return data;
3480 }
3481 });
3482
3483 return promise.then(function(data) {
3484 var dataType = exports.getTypeOf(data);
3485
3486 if (!dataType) {
3487 return external.Promise.reject(
3488 new Error("Can't read the data of '" + name + "'. Is it " +
3489 "in a supported JavaScript type (String, Blob, ArrayBuffer, etc) ?")
3490 );
3491 }
3492 // special case : it's way easier to work with Uint8Array than with ArrayBuffer
3493 if (dataType === "arraybuffer") {
3494 data = exports.transformTo("uint8array", data);
3495 } else if (dataType === "string") {
3496 if (isBase64) {
3497 data = base64.decode(data);
3498 }
3499 else if (isBinary) {
3500 // optimizedBinaryString === true means that the file has already been filtered with a 0xFF mask
3501 if (isOptimizedBinaryString !== true) {
3502 // this is a string, not in a base64 format.
3503 // Be sure that this is a correct "binary string"
3504 data = string2binary(data);
3505 }
3506 }
3507 }
3508 return data;
3509 });
3510 };
3511
3512 },{"./base64":1,"./external":6,"./nodejsUtils":14,"./support":30,"set-immediate-shim":54}],33:[function(require,module,exports){
3513 'use strict';
3514 var readerFor = require('./reader/readerFor');
3515 var utils = require('./utils');
3516 var sig = require('./signature');
3517 var ZipEntry = require('./zipEntry');
3518 var utf8 = require('./utf8');
3519 var support = require('./support');
3520 // class ZipEntries {{{
3521 /**
3522 * All the entries in the zip file.
3523 * @constructor
3524 * @param {Object} loadOptions Options for loading the stream.
3525 */
3526 function ZipEntries(loadOptions) {
3527 this.files = [];
3528 this.loadOptions = loadOptions;
3529 }
3530 ZipEntries.prototype = {
3531 /**
3532 * Check that the reader is on the specified signature.
3533 * @param {string} expectedSignature the expected signature.
3534 * @throws {Error} if it is an other signature.
3535 */
3536 checkSignature: function(expectedSignature) {
3537 if (!this.reader.readAndCheckSignature(expectedSignature)) {
3538 this.reader.index -= 4;
3539 var signature = this.reader.readString(4);
3540 throw new Error("Corrupted zip or bug: unexpected signature " + "(" + utils.pretty(signature) + ", expected " + utils.pretty(expectedSignature) + ")");
3541 }
3542 },
3543 /**
3544 * Check if the given signature is at the given index.
3545 * @param {number} askedIndex the index to check.
3546 * @param {string} expectedSignature the signature to expect.
3547 * @return {boolean} true if the signature is here, false otherwise.
3548 */
3549 isSignature: function(askedIndex, expectedSignature) {
3550 var currentIndex = this.reader.index;
3551 this.reader.setIndex(askedIndex);
3552 var signature = this.reader.readString(4);
3553 var result = signature === expectedSignature;
3554 this.reader.setIndex(currentIndex);
3555 return result;
3556 },
3557 /**
3558 * Read the end of the central directory.
3559 */
3560 readBlockEndOfCentral: function() {
3561 this.diskNumber = this.reader.readInt(2);
3562 this.diskWithCentralDirStart = this.reader.readInt(2);
3563 this.centralDirRecordsOnThisDisk = this.reader.readInt(2);
3564 this.centralDirRecords = this.reader.readInt(2);
3565 this.centralDirSize = this.reader.readInt(4);
3566 this.centralDirOffset = this.reader.readInt(4);
3567
3568 this.zipCommentLength = this.reader.readInt(2);
3569 // warning : the encoding depends of the system locale
3570 // On a linux machine with LANG=en_US.utf8, this field is utf8 encoded.
3571 // On a windows machine, this field is encoded with the localized windows code page.
3572 var zipComment = this.reader.readData(this.zipCommentLength);
3573 var decodeParamType = support.uint8array ? "uint8array" : "array";
3574 // To get consistent behavior with the generation part, we will assume that
3575 // this is utf8 encoded unless specified otherwise.
3576 var decodeContent = utils.transformTo(decodeParamType, zipComment);
3577 this.zipComment = this.loadOptions.decodeFileName(decodeContent);
3578 },
3579 /**
3580 * Read the end of the Zip 64 central directory.
3581 * Not merged with the method readEndOfCentral :
3582 * The end of central can coexist with its Zip64 brother,
3583 * I don't want to read the wrong number of bytes !
3584 */
3585 readBlockZip64EndOfCentral: function() {
3586 this.zip64EndOfCentralSize = this.reader.readInt(8);
3587 this.reader.skip(4);
3588 // this.versionMadeBy = this.reader.readString(2);
3589 // this.versionNeeded = this.reader.readInt(2);
3590 this.diskNumber = this.reader.readInt(4);
3591 this.diskWithCentralDirStart = this.reader.readInt(4);
3592 this.centralDirRecordsOnThisDisk = this.reader.readInt(8);
3593 this.centralDirRecords = this.reader.readInt(8);
3594 this.centralDirSize = this.reader.readInt(8);
3595 this.centralDirOffset = this.reader.readInt(8);
3596
3597 this.zip64ExtensibleData = {};
3598 var extraDataSize = this.zip64EndOfCentralSize - 44,
3599 index = 0,
3600 extraFieldId,
3601 extraFieldLength,
3602 extraFieldValue;
3603 while (index < extraDataSize) {
3604 extraFieldId = this.reader.readInt(2);
3605 extraFieldLength = this.reader.readInt(4);
3606 extraFieldValue = this.reader.readData(extraFieldLength);
3607 this.zip64ExtensibleData[extraFieldId] = {
3608 id: extraFieldId,
3609 length: extraFieldLength,
3610 value: extraFieldValue
3611 };
3612 }
3613 },
3614 /**
3615 * Read the end of the Zip 64 central directory locator.
3616 */
3617 readBlockZip64EndOfCentralLocator: function() {
3618 this.diskWithZip64CentralDirStart = this.reader.readInt(4);
3619 this.relativeOffsetEndOfZip64CentralDir = this.reader.readInt(8);
3620 this.disksCount = this.reader.readInt(4);
3621 if (this.disksCount > 1) {
3622 throw new Error("Multi-volumes zip are not supported");
3623 }
3624 },
3625 /**
3626 * Read the local files, based on the offset read in the central part.
3627 */
3628 readLocalFiles: function() {
3629 var i, file;
3630 for (i = 0; i < this.files.length; i++) {
3631 file = this.files[i];
3632 this.reader.setIndex(file.localHeaderOffset);
3633 this.checkSignature(sig.LOCAL_FILE_HEADER);
3634 file.readLocalPart(this.reader);
3635 file.handleUTF8();
3636 file.processAttributes();
3637 }
3638 },
3639 /**
3640 * Read the central directory.
3641 */
3642 readCentralDir: function() {
3643 var file;
3644
3645 this.reader.setIndex(this.centralDirOffset);
3646 while (this.reader.readAndCheckSignature(sig.CENTRAL_FILE_HEADER)) {
3647 file = new ZipEntry({
3648 zip64: this.zip64
3649 }, this.loadOptions);
3650 file.readCentralPart(this.reader);
3651 this.files.push(file);
3652 }
3653
3654 if (this.centralDirRecords !== this.files.length) {
3655 if (this.centralDirRecords !== 0 && this.files.length === 0) {
3656 // We expected some records but couldn't find ANY.
3657 // This is really suspicious, as if something went wrong.
3658 throw new Error("Corrupted zip or bug: expected " + this.centralDirRecords + " records in central dir, got " + this.files.length);
3659 } else {
3660 // We found some records but not all.
3661 // Something is wrong but we got something for the user: no error here.
3662 // console.warn("expected", this.centralDirRecords, "records in central dir, got", this.files.length);
3663 }
3664 }
3665 },
3666 /**
3667 * Read the end of central directory.
3668 */
3669 readEndOfCentral: function() {
3670 var offset = this.reader.lastIndexOfSignature(sig.CENTRAL_DIRECTORY_END);
3671 if (offset < 0) {
3672 // Check if the content is a truncated zip or complete garbage.
3673 // A "LOCAL_FILE_HEADER" is not required at the beginning (auto
3674 // extractible zip for example) but it can give a good hint.
3675 // If an ajax request was used without responseType, we will also
3676 // get unreadable data.
3677 var isGarbage = !this.isSignature(0, sig.LOCAL_FILE_HEADER);
3678
3679 if (isGarbage) {
3680 throw new Error("Can't find end of central directory : is this a zip file ? " +
3681 "If it is, see https://stuk.github.io/jszip/documentation/howto/read_zip.html");
3682 } else {
3683 throw new Error("Corrupted zip: can't find end of central directory");
3684 }
3685
3686 }
3687 this.reader.setIndex(offset);
3688 var endOfCentralDirOffset = offset;
3689 this.checkSignature(sig.CENTRAL_DIRECTORY_END);
3690 this.readBlockEndOfCentral();
3691
3692
3693 /* extract from the zip spec :
3694 4) If one of the fields in the end of central directory
3695 record is too small to hold required data, the field
3696 should be set to -1 (0xFFFF or 0xFFFFFFFF) and the
3697 ZIP64 format record should be created.
3698 5) The end of central directory record and the
3699 Zip64 end of central directory locator record must
3700 reside on the same disk when splitting or spanning
3701 an archive.
3702 */
3703 if (this.diskNumber === utils.MAX_VALUE_16BITS || this.diskWithCentralDirStart === utils.MAX_VALUE_16BITS || this.centralDirRecordsOnThisDisk === utils.MAX_VALUE_16BITS || this.centralDirRecords === utils.MAX_VALUE_16BITS || this.centralDirSize === utils.MAX_VALUE_32BITS || this.centralDirOffset === utils.MAX_VALUE_32BITS) {
3704 this.zip64 = true;
3705
3706 /*
3707 Warning : the zip64 extension is supported, but ONLY if the 64bits integer read from
3708 the zip file can fit into a 32bits integer. This cannot be solved : JavaScript represents
3709 all numbers as 64-bit double precision IEEE 754 floating point numbers.
3710 So, we have 53bits for integers and bitwise operations treat everything as 32bits.
3711 see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/Bitwise_Operators
3712 and http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf section 8.5
3713 */
3714
3715 // should look for a zip64 EOCD locator
3716 offset = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
3717 if (offset < 0) {
3718 throw new Error("Corrupted zip: can't find the ZIP64 end of central directory locator");
3719 }
3720 this.reader.setIndex(offset);
3721 this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
3722 this.readBlockZip64EndOfCentralLocator();
3723
3724 // now the zip64 EOCD record
3725 if (!this.isSignature(this.relativeOffsetEndOfZip64CentralDir, sig.ZIP64_CENTRAL_DIRECTORY_END)) {
3726 // console.warn("ZIP64 end of central directory not where expected.");
3727 this.relativeOffsetEndOfZip64CentralDir = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
3728 if (this.relativeOffsetEndOfZip64CentralDir < 0) {
3729 throw new Error("Corrupted zip: can't find the ZIP64 end of central directory");
3730 }
3731 }
3732 this.reader.setIndex(this.relativeOffsetEndOfZip64CentralDir);
3733 this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
3734 this.readBlockZip64EndOfCentral();
3735 }
3736
3737 var expectedEndOfCentralDirOffset = this.centralDirOffset + this.centralDirSize;
3738 if (this.zip64) {
3739 expectedEndOfCentralDirOffset += 20; // end of central dir 64 locator
3740 expectedEndOfCentralDirOffset += 12 /* should not include the leading 12 bytes */ + this.zip64EndOfCentralSize;
3741 }
3742
3743 var extraBytes = endOfCentralDirOffset - expectedEndOfCentralDirOffset;
3744
3745 if (extraBytes > 0) {
3746 // console.warn(extraBytes, "extra bytes at beginning or within zipfile");
3747 if (this.isSignature(endOfCentralDirOffset, sig.CENTRAL_FILE_HEADER)) {
3748 // The offsets seem wrong, but we have something at the specified offset.
3749 // So… we keep it.
3750 } else {
3751 // the offset is wrong, update the "zero" of the reader
3752 // this happens if data has been prepended (crx files for example)
3753 this.reader.zero = extraBytes;
3754 }
3755 } else if (extraBytes < 0) {
3756 throw new Error("Corrupted zip: missing " + Math.abs(extraBytes) + " bytes.");
3757 }
3758 },
3759 prepareReader: function(data) {
3760 this.reader = readerFor(data);
3761 },
3762 /**
3763 * Read a zip file and create ZipEntries.
3764 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the binary string representing a zip file.
3765 */
3766 load: function(data) {
3767 this.prepareReader(data);
3768 this.readEndOfCentral();
3769 this.readCentralDir();
3770 this.readLocalFiles();
3771 }
3772 };
3773 // }}} end of ZipEntries
3774 module.exports = ZipEntries;
3775
3776 },{"./reader/readerFor":22,"./signature":23,"./support":30,"./utf8":31,"./utils":32,"./zipEntry":34}],34:[function(require,module,exports){
3777 'use strict';
3778 var readerFor = require('./reader/readerFor');
3779 var utils = require('./utils');
3780 var CompressedObject = require('./compressedObject');
3781 var crc32fn = require('./crc32');
3782 var utf8 = require('./utf8');
3783 var compressions = require('./compressions');
3784 var support = require('./support');
3785
3786 var MADE_BY_DOS = 0x00;
3787 var MADE_BY_UNIX = 0x03;
3788
3789 /**
3790 * Find a compression registered in JSZip.
3791 * @param {string} compressionMethod the method magic to find.
3792 * @return {Object|null} the JSZip compression object, null if none found.
3793 */
3794 var findCompression = function(compressionMethod) {
3795 for (var method in compressions) {
3796 if (!compressions.hasOwnProperty(method)) {
3797 continue;
3798 }
3799 if (compressions[method].magic === compressionMethod) {
3800 return compressions[method];
3801 }
3802 }
3803 return null;
3804 };
3805
3806 // class ZipEntry {{{
3807 /**
3808 * An entry in the zip file.
3809 * @constructor
3810 * @param {Object} options Options of the current file.
3811 * @param {Object} loadOptions Options for loading the stream.
3812 */
3813 function ZipEntry(options, loadOptions) {
3814 this.options = options;
3815 this.loadOptions = loadOptions;
3816 }
3817 ZipEntry.prototype = {
3818 /**
3819 * say if the file is encrypted.
3820 * @return {boolean} true if the file is encrypted, false otherwise.
3821 */
3822 isEncrypted: function() {
3823 // bit 1 is set
3824 return (this.bitFlag & 0x0001) === 0x0001;
3825 },
3826 /**
3827 * say if the file has utf-8 filename/comment.
3828 * @return {boolean} true if the filename/comment is in utf-8, false otherwise.
3829 */
3830 useUTF8: function() {
3831 // bit 11 is set
3832 return (this.bitFlag & 0x0800) === 0x0800;
3833 },
3834 /**
3835 * Read the local part of a zip file and add the info in this object.
3836 * @param {DataReader} reader the reader to use.
3837 */
3838 readLocalPart: function(reader) {
3839 var compression, localExtraFieldsLength;
3840
3841 // we already know everything from the central dir !
3842 // If the central dir data are false, we are doomed.
3843 // On the bright side, the local part is scary : zip64, data descriptors, both, etc.
3844 // The less data we get here, the more reliable this should be.
3845 // Let's skip the whole header and dash to the data !
3846 reader.skip(22);
3847 // in some zip created on windows, the filename stored in the central dir contains \ instead of /.
3848 // Strangely, the filename here is OK.
3849 // I would love to treat these zip files as corrupted (see http://www.info-zip.org/FAQ.html#backslashes
3850 // or APPNOTE#4.4.17.1, "All slashes MUST be forward slashes '/'") but there are a lot of bad zip generators...
3851 // Search "unzip mismatching "local" filename continuing with "central" filename version" on
3852 // the internet.
3853 //
3854 // I think I see the logic here : the central directory is used to display
3855 // content and the local directory is used to extract the files. Mixing / and \
3856 // may be used to display \ to windows users and use / when extracting the files.
3857 // Unfortunately, this lead also to some issues : http://seclists.org/fulldisclosure/2009/Sep/394
3858 this.fileNameLength = reader.readInt(2);
3859 localExtraFieldsLength = reader.readInt(2); // can't be sure this will be the same as the central dir
3860 // the fileName is stored as binary data, the handleUTF8 method will take care of the encoding.
3861 this.fileName = reader.readData(this.fileNameLength);
3862 reader.skip(localExtraFieldsLength);
3863
3864 if (this.compressedSize === -1 || this.uncompressedSize === -1) {
3865 throw new Error("Bug or corrupted zip : didn't get enough informations from the central directory " + "(compressedSize === -1 || uncompressedSize === -1)");
3866 }
3867
3868 compression = findCompression(this.compressionMethod);
3869 if (compression === null) { // no compression found
3870 throw new Error("Corrupted zip : compression " + utils.pretty(this.compressionMethod) + " unknown (inner file : " + utils.transformTo("string", this.fileName) + ")");
3871 }
3872 this.decompressed = new CompressedObject(this.compressedSize, this.uncompressedSize, this.crc32, compression, reader.readData(this.compressedSize));
3873 },
3874
3875 /**
3876 * Read the central part of a zip file and add the info in this object.
3877 * @param {DataReader} reader the reader to use.
3878 */
3879 readCentralPart: function(reader) {
3880 this.versionMadeBy = reader.readInt(2);
3881 reader.skip(2);
3882 // this.versionNeeded = reader.readInt(2);
3883 this.bitFlag = reader.readInt(2);
3884 this.compressionMethod = reader.readString(2);
3885 this.date = reader.readDate();
3886 this.crc32 = reader.readInt(4);
3887 this.compressedSize = reader.readInt(4);
3888 this.uncompressedSize = reader.readInt(4);
3889 var fileNameLength = reader.readInt(2);
3890 this.extraFieldsLength = reader.readInt(2);
3891 this.fileCommentLength = reader.readInt(2);
3892 this.diskNumberStart = reader.readInt(2);
3893 this.internalFileAttributes = reader.readInt(2);
3894 this.externalFileAttributes = reader.readInt(4);
3895 this.localHeaderOffset = reader.readInt(4);
3896
3897 if (this.isEncrypted()) {
3898 throw new Error("Encrypted zip are not supported");
3899 }
3900
3901 // will be read in the local part, see the comments there
3902 reader.skip(fileNameLength);
3903 this.readExtraFields(reader);
3904 this.parseZIP64ExtraField(reader);
3905 this.fileComment = reader.readData(this.fileCommentLength);
3906 },
3907
3908 /**
3909 * Parse the external file attributes and get the unix/dos permissions.
3910 */
3911 processAttributes: function () {
3912 this.unixPermissions = null;
3913 this.dosPermissions = null;
3914 var madeBy = this.versionMadeBy >> 8;
3915
3916 // Check if we have the DOS directory flag set.
3917 // We look for it in the DOS and UNIX permissions
3918 // but some unknown platform could set it as a compatibility flag.
3919 this.dir = this.externalFileAttributes & 0x0010 ? true : false;
3920
3921 if(madeBy === MADE_BY_DOS) {
3922 // first 6 bits (0 to 5)
3923 this.dosPermissions = this.externalFileAttributes & 0x3F;
3924 }
3925
3926 if(madeBy === MADE_BY_UNIX) {
3927 this.unixPermissions = (this.externalFileAttributes >> 16) & 0xFFFF;
3928 // the octal permissions are in (this.unixPermissions & 0x01FF).toString(8);
3929 }
3930
3931 // fail safe : if the name ends with a / it probably means a folder
3932 if (!this.dir && this.fileNameStr.slice(-1) === '/') {
3933 this.dir = true;
3934 }
3935 },
3936
3937 /**
3938 * Parse the ZIP64 extra field and merge the info in the current ZipEntry.
3939 * @param {DataReader} reader the reader to use.
3940 */
3941 parseZIP64ExtraField: function(reader) {
3942
3943 if (!this.extraFields[0x0001]) {
3944 return;
3945 }
3946
3947 // should be something, preparing the extra reader
3948 var extraReader = readerFor(this.extraFields[0x0001].value);
3949
3950 // I really hope that these 64bits integer can fit in 32 bits integer, because js
3951 // won't let us have more.
3952 if (this.uncompressedSize === utils.MAX_VALUE_32BITS) {
3953 this.uncompressedSize = extraReader.readInt(8);
3954 }
3955 if (this.compressedSize === utils.MAX_VALUE_32BITS) {
3956 this.compressedSize = extraReader.readInt(8);
3957 }
3958 if (this.localHeaderOffset === utils.MAX_VALUE_32BITS) {
3959 this.localHeaderOffset = extraReader.readInt(8);
3960 }
3961 if (this.diskNumberStart === utils.MAX_VALUE_32BITS) {
3962 this.diskNumberStart = extraReader.readInt(4);
3963 }
3964 },
3965 /**
3966 * Read the central part of a zip file and add the info in this object.
3967 * @param {DataReader} reader the reader to use.
3968 */
3969 readExtraFields: function(reader) {
3970 var end = reader.index + this.extraFieldsLength,
3971 extraFieldId,
3972 extraFieldLength,
3973 extraFieldValue;
3974
3975 if (!this.extraFields) {
3976 this.extraFields = {};
3977 }
3978
3979 while (reader.index < end) {
3980 extraFieldId = reader.readInt(2);
3981 extraFieldLength = reader.readInt(2);
3982 extraFieldValue = reader.readData(extraFieldLength);
3983
3984 this.extraFields[extraFieldId] = {
3985 id: extraFieldId,
3986 length: extraFieldLength,
3987 value: extraFieldValue
3988 };
3989 }
3990 },
3991 /**
3992 * Apply an UTF8 transformation if needed.
3993 */
3994 handleUTF8: function() {
3995 var decodeParamType = support.uint8array ? "uint8array" : "array";
3996 if (this.useUTF8()) {
3997 this.fileNameStr = utf8.utf8decode(this.fileName);
3998 this.fileCommentStr = utf8.utf8decode(this.fileComment);
3999 } else {
4000 var upath = this.findExtraFieldUnicodePath();
4001 if (upath !== null) {
4002 this.fileNameStr = upath;
4003 } else {
4004 // ASCII text or unsupported code page
4005 var fileNameByteArray = utils.transformTo(decodeParamType, this.fileName);
4006 this.fileNameStr = this.loadOptions.decodeFileName(fileNameByteArray);
4007 }
4008
4009 var ucomment = this.findExtraFieldUnicodeComment();
4010 if (ucomment !== null) {
4011 this.fileCommentStr = ucomment;
4012 } else {
4013 // ASCII text or unsupported code page
4014 var commentByteArray = utils.transformTo(decodeParamType, this.fileComment);
4015 this.fileCommentStr = this.loadOptions.decodeFileName(commentByteArray);
4016 }
4017 }
4018 },
4019
4020 /**
4021 * Find the unicode path declared in the extra field, if any.
4022 * @return {String} the unicode path, null otherwise.
4023 */
4024 findExtraFieldUnicodePath: function() {
4025 var upathField = this.extraFields[0x7075];
4026 if (upathField) {
4027 var extraReader = readerFor(upathField.value);
4028
4029 // wrong version
4030 if (extraReader.readInt(1) !== 1) {
4031 return null;
4032 }
4033
4034 // the crc of the filename changed, this field is out of date.
4035 if (crc32fn(this.fileName) !== extraReader.readInt(4)) {
4036 return null;
4037 }
4038
4039 return utf8.utf8decode(extraReader.readData(upathField.length - 5));
4040 }
4041 return null;
4042 },
4043
4044 /**
4045 * Find the unicode comment declared in the extra field, if any.
4046 * @return {String} the unicode comment, null otherwise.
4047 */
4048 findExtraFieldUnicodeComment: function() {
4049 var ucommentField = this.extraFields[0x6375];
4050 if (ucommentField) {
4051 var extraReader = readerFor(ucommentField.value);
4052
4053 // wrong version
4054 if (extraReader.readInt(1) !== 1) {
4055 return null;
4056 }
4057
4058 // the crc of the comment changed, this field is out of date.
4059 if (crc32fn(this.fileComment) !== extraReader.readInt(4)) {
4060 return null;
4061 }
4062
4063 return utf8.utf8decode(extraReader.readData(ucommentField.length - 5));
4064 }
4065 return null;
4066 }
4067 };
4068 module.exports = ZipEntry;
4069
4070 },{"./compressedObject":2,"./compressions":3,"./crc32":4,"./reader/readerFor":22,"./support":30,"./utf8":31,"./utils":32}],35:[function(require,module,exports){
4071 'use strict';
4072
4073 var StreamHelper = require('./stream/StreamHelper');
4074 var DataWorker = require('./stream/DataWorker');
4075 var utf8 = require('./utf8');
4076 var CompressedObject = require('./compressedObject');
4077 var GenericWorker = require('./stream/GenericWorker');
4078
4079 /**
4080 * A simple object representing a file in the zip file.
4081 * @constructor
4082 * @param {string} name the name of the file
4083 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data
4084 * @param {Object} options the options of the file
4085 */
4086 var ZipObject = function(name, data, options) {
4087 this.name = name;
4088 this.dir = options.dir;
4089 this.date = options.date;
4090 this.comment = options.comment;
4091 this.unixPermissions = options.unixPermissions;
4092 this.dosPermissions = options.dosPermissions;
4093
4094 this._data = data;
4095 this._dataBinary = options.binary;
4096 // keep only the compression
4097 this.options = {
4098 compression : options.compression,
4099 compressionOptions : options.compressionOptions
4100 };
4101 };
4102
4103 ZipObject.prototype = {
4104 /**
4105 * Create an internal stream for the content of this object.
4106 * @param {String} type the type of each chunk.
4107 * @return StreamHelper the stream.
4108 */
4109 internalStream: function (type) {
4110 var result = null, outputType = "string";
4111 try {
4112 if (!type) {
4113 throw new Error("No output type specified.");
4114 }
4115 outputType = type.toLowerCase();
4116 var askUnicodeString = outputType === "string" || outputType === "text";
4117 if (outputType === "binarystring" || outputType === "text") {
4118 outputType = "string";
4119 }
4120 result = this._decompressWorker();
4121
4122 var isUnicodeString = !this._dataBinary;
4123
4124 if (isUnicodeString && !askUnicodeString) {
4125 result = result.pipe(new utf8.Utf8EncodeWorker());
4126 }
4127 if (!isUnicodeString && askUnicodeString) {
4128 result = result.pipe(new utf8.Utf8DecodeWorker());
4129 }
4130 } catch (e) {
4131 result = new GenericWorker("error");
4132 result.error(e);
4133 }
4134
4135 return new StreamHelper(result, outputType, "");
4136 },
4137
4138 /**
4139 * Prepare the content in the asked type.
4140 * @param {String} type the type of the result.
4141 * @param {Function} onUpdate a function to call on each internal update.
4142 * @return Promise the promise of the result.
4143 */
4144 async: function (type, onUpdate) {
4145 return this.internalStream(type).accumulate(onUpdate);
4146 },
4147
4148 /**
4149 * Prepare the content as a nodejs stream.
4150 * @param {String} type the type of each chunk.
4151 * @param {Function} onUpdate a function to call on each internal update.
4152 * @return Stream the stream.
4153 */
4154 nodeStream: function (type, onUpdate) {
4155 return this.internalStream(type || "nodebuffer").toNodejsStream(onUpdate);
4156 },
4157
4158 /**
4159 * Return a worker for the compressed content.
4160 * @private
4161 * @param {Object} compression the compression object to use.
4162 * @param {Object} compressionOptions the options to use when compressing.
4163 * @return Worker the worker.
4164 */
4165 _compressWorker: function (compression, compressionOptions) {
4166 if (
4167 this._data instanceof CompressedObject &&
4168 this._data.compression.magic === compression.magic
4169 ) {
4170 return this._data.getCompressedWorker();
4171 } else {
4172 var result = this._decompressWorker();
4173 if(!this._dataBinary) {
4174 result = result.pipe(new utf8.Utf8EncodeWorker());
4175 }
4176 return CompressedObject.createWorkerFrom(result, compression, compressionOptions);
4177 }
4178 },
4179 /**
4180 * Return a worker for the decompressed content.
4181 * @private
4182 * @return Worker the worker.
4183 */
4184 _decompressWorker : function () {
4185 if (this._data instanceof CompressedObject) {
4186 return this._data.getContentWorker();
4187 } else if (this._data instanceof GenericWorker) {
4188 return this._data;
4189 } else {
4190 return new DataWorker(this._data);
4191 }
4192 }
4193 };
4194
4195 var removedMethods = ["asText", "asBinary", "asNodeBuffer", "asUint8Array", "asArrayBuffer"];
4196 var removedFn = function () {
4197 throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
4198 };
4199
4200 for(var i = 0; i < removedMethods.length; i++) {
4201 ZipObject.prototype[removedMethods[i]] = removedFn;
4202 }
4203 module.exports = ZipObject;
4204
4205 },{"./compressedObject":2,"./stream/DataWorker":27,"./stream/GenericWorker":28,"./stream/StreamHelper":29,"./utf8":31}],36:[function(require,module,exports){
4206 (function (global){
4207 'use strict';
4208 var Mutation = global.MutationObserver || global.WebKitMutationObserver;
4209
4210 var scheduleDrain;
4211
4212 {
4213 if (Mutation) {
4214 var called = 0;
4215 var observer = new Mutation(nextTick);
4216 var element = global.document.createTextNode('');
4217 observer.observe(element, {
4218 characterData: true
4219 });
4220 scheduleDrain = function () {
4221 element.data = (called = ++called % 2);
4222 };
4223 } else if (!global.setImmediate && typeof global.MessageChannel !== 'undefined') {
4224 var channel = new global.MessageChannel();
4225 channel.port1.onmessage = nextTick;
4226 scheduleDrain = function () {
4227 channel.port2.postMessage(0);
4228 };
4229 } else if ('document' in global && 'onreadystatechange' in global.document.createElement('script')) {
4230 scheduleDrain = function () {
4231
4232 // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
4233 // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
4234 var scriptEl = global.document.createElement('script');
4235 scriptEl.onreadystatechange = function () {
4236 nextTick();
4237
4238 scriptEl.onreadystatechange = null;
4239 scriptEl.parentNode.removeChild(scriptEl);
4240 scriptEl = null;
4241 };
4242 global.document.documentElement.appendChild(scriptEl);
4243 };
4244 } else {
4245 scheduleDrain = function () {
4246 setTimeout(nextTick, 0);
4247 };
4248 }
4249 }
4250
4251 var draining;
4252 var queue = [];
4253 //named nextTick for less confusing stack traces
4254 function nextTick() {
4255 draining = true;
4256 var i, oldQueue;
4257 var len = queue.length;
4258 while (len) {
4259 oldQueue = queue;
4260 queue = [];
4261 i = -1;
4262 while (++i < len) {
4263 oldQueue[i]();
4264 }
4265 len = queue.length;
4266 }
4267 draining = false;
4268 }
4269
4270 module.exports = immediate;
4271 function immediate(task) {
4272 if (queue.push(task) === 1 && !draining) {
4273 scheduleDrain();
4274 }
4275 }
4276
4277 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
4278 },{}],37:[function(require,module,exports){
4279 'use strict';
4280 var immediate = require('immediate');
4281
4282 /* istanbul ignore next */
4283 function INTERNAL() {}
4284
4285 var handlers = {};
4286
4287 var REJECTED = ['REJECTED'];
4288 var FULFILLED = ['FULFILLED'];
4289 var PENDING = ['PENDING'];
4290
4291 module.exports = Promise;
4292
4293 function Promise(resolver) {
4294 if (typeof resolver !== 'function') {
4295 throw new TypeError('resolver must be a function');
4296 }
4297 this.state = PENDING;
4298 this.queue = [];
4299 this.outcome = void 0;
4300 if (resolver !== INTERNAL) {
4301 safelyResolveThenable(this, resolver);
4302 }
4303 }
4304
4305 Promise.prototype["finally"] = function (callback) {
4306 if (typeof callback !== 'function') {
4307 return this;
4308 }
4309 var p = this.constructor;
4310 return this.then(resolve, reject);
4311
4312 function resolve(value) {
4313 function yes () {
4314 return value;
4315 }
4316 return p.resolve(callback()).then(yes);
4317 }
4318 function reject(reason) {
4319 function no () {
4320 throw reason;
4321 }
4322 return p.resolve(callback()).then(no);
4323 }
4324 };
4325 Promise.prototype["catch"] = function (onRejected) {
4326 return this.then(null, onRejected);
4327 };
4328 Promise.prototype.then = function (onFulfilled, onRejected) {
4329 if (typeof onFulfilled !== 'function' && this.state === FULFILLED ||
4330 typeof onRejected !== 'function' && this.state === REJECTED) {
4331 return this;
4332 }
4333 var promise = new this.constructor(INTERNAL);
4334 if (this.state !== PENDING) {
4335 var resolver = this.state === FULFILLED ? onFulfilled : onRejected;
4336 unwrap(promise, resolver, this.outcome);
4337 } else {
4338 this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
4339 }
4340
4341 return promise;
4342 };
4343 function QueueItem(promise, onFulfilled, onRejected) {
4344 this.promise = promise;
4345 if (typeof onFulfilled === 'function') {
4346 this.onFulfilled = onFulfilled;
4347 this.callFulfilled = this.otherCallFulfilled;
4348 }
4349 if (typeof onRejected === 'function') {
4350 this.onRejected = onRejected;
4351 this.callRejected = this.otherCallRejected;
4352 }
4353 }
4354 QueueItem.prototype.callFulfilled = function (value) {
4355 handlers.resolve(this.promise, value);
4356 };
4357 QueueItem.prototype.otherCallFulfilled = function (value) {
4358 unwrap(this.promise, this.onFulfilled, value);
4359 };
4360 QueueItem.prototype.callRejected = function (value) {
4361 handlers.reject(this.promise, value);
4362 };
4363 QueueItem.prototype.otherCallRejected = function (value) {
4364 unwrap(this.promise, this.onRejected, value);
4365 };
4366
4367 function unwrap(promise, func, value) {
4368 immediate(function () {
4369 var returnValue;
4370 try {
4371 returnValue = func(value);
4372 } catch (e) {
4373 return handlers.reject(promise, e);
4374 }
4375 if (returnValue === promise) {
4376 handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
4377 } else {
4378 handlers.resolve(promise, returnValue);
4379 }
4380 });
4381 }
4382
4383 handlers.resolve = function (self, value) {
4384 var result = tryCatch(getThen, value);
4385 if (result.status === 'error') {
4386 return handlers.reject(self, result.value);
4387 }
4388 var thenable = result.value;
4389
4390 if (thenable) {
4391 safelyResolveThenable(self, thenable);
4392 } else {
4393 self.state = FULFILLED;
4394 self.outcome = value;
4395 var i = -1;
4396 var len = self.queue.length;
4397 while (++i < len) {
4398 self.queue[i].callFulfilled(value);
4399 }
4400 }
4401 return self;
4402 };
4403 handlers.reject = function (self, error) {
4404 self.state = REJECTED;
4405 self.outcome = error;
4406 var i = -1;
4407 var len = self.queue.length;
4408 while (++i < len) {
4409 self.queue[i].callRejected(error);
4410 }
4411 return self;
4412 };
4413
4414 function getThen(obj) {
4415 // Make sure we only access the accessor once as required by the spec
4416 var then = obj && obj.then;
4417 if (obj && (typeof obj === 'object' || typeof obj === 'function') && typeof then === 'function') {
4418 return function appyThen() {
4419 then.apply(obj, arguments);
4420 };
4421 }
4422 }
4423
4424 function safelyResolveThenable(self, thenable) {
4425 // Either fulfill, reject or reject with error
4426 var called = false;
4427 function onError(value) {
4428 if (called) {
4429 return;
4430 }
4431 called = true;
4432 handlers.reject(self, value);
4433 }
4434
4435 function onSuccess(value) {
4436 if (called) {
4437 return;
4438 }
4439 called = true;
4440 handlers.resolve(self, value);
4441 }
4442
4443 function tryToUnwrap() {
4444 thenable(onSuccess, onError);
4445 }
4446
4447 var result = tryCatch(tryToUnwrap);
4448 if (result.status === 'error') {
4449 onError(result.value);
4450 }
4451 }
4452
4453 function tryCatch(func, value) {
4454 var out = {};
4455 try {
4456 out.value = func(value);
4457 out.status = 'success';
4458 } catch (e) {
4459 out.status = 'error';
4460 out.value = e;
4461 }
4462 return out;
4463 }
4464
4465 Promise.resolve = resolve;
4466 function resolve(value) {
4467 if (value instanceof this) {
4468 return value;
4469 }
4470 return handlers.resolve(new this(INTERNAL), value);
4471 }
4472
4473 Promise.reject = reject;
4474 function reject(reason) {
4475 var promise = new this(INTERNAL);
4476 return handlers.reject(promise, reason);
4477 }
4478
4479 Promise.all = all;
4480 function all(iterable) {
4481 var self = this;
4482 if (Object.prototype.toString.call(iterable) !== '[object Array]') {
4483 return this.reject(new TypeError('must be an array'));
4484 }
4485
4486 var len = iterable.length;
4487 var called = false;
4488 if (!len) {
4489 return this.resolve([]);
4490 }
4491
4492 var values = new Array(len);
4493 var resolved = 0;
4494 var i = -1;
4495 var promise = new this(INTERNAL);
4496
4497 while (++i < len) {
4498 allResolver(iterable[i], i);
4499 }
4500 return promise;
4501 function allResolver(value, i) {
4502 self.resolve(value).then(resolveFromAll, function (error) {
4503 if (!called) {
4504 called = true;
4505 handlers.reject(promise, error);
4506 }
4507 });
4508 function resolveFromAll(outValue) {
4509 values[i] = outValue;
4510 if (++resolved === len && !called) {
4511 called = true;
4512 handlers.resolve(promise, values);
4513 }
4514 }
4515 }
4516 }
4517
4518 Promise.race = race;
4519 function race(iterable) {
4520 var self = this;
4521 if (Object.prototype.toString.call(iterable) !== '[object Array]') {
4522 return this.reject(new TypeError('must be an array'));
4523 }
4524
4525 var len = iterable.length;
4526 var called = false;
4527 if (!len) {
4528 return this.resolve([]);
4529 }
4530
4531 var i = -1;
4532 var promise = new this(INTERNAL);
4533
4534 while (++i < len) {
4535 resolver(iterable[i]);
4536 }
4537 return promise;
4538 function resolver(value) {
4539 self.resolve(value).then(function (response) {
4540 if (!called) {
4541 called = true;
4542 handlers.resolve(promise, response);
4543 }
4544 }, function (error) {
4545 if (!called) {
4546 called = true;
4547 handlers.reject(promise, error);
4548 }
4549 });
4550 }
4551 }
4552
4553 },{"immediate":36}],38:[function(require,module,exports){
4554 // Top level file is just a mixin of submodules & constants
4555 'use strict';
4556
4557 var assign = require('./lib/utils/common').assign;
4558
4559 var deflate = require('./lib/deflate');
4560 var inflate = require('./lib/inflate');
4561 var constants = require('./lib/zlib/constants');
4562
4563 var pako = {};
4564
4565 assign(pako, deflate, inflate, constants);
4566
4567 module.exports = pako;
4568
4569 },{"./lib/deflate":39,"./lib/inflate":40,"./lib/utils/common":41,"./lib/zlib/constants":44}],39:[function(require,module,exports){
4570 'use strict';
4571
4572
4573 var zlib_deflate = require('./zlib/deflate');
4574 var utils = require('./utils/common');
4575 var strings = require('./utils/strings');
4576 var msg = require('./zlib/messages');
4577 var ZStream = require('./zlib/zstream');
4578
4579 var toString = Object.prototype.toString;
4580
4581 /* Public constants ==========================================================*/
4582 /* ===========================================================================*/
4583
4584 var Z_NO_FLUSH = 0;
4585 var Z_FINISH = 4;
4586
4587 var Z_OK = 0;
4588 var Z_STREAM_END = 1;
4589 var Z_SYNC_FLUSH = 2;
4590
4591 var Z_DEFAULT_COMPRESSION = -1;
4592
4593 var Z_DEFAULT_STRATEGY = 0;
4594
4595 var Z_DEFLATED = 8;
4596
4597 /* ===========================================================================*/
4598
4599
4600 /**
4601 * class Deflate
4602 *
4603 * Generic JS-style wrapper for zlib calls. If you don't need
4604 * streaming behaviour - use more simple functions: [[deflate]],
4605 * [[deflateRaw]] and [[gzip]].
4606 **/
4607
4608 /* internal
4609 * Deflate.chunks -> Array
4610 *
4611 * Chunks of output data, if [[Deflate#onData]] not overriden.
4612 **/
4613
4614 /**
4615 * Deflate.result -> Uint8Array|Array
4616 *
4617 * Compressed result, generated by default [[Deflate#onData]]
4618 * and [[Deflate#onEnd]] handlers. Filled after you push last chunk
4619 * (call [[Deflate#push]] with `Z_FINISH` / `true` param) or if you
4620 * push a chunk with explicit flush (call [[Deflate#push]] with
4621 * `Z_SYNC_FLUSH` param).
4622 **/
4623
4624 /**
4625 * Deflate.err -> Number
4626 *
4627 * Error code after deflate finished. 0 (Z_OK) on success.
4628 * You will not need it in real life, because deflate errors
4629 * are possible only on wrong options or bad `onData` / `onEnd`
4630 * custom handlers.
4631 **/
4632
4633 /**
4634 * Deflate.msg -> String
4635 *
4636 * Error message, if [[Deflate.err]] != 0
4637 **/
4638
4639
4640 /**
4641 * new Deflate(options)
4642 * - options (Object): zlib deflate options.
4643 *
4644 * Creates new deflator instance with specified params. Throws exception
4645 * on bad params. Supported options:
4646 *
4647 * - `level`
4648 * - `windowBits`
4649 * - `memLevel`
4650 * - `strategy`
4651 * - `dictionary`
4652 *
4653 * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
4654 * for more information on these.
4655 *
4656 * Additional options, for internal needs:
4657 *
4658 * - `chunkSize` - size of generated data chunks (16K by default)
4659 * - `raw` (Boolean) - do raw deflate
4660 * - `gzip` (Boolean) - create gzip wrapper
4661 * - `to` (String) - if equal to 'string', then result will be "binary string"
4662 * (each char code [0..255])
4663 * - `header` (Object) - custom header for gzip
4664 * - `text` (Boolean) - true if compressed data believed to be text
4665 * - `time` (Number) - modification time, unix timestamp
4666 * - `os` (Number) - operation system code
4667 * - `extra` (Array) - array of bytes with extra data (max 65536)
4668 * - `name` (String) - file name (binary string)
4669 * - `comment` (String) - comment (binary string)
4670 * - `hcrc` (Boolean) - true if header crc should be added
4671 *
4672 * ##### Example:
4673 *
4674 * ```javascript
4675 * var pako = require('pako')
4676 * , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
4677 * , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
4678 *
4679 * var deflate = new pako.Deflate({ level: 3});
4680 *
4681 * deflate.push(chunk1, false);
4682 * deflate.push(chunk2, true); // true -> last chunk
4683 *
4684 * if (deflate.err) { throw new Error(deflate.err); }
4685 *
4686 * console.log(deflate.result);
4687 * ```
4688 **/
4689 function Deflate(options) {
4690 if (!(this instanceof Deflate)) return new Deflate(options);
4691
4692 this.options = utils.assign({
4693 level: Z_DEFAULT_COMPRESSION,
4694 method: Z_DEFLATED,
4695 chunkSize: 16384,
4696 windowBits: 15,
4697 memLevel: 8,
4698 strategy: Z_DEFAULT_STRATEGY,
4699 to: ''
4700 }, options || {});
4701
4702 var opt = this.options;
4703
4704 if (opt.raw && (opt.windowBits > 0)) {
4705 opt.windowBits = -opt.windowBits;
4706 }
4707
4708 else if (opt.gzip && (opt.windowBits > 0) && (opt.windowBits < 16)) {
4709 opt.windowBits += 16;
4710 }
4711
4712 this.err = 0; // error code, if happens (0 = Z_OK)
4713 this.msg = ''; // error message
4714 this.ended = false; // used to avoid multiple onEnd() calls
4715 this.chunks = []; // chunks of compressed data
4716
4717 this.strm = new ZStream();
4718 this.strm.avail_out = 0;
4719
4720 var status = zlib_deflate.deflateInit2(
4721 this.strm,
4722 opt.level,
4723 opt.method,
4724 opt.windowBits,
4725 opt.memLevel,
4726 opt.strategy
4727 );
4728
4729 if (status !== Z_OK) {
4730 throw new Error(msg[status]);
4731 }
4732
4733 if (opt.header) {
4734 zlib_deflate.deflateSetHeader(this.strm, opt.header);
4735 }
4736
4737 if (opt.dictionary) {
4738 var dict;
4739 // Convert data if needed
4740 if (typeof opt.dictionary === 'string') {
4741 // If we need to compress text, change encoding to utf8.
4742 dict = strings.string2buf(opt.dictionary);
4743 } else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {
4744 dict = new Uint8Array(opt.dictionary);
4745 } else {
4746 dict = opt.dictionary;
4747 }
4748
4749 status = zlib_deflate.deflateSetDictionary(this.strm, dict);
4750
4751 if (status !== Z_OK) {
4752 throw new Error(msg[status]);
4753 }
4754
4755 this._dict_set = true;
4756 }
4757 }
4758
4759 /**
4760 * Deflate#push(data[, mode]) -> Boolean
4761 * - data (Uint8Array|Array|ArrayBuffer|String): input data. Strings will be
4762 * converted to utf8 byte sequence.
4763 * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
4764 * See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH.
4765 *
4766 * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with
4767 * new compressed chunks. Returns `true` on success. The last data block must have
4768 * mode Z_FINISH (or `true`). That will flush internal pending buffers and call
4769 * [[Deflate#onEnd]]. For interim explicit flushes (without ending the stream) you
4770 * can use mode Z_SYNC_FLUSH, keeping the compression context.
4771 *
4772 * On fail call [[Deflate#onEnd]] with error code and return false.
4773 *
4774 * We strongly recommend to use `Uint8Array` on input for best speed (output
4775 * array format is detected automatically). Also, don't skip last param and always
4776 * use the same type in your code (boolean or number). That will improve JS speed.
4777 *
4778 * For regular `Array`-s make sure all elements are [0..255].
4779 *
4780 * ##### Example
4781 *
4782 * ```javascript
4783 * push(chunk, false); // push one of data chunks
4784 * ...
4785 * push(chunk, true); // push last chunk
4786 * ```
4787 **/
4788 Deflate.prototype.push = function (data, mode) {
4789 var strm = this.strm;
4790 var chunkSize = this.options.chunkSize;
4791 var status, _mode;
4792
4793 if (this.ended) { return false; }
4794
4795 _mode = (mode === ~~mode) ? mode : ((mode === true) ? Z_FINISH : Z_NO_FLUSH);
4796
4797 // Convert data if needed
4798 if (typeof data === 'string') {
4799 // If we need to compress text, change encoding to utf8.
4800 strm.input = strings.string2buf(data);
4801 } else if (toString.call(data) === '[object ArrayBuffer]') {
4802 strm.input = new Uint8Array(data);
4803 } else {
4804 strm.input = data;
4805 }
4806
4807 strm.next_in = 0;
4808 strm.avail_in = strm.input.length;
4809
4810 do {
4811 if (strm.avail_out === 0) {
4812 strm.output = new utils.Buf8(chunkSize);
4813 strm.next_out = 0;
4814 strm.avail_out = chunkSize;
4815 }
4816 status = zlib_deflate.deflate(strm, _mode); /* no bad return value */
4817
4818 if (status !== Z_STREAM_END && status !== Z_OK) {
4819 this.onEnd(status);
4820 this.ended = true;
4821 return false;
4822 }
4823 if (strm.avail_out === 0 || (strm.avail_in === 0 && (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH))) {
4824 if (this.options.to === 'string') {
4825 this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out)));
4826 } else {
4827 this.onData(utils.shrinkBuf(strm.output, strm.next_out));
4828 }
4829 }
4830 } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END);
4831
4832 // Finalize on the last chunk.
4833 if (_mode === Z_FINISH) {
4834 status = zlib_deflate.deflateEnd(this.strm);
4835 this.onEnd(status);
4836 this.ended = true;
4837 return status === Z_OK;
4838 }
4839
4840 // callback interim results if Z_SYNC_FLUSH.
4841 if (_mode === Z_SYNC_FLUSH) {
4842 this.onEnd(Z_OK);
4843 strm.avail_out = 0;
4844 return true;
4845 }
4846
4847 return true;
4848 };
4849
4850
4851 /**
4852 * Deflate#onData(chunk) -> Void
4853 * - chunk (Uint8Array|Array|String): ouput data. Type of array depends
4854 * on js engine support. When string output requested, each chunk
4855 * will be string.
4856 *
4857 * By default, stores data blocks in `chunks[]` property and glue
4858 * those in `onEnd`. Override this handler, if you need another behaviour.
4859 **/
4860 Deflate.prototype.onData = function (chunk) {
4861 this.chunks.push(chunk);
4862 };
4863
4864
4865 /**
4866 * Deflate#onEnd(status) -> Void
4867 * - status (Number): deflate status. 0 (Z_OK) on success,
4868 * other if not.
4869 *
4870 * Called once after you tell deflate that the input stream is
4871 * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)
4872 * or if an error happened. By default - join collected chunks,
4873 * free memory and fill `results` / `err` properties.
4874 **/
4875 Deflate.prototype.onEnd = function (status) {
4876 // On success - join
4877 if (status === Z_OK) {
4878 if (this.options.to === 'string') {
4879 this.result = this.chunks.join('');
4880 } else {
4881 this.result = utils.flattenChunks(this.chunks);
4882 }
4883 }
4884 this.chunks = [];
4885 this.err = status;
4886 this.msg = this.strm.msg;
4887 };
4888
4889
4890 /**
4891 * deflate(data[, options]) -> Uint8Array|Array|String
4892 * - data (Uint8Array|Array|String): input data to compress.
4893 * - options (Object): zlib deflate options.
4894 *
4895 * Compress `data` with deflate algorithm and `options`.
4896 *
4897 * Supported options are:
4898 *
4899 * - level
4900 * - windowBits
4901 * - memLevel
4902 * - strategy
4903 * - dictionary
4904 *
4905 * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
4906 * for more information on these.
4907 *
4908 * Sugar (options):
4909 *
4910 * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
4911 * negative windowBits implicitly.
4912 * - `to` (String) - if equal to 'string', then result will be "binary string"
4913 * (each char code [0..255])
4914 *
4915 * ##### Example:
4916 *
4917 * ```javascript
4918 * var pako = require('pako')
4919 * , data = Uint8Array([1,2,3,4,5,6,7,8,9]);
4920 *
4921 * console.log(pako.deflate(data));
4922 * ```
4923 **/
4924 function deflate(input, options) {
4925 var deflator = new Deflate(options);
4926
4927 deflator.push(input, true);
4928
4929 // That will never happens, if you don't cheat with options :)
4930 if (deflator.err) { throw deflator.msg || msg[deflator.err]; }
4931
4932 return deflator.result;
4933 }
4934
4935
4936 /**
4937 * deflateRaw(data[, options]) -> Uint8Array|Array|String
4938 * - data (Uint8Array|Array|String): input data to compress.
4939 * - options (Object): zlib deflate options.
4940 *
4941 * The same as [[deflate]], but creates raw data, without wrapper
4942 * (header and adler32 crc).
4943 **/
4944 function deflateRaw(input, options) {
4945 options = options || {};
4946 options.raw = true;
4947 return deflate(input, options);
4948 }
4949
4950
4951 /**
4952 * gzip(data[, options]) -> Uint8Array|Array|String
4953 * - data (Uint8Array|Array|String): input data to compress.
4954 * - options (Object): zlib deflate options.
4955 *
4956 * The same as [[deflate]], but create gzip wrapper instead of
4957 * deflate one.
4958 **/
4959 function gzip(input, options) {
4960 options = options || {};
4961 options.gzip = true;
4962 return deflate(input, options);
4963 }
4964
4965
4966 exports.Deflate = Deflate;
4967 exports.deflate = deflate;
4968 exports.deflateRaw = deflateRaw;
4969 exports.gzip = gzip;
4970
4971 },{"./utils/common":41,"./utils/strings":42,"./zlib/deflate":46,"./zlib/messages":51,"./zlib/zstream":53}],40:[function(require,module,exports){
4972 'use strict';
4973
4974
4975 var zlib_inflate = require('./zlib/inflate');
4976 var utils = require('./utils/common');
4977 var strings = require('./utils/strings');
4978 var c = require('./zlib/constants');
4979 var msg = require('./zlib/messages');
4980 var ZStream = require('./zlib/zstream');
4981 var GZheader = require('./zlib/gzheader');
4982
4983 var toString = Object.prototype.toString;
4984
4985 /**
4986 * class Inflate
4987 *
4988 * Generic JS-style wrapper for zlib calls. If you don't need
4989 * streaming behaviour - use more simple functions: [[inflate]]
4990 * and [[inflateRaw]].
4991 **/
4992
4993 /* internal
4994 * inflate.chunks -> Array
4995 *
4996 * Chunks of output data, if [[Inflate#onData]] not overriden.
4997 **/
4998
4999 /**
5000 * Inflate.result -> Uint8Array|Array|String
5001 *
5002 * Uncompressed result, generated by default [[Inflate#onData]]
5003 * and [[Inflate#onEnd]] handlers. Filled after you push last chunk
5004 * (call [[Inflate#push]] with `Z_FINISH` / `true` param) or if you
5005 * push a chunk with explicit flush (call [[Inflate#push]] with
5006 * `Z_SYNC_FLUSH` param).
5007 **/
5008
5009 /**
5010 * Inflate.err -> Number
5011 *
5012 * Error code after inflate finished. 0 (Z_OK) on success.
5013 * Should be checked if broken data possible.
5014 **/
5015
5016 /**
5017 * Inflate.msg -> String
5018 *
5019 * Error message, if [[Inflate.err]] != 0
5020 **/
5021
5022
5023 /**
5024 * new Inflate(options)
5025 * - options (Object): zlib inflate options.
5026 *
5027 * Creates new inflator instance with specified params. Throws exception
5028 * on bad params. Supported options:
5029 *
5030 * - `windowBits`
5031 * - `dictionary`
5032 *
5033 * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
5034 * for more information on these.
5035 *
5036 * Additional options, for internal needs:
5037 *
5038 * - `chunkSize` - size of generated data chunks (16K by default)
5039 * - `raw` (Boolean) - do raw inflate
5040 * - `to` (String) - if equal to 'string', then result will be converted
5041 * from utf8 to utf16 (javascript) string. When string output requested,
5042 * chunk length can differ from `chunkSize`, depending on content.
5043 *
5044 * By default, when no options set, autodetect deflate/gzip data format via
5045 * wrapper header.
5046 *
5047 * ##### Example:
5048 *
5049 * ```javascript
5050 * var pako = require('pako')
5051 * , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
5052 * , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
5053 *
5054 * var inflate = new pako.Inflate({ level: 3});
5055 *
5056 * inflate.push(chunk1, false);
5057 * inflate.push(chunk2, true); // true -> last chunk
5058 *
5059 * if (inflate.err) { throw new Error(inflate.err); }
5060 *
5061 * console.log(inflate.result);
5062 * ```
5063 **/
5064 function Inflate(options) {
5065 if (!(this instanceof Inflate)) return new Inflate(options);
5066
5067 this.options = utils.assign({
5068 chunkSize: 16384,
5069 windowBits: 0,
5070 to: ''
5071 }, options || {});
5072
5073 var opt = this.options;
5074
5075 // Force window size for `raw` data, if not set directly,
5076 // because we have no header for autodetect.
5077 if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {
5078 opt.windowBits = -opt.windowBits;
5079 if (opt.windowBits === 0) { opt.windowBits = -15; }
5080 }
5081
5082 // If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate
5083 if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&
5084 !(options && options.windowBits)) {
5085 opt.windowBits += 32;
5086 }
5087
5088 // Gzip header has no info about windows size, we can do autodetect only
5089 // for deflate. So, if window size not set, force it to max when gzip possible
5090 if ((opt.windowBits > 15) && (opt.windowBits < 48)) {
5091 // bit 3 (16) -> gzipped data
5092 // bit 4 (32) -> autodetect gzip/deflate
5093 if ((opt.windowBits & 15) === 0) {
5094 opt.windowBits |= 15;
5095 }
5096 }
5097
5098 this.err = 0; // error code, if happens (0 = Z_OK)
5099 this.msg = ''; // error message
5100 this.ended = false; // used to avoid multiple onEnd() calls
5101 this.chunks = []; // chunks of compressed data
5102
5103 this.strm = new ZStream();
5104 this.strm.avail_out = 0;
5105
5106 var status = zlib_inflate.inflateInit2(
5107 this.strm,
5108 opt.windowBits
5109 );
5110
5111 if (status !== c.Z_OK) {
5112 throw new Error(msg[status]);
5113 }
5114
5115 this.header = new GZheader();
5116
5117 zlib_inflate.inflateGetHeader(this.strm, this.header);
5118 }
5119
5120 /**
5121 * Inflate#push(data[, mode]) -> Boolean
5122 * - data (Uint8Array|Array|ArrayBuffer|String): input data
5123 * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
5124 * See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH.
5125 *
5126 * Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
5127 * new output chunks. Returns `true` on success. The last data block must have
5128 * mode Z_FINISH (or `true`). That will flush internal pending buffers and call
5129 * [[Inflate#onEnd]]. For interim explicit flushes (without ending the stream) you
5130 * can use mode Z_SYNC_FLUSH, keeping the decompression context.
5131 *
5132 * On fail call [[Inflate#onEnd]] with error code and return false.
5133 *
5134 * We strongly recommend to use `Uint8Array` on input for best speed (output
5135 * format is detected automatically). Also, don't skip last param and always
5136 * use the same type in your code (boolean or number). That will improve JS speed.
5137 *
5138 * For regular `Array`-s make sure all elements are [0..255].
5139 *
5140 * ##### Example
5141 *
5142 * ```javascript
5143 * push(chunk, false); // push one of data chunks
5144 * ...
5145 * push(chunk, true); // push last chunk
5146 * ```
5147 **/
5148 Inflate.prototype.push = function (data, mode) {
5149 var strm = this.strm;
5150 var chunkSize = this.options.chunkSize;
5151 var dictionary = this.options.dictionary;
5152 var status, _mode;
5153 var next_out_utf8, tail, utf8str;
5154 var dict;
5155
5156 // Flag to properly process Z_BUF_ERROR on testing inflate call
5157 // when we check that all output data was flushed.
5158 var allowBufError = false;
5159
5160 if (this.ended) { return false; }
5161 _mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH);
5162
5163 // Convert data if needed
5164 if (typeof data === 'string') {
5165 // Only binary strings can be decompressed on practice
5166 strm.input = strings.binstring2buf(data);
5167 } else if (toString.call(data) === '[object ArrayBuffer]') {
5168 strm.input = new Uint8Array(data);
5169 } else {
5170 strm.input = data;
5171 }
5172
5173 strm.next_in = 0;
5174 strm.avail_in = strm.input.length;
5175
5176 do {
5177 if (strm.avail_out === 0) {
5178 strm.output = new utils.Buf8(chunkSize);
5179 strm.next_out = 0;
5180 strm.avail_out = chunkSize;
5181 }
5182
5183 status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH); /* no bad return value */
5184
5185 if (status === c.Z_NEED_DICT && dictionary) {
5186 // Convert data if needed
5187 if (typeof dictionary === 'string') {
5188 dict = strings.string2buf(dictionary);
5189 } else if (toString.call(dictionary) === '[object ArrayBuffer]') {
5190 dict = new Uint8Array(dictionary);
5191 } else {
5192 dict = dictionary;
5193 }
5194
5195 status = zlib_inflate.inflateSetDictionary(this.strm, dict);
5196
5197 }
5198
5199 if (status === c.Z_BUF_ERROR && allowBufError === true) {
5200 status = c.Z_OK;
5201 allowBufError = false;
5202 }
5203
5204 if (status !== c.Z_STREAM_END && status !== c.Z_OK) {
5205 this.onEnd(status);
5206 this.ended = true;
5207 return false;
5208 }
5209
5210 if (strm.next_out) {
5211 if (strm.avail_out === 0 || status === c.Z_STREAM_END || (strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH))) {
5212
5213 if (this.options.to === 'string') {
5214
5215 next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
5216
5217 tail = strm.next_out - next_out_utf8;
5218 utf8str = strings.buf2string(strm.output, next_out_utf8);
5219
5220 // move tail
5221 strm.next_out = tail;
5222 strm.avail_out = chunkSize - tail;
5223 if (tail) { utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); }
5224
5225 this.onData(utf8str);
5226
5227 } else {
5228 this.onData(utils.shrinkBuf(strm.output, strm.next_out));
5229 }
5230 }
5231 }
5232
5233 // When no more input data, we should check that internal inflate buffers
5234 // are flushed. The only way to do it when avail_out = 0 - run one more
5235 // inflate pass. But if output data not exists, inflate return Z_BUF_ERROR.
5236 // Here we set flag to process this error properly.
5237 //
5238 // NOTE. Deflate does not return error in this case and does not needs such
5239 // logic.
5240 if (strm.avail_in === 0 && strm.avail_out === 0) {
5241 allowBufError = true;
5242 }
5243
5244 } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END);
5245
5246 if (status === c.Z_STREAM_END) {
5247 _mode = c.Z_FINISH;
5248 }
5249
5250 // Finalize on the last chunk.
5251 if (_mode === c.Z_FINISH) {
5252 status = zlib_inflate.inflateEnd(this.strm);
5253 this.onEnd(status);
5254 this.ended = true;
5255 return status === c.Z_OK;
5256 }
5257
5258 // callback interim results if Z_SYNC_FLUSH.
5259 if (_mode === c.Z_SYNC_FLUSH) {
5260 this.onEnd(c.Z_OK);
5261 strm.avail_out = 0;
5262 return true;
5263 }
5264
5265 return true;
5266 };
5267
5268
5269 /**
5270 * Inflate#onData(chunk) -> Void
5271 * - chunk (Uint8Array|Array|String): ouput data. Type of array depends
5272 * on js engine support. When string output requested, each chunk
5273 * will be string.
5274 *
5275 * By default, stores data blocks in `chunks[]` property and glue
5276 * those in `onEnd`. Override this handler, if you need another behaviour.
5277 **/
5278 Inflate.prototype.onData = function (chunk) {
5279 this.chunks.push(chunk);
5280 };
5281
5282
5283 /**
5284 * Inflate#onEnd(status) -> Void
5285 * - status (Number): inflate status. 0 (Z_OK) on success,
5286 * other if not.
5287 *
5288 * Called either after you tell inflate that the input stream is
5289 * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)
5290 * or if an error happened. By default - join collected chunks,
5291 * free memory and fill `results` / `err` properties.
5292 **/
5293 Inflate.prototype.onEnd = function (status) {
5294 // On success - join
5295 if (status === c.Z_OK) {
5296 if (this.options.to === 'string') {
5297 // Glue & convert here, until we teach pako to send
5298 // utf8 alligned strings to onData
5299 this.result = this.chunks.join('');
5300 } else {
5301 this.result = utils.flattenChunks(this.chunks);
5302 }
5303 }
5304 this.chunks = [];
5305 this.err = status;
5306 this.msg = this.strm.msg;
5307 };
5308
5309
5310 /**
5311 * inflate(data[, options]) -> Uint8Array|Array|String
5312 * - data (Uint8Array|Array|String): input data to decompress.
5313 * - options (Object): zlib inflate options.
5314 *
5315 * Decompress `data` with inflate/ungzip and `options`. Autodetect
5316 * format via wrapper header by default. That's why we don't provide
5317 * separate `ungzip` method.
5318 *
5319 * Supported options are:
5320 *
5321 * - windowBits
5322 *
5323 * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
5324 * for more information.
5325 *
5326 * Sugar (options):
5327 *
5328 * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
5329 * negative windowBits implicitly.
5330 * - `to` (String) - if equal to 'string', then result will be converted
5331 * from utf8 to utf16 (javascript) string. When string output requested,
5332 * chunk length can differ from `chunkSize`, depending on content.
5333 *
5334 *
5335 * ##### Example:
5336 *
5337 * ```javascript
5338 * var pako = require('pako')
5339 * , input = pako.deflate([1,2,3,4,5,6,7,8,9])
5340 * , output;
5341 *
5342 * try {
5343 * output = pako.inflate(input);
5344 * } catch (err)
5345 * console.log(err);
5346 * }
5347 * ```
5348 **/
5349 function inflate(input, options) {
5350 var inflator = new Inflate(options);
5351
5352 inflator.push(input, true);
5353
5354 // That will never happens, if you don't cheat with options :)
5355 if (inflator.err) { throw inflator.msg || msg[inflator.err]; }
5356
5357 return inflator.result;
5358 }
5359
5360
5361 /**
5362 * inflateRaw(data[, options]) -> Uint8Array|Array|String
5363 * - data (Uint8Array|Array|String): input data to decompress.
5364 * - options (Object): zlib inflate options.
5365 *
5366 * The same as [[inflate]], but creates raw data, without wrapper
5367 * (header and adler32 crc).
5368 **/
5369 function inflateRaw(input, options) {
5370 options = options || {};
5371 options.raw = true;
5372 return inflate(input, options);
5373 }
5374
5375
5376 /**
5377 * ungzip(data[, options]) -> Uint8Array|Array|String
5378 * - data (Uint8Array|Array|String): input data to decompress.
5379 * - options (Object): zlib inflate options.
5380 *
5381 * Just shortcut to [[inflate]], because it autodetects format
5382 * by header.content. Done for convenience.
5383 **/
5384
5385
5386 exports.Inflate = Inflate;
5387 exports.inflate = inflate;
5388 exports.inflateRaw = inflateRaw;
5389 exports.ungzip = inflate;
5390
5391 },{"./utils/common":41,"./utils/strings":42,"./zlib/constants":44,"./zlib/gzheader":47,"./zlib/inflate":49,"./zlib/messages":51,"./zlib/zstream":53}],41:[function(require,module,exports){
5392 'use strict';
5393
5394
5395 var TYPED_OK = (typeof Uint8Array !== 'undefined') &&
5396 (typeof Uint16Array !== 'undefined') &&
5397 (typeof Int32Array !== 'undefined');
5398
5399
5400 exports.assign = function (obj /*from1, from2, from3, ...*/) {
5401 var sources = Array.prototype.slice.call(arguments, 1);
5402 while (sources.length) {
5403 var source = sources.shift();
5404 if (!source) { continue; }
5405
5406 if (typeof source !== 'object') {
5407 throw new TypeError(source + 'must be non-object');
5408 }
5409
5410 for (var p in source) {
5411 if (source.hasOwnProperty(p)) {
5412 obj[p] = source[p];
5413 }
5414 }
5415 }
5416
5417 return obj;
5418 };
5419
5420
5421 // reduce buffer size, avoiding mem copy
5422 exports.shrinkBuf = function (buf, size) {
5423 if (buf.length === size) { return buf; }
5424 if (buf.subarray) { return buf.subarray(0, size); }
5425 buf.length = size;
5426 return buf;
5427 };
5428
5429
5430 var fnTyped = {
5431 arraySet: function (dest, src, src_offs, len, dest_offs) {
5432 if (src.subarray && dest.subarray) {
5433 dest.set(src.subarray(src_offs, src_offs + len), dest_offs);
5434 return;
5435 }
5436 // Fallback to ordinary array
5437 for (var i = 0; i < len; i++) {
5438 dest[dest_offs + i] = src[src_offs + i];
5439 }
5440 },
5441 // Join array of chunks to single array.
5442 flattenChunks: function (chunks) {
5443 var i, l, len, pos, chunk, result;
5444
5445 // calculate data length
5446 len = 0;
5447 for (i = 0, l = chunks.length; i < l; i++) {
5448 len += chunks[i].length;
5449 }
5450
5451 // join chunks
5452 result = new Uint8Array(len);
5453 pos = 0;
5454 for (i = 0, l = chunks.length; i < l; i++) {
5455 chunk = chunks[i];
5456 result.set(chunk, pos);
5457 pos += chunk.length;
5458 }
5459
5460 return result;
5461 }
5462 };
5463
5464 var fnUntyped = {
5465 arraySet: function (dest, src, src_offs, len, dest_offs) {
5466 for (var i = 0; i < len; i++) {
5467 dest[dest_offs + i] = src[src_offs + i];
5468 }
5469 },
5470 // Join array of chunks to single array.
5471 flattenChunks: function (chunks) {
5472 return [].concat.apply([], chunks);
5473 }
5474 };
5475
5476
5477 // Enable/Disable typed arrays use, for testing
5478 //
5479 exports.setTyped = function (on) {
5480 if (on) {
5481 exports.Buf8 = Uint8Array;
5482 exports.Buf16 = Uint16Array;
5483 exports.Buf32 = Int32Array;
5484 exports.assign(exports, fnTyped);
5485 } else {
5486 exports.Buf8 = Array;
5487 exports.Buf16 = Array;
5488 exports.Buf32 = Array;
5489 exports.assign(exports, fnUntyped);
5490 }
5491 };
5492
5493 exports.setTyped(TYPED_OK);
5494
5495 },{}],42:[function(require,module,exports){
5496 // String encode/decode helpers
5497 'use strict';
5498
5499
5500 var utils = require('./common');
5501
5502
5503 // Quick check if we can use fast array to bin string conversion
5504 //
5505 // - apply(Array) can fail on Android 2.2
5506 // - apply(Uint8Array) can fail on iOS 5.1 Safary
5507 //
5508 var STR_APPLY_OK = true;
5509 var STR_APPLY_UIA_OK = true;
5510
5511 try { String.fromCharCode.apply(null, [ 0 ]); } catch (__) { STR_APPLY_OK = false; }
5512 try { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; }
5513
5514
5515 // Table with utf8 lengths (calculated by first byte of sequence)
5516 // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
5517 // because max possible codepoint is 0x10ffff
5518 var _utf8len = new utils.Buf8(256);
5519 for (var q = 0; q < 256; q++) {
5520 _utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);
5521 }
5522 _utf8len[254] = _utf8len[254] = 1; // Invalid sequence start
5523
5524
5525 // convert string to array (typed, when possible)
5526 exports.string2buf = function (str) {
5527 var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
5528
5529 // count binary size
5530 for (m_pos = 0; m_pos < str_len; m_pos++) {
5531 c = str.charCodeAt(m_pos);
5532 if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
5533 c2 = str.charCodeAt(m_pos + 1);
5534 if ((c2 & 0xfc00) === 0xdc00) {
5535 c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
5536 m_pos++;
5537 }
5538 }
5539 buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
5540 }
5541
5542 // allocate buffer
5543 buf = new utils.Buf8(buf_len);
5544
5545 // convert
5546 for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
5547 c = str.charCodeAt(m_pos);
5548 if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
5549 c2 = str.charCodeAt(m_pos + 1);
5550 if ((c2 & 0xfc00) === 0xdc00) {
5551 c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
5552 m_pos++;
5553 }
5554 }
5555 if (c < 0x80) {
5556 /* one byte */
5557 buf[i++] = c;
5558 } else if (c < 0x800) {
5559 /* two bytes */
5560 buf[i++] = 0xC0 | (c >>> 6);
5561 buf[i++] = 0x80 | (c & 0x3f);
5562 } else if (c < 0x10000) {
5563 /* three bytes */
5564 buf[i++] = 0xE0 | (c >>> 12);
5565 buf[i++] = 0x80 | (c >>> 6 & 0x3f);
5566 buf[i++] = 0x80 | (c & 0x3f);
5567 } else {
5568 /* four bytes */
5569 buf[i++] = 0xf0 | (c >>> 18);
5570 buf[i++] = 0x80 | (c >>> 12 & 0x3f);
5571 buf[i++] = 0x80 | (c >>> 6 & 0x3f);
5572 buf[i++] = 0x80 | (c & 0x3f);
5573 }
5574 }
5575
5576 return buf;
5577 };
5578
5579 // Helper (used in 2 places)
5580 function buf2binstring(buf, len) {
5581 // use fallback for big arrays to avoid stack overflow
5582 if (len < 65537) {
5583 if ((buf.subarray && STR_APPLY_UIA_OK) || (!buf.subarray && STR_APPLY_OK)) {
5584 return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len));
5585 }
5586 }
5587
5588 var result = '';
5589 for (var i = 0; i < len; i++) {
5590 result += String.fromCharCode(buf[i]);
5591 }
5592 return result;
5593 }
5594
5595
5596 // Convert byte array to binary string
5597 exports.buf2binstring = function (buf) {
5598 return buf2binstring(buf, buf.length);
5599 };
5600
5601
5602 // Convert binary string (typed, when possible)
5603 exports.binstring2buf = function (str) {
5604 var buf = new utils.Buf8(str.length);
5605 for (var i = 0, len = buf.length; i < len; i++) {
5606 buf[i] = str.charCodeAt(i);
5607 }
5608 return buf;
5609 };
5610
5611
5612 // convert array to string
5613 exports.buf2string = function (buf, max) {
5614 var i, out, c, c_len;
5615 var len = max || buf.length;
5616
5617 // Reserve max possible length (2 words per char)
5618 // NB: by unknown reasons, Array is significantly faster for
5619 // String.fromCharCode.apply than Uint16Array.
5620 var utf16buf = new Array(len * 2);
5621
5622 for (out = 0, i = 0; i < len;) {
5623 c = buf[i++];
5624 // quick process ascii
5625 if (c < 0x80) { utf16buf[out++] = c; continue; }
5626
5627 c_len = _utf8len[c];
5628 // skip 5 & 6 byte codes
5629 if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; }
5630
5631 // apply mask on first byte
5632 c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
5633 // join the rest
5634 while (c_len > 1 && i < len) {
5635 c = (c << 6) | (buf[i++] & 0x3f);
5636 c_len--;
5637 }
5638
5639 // terminated by end of string?
5640 if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }
5641
5642 if (c < 0x10000) {
5643 utf16buf[out++] = c;
5644 } else {
5645 c -= 0x10000;
5646 utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);
5647 utf16buf[out++] = 0xdc00 | (c & 0x3ff);
5648 }
5649 }
5650
5651 return buf2binstring(utf16buf, out);
5652 };
5653
5654
5655 // Calculate max possible position in utf8 buffer,
5656 // that will not break sequence. If that's not possible
5657 // - (very small limits) return max size as is.
5658 //
5659 // buf[] - utf8 bytes array
5660 // max - length limit (mandatory);
5661 exports.utf8border = function (buf, max) {
5662 var pos;
5663
5664 max = max || buf.length;
5665 if (max > buf.length) { max = buf.length; }
5666
5667 // go back from last position, until start of sequence found
5668 pos = max - 1;
5669 while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }
5670
5671 // Fuckup - very small and broken sequence,
5672 // return max, because we should return something anyway.
5673 if (pos < 0) { return max; }
5674
5675 // If we came to start of buffer - that means vuffer is too small,
5676 // return max too.
5677 if (pos === 0) { return max; }
5678
5679 return (pos + _utf8len[buf[pos]] > max) ? pos : max;
5680 };
5681
5682 },{"./common":41}],43:[function(require,module,exports){
5683 'use strict';
5684
5685 // Note: adler32 takes 12% for level 0 and 2% for level 6.
5686 // It doesn't worth to make additional optimizationa as in original.
5687 // Small size is preferable.
5688
5689 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
5690 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
5691 //
5692 // This software is provided 'as-is', without any express or implied
5693 // warranty. In no event will the authors be held liable for any damages
5694 // arising from the use of this software.
5695 //
5696 // Permission is granted to anyone to use this software for any purpose,
5697 // including commercial applications, and to alter it and redistribute it
5698 // freely, subject to the following restrictions:
5699 //
5700 // 1. The origin of this software must not be misrepresented; you must not
5701 // claim that you wrote the original software. If you use this software
5702 // in a product, an acknowledgment in the product documentation would be
5703 // appreciated but is not required.
5704 // 2. Altered source versions must be plainly marked as such, and must not be
5705 // misrepresented as being the original software.
5706 // 3. This notice may not be removed or altered from any source distribution.
5707
5708 function adler32(adler, buf, len, pos) {
5709 var s1 = (adler & 0xffff) |0,
5710 s2 = ((adler >>> 16) & 0xffff) |0,
5711 n = 0;
5712
5713 while (len !== 0) {
5714 // Set limit ~ twice less than 5552, to keep
5715 // s2 in 31-bits, because we force signed ints.
5716 // in other case %= will fail.
5717 n = len > 2000 ? 2000 : len;
5718 len -= n;
5719
5720 do {
5721 s1 = (s1 + buf[pos++]) |0;
5722 s2 = (s2 + s1) |0;
5723 } while (--n);
5724
5725 s1 %= 65521;
5726 s2 %= 65521;
5727 }
5728
5729 return (s1 | (s2 << 16)) |0;
5730 }
5731
5732
5733 module.exports = adler32;
5734
5735 },{}],44:[function(require,module,exports){
5736 'use strict';
5737
5738 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
5739 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
5740 //
5741 // This software is provided 'as-is', without any express or implied
5742 // warranty. In no event will the authors be held liable for any damages
5743 // arising from the use of this software.
5744 //
5745 // Permission is granted to anyone to use this software for any purpose,
5746 // including commercial applications, and to alter it and redistribute it
5747 // freely, subject to the following restrictions:
5748 //
5749 // 1. The origin of this software must not be misrepresented; you must not
5750 // claim that you wrote the original software. If you use this software
5751 // in a product, an acknowledgment in the product documentation would be
5752 // appreciated but is not required.
5753 // 2. Altered source versions must be plainly marked as such, and must not be
5754 // misrepresented as being the original software.
5755 // 3. This notice may not be removed or altered from any source distribution.
5756
5757 module.exports = {
5758
5759 /* Allowed flush values; see deflate() and inflate() below for details */
5760 Z_NO_FLUSH: 0,
5761 Z_PARTIAL_FLUSH: 1,
5762 Z_SYNC_FLUSH: 2,
5763 Z_FULL_FLUSH: 3,
5764 Z_FINISH: 4,
5765 Z_BLOCK: 5,
5766 Z_TREES: 6,
5767
5768 /* Return codes for the compression/decompression functions. Negative values
5769 * are errors, positive values are used for special but normal events.
5770 */
5771 Z_OK: 0,
5772 Z_STREAM_END: 1,
5773 Z_NEED_DICT: 2,
5774 Z_ERRNO: -1,
5775 Z_STREAM_ERROR: -2,
5776 Z_DATA_ERROR: -3,
5777 //Z_MEM_ERROR: -4,
5778 Z_BUF_ERROR: -5,
5779 //Z_VERSION_ERROR: -6,
5780
5781 /* compression levels */
5782 Z_NO_COMPRESSION: 0,
5783 Z_BEST_SPEED: 1,
5784 Z_BEST_COMPRESSION: 9,
5785 Z_DEFAULT_COMPRESSION: -1,
5786
5787
5788 Z_FILTERED: 1,
5789 Z_HUFFMAN_ONLY: 2,
5790 Z_RLE: 3,
5791 Z_FIXED: 4,
5792 Z_DEFAULT_STRATEGY: 0,
5793
5794 /* Possible values of the data_type field (though see inflate()) */
5795 Z_BINARY: 0,
5796 Z_TEXT: 1,
5797 //Z_ASCII: 1, // = Z_TEXT (deprecated)
5798 Z_UNKNOWN: 2,
5799
5800 /* The deflate compression method */
5801 Z_DEFLATED: 8
5802 //Z_NULL: null // Use -1 or null inline, depending on var type
5803 };
5804
5805 },{}],45:[function(require,module,exports){
5806 'use strict';
5807
5808 // Note: we can't get significant speed boost here.
5809 // So write code to minimize size - no pregenerated tables
5810 // and array tools dependencies.
5811
5812 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
5813 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
5814 //
5815 // This software is provided 'as-is', without any express or implied
5816 // warranty. In no event will the authors be held liable for any damages
5817 // arising from the use of this software.
5818 //
5819 // Permission is granted to anyone to use this software for any purpose,
5820 // including commercial applications, and to alter it and redistribute it
5821 // freely, subject to the following restrictions:
5822 //
5823 // 1. The origin of this software must not be misrepresented; you must not
5824 // claim that you wrote the original software. If you use this software
5825 // in a product, an acknowledgment in the product documentation would be
5826 // appreciated but is not required.
5827 // 2. Altered source versions must be plainly marked as such, and must not be
5828 // misrepresented as being the original software.
5829 // 3. This notice may not be removed or altered from any source distribution.
5830
5831 // Use ordinary array, since untyped makes no boost here
5832 function makeTable() {
5833 var c, table = [];
5834
5835 for (var n = 0; n < 256; n++) {
5836 c = n;
5837 for (var k = 0; k < 8; k++) {
5838 c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
5839 }
5840 table[n] = c;
5841 }
5842
5843 return table;
5844 }
5845
5846 // Create table on load. Just 255 signed longs. Not a problem.
5847 var crcTable = makeTable();
5848
5849
5850 function crc32(crc, buf, len, pos) {
5851 var t = crcTable,
5852 end = pos + len;
5853
5854 crc ^= -1;
5855
5856 for (var i = pos; i < end; i++) {
5857 crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
5858 }
5859
5860 return (crc ^ (-1)); // >>> 0;
5861 }
5862
5863
5864 module.exports = crc32;
5865
5866 },{}],46:[function(require,module,exports){
5867 'use strict';
5868
5869 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
5870 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
5871 //
5872 // This software is provided 'as-is', without any express or implied
5873 // warranty. In no event will the authors be held liable for any damages
5874 // arising from the use of this software.
5875 //
5876 // Permission is granted to anyone to use this software for any purpose,
5877 // including commercial applications, and to alter it and redistribute it
5878 // freely, subject to the following restrictions:
5879 //
5880 // 1. The origin of this software must not be misrepresented; you must not
5881 // claim that you wrote the original software. If you use this software
5882 // in a product, an acknowledgment in the product documentation would be
5883 // appreciated but is not required.
5884 // 2. Altered source versions must be plainly marked as such, and must not be
5885 // misrepresented as being the original software.
5886 // 3. This notice may not be removed or altered from any source distribution.
5887
5888 var utils = require('../utils/common');
5889 var trees = require('./trees');
5890 var adler32 = require('./adler32');
5891 var crc32 = require('./crc32');
5892 var msg = require('./messages');
5893
5894 /* Public constants ==========================================================*/
5895 /* ===========================================================================*/
5896
5897
5898 /* Allowed flush values; see deflate() and inflate() below for details */
5899 var Z_NO_FLUSH = 0;
5900 var Z_PARTIAL_FLUSH = 1;
5901 //var Z_SYNC_FLUSH = 2;
5902 var Z_FULL_FLUSH = 3;
5903 var Z_FINISH = 4;
5904 var Z_BLOCK = 5;
5905 //var Z_TREES = 6;
5906
5907
5908 /* Return codes for the compression/decompression functions. Negative values
5909 * are errors, positive values are used for special but normal events.
5910 */
5911 var Z_OK = 0;
5912 var Z_STREAM_END = 1;
5913 //var Z_NEED_DICT = 2;
5914 //var Z_ERRNO = -1;
5915 var Z_STREAM_ERROR = -2;
5916 var Z_DATA_ERROR = -3;
5917 //var Z_MEM_ERROR = -4;
5918 var Z_BUF_ERROR = -5;
5919 //var Z_VERSION_ERROR = -6;
5920
5921
5922 /* compression levels */
5923 //var Z_NO_COMPRESSION = 0;
5924 //var Z_BEST_SPEED = 1;
5925 //var Z_BEST_COMPRESSION = 9;
5926 var Z_DEFAULT_COMPRESSION = -1;
5927
5928
5929 var Z_FILTERED = 1;
5930 var Z_HUFFMAN_ONLY = 2;
5931 var Z_RLE = 3;
5932 var Z_FIXED = 4;
5933 var Z_DEFAULT_STRATEGY = 0;
5934
5935 /* Possible values of the data_type field (though see inflate()) */
5936 //var Z_BINARY = 0;
5937 //var Z_TEXT = 1;
5938 //var Z_ASCII = 1; // = Z_TEXT
5939 var Z_UNKNOWN = 2;
5940
5941
5942 /* The deflate compression method */
5943 var Z_DEFLATED = 8;
5944
5945 /*============================================================================*/
5946
5947
5948 var MAX_MEM_LEVEL = 9;
5949 /* Maximum value for memLevel in deflateInit2 */
5950 var MAX_WBITS = 15;
5951 /* 32K LZ77 window */
5952 var DEF_MEM_LEVEL = 8;
5953
5954
5955 var LENGTH_CODES = 29;
5956 /* number of length codes, not counting the special END_BLOCK code */
5957 var LITERALS = 256;
5958 /* number of literal bytes 0..255 */
5959 var L_CODES = LITERALS + 1 + LENGTH_CODES;
5960 /* number of Literal or Length codes, including the END_BLOCK code */
5961 var D_CODES = 30;
5962 /* number of distance codes */
5963 var BL_CODES = 19;
5964 /* number of codes used to transfer the bit lengths */
5965 var HEAP_SIZE = 2 * L_CODES + 1;
5966 /* maximum heap size */
5967 var MAX_BITS = 15;
5968 /* All codes must not exceed MAX_BITS bits */
5969
5970 var MIN_MATCH = 3;
5971 var MAX_MATCH = 258;
5972 var MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);
5973
5974 var PRESET_DICT = 0x20;
5975
5976 var INIT_STATE = 42;
5977 var EXTRA_STATE = 69;
5978 var NAME_STATE = 73;
5979 var COMMENT_STATE = 91;
5980 var HCRC_STATE = 103;
5981 var BUSY_STATE = 113;
5982 var FINISH_STATE = 666;
5983
5984 var BS_NEED_MORE = 1; /* block not completed, need more input or more output */
5985 var BS_BLOCK_DONE = 2; /* block flush performed */
5986 var BS_FINISH_STARTED = 3; /* finish started, need only more output at next deflate */
5987 var BS_FINISH_DONE = 4; /* finish done, accept no more input or output */
5988
5989 var OS_CODE = 0x03; // Unix :) . Don't detect, use this default.
5990
5991 function err(strm, errorCode) {
5992 strm.msg = msg[errorCode];
5993 return errorCode;
5994 }
5995
5996 function rank(f) {
5997 return ((f) << 1) - ((f) > 4 ? 9 : 0);
5998 }
5999
6000 function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }
6001
6002
6003 /* =========================================================================
6004 * Flush as much pending output as possible. All deflate() output goes
6005 * through this function so some applications may wish to modify it
6006 * to avoid allocating a large strm->output buffer and copying into it.
6007 * (See also read_buf()).
6008 */
6009 function flush_pending(strm) {
6010 var s = strm.state;
6011
6012 //_tr_flush_bits(s);
6013 var len = s.pending;
6014 if (len > strm.avail_out) {
6015 len = strm.avail_out;
6016 }
6017 if (len === 0) { return; }
6018
6019 utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out);
6020 strm.next_out += len;
6021 s.pending_out += len;
6022 strm.total_out += len;
6023 strm.avail_out -= len;
6024 s.pending -= len;
6025 if (s.pending === 0) {
6026 s.pending_out = 0;
6027 }
6028 }
6029
6030
6031 function flush_block_only(s, last) {
6032 trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last);
6033 s.block_start = s.strstart;
6034 flush_pending(s.strm);
6035 }
6036
6037
6038 function put_byte(s, b) {
6039 s.pending_buf[s.pending++] = b;
6040 }
6041
6042
6043 /* =========================================================================
6044 * Put a short in the pending buffer. The 16-bit value is put in MSB order.
6045 * IN assertion: the stream state is correct and there is enough room in
6046 * pending_buf.
6047 */
6048 function putShortMSB(s, b) {
6049 // put_byte(s, (Byte)(b >> 8));
6050 // put_byte(s, (Byte)(b & 0xff));
6051 s.pending_buf[s.pending++] = (b >>> 8) & 0xff;
6052 s.pending_buf[s.pending++] = b & 0xff;
6053 }
6054
6055
6056 /* ===========================================================================
6057 * Read a new buffer from the current input stream, update the adler32
6058 * and total number of bytes read. All deflate() input goes through
6059 * this function so some applications may wish to modify it to avoid
6060 * allocating a large strm->input buffer and copying from it.
6061 * (See also flush_pending()).
6062 */
6063 function read_buf(strm, buf, start, size) {
6064 var len = strm.avail_in;
6065
6066 if (len > size) { len = size; }
6067 if (len === 0) { return 0; }
6068
6069 strm.avail_in -= len;
6070
6071 // zmemcpy(buf, strm->next_in, len);
6072 utils.arraySet(buf, strm.input, strm.next_in, len, start);
6073 if (strm.state.wrap === 1) {
6074 strm.adler = adler32(strm.adler, buf, len, start);
6075 }
6076
6077 else if (strm.state.wrap === 2) {
6078 strm.adler = crc32(strm.adler, buf, len, start);
6079 }
6080
6081 strm.next_in += len;
6082 strm.total_in += len;
6083
6084 return len;
6085 }
6086
6087
6088 /* ===========================================================================
6089 * Set match_start to the longest match starting at the given string and
6090 * return its length. Matches shorter or equal to prev_length are discarded,
6091 * in which case the result is equal to prev_length and match_start is
6092 * garbage.
6093 * IN assertions: cur_match is the head of the hash chain for the current
6094 * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
6095 * OUT assertion: the match length is not greater than s->lookahead.
6096 */
6097 function longest_match(s, cur_match) {
6098 var chain_length = s.max_chain_length; /* max hash chain length */
6099 var scan = s.strstart; /* current string */
6100 var match; /* matched string */
6101 var len; /* length of current match */
6102 var best_len = s.prev_length; /* best match length so far */
6103 var nice_match = s.nice_match; /* stop if match long enough */
6104 var limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ?
6105 s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0/*NIL*/;
6106
6107 var _win = s.window; // shortcut
6108
6109 var wmask = s.w_mask;
6110 var prev = s.prev;
6111
6112 /* Stop when cur_match becomes <= limit. To simplify the code,
6113 * we prevent matches with the string of window index 0.
6114 */
6115
6116 var strend = s.strstart + MAX_MATCH;
6117 var scan_end1 = _win[scan + best_len - 1];
6118 var scan_end = _win[scan + best_len];
6119
6120 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
6121 * It is easy to get rid of this optimization if necessary.
6122 */
6123 // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
6124
6125 /* Do not waste too much time if we already have a good match: */
6126 if (s.prev_length >= s.good_match) {
6127 chain_length >>= 2;
6128 }
6129 /* Do not look for matches beyond the end of the input. This is necessary
6130 * to make deflate deterministic.
6131 */
6132 if (nice_match > s.lookahead) { nice_match = s.lookahead; }
6133
6134 // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
6135
6136 do {
6137 // Assert(cur_match < s->strstart, "no future");
6138 match = cur_match;
6139
6140 /* Skip to next match if the match length cannot increase
6141 * or if the match length is less than 2. Note that the checks below
6142 * for insufficient lookahead only occur occasionally for performance
6143 * reasons. Therefore uninitialized memory will be accessed, and
6144 * conditional jumps will be made that depend on those values.
6145 * However the length of the match is limited to the lookahead, so
6146 * the output of deflate is not affected by the uninitialized values.
6147 */
6148
6149 if (_win[match + best_len] !== scan_end ||
6150 _win[match + best_len - 1] !== scan_end1 ||
6151 _win[match] !== _win[scan] ||
6152 _win[++match] !== _win[scan + 1]) {
6153 continue;
6154 }
6155
6156 /* The check at best_len-1 can be removed because it will be made
6157 * again later. (This heuristic is not always a win.)
6158 * It is not necessary to compare scan[2] and match[2] since they
6159 * are always equal when the other bytes match, given that
6160 * the hash keys are equal and that HASH_BITS >= 8.
6161 */
6162 scan += 2;
6163 match++;
6164 // Assert(*scan == *match, "match[2]?");
6165
6166 /* We check for insufficient lookahead only every 8th comparison;
6167 * the 256th check will be made at strstart+258.
6168 */
6169 do {
6170 /*jshint noempty:false*/
6171 } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
6172 _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
6173 _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
6174 _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
6175 scan < strend);
6176
6177 // Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
6178
6179 len = MAX_MATCH - (strend - scan);
6180 scan = strend - MAX_MATCH;
6181
6182 if (len > best_len) {
6183 s.match_start = cur_match;
6184 best_len = len;
6185 if (len >= nice_match) {
6186 break;
6187 }
6188 scan_end1 = _win[scan + best_len - 1];
6189 scan_end = _win[scan + best_len];
6190 }
6191 } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);
6192
6193 if (best_len <= s.lookahead) {
6194 return best_len;
6195 }
6196 return s.lookahead;
6197 }
6198
6199
6200 /* ===========================================================================
6201 * Fill the window when the lookahead becomes insufficient.
6202 * Updates strstart and lookahead.
6203 *
6204 * IN assertion: lookahead < MIN_LOOKAHEAD
6205 * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
6206 * At least one byte has been read, or avail_in == 0; reads are
6207 * performed for at least two bytes (required for the zip translate_eol
6208 * option -- not supported here).
6209 */
6210 function fill_window(s) {
6211 var _w_size = s.w_size;
6212 var p, n, m, more, str;
6213
6214 //Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
6215
6216 do {
6217 more = s.window_size - s.lookahead - s.strstart;
6218
6219 // JS ints have 32 bit, block below not needed
6220 /* Deal with !@#$% 64K limit: */
6221 //if (sizeof(int) <= 2) {
6222 // if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
6223 // more = wsize;
6224 //
6225 // } else if (more == (unsigned)(-1)) {
6226 // /* Very unlikely, but possible on 16 bit machine if
6227 // * strstart == 0 && lookahead == 1 (input done a byte at time)
6228 // */
6229 // more--;
6230 // }
6231 //}
6232
6233
6234 /* If the window is almost full and there is insufficient lookahead,
6235 * move the upper half to the lower one to make room in the upper half.
6236 */
6237 if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {
6238
6239 utils.arraySet(s.window, s.window, _w_size, _w_size, 0);
6240 s.match_start -= _w_size;
6241 s.strstart -= _w_size;
6242 /* we now have strstart >= MAX_DIST */
6243 s.block_start -= _w_size;
6244
6245 /* Slide the hash table (could be avoided with 32 bit values
6246 at the expense of memory usage). We slide even when level == 0
6247 to keep the hash table consistent if we switch back to level > 0
6248 later. (Using level 0 permanently is not an optimal usage of
6249 zlib, so we don't care about this pathological case.)
6250 */
6251
6252 n = s.hash_size;
6253 p = n;
6254 do {
6255 m = s.head[--p];
6256 s.head[p] = (m >= _w_size ? m - _w_size : 0);
6257 } while (--n);
6258
6259 n = _w_size;
6260 p = n;
6261 do {
6262 m = s.prev[--p];
6263 s.prev[p] = (m >= _w_size ? m - _w_size : 0);
6264 /* If n is not on any hash chain, prev[n] is garbage but
6265 * its value will never be used.
6266 */
6267 } while (--n);
6268
6269 more += _w_size;
6270 }
6271 if (s.strm.avail_in === 0) {
6272 break;
6273 }
6274
6275 /* If there was no sliding:
6276 * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
6277 * more == window_size - lookahead - strstart
6278 * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
6279 * => more >= window_size - 2*WSIZE + 2
6280 * In the BIG_MEM or MMAP case (not yet supported),
6281 * window_size == input_size + MIN_LOOKAHEAD &&
6282 * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
6283 * Otherwise, window_size == 2*WSIZE so more >= 2.
6284 * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
6285 */
6286 //Assert(more >= 2, "more < 2");
6287 n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);
6288 s.lookahead += n;
6289
6290 /* Initialize the hash value now that we have some input: */
6291 if (s.lookahead + s.insert >= MIN_MATCH) {
6292 str = s.strstart - s.insert;
6293 s.ins_h = s.window[str];
6294
6295 /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */
6296 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + 1]) & s.hash_mask;
6297 //#if MIN_MATCH != 3
6298 // Call update_hash() MIN_MATCH-3 more times
6299 //#endif
6300 while (s.insert) {
6301 /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
6302 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
6303
6304 s.prev[str & s.w_mask] = s.head[s.ins_h];
6305 s.head[s.ins_h] = str;
6306 str++;
6307 s.insert--;
6308 if (s.lookahead + s.insert < MIN_MATCH) {
6309 break;
6310 }
6311 }
6312 }
6313 /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
6314 * but this is not important since only literal bytes will be emitted.
6315 */
6316
6317 } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);
6318
6319 /* If the WIN_INIT bytes after the end of the current data have never been
6320 * written, then zero those bytes in order to avoid memory check reports of
6321 * the use of uninitialized (or uninitialised as Julian writes) bytes by
6322 * the longest match routines. Update the high water mark for the next
6323 * time through here. WIN_INIT is set to MAX_MATCH since the longest match
6324 * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
6325 */
6326 // if (s.high_water < s.window_size) {
6327 // var curr = s.strstart + s.lookahead;
6328 // var init = 0;
6329 //
6330 // if (s.high_water < curr) {
6331 // /* Previous high water mark below current data -- zero WIN_INIT
6332 // * bytes or up to end of window, whichever is less.
6333 // */
6334 // init = s.window_size - curr;
6335 // if (init > WIN_INIT)
6336 // init = WIN_INIT;
6337 // zmemzero(s->window + curr, (unsigned)init);
6338 // s->high_water = curr + init;
6339 // }
6340 // else if (s->high_water < (ulg)curr + WIN_INIT) {
6341 // /* High water mark at or above current data, but below current data
6342 // * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
6343 // * to end of window, whichever is less.
6344 // */
6345 // init = (ulg)curr + WIN_INIT - s->high_water;
6346 // if (init > s->window_size - s->high_water)
6347 // init = s->window_size - s->high_water;
6348 // zmemzero(s->window + s->high_water, (unsigned)init);
6349 // s->high_water += init;
6350 // }
6351 // }
6352 //
6353 // Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
6354 // "not enough room for search");
6355 }
6356
6357 /* ===========================================================================
6358 * Copy without compression as much as possible from the input stream, return
6359 * the current block state.
6360 * This function does not insert new strings in the dictionary since
6361 * uncompressible data is probably not useful. This function is used
6362 * only for the level=0 compression option.
6363 * NOTE: this function should be optimized to avoid extra copying from
6364 * window to pending_buf.
6365 */
6366 function deflate_stored(s, flush) {
6367 /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
6368 * to pending_buf_size, and each stored block has a 5 byte header:
6369 */
6370 var max_block_size = 0xffff;
6371
6372 if (max_block_size > s.pending_buf_size - 5) {
6373 max_block_size = s.pending_buf_size - 5;
6374 }
6375
6376 /* Copy as much as possible from input to output: */
6377 for (;;) {
6378 /* Fill the window as much as possible: */
6379 if (s.lookahead <= 1) {
6380
6381 //Assert(s->strstart < s->w_size+MAX_DIST(s) ||
6382 // s->block_start >= (long)s->w_size, "slide too late");
6383 // if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||
6384 // s.block_start >= s.w_size)) {
6385 // throw new Error("slide too late");
6386 // }
6387
6388 fill_window(s);
6389 if (s.lookahead === 0 && flush === Z_NO_FLUSH) {
6390 return BS_NEED_MORE;
6391 }
6392
6393 if (s.lookahead === 0) {
6394 break;
6395 }
6396 /* flush the current block */
6397 }
6398 //Assert(s->block_start >= 0L, "block gone");
6399 // if (s.block_start < 0) throw new Error("block gone");
6400
6401 s.strstart += s.lookahead;
6402 s.lookahead = 0;
6403
6404 /* Emit a stored block if pending_buf will be full: */
6405 var max_start = s.block_start + max_block_size;
6406
6407 if (s.strstart === 0 || s.strstart >= max_start) {
6408 /* strstart == 0 is possible when wraparound on 16-bit machine */
6409 s.lookahead = s.strstart - max_start;
6410 s.strstart = max_start;
6411 /*** FLUSH_BLOCK(s, 0); ***/
6412 flush_block_only(s, false);
6413 if (s.strm.avail_out === 0) {
6414 return BS_NEED_MORE;
6415 }
6416 /***/
6417
6418
6419 }
6420 /* Flush if we may have to slide, otherwise block_start may become
6421 * negative and the data will be gone:
6422 */
6423 if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) {
6424 /*** FLUSH_BLOCK(s, 0); ***/
6425 flush_block_only(s, false);
6426 if (s.strm.avail_out === 0) {
6427 return BS_NEED_MORE;
6428 }
6429 /***/
6430 }
6431 }
6432
6433 s.insert = 0;
6434
6435 if (flush === Z_FINISH) {
6436 /*** FLUSH_BLOCK(s, 1); ***/
6437 flush_block_only(s, true);
6438 if (s.strm.avail_out === 0) {
6439 return BS_FINISH_STARTED;
6440 }
6441 /***/
6442 return BS_FINISH_DONE;
6443 }
6444
6445 if (s.strstart > s.block_start) {
6446 /*** FLUSH_BLOCK(s, 0); ***/
6447 flush_block_only(s, false);
6448 if (s.strm.avail_out === 0) {
6449 return BS_NEED_MORE;
6450 }
6451 /***/
6452 }
6453
6454 return BS_NEED_MORE;
6455 }
6456
6457 /* ===========================================================================
6458 * Compress as much as possible from the input stream, return the current
6459 * block state.
6460 * This function does not perform lazy evaluation of matches and inserts
6461 * new strings in the dictionary only for unmatched strings or for short
6462 * matches. It is used only for the fast compression options.
6463 */
6464 function deflate_fast(s, flush) {
6465 var hash_head; /* head of the hash chain */
6466 var bflush; /* set if current block must be flushed */
6467
6468 for (;;) {
6469 /* Make sure that we always have enough lookahead, except
6470 * at the end of the input file. We need MAX_MATCH bytes
6471 * for the next match, plus MIN_MATCH bytes to insert the
6472 * string following the next match.
6473 */
6474 if (s.lookahead < MIN_LOOKAHEAD) {
6475 fill_window(s);
6476 if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
6477 return BS_NEED_MORE;
6478 }
6479 if (s.lookahead === 0) {
6480 break; /* flush the current block */
6481 }
6482 }
6483
6484 /* Insert the string window[strstart .. strstart+2] in the
6485 * dictionary, and set hash_head to the head of the hash chain:
6486 */
6487 hash_head = 0/*NIL*/;
6488 if (s.lookahead >= MIN_MATCH) {
6489 /*** INSERT_STRING(s, s.strstart, hash_head); ***/
6490 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
6491 hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
6492 s.head[s.ins_h] = s.strstart;
6493 /***/
6494 }
6495
6496 /* Find the longest match, discarding those <= prev_length.
6497 * At this point we have always match_length < MIN_MATCH
6498 */
6499 if (hash_head !== 0/*NIL*/ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) {
6500 /* To simplify the code, we prevent matches with the string
6501 * of window index 0 (in particular we have to avoid a match
6502 * of the string with itself at the start of the input file).
6503 */
6504 s.match_length = longest_match(s, hash_head);
6505 /* longest_match() sets match_start */
6506 }
6507 if (s.match_length >= MIN_MATCH) {
6508 // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only
6509
6510 /*** _tr_tally_dist(s, s.strstart - s.match_start,
6511 s.match_length - MIN_MATCH, bflush); ***/
6512 bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);
6513
6514 s.lookahead -= s.match_length;
6515
6516 /* Insert new strings in the hash table only if the match length
6517 * is not too large. This saves time but degrades compression.
6518 */
6519 if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH) {
6520 s.match_length--; /* string at strstart already in table */
6521 do {
6522 s.strstart++;
6523 /*** INSERT_STRING(s, s.strstart, hash_head); ***/
6524 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
6525 hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
6526 s.head[s.ins_h] = s.strstart;
6527 /***/
6528 /* strstart never exceeds WSIZE-MAX_MATCH, so there are
6529 * always MIN_MATCH bytes ahead.
6530 */
6531 } while (--s.match_length !== 0);
6532 s.strstart++;
6533 } else
6534 {
6535 s.strstart += s.match_length;
6536 s.match_length = 0;
6537 s.ins_h = s.window[s.strstart];
6538 /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */
6539 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + 1]) & s.hash_mask;
6540
6541 //#if MIN_MATCH != 3
6542 // Call UPDATE_HASH() MIN_MATCH-3 more times
6543 //#endif
6544 /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
6545 * matter since it will be recomputed at next deflate call.
6546 */
6547 }
6548 } else {
6549 /* No match, output a literal byte */
6550 //Tracevv((stderr,"%c", s.window[s.strstart]));
6551 /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
6552 bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
6553
6554 s.lookahead--;
6555 s.strstart++;
6556 }
6557 if (bflush) {
6558 /*** FLUSH_BLOCK(s, 0); ***/
6559 flush_block_only(s, false);
6560 if (s.strm.avail_out === 0) {
6561 return BS_NEED_MORE;
6562 }
6563 /***/
6564 }
6565 }
6566 s.insert = ((s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1);
6567 if (flush === Z_FINISH) {
6568 /*** FLUSH_BLOCK(s, 1); ***/
6569 flush_block_only(s, true);
6570 if (s.strm.avail_out === 0) {
6571 return BS_FINISH_STARTED;
6572 }
6573 /***/
6574 return BS_FINISH_DONE;
6575 }
6576 if (s.last_lit) {
6577 /*** FLUSH_BLOCK(s, 0); ***/
6578 flush_block_only(s, false);
6579 if (s.strm.avail_out === 0) {
6580 return BS_NEED_MORE;
6581 }
6582 /***/
6583 }
6584 return BS_BLOCK_DONE;
6585 }
6586
6587 /* ===========================================================================
6588 * Same as above, but achieves better compression. We use a lazy
6589 * evaluation for matches: a match is finally adopted only if there is
6590 * no better match at the next window position.
6591 */
6592 function deflate_slow(s, flush) {
6593 var hash_head; /* head of hash chain */
6594 var bflush; /* set if current block must be flushed */
6595
6596 var max_insert;
6597
6598 /* Process the input block. */
6599 for (;;) {
6600 /* Make sure that we always have enough lookahead, except
6601 * at the end of the input file. We need MAX_MATCH bytes
6602 * for the next match, plus MIN_MATCH bytes to insert the
6603 * string following the next match.
6604 */
6605 if (s.lookahead < MIN_LOOKAHEAD) {
6606 fill_window(s);
6607 if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
6608 return BS_NEED_MORE;
6609 }
6610 if (s.lookahead === 0) { break; } /* flush the current block */
6611 }
6612
6613 /* Insert the string window[strstart .. strstart+2] in the
6614 * dictionary, and set hash_head to the head of the hash chain:
6615 */
6616 hash_head = 0/*NIL*/;
6617 if (s.lookahead >= MIN_MATCH) {
6618 /*** INSERT_STRING(s, s.strstart, hash_head); ***/
6619 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
6620 hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
6621 s.head[s.ins_h] = s.strstart;
6622 /***/
6623 }
6624
6625 /* Find the longest match, discarding those <= prev_length.
6626 */
6627 s.prev_length = s.match_length;
6628 s.prev_match = s.match_start;
6629 s.match_length = MIN_MATCH - 1;
6630
6631 if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match &&
6632 s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)/*MAX_DIST(s)*/) {
6633 /* To simplify the code, we prevent matches with the string
6634 * of window index 0 (in particular we have to avoid a match
6635 * of the string with itself at the start of the input file).
6636 */
6637 s.match_length = longest_match(s, hash_head);
6638 /* longest_match() sets match_start */
6639
6640 if (s.match_length <= 5 &&
6641 (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/*TOO_FAR*/))) {
6642
6643 /* If prev_match is also MIN_MATCH, match_start is garbage
6644 * but we will ignore the current match anyway.
6645 */
6646 s.match_length = MIN_MATCH - 1;
6647 }
6648 }
6649 /* If there was a match at the previous step and the current
6650 * match is not better, output the previous match:
6651 */
6652 if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {
6653 max_insert = s.strstart + s.lookahead - MIN_MATCH;
6654 /* Do not insert strings in hash table beyond this. */
6655
6656 //check_match(s, s.strstart-1, s.prev_match, s.prev_length);
6657
6658 /***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,
6659 s.prev_length - MIN_MATCH, bflush);***/
6660 bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);
6661 /* Insert in hash table all strings up to the end of the match.
6662 * strstart-1 and strstart are already inserted. If there is not
6663 * enough lookahead, the last two strings are not inserted in
6664 * the hash table.
6665 */
6666 s.lookahead -= s.prev_length - 1;
6667 s.prev_length -= 2;
6668 do {
6669 if (++s.strstart <= max_insert) {
6670 /*** INSERT_STRING(s, s.strstart, hash_head); ***/
6671 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
6672 hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
6673 s.head[s.ins_h] = s.strstart;
6674 /***/
6675 }
6676 } while (--s.prev_length !== 0);
6677 s.match_available = 0;
6678 s.match_length = MIN_MATCH - 1;
6679 s.strstart++;
6680
6681 if (bflush) {
6682 /*** FLUSH_BLOCK(s, 0); ***/
6683 flush_block_only(s, false);
6684 if (s.strm.avail_out === 0) {
6685 return BS_NEED_MORE;
6686 }
6687 /***/
6688 }
6689
6690 } else if (s.match_available) {
6691 /* If there was no match at the previous position, output a
6692 * single literal. If there was a match but the current match
6693 * is longer, truncate the previous match to a single literal.
6694 */
6695 //Tracevv((stderr,"%c", s->window[s->strstart-1]));
6696 /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
6697 bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
6698
6699 if (bflush) {
6700 /*** FLUSH_BLOCK_ONLY(s, 0) ***/
6701 flush_block_only(s, false);
6702 /***/
6703 }
6704 s.strstart++;
6705 s.lookahead--;
6706 if (s.strm.avail_out === 0) {
6707 return BS_NEED_MORE;
6708 }
6709 } else {
6710 /* There is no previous match to compare with, wait for
6711 * the next step to decide.
6712 */
6713 s.match_available = 1;
6714 s.strstart++;
6715 s.lookahead--;
6716 }
6717 }
6718 //Assert (flush != Z_NO_FLUSH, "no flush?");
6719 if (s.match_available) {
6720 //Tracevv((stderr,"%c", s->window[s->strstart-1]));
6721 /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
6722 bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
6723
6724 s.match_available = 0;
6725 }
6726 s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
6727 if (flush === Z_FINISH) {
6728 /*** FLUSH_BLOCK(s, 1); ***/
6729 flush_block_only(s, true);
6730 if (s.strm.avail_out === 0) {
6731 return BS_FINISH_STARTED;
6732 }
6733 /***/
6734 return BS_FINISH_DONE;
6735 }
6736 if (s.last_lit) {
6737 /*** FLUSH_BLOCK(s, 0); ***/
6738 flush_block_only(s, false);
6739 if (s.strm.avail_out === 0) {
6740 return BS_NEED_MORE;
6741 }
6742 /***/
6743 }
6744
6745 return BS_BLOCK_DONE;
6746 }
6747
6748
6749 /* ===========================================================================
6750 * For Z_RLE, simply look for runs of bytes, generate matches only of distance
6751 * one. Do not maintain a hash table. (It will be regenerated if this run of
6752 * deflate switches away from Z_RLE.)
6753 */
6754 function deflate_rle(s, flush) {
6755 var bflush; /* set if current block must be flushed */
6756 var prev; /* byte at distance one to match */
6757 var scan, strend; /* scan goes up to strend for length of run */
6758
6759 var _win = s.window;
6760
6761 for (;;) {
6762 /* Make sure that we always have enough lookahead, except
6763 * at the end of the input file. We need MAX_MATCH bytes
6764 * for the longest run, plus one for the unrolled loop.
6765 */
6766 if (s.lookahead <= MAX_MATCH) {
6767 fill_window(s);
6768 if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) {
6769 return BS_NEED_MORE;
6770 }
6771 if (s.lookahead === 0) { break; } /* flush the current block */
6772 }
6773
6774 /* See how many times the previous byte repeats */
6775 s.match_length = 0;
6776 if (s.lookahead >= MIN_MATCH && s.strstart > 0) {
6777 scan = s.strstart - 1;
6778 prev = _win[scan];
6779 if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {
6780 strend = s.strstart + MAX_MATCH;
6781 do {
6782 /*jshint noempty:false*/
6783 } while (prev === _win[++scan] && prev === _win[++scan] &&
6784 prev === _win[++scan] && prev === _win[++scan] &&
6785 prev === _win[++scan] && prev === _win[++scan] &&
6786 prev === _win[++scan] && prev === _win[++scan] &&
6787 scan < strend);
6788 s.match_length = MAX_MATCH - (strend - scan);
6789 if (s.match_length > s.lookahead) {
6790 s.match_length = s.lookahead;
6791 }
6792 }
6793 //Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
6794 }
6795
6796 /* Emit match if have run of MIN_MATCH or longer, else emit literal */
6797 if (s.match_length >= MIN_MATCH) {
6798 //check_match(s, s.strstart, s.strstart - 1, s.match_length);
6799
6800 /*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/
6801 bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH);
6802
6803 s.lookahead -= s.match_length;
6804 s.strstart += s.match_length;
6805 s.match_length = 0;
6806 } else {
6807 /* No match, output a literal byte */
6808 //Tracevv((stderr,"%c", s->window[s->strstart]));
6809 /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
6810 bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
6811
6812 s.lookahead--;
6813 s.strstart++;
6814 }
6815 if (bflush) {
6816 /*** FLUSH_BLOCK(s, 0); ***/
6817 flush_block_only(s, false);
6818 if (s.strm.avail_out === 0) {
6819 return BS_NEED_MORE;
6820 }
6821 /***/
6822 }
6823 }
6824 s.insert = 0;
6825 if (flush === Z_FINISH) {
6826 /*** FLUSH_BLOCK(s, 1); ***/
6827 flush_block_only(s, true);
6828 if (s.strm.avail_out === 0) {
6829 return BS_FINISH_STARTED;
6830 }
6831 /***/
6832 return BS_FINISH_DONE;
6833 }
6834 if (s.last_lit) {
6835 /*** FLUSH_BLOCK(s, 0); ***/
6836 flush_block_only(s, false);
6837 if (s.strm.avail_out === 0) {
6838 return BS_NEED_MORE;
6839 }
6840 /***/
6841 }
6842 return BS_BLOCK_DONE;
6843 }
6844
6845 /* ===========================================================================
6846 * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table.
6847 * (It will be regenerated if this run of deflate switches away from Huffman.)
6848 */
6849 function deflate_huff(s, flush) {
6850 var bflush; /* set if current block must be flushed */
6851
6852 for (;;) {
6853 /* Make sure that we have a literal to write. */
6854 if (s.lookahead === 0) {
6855 fill_window(s);
6856 if (s.lookahead === 0) {
6857 if (flush === Z_NO_FLUSH) {
6858 return BS_NEED_MORE;
6859 }
6860 break; /* flush the current block */
6861 }
6862 }
6863
6864 /* Output a literal byte */
6865 s.match_length = 0;
6866 //Tracevv((stderr,"%c", s->window[s->strstart]));
6867 /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
6868 bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
6869 s.lookahead--;
6870 s.strstart++;
6871 if (bflush) {
6872 /*** FLUSH_BLOCK(s, 0); ***/
6873 flush_block_only(s, false);
6874 if (s.strm.avail_out === 0) {
6875 return BS_NEED_MORE;
6876 }
6877 /***/
6878 }
6879 }
6880 s.insert = 0;
6881 if (flush === Z_FINISH) {
6882 /*** FLUSH_BLOCK(s, 1); ***/
6883 flush_block_only(s, true);
6884 if (s.strm.avail_out === 0) {
6885 return BS_FINISH_STARTED;
6886 }
6887 /***/
6888 return BS_FINISH_DONE;
6889 }
6890 if (s.last_lit) {
6891 /*** FLUSH_BLOCK(s, 0); ***/
6892 flush_block_only(s, false);
6893 if (s.strm.avail_out === 0) {
6894 return BS_NEED_MORE;
6895 }
6896 /***/
6897 }
6898 return BS_BLOCK_DONE;
6899 }
6900
6901 /* Values for max_lazy_match, good_match and max_chain_length, depending on
6902 * the desired pack level (0..9). The values given below have been tuned to
6903 * exclude worst case performance for pathological files. Better values may be
6904 * found for specific files.
6905 */
6906 function Config(good_length, max_lazy, nice_length, max_chain, func) {
6907 this.good_length = good_length;
6908 this.max_lazy = max_lazy;
6909 this.nice_length = nice_length;
6910 this.max_chain = max_chain;
6911 this.func = func;
6912 }
6913
6914 var configuration_table;
6915
6916 configuration_table = [
6917 /* good lazy nice chain */
6918 new Config(0, 0, 0, 0, deflate_stored), /* 0 store only */
6919 new Config(4, 4, 8, 4, deflate_fast), /* 1 max speed, no lazy matches */
6920 new Config(4, 5, 16, 8, deflate_fast), /* 2 */
6921 new Config(4, 6, 32, 32, deflate_fast), /* 3 */
6922
6923 new Config(4, 4, 16, 16, deflate_slow), /* 4 lazy matches */
6924 new Config(8, 16, 32, 32, deflate_slow), /* 5 */
6925 new Config(8, 16, 128, 128, deflate_slow), /* 6 */
6926 new Config(8, 32, 128, 256, deflate_slow), /* 7 */
6927 new Config(32, 128, 258, 1024, deflate_slow), /* 8 */
6928 new Config(32, 258, 258, 4096, deflate_slow) /* 9 max compression */
6929 ];
6930
6931
6932 /* ===========================================================================
6933 * Initialize the "longest match" routines for a new zlib stream
6934 */
6935 function lm_init(s) {
6936 s.window_size = 2 * s.w_size;
6937
6938 /*** CLEAR_HASH(s); ***/
6939 zero(s.head); // Fill with NIL (= 0);
6940
6941 /* Set the default configuration parameters:
6942 */
6943 s.max_lazy_match = configuration_table[s.level].max_lazy;
6944 s.good_match = configuration_table[s.level].good_length;
6945 s.nice_match = configuration_table[s.level].nice_length;
6946 s.max_chain_length = configuration_table[s.level].max_chain;
6947
6948 s.strstart = 0;
6949 s.block_start = 0;
6950 s.lookahead = 0;
6951 s.insert = 0;
6952 s.match_length = s.prev_length = MIN_MATCH - 1;
6953 s.match_available = 0;
6954 s.ins_h = 0;
6955 }
6956
6957
6958 function DeflateState() {
6959 this.strm = null; /* pointer back to this zlib stream */
6960 this.status = 0; /* as the name implies */
6961 this.pending_buf = null; /* output still pending */
6962 this.pending_buf_size = 0; /* size of pending_buf */
6963 this.pending_out = 0; /* next pending byte to output to the stream */
6964 this.pending = 0; /* nb of bytes in the pending buffer */
6965 this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */
6966 this.gzhead = null; /* gzip header information to write */
6967 this.gzindex = 0; /* where in extra, name, or comment */
6968 this.method = Z_DEFLATED; /* can only be DEFLATED */
6969 this.last_flush = -1; /* value of flush param for previous deflate call */
6970
6971 this.w_size = 0; /* LZ77 window size (32K by default) */
6972 this.w_bits = 0; /* log2(w_size) (8..16) */
6973 this.w_mask = 0; /* w_size - 1 */
6974
6975 this.window = null;
6976 /* Sliding window. Input bytes are read into the second half of the window,
6977 * and move to the first half later to keep a dictionary of at least wSize
6978 * bytes. With this organization, matches are limited to a distance of
6979 * wSize-MAX_MATCH bytes, but this ensures that IO is always
6980 * performed with a length multiple of the block size.
6981 */
6982
6983 this.window_size = 0;
6984 /* Actual size of window: 2*wSize, except when the user input buffer
6985 * is directly used as sliding window.
6986 */
6987
6988 this.prev = null;
6989 /* Link to older string with same hash index. To limit the size of this
6990 * array to 64K, this link is maintained only for the last 32K strings.
6991 * An index in this array is thus a window index modulo 32K.
6992 */
6993
6994 this.head = null; /* Heads of the hash chains or NIL. */
6995
6996 this.ins_h = 0; /* hash index of string to be inserted */
6997 this.hash_size = 0; /* number of elements in hash table */
6998 this.hash_bits = 0; /* log2(hash_size) */
6999 this.hash_mask = 0; /* hash_size-1 */
7000
7001 this.hash_shift = 0;
7002 /* Number of bits by which ins_h must be shifted at each input
7003 * step. It must be such that after MIN_MATCH steps, the oldest
7004 * byte no longer takes part in the hash key, that is:
7005 * hash_shift * MIN_MATCH >= hash_bits
7006 */
7007
7008 this.block_start = 0;
7009 /* Window position at the beginning of the current output block. Gets
7010 * negative when the window is moved backwards.
7011 */
7012
7013 this.match_length = 0; /* length of best match */
7014 this.prev_match = 0; /* previous match */
7015 this.match_available = 0; /* set if previous match exists */
7016 this.strstart = 0; /* start of string to insert */
7017 this.match_start = 0; /* start of matching string */
7018 this.lookahead = 0; /* number of valid bytes ahead in window */
7019
7020 this.prev_length = 0;
7021 /* Length of the best match at previous step. Matches not greater than this
7022 * are discarded. This is used in the lazy match evaluation.
7023 */
7024
7025 this.max_chain_length = 0;
7026 /* To speed up deflation, hash chains are never searched beyond this
7027 * length. A higher limit improves compression ratio but degrades the
7028 * speed.
7029 */
7030
7031 this.max_lazy_match = 0;
7032 /* Attempt to find a better match only when the current match is strictly
7033 * smaller than this value. This mechanism is used only for compression
7034 * levels >= 4.
7035 */
7036 // That's alias to max_lazy_match, don't use directly
7037 //this.max_insert_length = 0;
7038 /* Insert new strings in the hash table only if the match length is not
7039 * greater than this length. This saves time but degrades compression.
7040 * max_insert_length is used only for compression levels <= 3.
7041 */
7042
7043 this.level = 0; /* compression level (1..9) */
7044 this.strategy = 0; /* favor or force Huffman coding*/
7045
7046 this.good_match = 0;
7047 /* Use a faster search when the previous match is longer than this */
7048
7049 this.nice_match = 0; /* Stop searching when current match exceeds this */
7050
7051 /* used by trees.c: */
7052
7053 /* Didn't use ct_data typedef below to suppress compiler warning */
7054
7055 // struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */
7056 // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
7057 // struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */
7058
7059 // Use flat array of DOUBLE size, with interleaved fata,
7060 // because JS does not support effective
7061 this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2);
7062 this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2);
7063 this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2);
7064 zero(this.dyn_ltree);
7065 zero(this.dyn_dtree);
7066 zero(this.bl_tree);
7067
7068 this.l_desc = null; /* desc. for literal tree */
7069 this.d_desc = null; /* desc. for distance tree */
7070 this.bl_desc = null; /* desc. for bit length tree */
7071
7072 //ush bl_count[MAX_BITS+1];
7073 this.bl_count = new utils.Buf16(MAX_BITS + 1);
7074 /* number of codes at each bit length for an optimal tree */
7075
7076 //int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
7077 this.heap = new utils.Buf16(2 * L_CODES + 1); /* heap used to build the Huffman trees */
7078 zero(this.heap);
7079
7080 this.heap_len = 0; /* number of elements in the heap */
7081 this.heap_max = 0; /* element of largest frequency */
7082 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
7083 * The same heap array is used to build all trees.
7084 */
7085
7086 this.depth = new utils.Buf16(2 * L_CODES + 1); //uch depth[2*L_CODES+1];
7087 zero(this.depth);
7088 /* Depth of each subtree used as tie breaker for trees of equal frequency
7089 */
7090
7091 this.l_buf = 0; /* buffer index for literals or lengths */
7092
7093 this.lit_bufsize = 0;
7094 /* Size of match buffer for literals/lengths. There are 4 reasons for
7095 * limiting lit_bufsize to 64K:
7096 * - frequencies can be kept in 16 bit counters
7097 * - if compression is not successful for the first block, all input
7098 * data is still in the window so we can still emit a stored block even
7099 * when input comes from standard input. (This can also be done for
7100 * all blocks if lit_bufsize is not greater than 32K.)
7101 * - if compression is not successful for a file smaller than 64K, we can
7102 * even emit a stored file instead of a stored block (saving 5 bytes).
7103 * This is applicable only for zip (not gzip or zlib).
7104 * - creating new Huffman trees less frequently may not provide fast
7105 * adaptation to changes in the input data statistics. (Take for
7106 * example a binary file with poorly compressible code followed by
7107 * a highly compressible string table.) Smaller buffer sizes give
7108 * fast adaptation but have of course the overhead of transmitting
7109 * trees more frequently.
7110 * - I can't count above 4
7111 */
7112
7113 this.last_lit = 0; /* running index in l_buf */
7114
7115 this.d_buf = 0;
7116 /* Buffer index for distances. To simplify the code, d_buf and l_buf have
7117 * the same number of elements. To use different lengths, an extra flag
7118 * array would be necessary.
7119 */
7120
7121 this.opt_len = 0; /* bit length of current block with optimal trees */
7122 this.static_len = 0; /* bit length of current block with static trees */
7123 this.matches = 0; /* number of string matches in current block */
7124 this.insert = 0; /* bytes at end of window left to insert */
7125
7126
7127 this.bi_buf = 0;
7128 /* Output buffer. bits are inserted starting at the bottom (least
7129 * significant bits).
7130 */
7131 this.bi_valid = 0;
7132 /* Number of valid bits in bi_buf. All bits above the last valid bit
7133 * are always zero.
7134 */
7135
7136 // Used for window memory init. We safely ignore it for JS. That makes
7137 // sense only for pointers and memory check tools.
7138 //this.high_water = 0;
7139 /* High water mark offset in window for initialized bytes -- bytes above
7140 * this are set to zero in order to avoid memory check warnings when
7141 * longest match routines access bytes past the input. This is then
7142 * updated to the new high water mark.
7143 */
7144 }
7145
7146
7147 function deflateResetKeep(strm) {
7148 var s;
7149
7150 if (!strm || !strm.state) {
7151 return err(strm, Z_STREAM_ERROR);
7152 }
7153
7154 strm.total_in = strm.total_out = 0;
7155 strm.data_type = Z_UNKNOWN;
7156
7157 s = strm.state;
7158 s.pending = 0;
7159 s.pending_out = 0;
7160
7161 if (s.wrap < 0) {
7162 s.wrap = -s.wrap;
7163 /* was made negative by deflate(..., Z_FINISH); */
7164 }
7165 s.status = (s.wrap ? INIT_STATE : BUSY_STATE);
7166 strm.adler = (s.wrap === 2) ?
7167 0 // crc32(0, Z_NULL, 0)
7168 :
7169 1; // adler32(0, Z_NULL, 0)
7170 s.last_flush = Z_NO_FLUSH;
7171 trees._tr_init(s);
7172 return Z_OK;
7173 }
7174
7175
7176 function deflateReset(strm) {
7177 var ret = deflateResetKeep(strm);
7178 if (ret === Z_OK) {
7179 lm_init(strm.state);
7180 }
7181 return ret;
7182 }
7183
7184
7185 function deflateSetHeader(strm, head) {
7186 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
7187 if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; }
7188 strm.state.gzhead = head;
7189 return Z_OK;
7190 }
7191
7192
7193 function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {
7194 if (!strm) { // === Z_NULL
7195 return Z_STREAM_ERROR;
7196 }
7197 var wrap = 1;
7198
7199 if (level === Z_DEFAULT_COMPRESSION) {
7200 level = 6;
7201 }
7202
7203 if (windowBits < 0) { /* suppress zlib wrapper */
7204 wrap = 0;
7205 windowBits = -windowBits;
7206 }
7207
7208 else if (windowBits > 15) {
7209 wrap = 2; /* write gzip wrapper instead */
7210 windowBits -= 16;
7211 }
7212
7213
7214 if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED ||
7215 windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
7216 strategy < 0 || strategy > Z_FIXED) {
7217 return err(strm, Z_STREAM_ERROR);
7218 }
7219
7220
7221 if (windowBits === 8) {
7222 windowBits = 9;
7223 }
7224 /* until 256-byte window bug fixed */
7225
7226 var s = new DeflateState();
7227
7228 strm.state = s;
7229 s.strm = strm;
7230
7231 s.wrap = wrap;
7232 s.gzhead = null;
7233 s.w_bits = windowBits;
7234 s.w_size = 1 << s.w_bits;
7235 s.w_mask = s.w_size - 1;
7236
7237 s.hash_bits = memLevel + 7;
7238 s.hash_size = 1 << s.hash_bits;
7239 s.hash_mask = s.hash_size - 1;
7240 s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
7241
7242 s.window = new utils.Buf8(s.w_size * 2);
7243 s.head = new utils.Buf16(s.hash_size);
7244 s.prev = new utils.Buf16(s.w_size);
7245
7246 // Don't need mem init magic for JS.
7247 //s.high_water = 0; /* nothing written to s->window yet */
7248
7249 s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
7250
7251 s.pending_buf_size = s.lit_bufsize * 4;
7252
7253 //overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
7254 //s->pending_buf = (uchf *) overlay;
7255 s.pending_buf = new utils.Buf8(s.pending_buf_size);
7256
7257 // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)
7258 //s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
7259 s.d_buf = 1 * s.lit_bufsize;
7260
7261 //s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
7262 s.l_buf = (1 + 2) * s.lit_bufsize;
7263
7264 s.level = level;
7265 s.strategy = strategy;
7266 s.method = method;
7267
7268 return deflateReset(strm);
7269 }
7270
7271 function deflateInit(strm, level) {
7272 return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
7273 }
7274
7275
7276 function deflate(strm, flush) {
7277 var old_flush, s;
7278 var beg, val; // for gzip header write only
7279
7280 if (!strm || !strm.state ||
7281 flush > Z_BLOCK || flush < 0) {
7282 return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;
7283 }
7284
7285 s = strm.state;
7286
7287 if (!strm.output ||
7288 (!strm.input && strm.avail_in !== 0) ||
7289 (s.status === FINISH_STATE && flush !== Z_FINISH)) {
7290 return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR);
7291 }
7292
7293 s.strm = strm; /* just in case */
7294 old_flush = s.last_flush;
7295 s.last_flush = flush;
7296
7297 /* Write the header */
7298 if (s.status === INIT_STATE) {
7299
7300 if (s.wrap === 2) { // GZIP header
7301 strm.adler = 0; //crc32(0L, Z_NULL, 0);
7302 put_byte(s, 31);
7303 put_byte(s, 139);
7304 put_byte(s, 8);
7305 if (!s.gzhead) { // s->gzhead == Z_NULL
7306 put_byte(s, 0);
7307 put_byte(s, 0);
7308 put_byte(s, 0);
7309 put_byte(s, 0);
7310 put_byte(s, 0);
7311 put_byte(s, s.level === 9 ? 2 :
7312 (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
7313 4 : 0));
7314 put_byte(s, OS_CODE);
7315 s.status = BUSY_STATE;
7316 }
7317 else {
7318 put_byte(s, (s.gzhead.text ? 1 : 0) +
7319 (s.gzhead.hcrc ? 2 : 0) +
7320 (!s.gzhead.extra ? 0 : 4) +
7321 (!s.gzhead.name ? 0 : 8) +
7322 (!s.gzhead.comment ? 0 : 16)
7323 );
7324 put_byte(s, s.gzhead.time & 0xff);
7325 put_byte(s, (s.gzhead.time >> 8) & 0xff);
7326 put_byte(s, (s.gzhead.time >> 16) & 0xff);
7327 put_byte(s, (s.gzhead.time >> 24) & 0xff);
7328 put_byte(s, s.level === 9 ? 2 :
7329 (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
7330 4 : 0));
7331 put_byte(s, s.gzhead.os & 0xff);
7332 if (s.gzhead.extra && s.gzhead.extra.length) {
7333 put_byte(s, s.gzhead.extra.length & 0xff);
7334 put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);
7335 }
7336 if (s.gzhead.hcrc) {
7337 strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0);
7338 }
7339 s.gzindex = 0;
7340 s.status = EXTRA_STATE;
7341 }
7342 }
7343 else // DEFLATE header
7344 {
7345 var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;
7346 var level_flags = -1;
7347
7348 if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
7349 level_flags = 0;
7350 } else if (s.level < 6) {
7351 level_flags = 1;
7352 } else if (s.level === 6) {
7353 level_flags = 2;
7354 } else {
7355 level_flags = 3;
7356 }
7357 header |= (level_flags << 6);
7358 if (s.strstart !== 0) { header |= PRESET_DICT; }
7359 header += 31 - (header % 31);
7360
7361 s.status = BUSY_STATE;
7362 putShortMSB(s, header);
7363
7364 /* Save the adler32 of the preset dictionary: */
7365 if (s.strstart !== 0) {
7366 putShortMSB(s, strm.adler >>> 16);
7367 putShortMSB(s, strm.adler & 0xffff);
7368 }
7369 strm.adler = 1; // adler32(0L, Z_NULL, 0);
7370 }
7371 }
7372
7373 //#ifdef GZIP
7374 if (s.status === EXTRA_STATE) {
7375 if (s.gzhead.extra/* != Z_NULL*/) {
7376 beg = s.pending; /* start of bytes to update crc */
7377
7378 while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {
7379 if (s.pending === s.pending_buf_size) {
7380 if (s.gzhead.hcrc && s.pending > beg) {
7381 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
7382 }
7383 flush_pending(strm);
7384 beg = s.pending;
7385 if (s.pending === s.pending_buf_size) {
7386 break;
7387 }
7388 }
7389 put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);
7390 s.gzindex++;
7391 }
7392 if (s.gzhead.hcrc && s.pending > beg) {
7393 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
7394 }
7395 if (s.gzindex === s.gzhead.extra.length) {
7396 s.gzindex = 0;
7397 s.status = NAME_STATE;
7398 }
7399 }
7400 else {
7401 s.status = NAME_STATE;
7402 }
7403 }
7404 if (s.status === NAME_STATE) {
7405 if (s.gzhead.name/* != Z_NULL*/) {
7406 beg = s.pending; /* start of bytes to update crc */
7407 //int val;
7408
7409 do {
7410 if (s.pending === s.pending_buf_size) {
7411 if (s.gzhead.hcrc && s.pending > beg) {
7412 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
7413 }
7414 flush_pending(strm);
7415 beg = s.pending;
7416 if (s.pending === s.pending_buf_size) {
7417 val = 1;
7418 break;
7419 }
7420 }
7421 // JS specific: little magic to add zero terminator to end of string
7422 if (s.gzindex < s.gzhead.name.length) {
7423 val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;
7424 } else {
7425 val = 0;
7426 }
7427 put_byte(s, val);
7428 } while (val !== 0);
7429
7430 if (s.gzhead.hcrc && s.pending > beg) {
7431 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
7432 }
7433 if (val === 0) {
7434 s.gzindex = 0;
7435 s.status = COMMENT_STATE;
7436 }
7437 }
7438 else {
7439 s.status = COMMENT_STATE;
7440 }
7441 }
7442 if (s.status === COMMENT_STATE) {
7443 if (s.gzhead.comment/* != Z_NULL*/) {
7444 beg = s.pending; /* start of bytes to update crc */
7445 //int val;
7446
7447 do {
7448 if (s.pending === s.pending_buf_size) {
7449 if (s.gzhead.hcrc && s.pending > beg) {
7450 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
7451 }
7452 flush_pending(strm);
7453 beg = s.pending;
7454 if (s.pending === s.pending_buf_size) {
7455 val = 1;
7456 break;
7457 }
7458 }
7459 // JS specific: little magic to add zero terminator to end of string
7460 if (s.gzindex < s.gzhead.comment.length) {
7461 val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;
7462 } else {
7463 val = 0;
7464 }
7465 put_byte(s, val);
7466 } while (val !== 0);
7467
7468 if (s.gzhead.hcrc && s.pending > beg) {
7469 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
7470 }
7471 if (val === 0) {
7472 s.status = HCRC_STATE;
7473 }
7474 }
7475 else {
7476 s.status = HCRC_STATE;
7477 }
7478 }
7479 if (s.status === HCRC_STATE) {
7480 if (s.gzhead.hcrc) {
7481 if (s.pending + 2 > s.pending_buf_size) {
7482 flush_pending(strm);
7483 }
7484 if (s.pending + 2 <= s.pending_buf_size) {
7485 put_byte(s, strm.adler & 0xff);
7486 put_byte(s, (strm.adler >> 8) & 0xff);
7487 strm.adler = 0; //crc32(0L, Z_NULL, 0);
7488 s.status = BUSY_STATE;
7489 }
7490 }
7491 else {
7492 s.status = BUSY_STATE;
7493 }
7494 }
7495 //#endif
7496
7497 /* Flush as much pending output as possible */
7498 if (s.pending !== 0) {
7499 flush_pending(strm);
7500 if (strm.avail_out === 0) {
7501 /* Since avail_out is 0, deflate will be called again with
7502 * more output space, but possibly with both pending and
7503 * avail_in equal to zero. There won't be anything to do,
7504 * but this is not an error situation so make sure we
7505 * return OK instead of BUF_ERROR at next call of deflate:
7506 */
7507 s.last_flush = -1;
7508 return Z_OK;
7509 }
7510
7511 /* Make sure there is something to do and avoid duplicate consecutive
7512 * flushes. For repeated and useless calls with Z_FINISH, we keep
7513 * returning Z_STREAM_END instead of Z_BUF_ERROR.
7514 */
7515 } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&
7516 flush !== Z_FINISH) {
7517 return err(strm, Z_BUF_ERROR);
7518 }
7519
7520 /* User must not provide more input after the first FINISH: */
7521 if (s.status === FINISH_STATE && strm.avail_in !== 0) {
7522 return err(strm, Z_BUF_ERROR);
7523 }
7524
7525 /* Start a new block or continue the current one.
7526 */
7527 if (strm.avail_in !== 0 || s.lookahead !== 0 ||
7528 (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {
7529 var bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) :
7530 (s.strategy === Z_RLE ? deflate_rle(s, flush) :
7531 configuration_table[s.level].func(s, flush));
7532
7533 if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {
7534 s.status = FINISH_STATE;
7535 }
7536 if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {
7537 if (strm.avail_out === 0) {
7538 s.last_flush = -1;
7539 /* avoid BUF_ERROR next call, see above */
7540 }
7541 return Z_OK;
7542 /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
7543 * of deflate should use the same flush parameter to make sure
7544 * that the flush is complete. So we don't have to output an
7545 * empty block here, this will be done at next call. This also
7546 * ensures that for a very small output buffer, we emit at most
7547 * one empty block.
7548 */
7549 }
7550 if (bstate === BS_BLOCK_DONE) {
7551 if (flush === Z_PARTIAL_FLUSH) {
7552 trees._tr_align(s);
7553 }
7554 else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */
7555
7556 trees._tr_stored_block(s, 0, 0, false);
7557 /* For a full flush, this empty block will be recognized
7558 * as a special marker by inflate_sync().
7559 */
7560 if (flush === Z_FULL_FLUSH) {
7561 /*** CLEAR_HASH(s); ***/ /* forget history */
7562 zero(s.head); // Fill with NIL (= 0);
7563
7564 if (s.lookahead === 0) {
7565 s.strstart = 0;
7566 s.block_start = 0;
7567 s.insert = 0;
7568 }
7569 }
7570 }
7571 flush_pending(strm);
7572 if (strm.avail_out === 0) {
7573 s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */
7574 return Z_OK;
7575 }
7576 }
7577 }
7578 //Assert(strm->avail_out > 0, "bug2");
7579 //if (strm.avail_out <= 0) { throw new Error("bug2");}
7580
7581 if (flush !== Z_FINISH) { return Z_OK; }
7582 if (s.wrap <= 0) { return Z_STREAM_END; }
7583
7584 /* Write the trailer */
7585 if (s.wrap === 2) {
7586 put_byte(s, strm.adler & 0xff);
7587 put_byte(s, (strm.adler >> 8) & 0xff);
7588 put_byte(s, (strm.adler >> 16) & 0xff);
7589 put_byte(s, (strm.adler >> 24) & 0xff);
7590 put_byte(s, strm.total_in & 0xff);
7591 put_byte(s, (strm.total_in >> 8) & 0xff);
7592 put_byte(s, (strm.total_in >> 16) & 0xff);
7593 put_byte(s, (strm.total_in >> 24) & 0xff);
7594 }
7595 else
7596 {
7597 putShortMSB(s, strm.adler >>> 16);
7598 putShortMSB(s, strm.adler & 0xffff);
7599 }
7600
7601 flush_pending(strm);
7602 /* If avail_out is zero, the application will call deflate again
7603 * to flush the rest.
7604 */
7605 if (s.wrap > 0) { s.wrap = -s.wrap; }
7606 /* write the trailer only once! */
7607 return s.pending !== 0 ? Z_OK : Z_STREAM_END;
7608 }
7609
7610 function deflateEnd(strm) {
7611 var status;
7612
7613 if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
7614 return Z_STREAM_ERROR;
7615 }
7616
7617 status = strm.state.status;
7618 if (status !== INIT_STATE &&
7619 status !== EXTRA_STATE &&
7620 status !== NAME_STATE &&
7621 status !== COMMENT_STATE &&
7622 status !== HCRC_STATE &&
7623 status !== BUSY_STATE &&
7624 status !== FINISH_STATE
7625 ) {
7626 return err(strm, Z_STREAM_ERROR);
7627 }
7628
7629 strm.state = null;
7630
7631 return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;
7632 }
7633
7634
7635 /* =========================================================================
7636 * Initializes the compression dictionary from the given byte
7637 * sequence without producing any compressed output.
7638 */
7639 function deflateSetDictionary(strm, dictionary) {
7640 var dictLength = dictionary.length;
7641
7642 var s;
7643 var str, n;
7644 var wrap;
7645 var avail;
7646 var next;
7647 var input;
7648 var tmpDict;
7649
7650 if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
7651 return Z_STREAM_ERROR;
7652 }
7653
7654 s = strm.state;
7655 wrap = s.wrap;
7656
7657 if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {
7658 return Z_STREAM_ERROR;
7659 }
7660
7661 /* when using zlib wrappers, compute Adler-32 for provided dictionary */
7662 if (wrap === 1) {
7663 /* adler32(strm->adler, dictionary, dictLength); */
7664 strm.adler = adler32(strm.adler, dictionary, dictLength, 0);
7665 }
7666
7667 s.wrap = 0; /* avoid computing Adler-32 in read_buf */
7668
7669 /* if dictionary would fill window, just replace the history */
7670 if (dictLength >= s.w_size) {
7671 if (wrap === 0) { /* already empty otherwise */
7672 /*** CLEAR_HASH(s); ***/
7673 zero(s.head); // Fill with NIL (= 0);
7674 s.strstart = 0;
7675 s.block_start = 0;
7676 s.insert = 0;
7677 }
7678 /* use the tail */
7679 // dictionary = dictionary.slice(dictLength - s.w_size);
7680 tmpDict = new utils.Buf8(s.w_size);
7681 utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0);
7682 dictionary = tmpDict;
7683 dictLength = s.w_size;
7684 }
7685 /* insert dictionary into window and hash */
7686 avail = strm.avail_in;
7687 next = strm.next_in;
7688 input = strm.input;
7689 strm.avail_in = dictLength;
7690 strm.next_in = 0;
7691 strm.input = dictionary;
7692 fill_window(s);
7693 while (s.lookahead >= MIN_MATCH) {
7694 str = s.strstart;
7695 n = s.lookahead - (MIN_MATCH - 1);
7696 do {
7697 /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
7698 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
7699
7700 s.prev[str & s.w_mask] = s.head[s.ins_h];
7701
7702 s.head[s.ins_h] = str;
7703 str++;
7704 } while (--n);
7705 s.strstart = str;
7706 s.lookahead = MIN_MATCH - 1;
7707 fill_window(s);
7708 }
7709 s.strstart += s.lookahead;
7710 s.block_start = s.strstart;
7711 s.insert = s.lookahead;
7712 s.lookahead = 0;
7713 s.match_length = s.prev_length = MIN_MATCH - 1;
7714 s.match_available = 0;
7715 strm.next_in = next;
7716 strm.input = input;
7717 strm.avail_in = avail;
7718 s.wrap = wrap;
7719 return Z_OK;
7720 }
7721
7722
7723 exports.deflateInit = deflateInit;
7724 exports.deflateInit2 = deflateInit2;
7725 exports.deflateReset = deflateReset;
7726 exports.deflateResetKeep = deflateResetKeep;
7727 exports.deflateSetHeader = deflateSetHeader;
7728 exports.deflate = deflate;
7729 exports.deflateEnd = deflateEnd;
7730 exports.deflateSetDictionary = deflateSetDictionary;
7731 exports.deflateInfo = 'pako deflate (from Nodeca project)';
7732
7733 /* Not implemented
7734 exports.deflateBound = deflateBound;
7735 exports.deflateCopy = deflateCopy;
7736 exports.deflateParams = deflateParams;
7737 exports.deflatePending = deflatePending;
7738 exports.deflatePrime = deflatePrime;
7739 exports.deflateTune = deflateTune;
7740 */
7741
7742 },{"../utils/common":41,"./adler32":43,"./crc32":45,"./messages":51,"./trees":52}],47:[function(require,module,exports){
7743 'use strict';
7744
7745 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
7746 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
7747 //
7748 // This software is provided 'as-is', without any express or implied
7749 // warranty. In no event will the authors be held liable for any damages
7750 // arising from the use of this software.
7751 //
7752 // Permission is granted to anyone to use this software for any purpose,
7753 // including commercial applications, and to alter it and redistribute it
7754 // freely, subject to the following restrictions:
7755 //
7756 // 1. The origin of this software must not be misrepresented; you must not
7757 // claim that you wrote the original software. If you use this software
7758 // in a product, an acknowledgment in the product documentation would be
7759 // appreciated but is not required.
7760 // 2. Altered source versions must be plainly marked as such, and must not be
7761 // misrepresented as being the original software.
7762 // 3. This notice may not be removed or altered from any source distribution.
7763
7764 function GZheader() {
7765 /* true if compressed data believed to be text */
7766 this.text = 0;
7767 /* modification time */
7768 this.time = 0;
7769 /* extra flags (not used when writing a gzip file) */
7770 this.xflags = 0;
7771 /* operating system */
7772 this.os = 0;
7773 /* pointer to extra field or Z_NULL if none */
7774 this.extra = null;
7775 /* extra field length (valid if extra != Z_NULL) */
7776 this.extra_len = 0; // Actually, we don't need it in JS,
7777 // but leave for few code modifications
7778
7779 //
7780 // Setup limits is not necessary because in js we should not preallocate memory
7781 // for inflate use constant limit in 65536 bytes
7782 //
7783
7784 /* space at extra (only when reading header) */
7785 // this.extra_max = 0;
7786 /* pointer to zero-terminated file name or Z_NULL */
7787 this.name = '';
7788 /* space at name (only when reading header) */
7789 // this.name_max = 0;
7790 /* pointer to zero-terminated comment or Z_NULL */
7791 this.comment = '';
7792 /* space at comment (only when reading header) */
7793 // this.comm_max = 0;
7794 /* true if there was or will be a header crc */
7795 this.hcrc = 0;
7796 /* true when done reading gzip header (not used when writing a gzip file) */
7797 this.done = false;
7798 }
7799
7800 module.exports = GZheader;
7801
7802 },{}],48:[function(require,module,exports){
7803 'use strict';
7804
7805 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
7806 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
7807 //
7808 // This software is provided 'as-is', without any express or implied
7809 // warranty. In no event will the authors be held liable for any damages
7810 // arising from the use of this software.
7811 //
7812 // Permission is granted to anyone to use this software for any purpose,
7813 // including commercial applications, and to alter it and redistribute it
7814 // freely, subject to the following restrictions:
7815 //
7816 // 1. The origin of this software must not be misrepresented; you must not
7817 // claim that you wrote the original software. If you use this software
7818 // in a product, an acknowledgment in the product documentation would be
7819 // appreciated but is not required.
7820 // 2. Altered source versions must be plainly marked as such, and must not be
7821 // misrepresented as being the original software.
7822 // 3. This notice may not be removed or altered from any source distribution.
7823
7824 // See state defs from inflate.js
7825 var BAD = 30; /* got a data error -- remain here until reset */
7826 var TYPE = 12; /* i: waiting for type bits, including last-flag bit */
7827
7828 /*
7829 Decode literal, length, and distance codes and write out the resulting
7830 literal and match bytes until either not enough input or output is
7831 available, an end-of-block is encountered, or a data error is encountered.
7832 When large enough input and output buffers are supplied to inflate(), for
7833 example, a 16K input buffer and a 64K output buffer, more than 95% of the
7834 inflate execution time is spent in this routine.
7835
7836 Entry assumptions:
7837
7838 state.mode === LEN
7839 strm.avail_in >= 6
7840 strm.avail_out >= 258
7841 start >= strm.avail_out
7842 state.bits < 8
7843
7844 On return, state.mode is one of:
7845
7846 LEN -- ran out of enough output space or enough available input
7847 TYPE -- reached end of block code, inflate() to interpret next block
7848 BAD -- error in block data
7849
7850 Notes:
7851
7852 - The maximum input bits used by a length/distance pair is 15 bits for the
7853 length code, 5 bits for the length extra, 15 bits for the distance code,
7854 and 13 bits for the distance extra. This totals 48 bits, or six bytes.
7855 Therefore if strm.avail_in >= 6, then there is enough input to avoid
7856 checking for available input while decoding.
7857
7858 - The maximum bytes that a single length/distance pair can output is 258
7859 bytes, which is the maximum length that can be coded. inflate_fast()
7860 requires strm.avail_out >= 258 for each loop to avoid checking for
7861 output space.
7862 */
7863 module.exports = function inflate_fast(strm, start) {
7864 var state;
7865 var _in; /* local strm.input */
7866 var last; /* have enough input while in < last */
7867 var _out; /* local strm.output */
7868 var beg; /* inflate()'s initial strm.output */
7869 var end; /* while out < end, enough space available */
7870 //#ifdef INFLATE_STRICT
7871 var dmax; /* maximum distance from zlib header */
7872 //#endif
7873 var wsize; /* window size or zero if not using window */
7874 var whave; /* valid bytes in the window */
7875 var wnext; /* window write index */
7876 // Use `s_window` instead `window`, avoid conflict with instrumentation tools
7877 var s_window; /* allocated sliding window, if wsize != 0 */
7878 var hold; /* local strm.hold */
7879 var bits; /* local strm.bits */
7880 var lcode; /* local strm.lencode */
7881 var dcode; /* local strm.distcode */
7882 var lmask; /* mask for first level of length codes */
7883 var dmask; /* mask for first level of distance codes */
7884 var here; /* retrieved table entry */
7885 var op; /* code bits, operation, extra bits, or */
7886 /* window position, window bytes to copy */
7887 var len; /* match length, unused bytes */
7888 var dist; /* match distance */
7889 var from; /* where to copy match from */
7890 var from_source;
7891
7892
7893 var input, output; // JS specific, because we have no pointers
7894
7895 /* copy state to local variables */
7896 state = strm.state;
7897 //here = state.here;
7898 _in = strm.next_in;
7899 input = strm.input;
7900 last = _in + (strm.avail_in - 5);
7901 _out = strm.next_out;
7902 output = strm.output;
7903 beg = _out - (start - strm.avail_out);
7904 end = _out + (strm.avail_out - 257);
7905 //#ifdef INFLATE_STRICT
7906 dmax = state.dmax;
7907 //#endif
7908 wsize = state.wsize;
7909 whave = state.whave;
7910 wnext = state.wnext;
7911 s_window = state.window;
7912 hold = state.hold;
7913 bits = state.bits;
7914 lcode = state.lencode;
7915 dcode = state.distcode;
7916 lmask = (1 << state.lenbits) - 1;
7917 dmask = (1 << state.distbits) - 1;
7918
7919
7920 /* decode literals and length/distances until end-of-block or not enough
7921 input data or output space */
7922
7923 top:
7924 do {
7925 if (bits < 15) {
7926 hold += input[_in++] << bits;
7927 bits += 8;
7928 hold += input[_in++] << bits;
7929 bits += 8;
7930 }
7931
7932 here = lcode[hold & lmask];
7933
7934 dolen:
7935 for (;;) { // Goto emulation
7936 op = here >>> 24/*here.bits*/;
7937 hold >>>= op;
7938 bits -= op;
7939 op = (here >>> 16) & 0xff/*here.op*/;
7940 if (op === 0) { /* literal */
7941 //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
7942 // "inflate: literal '%c'\n" :
7943 // "inflate: literal 0x%02x\n", here.val));
7944 output[_out++] = here & 0xffff/*here.val*/;
7945 }
7946 else if (op & 16) { /* length base */
7947 len = here & 0xffff/*here.val*/;
7948 op &= 15; /* number of extra bits */
7949 if (op) {
7950 if (bits < op) {
7951 hold += input[_in++] << bits;
7952 bits += 8;
7953 }
7954 len += hold & ((1 << op) - 1);
7955 hold >>>= op;
7956 bits -= op;
7957 }
7958 //Tracevv((stderr, "inflate: length %u\n", len));
7959 if (bits < 15) {
7960 hold += input[_in++] << bits;
7961 bits += 8;
7962 hold += input[_in++] << bits;
7963 bits += 8;
7964 }
7965 here = dcode[hold & dmask];
7966
7967 dodist:
7968 for (;;) { // goto emulation
7969 op = here >>> 24/*here.bits*/;
7970 hold >>>= op;
7971 bits -= op;
7972 op = (here >>> 16) & 0xff/*here.op*/;
7973
7974 if (op & 16) { /* distance base */
7975 dist = here & 0xffff/*here.val*/;
7976 op &= 15; /* number of extra bits */
7977 if (bits < op) {
7978 hold += input[_in++] << bits;
7979 bits += 8;
7980 if (bits < op) {
7981 hold += input[_in++] << bits;
7982 bits += 8;
7983 }
7984 }
7985 dist += hold & ((1 << op) - 1);
7986 //#ifdef INFLATE_STRICT
7987 if (dist > dmax) {
7988 strm.msg = 'invalid distance too far back';
7989 state.mode = BAD;
7990 break top;
7991 }
7992 //#endif
7993 hold >>>= op;
7994 bits -= op;
7995 //Tracevv((stderr, "inflate: distance %u\n", dist));
7996 op = _out - beg; /* max distance in output */
7997 if (dist > op) { /* see if copy from window */
7998 op = dist - op; /* distance back in window */
7999 if (op > whave) {
8000 if (state.sane) {
8001 strm.msg = 'invalid distance too far back';
8002 state.mode = BAD;
8003 break top;
8004 }
8005
8006 // (!) This block is disabled in zlib defailts,
8007 // don't enable it for binary compatibility
8008 //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
8009 // if (len <= op - whave) {
8010 // do {
8011 // output[_out++] = 0;
8012 // } while (--len);
8013 // continue top;
8014 // }
8015 // len -= op - whave;
8016 // do {
8017 // output[_out++] = 0;
8018 // } while (--op > whave);
8019 // if (op === 0) {
8020 // from = _out - dist;
8021 // do {
8022 // output[_out++] = output[from++];
8023 // } while (--len);
8024 // continue top;
8025 // }
8026 //#endif
8027 }
8028 from = 0; // window index
8029 from_source = s_window;
8030 if (wnext === 0) { /* very common case */
8031 from += wsize - op;
8032 if (op < len) { /* some from window */
8033 len -= op;
8034 do {
8035 output[_out++] = s_window[from++];
8036 } while (--op);
8037 from = _out - dist; /* rest from output */
8038 from_source = output;
8039 }
8040 }
8041 else if (wnext < op) { /* wrap around window */
8042 from += wsize + wnext - op;
8043 op -= wnext;
8044 if (op < len) { /* some from end of window */
8045 len -= op;
8046 do {
8047 output[_out++] = s_window[from++];
8048 } while (--op);
8049 from = 0;
8050 if (wnext < len) { /* some from start of window */
8051 op = wnext;
8052 len -= op;
8053 do {
8054 output[_out++] = s_window[from++];
8055 } while (--op);
8056 from = _out - dist; /* rest from output */
8057 from_source = output;
8058 }
8059 }
8060 }
8061 else { /* contiguous in window */
8062 from += wnext - op;
8063 if (op < len) { /* some from window */
8064 len -= op;
8065 do {
8066 output[_out++] = s_window[from++];
8067 } while (--op);
8068 from = _out - dist; /* rest from output */
8069 from_source = output;
8070 }
8071 }
8072 while (len > 2) {
8073 output[_out++] = from_source[from++];
8074 output[_out++] = from_source[from++];
8075 output[_out++] = from_source[from++];
8076 len -= 3;
8077 }
8078 if (len) {
8079 output[_out++] = from_source[from++];
8080 if (len > 1) {
8081 output[_out++] = from_source[from++];
8082 }
8083 }
8084 }
8085 else {
8086 from = _out - dist; /* copy direct from output */
8087 do { /* minimum length is three */
8088 output[_out++] = output[from++];
8089 output[_out++] = output[from++];
8090 output[_out++] = output[from++];
8091 len -= 3;
8092 } while (len > 2);
8093 if (len) {
8094 output[_out++] = output[from++];
8095 if (len > 1) {
8096 output[_out++] = output[from++];
8097 }
8098 }
8099 }
8100 }
8101 else if ((op & 64) === 0) { /* 2nd level distance code */
8102 here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
8103 continue dodist;
8104 }
8105 else {
8106 strm.msg = 'invalid distance code';
8107 state.mode = BAD;
8108 break top;
8109 }
8110
8111 break; // need to emulate goto via "continue"
8112 }
8113 }
8114 else if ((op & 64) === 0) { /* 2nd level length code */
8115 here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
8116 continue dolen;
8117 }
8118 else if (op & 32) { /* end-of-block */
8119 //Tracevv((stderr, "inflate: end of block\n"));
8120 state.mode = TYPE;
8121 break top;
8122 }
8123 else {
8124 strm.msg = 'invalid literal/length code';
8125 state.mode = BAD;
8126 break top;
8127 }
8128
8129 break; // need to emulate goto via "continue"
8130 }
8131 } while (_in < last && _out < end);
8132
8133 /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
8134 len = bits >> 3;
8135 _in -= len;
8136 bits -= len << 3;
8137 hold &= (1 << bits) - 1;
8138
8139 /* update state and return */
8140 strm.next_in = _in;
8141 strm.next_out = _out;
8142 strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));
8143 strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));
8144 state.hold = hold;
8145 state.bits = bits;
8146 return;
8147 };
8148
8149 },{}],49:[function(require,module,exports){
8150 'use strict';
8151
8152 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
8153 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
8154 //
8155 // This software is provided 'as-is', without any express or implied
8156 // warranty. In no event will the authors be held liable for any damages
8157 // arising from the use of this software.
8158 //
8159 // Permission is granted to anyone to use this software for any purpose,
8160 // including commercial applications, and to alter it and redistribute it
8161 // freely, subject to the following restrictions:
8162 //
8163 // 1. The origin of this software must not be misrepresented; you must not
8164 // claim that you wrote the original software. If you use this software
8165 // in a product, an acknowledgment in the product documentation would be
8166 // appreciated but is not required.
8167 // 2. Altered source versions must be plainly marked as such, and must not be
8168 // misrepresented as being the original software.
8169 // 3. This notice may not be removed or altered from any source distribution.
8170
8171 var utils = require('../utils/common');
8172 var adler32 = require('./adler32');
8173 var crc32 = require('./crc32');
8174 var inflate_fast = require('./inffast');
8175 var inflate_table = require('./inftrees');
8176
8177 var CODES = 0;
8178 var LENS = 1;
8179 var DISTS = 2;
8180
8181 /* Public constants ==========================================================*/
8182 /* ===========================================================================*/
8183
8184
8185 /* Allowed flush values; see deflate() and inflate() below for details */
8186 //var Z_NO_FLUSH = 0;
8187 //var Z_PARTIAL_FLUSH = 1;
8188 //var Z_SYNC_FLUSH = 2;
8189 //var Z_FULL_FLUSH = 3;
8190 var Z_FINISH = 4;
8191 var Z_BLOCK = 5;
8192 var Z_TREES = 6;
8193
8194
8195 /* Return codes for the compression/decompression functions. Negative values
8196 * are errors, positive values are used for special but normal events.
8197 */
8198 var Z_OK = 0;
8199 var Z_STREAM_END = 1;
8200 var Z_NEED_DICT = 2;
8201 //var Z_ERRNO = -1;
8202 var Z_STREAM_ERROR = -2;
8203 var Z_DATA_ERROR = -3;
8204 var Z_MEM_ERROR = -4;
8205 var Z_BUF_ERROR = -5;
8206 //var Z_VERSION_ERROR = -6;
8207
8208 /* The deflate compression method */
8209 var Z_DEFLATED = 8;
8210
8211
8212 /* STATES ====================================================================*/
8213 /* ===========================================================================*/
8214
8215
8216 var HEAD = 1; /* i: waiting for magic header */
8217 var FLAGS = 2; /* i: waiting for method and flags (gzip) */
8218 var TIME = 3; /* i: waiting for modification time (gzip) */
8219 var OS = 4; /* i: waiting for extra flags and operating system (gzip) */
8220 var EXLEN = 5; /* i: waiting for extra length (gzip) */
8221 var EXTRA = 6; /* i: waiting for extra bytes (gzip) */
8222 var NAME = 7; /* i: waiting for end of file name (gzip) */
8223 var COMMENT = 8; /* i: waiting for end of comment (gzip) */
8224 var HCRC = 9; /* i: waiting for header crc (gzip) */
8225 var DICTID = 10; /* i: waiting for dictionary check value */
8226 var DICT = 11; /* waiting for inflateSetDictionary() call */
8227 var TYPE = 12; /* i: waiting for type bits, including last-flag bit */
8228 var TYPEDO = 13; /* i: same, but skip check to exit inflate on new block */
8229 var STORED = 14; /* i: waiting for stored size (length and complement) */
8230 var COPY_ = 15; /* i/o: same as COPY below, but only first time in */
8231 var COPY = 16; /* i/o: waiting for input or output to copy stored block */
8232 var TABLE = 17; /* i: waiting for dynamic block table lengths */
8233 var LENLENS = 18; /* i: waiting for code length code lengths */
8234 var CODELENS = 19; /* i: waiting for length/lit and distance code lengths */
8235 var LEN_ = 20; /* i: same as LEN below, but only first time in */
8236 var LEN = 21; /* i: waiting for length/lit/eob code */
8237 var LENEXT = 22; /* i: waiting for length extra bits */
8238 var DIST = 23; /* i: waiting for distance code */
8239 var DISTEXT = 24; /* i: waiting for distance extra bits */
8240 var MATCH = 25; /* o: waiting for output space to copy string */
8241 var LIT = 26; /* o: waiting for output space to write literal */
8242 var CHECK = 27; /* i: waiting for 32-bit check value */
8243 var LENGTH = 28; /* i: waiting for 32-bit length (gzip) */
8244 var DONE = 29; /* finished check, done -- remain here until reset */
8245 var BAD = 30; /* got a data error -- remain here until reset */
8246 var MEM = 31; /* got an inflate() memory error -- remain here until reset */
8247 var SYNC = 32; /* looking for synchronization bytes to restart inflate() */
8248
8249 /* ===========================================================================*/
8250
8251
8252
8253 var ENOUGH_LENS = 852;
8254 var ENOUGH_DISTS = 592;
8255 //var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
8256
8257 var MAX_WBITS = 15;
8258 /* 32K LZ77 window */
8259 var DEF_WBITS = MAX_WBITS;
8260
8261
8262 function zswap32(q) {
8263 return (((q >>> 24) & 0xff) +
8264 ((q >>> 8) & 0xff00) +
8265 ((q & 0xff00) << 8) +
8266 ((q & 0xff) << 24));
8267 }
8268
8269
8270 function InflateState() {
8271 this.mode = 0; /* current inflate mode */
8272 this.last = false; /* true if processing last block */
8273 this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */
8274 this.havedict = false; /* true if dictionary provided */
8275 this.flags = 0; /* gzip header method and flags (0 if zlib) */
8276 this.dmax = 0; /* zlib header max distance (INFLATE_STRICT) */
8277 this.check = 0; /* protected copy of check value */
8278 this.total = 0; /* protected copy of output count */
8279 // TODO: may be {}
8280 this.head = null; /* where to save gzip header information */
8281
8282 /* sliding window */
8283 this.wbits = 0; /* log base 2 of requested window size */
8284 this.wsize = 0; /* window size or zero if not using window */
8285 this.whave = 0; /* valid bytes in the window */
8286 this.wnext = 0; /* window write index */
8287 this.window = null; /* allocated sliding window, if needed */
8288
8289 /* bit accumulator */
8290 this.hold = 0; /* input bit accumulator */
8291 this.bits = 0; /* number of bits in "in" */
8292
8293 /* for string and stored block copying */
8294 this.length = 0; /* literal or length of data to copy */
8295 this.offset = 0; /* distance back to copy string from */
8296
8297 /* for table and code decoding */
8298 this.extra = 0; /* extra bits needed */
8299
8300 /* fixed and dynamic code tables */
8301 this.lencode = null; /* starting table for length/literal codes */
8302 this.distcode = null; /* starting table for distance codes */
8303 this.lenbits = 0; /* index bits for lencode */
8304 this.distbits = 0; /* index bits for distcode */
8305
8306 /* dynamic table building */
8307 this.ncode = 0; /* number of code length code lengths */
8308 this.nlen = 0; /* number of length code lengths */
8309 this.ndist = 0; /* number of distance code lengths */
8310 this.have = 0; /* number of code lengths in lens[] */
8311 this.next = null; /* next available space in codes[] */
8312
8313 this.lens = new utils.Buf16(320); /* temporary storage for code lengths */
8314 this.work = new utils.Buf16(288); /* work area for code table building */
8315
8316 /*
8317 because we don't have pointers in js, we use lencode and distcode directly
8318 as buffers so we don't need codes
8319 */
8320 //this.codes = new utils.Buf32(ENOUGH); /* space for code tables */
8321 this.lendyn = null; /* dynamic table for length/literal codes (JS specific) */
8322 this.distdyn = null; /* dynamic table for distance codes (JS specific) */
8323 this.sane = 0; /* if false, allow invalid distance too far */
8324 this.back = 0; /* bits back of last unprocessed length/lit */
8325 this.was = 0; /* initial length of match */
8326 }
8327
8328 function inflateResetKeep(strm) {
8329 var state;
8330
8331 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
8332 state = strm.state;
8333 strm.total_in = strm.total_out = state.total = 0;
8334 strm.msg = ''; /*Z_NULL*/
8335 if (state.wrap) { /* to support ill-conceived Java test suite */
8336 strm.adler = state.wrap & 1;
8337 }
8338 state.mode = HEAD;
8339 state.last = 0;
8340 state.havedict = 0;
8341 state.dmax = 32768;
8342 state.head = null/*Z_NULL*/;
8343 state.hold = 0;
8344 state.bits = 0;
8345 //state.lencode = state.distcode = state.next = state.codes;
8346 state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);
8347 state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);
8348
8349 state.sane = 1;
8350 state.back = -1;
8351 //Tracev((stderr, "inflate: reset\n"));
8352 return Z_OK;
8353 }
8354
8355 function inflateReset(strm) {
8356 var state;
8357
8358 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
8359 state = strm.state;
8360 state.wsize = 0;
8361 state.whave = 0;
8362 state.wnext = 0;
8363 return inflateResetKeep(strm);
8364
8365 }
8366
8367 function inflateReset2(strm, windowBits) {
8368 var wrap;
8369 var state;
8370
8371 /* get the state */
8372 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
8373 state = strm.state;
8374
8375 /* extract wrap request from windowBits parameter */
8376 if (windowBits < 0) {
8377 wrap = 0;
8378 windowBits = -windowBits;
8379 }
8380 else {
8381 wrap = (windowBits >> 4) + 1;
8382 if (windowBits < 48) {
8383 windowBits &= 15;
8384 }
8385 }
8386
8387 /* set number of window bits, free window if different */
8388 if (windowBits && (windowBits < 8 || windowBits > 15)) {
8389 return Z_STREAM_ERROR;
8390 }
8391 if (state.window !== null && state.wbits !== windowBits) {
8392 state.window = null;
8393 }
8394
8395 /* update state and reset the rest of it */
8396 state.wrap = wrap;
8397 state.wbits = windowBits;
8398 return inflateReset(strm);
8399 }
8400
8401 function inflateInit2(strm, windowBits) {
8402 var ret;
8403 var state;
8404
8405 if (!strm) { return Z_STREAM_ERROR; }
8406 //strm.msg = Z_NULL; /* in case we return an error */
8407
8408 state = new InflateState();
8409
8410 //if (state === Z_NULL) return Z_MEM_ERROR;
8411 //Tracev((stderr, "inflate: allocated\n"));
8412 strm.state = state;
8413 state.window = null/*Z_NULL*/;
8414 ret = inflateReset2(strm, windowBits);
8415 if (ret !== Z_OK) {
8416 strm.state = null/*Z_NULL*/;
8417 }
8418 return ret;
8419 }
8420
8421 function inflateInit(strm) {
8422 return inflateInit2(strm, DEF_WBITS);
8423 }
8424
8425
8426 /*
8427 Return state with length and distance decoding tables and index sizes set to
8428 fixed code decoding. Normally this returns fixed tables from inffixed.h.
8429 If BUILDFIXED is defined, then instead this routine builds the tables the
8430 first time it's called, and returns those tables the first time and
8431 thereafter. This reduces the size of the code by about 2K bytes, in
8432 exchange for a little execution time. However, BUILDFIXED should not be
8433 used for threaded applications, since the rewriting of the tables and virgin
8434 may not be thread-safe.
8435 */
8436 var virgin = true;
8437
8438 var lenfix, distfix; // We have no pointers in JS, so keep tables separate
8439
8440 function fixedtables(state) {
8441 /* build fixed huffman tables if first call (may not be thread safe) */
8442 if (virgin) {
8443 var sym;
8444
8445 lenfix = new utils.Buf32(512);
8446 distfix = new utils.Buf32(32);
8447
8448 /* literal/length table */
8449 sym = 0;
8450 while (sym < 144) { state.lens[sym++] = 8; }
8451 while (sym < 256) { state.lens[sym++] = 9; }
8452 while (sym < 280) { state.lens[sym++] = 7; }
8453 while (sym < 288) { state.lens[sym++] = 8; }
8454
8455 inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });
8456
8457 /* distance table */
8458 sym = 0;
8459 while (sym < 32) { state.lens[sym++] = 5; }
8460
8461 inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });
8462
8463 /* do this just once */
8464 virgin = false;
8465 }
8466
8467 state.lencode = lenfix;
8468 state.lenbits = 9;
8469 state.distcode = distfix;
8470 state.distbits = 5;
8471 }
8472
8473
8474 /*
8475 Update the window with the last wsize (normally 32K) bytes written before
8476 returning. If window does not exist yet, create it. This is only called
8477 when a window is already in use, or when output has been written during this
8478 inflate call, but the end of the deflate stream has not been reached yet.
8479 It is also called to create a window for dictionary data when a dictionary
8480 is loaded.
8481
8482 Providing output buffers larger than 32K to inflate() should provide a speed
8483 advantage, since only the last 32K of output is copied to the sliding window
8484 upon return from inflate(), and since all distances after the first 32K of
8485 output will fall in the output data, making match copies simpler and faster.
8486 The advantage may be dependent on the size of the processor's data caches.
8487 */
8488 function updatewindow(strm, src, end, copy) {
8489 var dist;
8490 var state = strm.state;
8491
8492 /* if it hasn't been done already, allocate space for the window */
8493 if (state.window === null) {
8494 state.wsize = 1 << state.wbits;
8495 state.wnext = 0;
8496 state.whave = 0;
8497
8498 state.window = new utils.Buf8(state.wsize);
8499 }
8500
8501 /* copy state->wsize or less output bytes into the circular window */
8502 if (copy >= state.wsize) {
8503 utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0);
8504 state.wnext = 0;
8505 state.whave = state.wsize;
8506 }
8507 else {
8508 dist = state.wsize - state.wnext;
8509 if (dist > copy) {
8510 dist = copy;
8511 }
8512 //zmemcpy(state->window + state->wnext, end - copy, dist);
8513 utils.arraySet(state.window, src, end - copy, dist, state.wnext);
8514 copy -= dist;
8515 if (copy) {
8516 //zmemcpy(state->window, end - copy, copy);
8517 utils.arraySet(state.window, src, end - copy, copy, 0);
8518 state.wnext = copy;
8519 state.whave = state.wsize;
8520 }
8521 else {
8522 state.wnext += dist;
8523 if (state.wnext === state.wsize) { state.wnext = 0; }
8524 if (state.whave < state.wsize) { state.whave += dist; }
8525 }
8526 }
8527 return 0;
8528 }
8529
8530 function inflate(strm, flush) {
8531 var state;
8532 var input, output; // input/output buffers
8533 var next; /* next input INDEX */
8534 var put; /* next output INDEX */
8535 var have, left; /* available input and output */
8536 var hold; /* bit buffer */
8537 var bits; /* bits in bit buffer */
8538 var _in, _out; /* save starting available input and output */
8539 var copy; /* number of stored or match bytes to copy */
8540 var from; /* where to copy match bytes from */
8541 var from_source;
8542 var here = 0; /* current decoding table entry */
8543 var here_bits, here_op, here_val; // paked "here" denormalized (JS specific)
8544 //var last; /* parent table entry */
8545 var last_bits, last_op, last_val; // paked "last" denormalized (JS specific)
8546 var len; /* length to copy for repeats, bits to drop */
8547 var ret; /* return code */
8548 var hbuf = new utils.Buf8(4); /* buffer for gzip header crc calculation */
8549 var opts;
8550
8551 var n; // temporary var for NEED_BITS
8552
8553 var order = /* permutation of code lengths */
8554 [ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ];
8555
8556
8557 if (!strm || !strm.state || !strm.output ||
8558 (!strm.input && strm.avail_in !== 0)) {
8559 return Z_STREAM_ERROR;
8560 }
8561
8562 state = strm.state;
8563 if (state.mode === TYPE) { state.mode = TYPEDO; } /* skip check */
8564
8565
8566 //--- LOAD() ---
8567 put = strm.next_out;
8568 output = strm.output;
8569 left = strm.avail_out;
8570 next = strm.next_in;
8571 input = strm.input;
8572 have = strm.avail_in;
8573 hold = state.hold;
8574 bits = state.bits;
8575 //---
8576
8577 _in = have;
8578 _out = left;
8579 ret = Z_OK;
8580
8581 inf_leave: // goto emulation
8582 for (;;) {
8583 switch (state.mode) {
8584 case HEAD:
8585 if (state.wrap === 0) {
8586 state.mode = TYPEDO;
8587 break;
8588 }
8589 //=== NEEDBITS(16);
8590 while (bits < 16) {
8591 if (have === 0) { break inf_leave; }
8592 have--;
8593 hold += input[next++] << bits;
8594 bits += 8;
8595 }
8596 //===//
8597 if ((state.wrap & 2) && hold === 0x8b1f) { /* gzip header */
8598 state.check = 0/*crc32(0L, Z_NULL, 0)*/;
8599 //=== CRC2(state.check, hold);
8600 hbuf[0] = hold & 0xff;
8601 hbuf[1] = (hold >>> 8) & 0xff;
8602 state.check = crc32(state.check, hbuf, 2, 0);
8603 //===//
8604
8605 //=== INITBITS();
8606 hold = 0;
8607 bits = 0;
8608 //===//
8609 state.mode = FLAGS;
8610 break;
8611 }
8612 state.flags = 0; /* expect zlib header */
8613 if (state.head) {
8614 state.head.done = false;
8615 }
8616 if (!(state.wrap & 1) || /* check if zlib header allowed */
8617 (((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) {
8618 strm.msg = 'incorrect header check';
8619 state.mode = BAD;
8620 break;
8621 }
8622 if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) {
8623 strm.msg = 'unknown compression method';
8624 state.mode = BAD;
8625 break;
8626 }
8627 //--- DROPBITS(4) ---//
8628 hold >>>= 4;
8629 bits -= 4;
8630 //---//
8631 len = (hold & 0x0f)/*BITS(4)*/ + 8;
8632 if (state.wbits === 0) {
8633 state.wbits = len;
8634 }
8635 else if (len > state.wbits) {
8636 strm.msg = 'invalid window size';
8637 state.mode = BAD;
8638 break;
8639 }
8640 state.dmax = 1 << len;
8641 //Tracev((stderr, "inflate: zlib header ok\n"));
8642 strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
8643 state.mode = hold & 0x200 ? DICTID : TYPE;
8644 //=== INITBITS();
8645 hold = 0;
8646 bits = 0;
8647 //===//
8648 break;
8649 case FLAGS:
8650 //=== NEEDBITS(16); */
8651 while (bits < 16) {
8652 if (have === 0) { break inf_leave; }
8653 have--;
8654 hold += input[next++] << bits;
8655 bits += 8;
8656 }
8657 //===//
8658 state.flags = hold;
8659 if ((state.flags & 0xff) !== Z_DEFLATED) {
8660 strm.msg = 'unknown compression method';
8661 state.mode = BAD;
8662 break;
8663 }
8664 if (state.flags & 0xe000) {
8665 strm.msg = 'unknown header flags set';
8666 state.mode = BAD;
8667 break;
8668 }
8669 if (state.head) {
8670 state.head.text = ((hold >> 8) & 1);
8671 }
8672 if (state.flags & 0x0200) {
8673 //=== CRC2(state.check, hold);
8674 hbuf[0] = hold & 0xff;
8675 hbuf[1] = (hold >>> 8) & 0xff;
8676 state.check = crc32(state.check, hbuf, 2, 0);
8677 //===//
8678 }
8679 //=== INITBITS();
8680 hold = 0;
8681 bits = 0;
8682 //===//
8683 state.mode = TIME;
8684 /* falls through */
8685 case TIME:
8686 //=== NEEDBITS(32); */
8687 while (bits < 32) {
8688 if (have === 0) { break inf_leave; }
8689 have--;
8690 hold += input[next++] << bits;
8691 bits += 8;
8692 }
8693 //===//
8694 if (state.head) {
8695 state.head.time = hold;
8696 }
8697 if (state.flags & 0x0200) {
8698 //=== CRC4(state.check, hold)
8699 hbuf[0] = hold & 0xff;
8700 hbuf[1] = (hold >>> 8) & 0xff;
8701 hbuf[2] = (hold >>> 16) & 0xff;
8702 hbuf[3] = (hold >>> 24) & 0xff;
8703 state.check = crc32(state.check, hbuf, 4, 0);
8704 //===
8705 }
8706 //=== INITBITS();
8707 hold = 0;
8708 bits = 0;
8709 //===//
8710 state.mode = OS;
8711 /* falls through */
8712 case OS:
8713 //=== NEEDBITS(16); */
8714 while (bits < 16) {
8715 if (have === 0) { break inf_leave; }
8716 have--;
8717 hold += input[next++] << bits;
8718 bits += 8;
8719 }
8720 //===//
8721 if (state.head) {
8722 state.head.xflags = (hold & 0xff);
8723 state.head.os = (hold >> 8);
8724 }
8725 if (state.flags & 0x0200) {
8726 //=== CRC2(state.check, hold);
8727 hbuf[0] = hold & 0xff;
8728 hbuf[1] = (hold >>> 8) & 0xff;
8729 state.check = crc32(state.check, hbuf, 2, 0);
8730 //===//
8731 }
8732 //=== INITBITS();
8733 hold = 0;
8734 bits = 0;
8735 //===//
8736 state.mode = EXLEN;
8737 /* falls through */
8738 case EXLEN:
8739 if (state.flags & 0x0400) {
8740 //=== NEEDBITS(16); */
8741 while (bits < 16) {
8742 if (have === 0) { break inf_leave; }
8743 have--;
8744 hold += input[next++] << bits;
8745 bits += 8;
8746 }
8747 //===//
8748 state.length = hold;
8749 if (state.head) {
8750 state.head.extra_len = hold;
8751 }
8752 if (state.flags & 0x0200) {
8753 //=== CRC2(state.check, hold);
8754 hbuf[0] = hold & 0xff;
8755 hbuf[1] = (hold >>> 8) & 0xff;
8756 state.check = crc32(state.check, hbuf, 2, 0);
8757 //===//
8758 }
8759 //=== INITBITS();
8760 hold = 0;
8761 bits = 0;
8762 //===//
8763 }
8764 else if (state.head) {
8765 state.head.extra = null/*Z_NULL*/;
8766 }
8767 state.mode = EXTRA;
8768 /* falls through */
8769 case EXTRA:
8770 if (state.flags & 0x0400) {
8771 copy = state.length;
8772 if (copy > have) { copy = have; }
8773 if (copy) {
8774 if (state.head) {
8775 len = state.head.extra_len - state.length;
8776 if (!state.head.extra) {
8777 // Use untyped array for more conveniend processing later
8778 state.head.extra = new Array(state.head.extra_len);
8779 }
8780 utils.arraySet(
8781 state.head.extra,
8782 input,
8783 next,
8784 // extra field is limited to 65536 bytes
8785 // - no need for additional size check
8786 copy,
8787 /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
8788 len
8789 );
8790 //zmemcpy(state.head.extra + len, next,
8791 // len + copy > state.head.extra_max ?
8792 // state.head.extra_max - len : copy);
8793 }
8794 if (state.flags & 0x0200) {
8795 state.check = crc32(state.check, input, copy, next);
8796 }
8797 have -= copy;
8798 next += copy;
8799 state.length -= copy;
8800 }
8801 if (state.length) { break inf_leave; }
8802 }
8803 state.length = 0;
8804 state.mode = NAME;
8805 /* falls through */
8806 case NAME:
8807 if (state.flags & 0x0800) {
8808 if (have === 0) { break inf_leave; }
8809 copy = 0;
8810 do {
8811 // TODO: 2 or 1 bytes?
8812 len = input[next + copy++];
8813 /* use constant limit because in js we should not preallocate memory */
8814 if (state.head && len &&
8815 (state.length < 65536 /*state.head.name_max*/)) {
8816 state.head.name += String.fromCharCode(len);
8817 }
8818 } while (len && copy < have);
8819
8820 if (state.flags & 0x0200) {
8821 state.check = crc32(state.check, input, copy, next);
8822 }
8823 have -= copy;
8824 next += copy;
8825 if (len) { break inf_leave; }
8826 }
8827 else if (state.head) {
8828 state.head.name = null;
8829 }
8830 state.length = 0;
8831 state.mode = COMMENT;
8832 /* falls through */
8833 case COMMENT:
8834 if (state.flags & 0x1000) {
8835 if (have === 0) { break inf_leave; }
8836 copy = 0;
8837 do {
8838 len = input[next + copy++];
8839 /* use constant limit because in js we should not preallocate memory */
8840 if (state.head && len &&
8841 (state.length < 65536 /*state.head.comm_max*/)) {
8842 state.head.comment += String.fromCharCode(len);
8843 }
8844 } while (len && copy < have);
8845 if (state.flags & 0x0200) {
8846 state.check = crc32(state.check, input, copy, next);
8847 }
8848 have -= copy;
8849 next += copy;
8850 if (len) { break inf_leave; }
8851 }
8852 else if (state.head) {
8853 state.head.comment = null;
8854 }
8855 state.mode = HCRC;
8856 /* falls through */
8857 case HCRC:
8858 if (state.flags & 0x0200) {
8859 //=== NEEDBITS(16); */
8860 while (bits < 16) {
8861 if (have === 0) { break inf_leave; }
8862 have--;
8863 hold += input[next++] << bits;
8864 bits += 8;
8865 }
8866 //===//
8867 if (hold !== (state.check & 0xffff)) {
8868 strm.msg = 'header crc mismatch';
8869 state.mode = BAD;
8870 break;
8871 }
8872 //=== INITBITS();
8873 hold = 0;
8874 bits = 0;
8875 //===//
8876 }
8877 if (state.head) {
8878 state.head.hcrc = ((state.flags >> 9) & 1);
8879 state.head.done = true;
8880 }
8881 strm.adler = state.check = 0;
8882 state.mode = TYPE;
8883 break;
8884 case DICTID:
8885 //=== NEEDBITS(32); */
8886 while (bits < 32) {
8887 if (have === 0) { break inf_leave; }
8888 have--;
8889 hold += input[next++] << bits;
8890 bits += 8;
8891 }
8892 //===//
8893 strm.adler = state.check = zswap32(hold);
8894 //=== INITBITS();
8895 hold = 0;
8896 bits = 0;
8897 //===//
8898 state.mode = DICT;
8899 /* falls through */
8900 case DICT:
8901 if (state.havedict === 0) {
8902 //--- RESTORE() ---
8903 strm.next_out = put;
8904 strm.avail_out = left;
8905 strm.next_in = next;
8906 strm.avail_in = have;
8907 state.hold = hold;
8908 state.bits = bits;
8909 //---
8910 return Z_NEED_DICT;
8911 }
8912 strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
8913 state.mode = TYPE;
8914 /* falls through */
8915 case TYPE:
8916 if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; }
8917 /* falls through */
8918 case TYPEDO:
8919 if (state.last) {
8920 //--- BYTEBITS() ---//
8921 hold >>>= bits & 7;
8922 bits -= bits & 7;
8923 //---//
8924 state.mode = CHECK;
8925 break;
8926 }
8927 //=== NEEDBITS(3); */
8928 while (bits < 3) {
8929 if (have === 0) { break inf_leave; }
8930 have--;
8931 hold += input[next++] << bits;
8932 bits += 8;
8933 }
8934 //===//
8935 state.last = (hold & 0x01)/*BITS(1)*/;
8936 //--- DROPBITS(1) ---//
8937 hold >>>= 1;
8938 bits -= 1;
8939 //---//
8940
8941 switch ((hold & 0x03)/*BITS(2)*/) {
8942 case 0: /* stored block */
8943 //Tracev((stderr, "inflate: stored block%s\n",
8944 // state.last ? " (last)" : ""));
8945 state.mode = STORED;
8946 break;
8947 case 1: /* fixed block */
8948 fixedtables(state);
8949 //Tracev((stderr, "inflate: fixed codes block%s\n",
8950 // state.last ? " (last)" : ""));
8951 state.mode = LEN_; /* decode codes */
8952 if (flush === Z_TREES) {
8953 //--- DROPBITS(2) ---//
8954 hold >>>= 2;
8955 bits -= 2;
8956 //---//
8957 break inf_leave;
8958 }
8959 break;
8960 case 2: /* dynamic block */
8961 //Tracev((stderr, "inflate: dynamic codes block%s\n",
8962 // state.last ? " (last)" : ""));
8963 state.mode = TABLE;
8964 break;
8965 case 3:
8966 strm.msg = 'invalid block type';
8967 state.mode = BAD;
8968 }
8969 //--- DROPBITS(2) ---//
8970 hold >>>= 2;
8971 bits -= 2;
8972 //---//
8973 break;
8974 case STORED:
8975 //--- BYTEBITS() ---// /* go to byte boundary */
8976 hold >>>= bits & 7;
8977 bits -= bits & 7;
8978 //---//
8979 //=== NEEDBITS(32); */
8980 while (bits < 32) {
8981 if (have === 0) { break inf_leave; }
8982 have--;
8983 hold += input[next++] << bits;
8984 bits += 8;
8985 }
8986 //===//
8987 if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {
8988 strm.msg = 'invalid stored block lengths';
8989 state.mode = BAD;
8990 break;
8991 }
8992 state.length = hold & 0xffff;
8993 //Tracev((stderr, "inflate: stored length %u\n",
8994 // state.length));
8995 //=== INITBITS();
8996 hold = 0;
8997 bits = 0;
8998 //===//
8999 state.mode = COPY_;
9000 if (flush === Z_TREES) { break inf_leave; }
9001 /* falls through */
9002 case COPY_:
9003 state.mode = COPY;
9004 /* falls through */
9005 case COPY:
9006 copy = state.length;
9007 if (copy) {
9008 if (copy > have) { copy = have; }
9009 if (copy > left) { copy = left; }
9010 if (copy === 0) { break inf_leave; }
9011 //--- zmemcpy(put, next, copy); ---
9012 utils.arraySet(output, input, next, copy, put);
9013 //---//
9014 have -= copy;
9015 next += copy;
9016 left -= copy;
9017 put += copy;
9018 state.length -= copy;
9019 break;
9020 }
9021 //Tracev((stderr, "inflate: stored end\n"));
9022 state.mode = TYPE;
9023 break;
9024 case TABLE:
9025 //=== NEEDBITS(14); */
9026 while (bits < 14) {
9027 if (have === 0) { break inf_leave; }
9028 have--;
9029 hold += input[next++] << bits;
9030 bits += 8;
9031 }
9032 //===//
9033 state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257;
9034 //--- DROPBITS(5) ---//
9035 hold >>>= 5;
9036 bits -= 5;
9037 //---//
9038 state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1;
9039 //--- DROPBITS(5) ---//
9040 hold >>>= 5;
9041 bits -= 5;
9042 //---//
9043 state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4;
9044 //--- DROPBITS(4) ---//
9045 hold >>>= 4;
9046 bits -= 4;
9047 //---//
9048 //#ifndef PKZIP_BUG_WORKAROUND
9049 if (state.nlen > 286 || state.ndist > 30) {
9050 strm.msg = 'too many length or distance symbols';
9051 state.mode = BAD;
9052 break;
9053 }
9054 //#endif
9055 //Tracev((stderr, "inflate: table sizes ok\n"));
9056 state.have = 0;
9057 state.mode = LENLENS;
9058 /* falls through */
9059 case LENLENS:
9060 while (state.have < state.ncode) {
9061 //=== NEEDBITS(3);
9062 while (bits < 3) {
9063 if (have === 0) { break inf_leave; }
9064 have--;
9065 hold += input[next++] << bits;
9066 bits += 8;
9067 }
9068 //===//
9069 state.lens[order[state.have++]] = (hold & 0x07);//BITS(3);
9070 //--- DROPBITS(3) ---//
9071 hold >>>= 3;
9072 bits -= 3;
9073 //---//
9074 }
9075 while (state.have < 19) {
9076 state.lens[order[state.have++]] = 0;
9077 }
9078 // We have separate tables & no pointers. 2 commented lines below not needed.
9079 //state.next = state.codes;
9080 //state.lencode = state.next;
9081 // Switch to use dynamic table
9082 state.lencode = state.lendyn;
9083 state.lenbits = 7;
9084
9085 opts = { bits: state.lenbits };
9086 ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);
9087 state.lenbits = opts.bits;
9088
9089 if (ret) {
9090 strm.msg = 'invalid code lengths set';
9091 state.mode = BAD;
9092 break;
9093 }
9094 //Tracev((stderr, "inflate: code lengths ok\n"));
9095 state.have = 0;
9096 state.mode = CODELENS;
9097 /* falls through */
9098 case CODELENS:
9099 while (state.have < state.nlen + state.ndist) {
9100 for (;;) {
9101 here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/
9102 here_bits = here >>> 24;
9103 here_op = (here >>> 16) & 0xff;
9104 here_val = here & 0xffff;
9105
9106 if ((here_bits) <= bits) { break; }
9107 //--- PULLBYTE() ---//
9108 if (have === 0) { break inf_leave; }
9109 have--;
9110 hold += input[next++] << bits;
9111 bits += 8;
9112 //---//
9113 }
9114 if (here_val < 16) {
9115 //--- DROPBITS(here.bits) ---//
9116 hold >>>= here_bits;
9117 bits -= here_bits;
9118 //---//
9119 state.lens[state.have++] = here_val;
9120 }
9121 else {
9122 if (here_val === 16) {
9123 //=== NEEDBITS(here.bits + 2);
9124 n = here_bits + 2;
9125 while (bits < n) {
9126 if (have === 0) { break inf_leave; }
9127 have--;
9128 hold += input[next++] << bits;
9129 bits += 8;
9130 }
9131 //===//
9132 //--- DROPBITS(here.bits) ---//
9133 hold >>>= here_bits;
9134 bits -= here_bits;
9135 //---//
9136 if (state.have === 0) {
9137 strm.msg = 'invalid bit length repeat';
9138 state.mode = BAD;
9139 break;
9140 }
9141 len = state.lens[state.have - 1];
9142 copy = 3 + (hold & 0x03);//BITS(2);
9143 //--- DROPBITS(2) ---//
9144 hold >>>= 2;
9145 bits -= 2;
9146 //---//
9147 }
9148 else if (here_val === 17) {
9149 //=== NEEDBITS(here.bits + 3);
9150 n = here_bits + 3;
9151 while (bits < n) {
9152 if (have === 0) { break inf_leave; }
9153 have--;
9154 hold += input[next++] << bits;
9155 bits += 8;
9156 }
9157 //===//
9158 //--- DROPBITS(here.bits) ---//
9159 hold >>>= here_bits;
9160 bits -= here_bits;
9161 //---//
9162 len = 0;
9163 copy = 3 + (hold & 0x07);//BITS(3);
9164 //--- DROPBITS(3) ---//
9165 hold >>>= 3;
9166 bits -= 3;
9167 //---//
9168 }
9169 else {
9170 //=== NEEDBITS(here.bits + 7);
9171 n = here_bits + 7;
9172 while (bits < n) {
9173 if (have === 0) { break inf_leave; }
9174 have--;
9175 hold += input[next++] << bits;
9176 bits += 8;
9177 }
9178 //===//
9179 //--- DROPBITS(here.bits) ---//
9180 hold >>>= here_bits;
9181 bits -= here_bits;
9182 //---//
9183 len = 0;
9184 copy = 11 + (hold & 0x7f);//BITS(7);
9185 //--- DROPBITS(7) ---//
9186 hold >>>= 7;
9187 bits -= 7;
9188 //---//
9189 }
9190 if (state.have + copy > state.nlen + state.ndist) {
9191 strm.msg = 'invalid bit length repeat';
9192 state.mode = BAD;
9193 break;
9194 }
9195 while (copy--) {
9196 state.lens[state.have++] = len;
9197 }
9198 }
9199 }
9200
9201 /* handle error breaks in while */
9202 if (state.mode === BAD) { break; }
9203
9204 /* check for end-of-block code (better have one) */
9205 if (state.lens[256] === 0) {
9206 strm.msg = 'invalid code -- missing end-of-block';
9207 state.mode = BAD;
9208 break;
9209 }
9210
9211 /* build code tables -- note: do not change the lenbits or distbits
9212 values here (9 and 6) without reading the comments in inftrees.h
9213 concerning the ENOUGH constants, which depend on those values */
9214 state.lenbits = 9;
9215
9216 opts = { bits: state.lenbits };
9217 ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
9218 // We have separate tables & no pointers. 2 commented lines below not needed.
9219 // state.next_index = opts.table_index;
9220 state.lenbits = opts.bits;
9221 // state.lencode = state.next;
9222
9223 if (ret) {
9224 strm.msg = 'invalid literal/lengths set';
9225 state.mode = BAD;
9226 break;
9227 }
9228
9229 state.distbits = 6;
9230 //state.distcode.copy(state.codes);
9231 // Switch to use dynamic table
9232 state.distcode = state.distdyn;
9233 opts = { bits: state.distbits };
9234 ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
9235 // We have separate tables & no pointers. 2 commented lines below not needed.
9236 // state.next_index = opts.table_index;
9237 state.distbits = opts.bits;
9238 // state.distcode = state.next;
9239
9240 if (ret) {
9241 strm.msg = 'invalid distances set';
9242 state.mode = BAD;
9243 break;
9244 }
9245 //Tracev((stderr, 'inflate: codes ok\n'));
9246 state.mode = LEN_;
9247 if (flush === Z_TREES) { break inf_leave; }
9248 /* falls through */
9249 case LEN_:
9250 state.mode = LEN;
9251 /* falls through */
9252 case LEN:
9253 if (have >= 6 && left >= 258) {
9254 //--- RESTORE() ---
9255 strm.next_out = put;
9256 strm.avail_out = left;
9257 strm.next_in = next;
9258 strm.avail_in = have;
9259 state.hold = hold;
9260 state.bits = bits;
9261 //---
9262 inflate_fast(strm, _out);
9263 //--- LOAD() ---
9264 put = strm.next_out;
9265 output = strm.output;
9266 left = strm.avail_out;
9267 next = strm.next_in;
9268 input = strm.input;
9269 have = strm.avail_in;
9270 hold = state.hold;
9271 bits = state.bits;
9272 //---
9273
9274 if (state.mode === TYPE) {
9275 state.back = -1;
9276 }
9277 break;
9278 }
9279 state.back = 0;
9280 for (;;) {
9281 here = state.lencode[hold & ((1 << state.lenbits) - 1)]; /*BITS(state.lenbits)*/
9282 here_bits = here >>> 24;
9283 here_op = (here >>> 16) & 0xff;
9284 here_val = here & 0xffff;
9285
9286 if (here_bits <= bits) { break; }
9287 //--- PULLBYTE() ---//
9288 if (have === 0) { break inf_leave; }
9289 have--;
9290 hold += input[next++] << bits;
9291 bits += 8;
9292 //---//
9293 }
9294 if (here_op && (here_op & 0xf0) === 0) {
9295 last_bits = here_bits;
9296 last_op = here_op;
9297 last_val = here_val;
9298 for (;;) {
9299 here = state.lencode[last_val +
9300 ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
9301 here_bits = here >>> 24;
9302 here_op = (here >>> 16) & 0xff;
9303 here_val = here & 0xffff;
9304
9305 if ((last_bits + here_bits) <= bits) { break; }
9306 //--- PULLBYTE() ---//
9307 if (have === 0) { break inf_leave; }
9308 have--;
9309 hold += input[next++] << bits;
9310 bits += 8;
9311 //---//
9312 }
9313 //--- DROPBITS(last.bits) ---//
9314 hold >>>= last_bits;
9315 bits -= last_bits;
9316 //---//
9317 state.back += last_bits;
9318 }
9319 //--- DROPBITS(here.bits) ---//
9320 hold >>>= here_bits;
9321 bits -= here_bits;
9322 //---//
9323 state.back += here_bits;
9324 state.length = here_val;
9325 if (here_op === 0) {
9326 //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
9327 // "inflate: literal '%c'\n" :
9328 // "inflate: literal 0x%02x\n", here.val));
9329 state.mode = LIT;
9330 break;
9331 }
9332 if (here_op & 32) {
9333 //Tracevv((stderr, "inflate: end of block\n"));
9334 state.back = -1;
9335 state.mode = TYPE;
9336 break;
9337 }
9338 if (here_op & 64) {
9339 strm.msg = 'invalid literal/length code';
9340 state.mode = BAD;
9341 break;
9342 }
9343 state.extra = here_op & 15;
9344 state.mode = LENEXT;
9345 /* falls through */
9346 case LENEXT:
9347 if (state.extra) {
9348 //=== NEEDBITS(state.extra);
9349 n = state.extra;
9350 while (bits < n) {
9351 if (have === 0) { break inf_leave; }
9352 have--;
9353 hold += input[next++] << bits;
9354 bits += 8;
9355 }
9356 //===//
9357 state.length += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
9358 //--- DROPBITS(state.extra) ---//
9359 hold >>>= state.extra;
9360 bits -= state.extra;
9361 //---//
9362 state.back += state.extra;
9363 }
9364 //Tracevv((stderr, "inflate: length %u\n", state.length));
9365 state.was = state.length;
9366 state.mode = DIST;
9367 /* falls through */
9368 case DIST:
9369 for (;;) {
9370 here = state.distcode[hold & ((1 << state.distbits) - 1)];/*BITS(state.distbits)*/
9371 here_bits = here >>> 24;
9372 here_op = (here >>> 16) & 0xff;
9373 here_val = here & 0xffff;
9374
9375 if ((here_bits) <= bits) { break; }
9376 //--- PULLBYTE() ---//
9377 if (have === 0) { break inf_leave; }
9378 have--;
9379 hold += input[next++] << bits;
9380 bits += 8;
9381 //---//
9382 }
9383 if ((here_op & 0xf0) === 0) {
9384 last_bits = here_bits;
9385 last_op = here_op;
9386 last_val = here_val;
9387 for (;;) {
9388 here = state.distcode[last_val +
9389 ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
9390 here_bits = here >>> 24;
9391 here_op = (here >>> 16) & 0xff;
9392 here_val = here & 0xffff;
9393
9394 if ((last_bits + here_bits) <= bits) { break; }
9395 //--- PULLBYTE() ---//
9396 if (have === 0) { break inf_leave; }
9397 have--;
9398 hold += input[next++] << bits;
9399 bits += 8;
9400 //---//
9401 }
9402 //--- DROPBITS(last.bits) ---//
9403 hold >>>= last_bits;
9404 bits -= last_bits;
9405 //---//
9406 state.back += last_bits;
9407 }
9408 //--- DROPBITS(here.bits) ---//
9409 hold >>>= here_bits;
9410 bits -= here_bits;
9411 //---//
9412 state.back += here_bits;
9413 if (here_op & 64) {
9414 strm.msg = 'invalid distance code';
9415 state.mode = BAD;
9416 break;
9417 }
9418 state.offset = here_val;
9419 state.extra = (here_op) & 15;
9420 state.mode = DISTEXT;
9421 /* falls through */
9422 case DISTEXT:
9423 if (state.extra) {
9424 //=== NEEDBITS(state.extra);
9425 n = state.extra;
9426 while (bits < n) {
9427 if (have === 0) { break inf_leave; }
9428 have--;
9429 hold += input[next++] << bits;
9430 bits += 8;
9431 }
9432 //===//
9433 state.offset += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
9434 //--- DROPBITS(state.extra) ---//
9435 hold >>>= state.extra;
9436 bits -= state.extra;
9437 //---//
9438 state.back += state.extra;
9439 }
9440 //#ifdef INFLATE_STRICT
9441 if (state.offset > state.dmax) {
9442 strm.msg = 'invalid distance too far back';
9443 state.mode = BAD;
9444 break;
9445 }
9446 //#endif
9447 //Tracevv((stderr, "inflate: distance %u\n", state.offset));
9448 state.mode = MATCH;
9449 /* falls through */
9450 case MATCH:
9451 if (left === 0) { break inf_leave; }
9452 copy = _out - left;
9453 if (state.offset > copy) { /* copy from window */
9454 copy = state.offset - copy;
9455 if (copy > state.whave) {
9456 if (state.sane) {
9457 strm.msg = 'invalid distance too far back';
9458 state.mode = BAD;
9459 break;
9460 }
9461 // (!) This block is disabled in zlib defailts,
9462 // don't enable it for binary compatibility
9463 //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
9464 // Trace((stderr, "inflate.c too far\n"));
9465 // copy -= state.whave;
9466 // if (copy > state.length) { copy = state.length; }
9467 // if (copy > left) { copy = left; }
9468 // left -= copy;
9469 // state.length -= copy;
9470 // do {
9471 // output[put++] = 0;
9472 // } while (--copy);
9473 // if (state.length === 0) { state.mode = LEN; }
9474 // break;
9475 //#endif
9476 }
9477 if (copy > state.wnext) {
9478 copy -= state.wnext;
9479 from = state.wsize - copy;
9480 }
9481 else {
9482 from = state.wnext - copy;
9483 }
9484 if (copy > state.length) { copy = state.length; }
9485 from_source = state.window;
9486 }
9487 else { /* copy from output */
9488 from_source = output;
9489 from = put - state.offset;
9490 copy = state.length;
9491 }
9492 if (copy > left) { copy = left; }
9493 left -= copy;
9494 state.length -= copy;
9495 do {
9496 output[put++] = from_source[from++];
9497 } while (--copy);
9498 if (state.length === 0) { state.mode = LEN; }
9499 break;
9500 case LIT:
9501 if (left === 0) { break inf_leave; }
9502 output[put++] = state.length;
9503 left--;
9504 state.mode = LEN;
9505 break;
9506 case CHECK:
9507 if (state.wrap) {
9508 //=== NEEDBITS(32);
9509 while (bits < 32) {
9510 if (have === 0) { break inf_leave; }
9511 have--;
9512 // Use '|' insdead of '+' to make sure that result is signed
9513 hold |= input[next++] << bits;
9514 bits += 8;
9515 }
9516 //===//
9517 _out -= left;
9518 strm.total_out += _out;
9519 state.total += _out;
9520 if (_out) {
9521 strm.adler = state.check =
9522 /*UPDATE(state.check, put - _out, _out);*/
9523 (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));
9524
9525 }
9526 _out = left;
9527 // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
9528 if ((state.flags ? hold : zswap32(hold)) !== state.check) {
9529 strm.msg = 'incorrect data check';
9530 state.mode = BAD;
9531 break;
9532 }
9533 //=== INITBITS();
9534 hold = 0;
9535 bits = 0;
9536 //===//
9537 //Tracev((stderr, "inflate: check matches trailer\n"));
9538 }
9539 state.mode = LENGTH;
9540 /* falls through */
9541 case LENGTH:
9542 if (state.wrap && state.flags) {
9543 //=== NEEDBITS(32);
9544 while (bits < 32) {
9545 if (have === 0) { break inf_leave; }
9546 have--;
9547 hold += input[next++] << bits;
9548 bits += 8;
9549 }
9550 //===//
9551 if (hold !== (state.total & 0xffffffff)) {
9552 strm.msg = 'incorrect length check';
9553 state.mode = BAD;
9554 break;
9555 }
9556 //=== INITBITS();
9557 hold = 0;
9558 bits = 0;
9559 //===//
9560 //Tracev((stderr, "inflate: length matches trailer\n"));
9561 }
9562 state.mode = DONE;
9563 /* falls through */
9564 case DONE:
9565 ret = Z_STREAM_END;
9566 break inf_leave;
9567 case BAD:
9568 ret = Z_DATA_ERROR;
9569 break inf_leave;
9570 case MEM:
9571 return Z_MEM_ERROR;
9572 case SYNC:
9573 /* falls through */
9574 default:
9575 return Z_STREAM_ERROR;
9576 }
9577 }
9578
9579 // inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave"
9580
9581 /*
9582 Return from inflate(), updating the total counts and the check value.
9583 If there was no progress during the inflate() call, return a buffer
9584 error. Call updatewindow() to create and/or update the window state.
9585 Note: a memory error from inflate() is non-recoverable.
9586 */
9587
9588 //--- RESTORE() ---
9589 strm.next_out = put;
9590 strm.avail_out = left;
9591 strm.next_in = next;
9592 strm.avail_in = have;
9593 state.hold = hold;
9594 state.bits = bits;
9595 //---
9596
9597 if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&
9598 (state.mode < CHECK || flush !== Z_FINISH))) {
9599 if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {
9600 state.mode = MEM;
9601 return Z_MEM_ERROR;
9602 }
9603 }
9604 _in -= strm.avail_in;
9605 _out -= strm.avail_out;
9606 strm.total_in += _in;
9607 strm.total_out += _out;
9608 state.total += _out;
9609 if (state.wrap && _out) {
9610 strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
9611 (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));
9612 }
9613 strm.data_type = state.bits + (state.last ? 64 : 0) +
9614 (state.mode === TYPE ? 128 : 0) +
9615 (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
9616 if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) {
9617 ret = Z_BUF_ERROR;
9618 }
9619 return ret;
9620 }
9621
9622 function inflateEnd(strm) {
9623
9624 if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) {
9625 return Z_STREAM_ERROR;
9626 }
9627
9628 var state = strm.state;
9629 if (state.window) {
9630 state.window = null;
9631 }
9632 strm.state = null;
9633 return Z_OK;
9634 }
9635
9636 function inflateGetHeader(strm, head) {
9637 var state;
9638
9639 /* check state */
9640 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
9641 state = strm.state;
9642 if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; }
9643
9644 /* save header structure */
9645 state.head = head;
9646 head.done = false;
9647 return Z_OK;
9648 }
9649
9650 function inflateSetDictionary(strm, dictionary) {
9651 var dictLength = dictionary.length;
9652
9653 var state;
9654 var dictid;
9655 var ret;
9656
9657 /* check state */
9658 if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR; }
9659 state = strm.state;
9660
9661 if (state.wrap !== 0 && state.mode !== DICT) {
9662 return Z_STREAM_ERROR;
9663 }
9664
9665 /* check for correct dictionary identifier */
9666 if (state.mode === DICT) {
9667 dictid = 1; /* adler32(0, null, 0)*/
9668 /* dictid = adler32(dictid, dictionary, dictLength); */
9669 dictid = adler32(dictid, dictionary, dictLength, 0);
9670 if (dictid !== state.check) {
9671 return Z_DATA_ERROR;
9672 }
9673 }
9674 /* copy dictionary to window using updatewindow(), which will amend the
9675 existing dictionary if appropriate */
9676 ret = updatewindow(strm, dictionary, dictLength, dictLength);
9677 if (ret) {
9678 state.mode = MEM;
9679 return Z_MEM_ERROR;
9680 }
9681 state.havedict = 1;
9682 // Tracev((stderr, "inflate: dictionary set\n"));
9683 return Z_OK;
9684 }
9685
9686 exports.inflateReset = inflateReset;
9687 exports.inflateReset2 = inflateReset2;
9688 exports.inflateResetKeep = inflateResetKeep;
9689 exports.inflateInit = inflateInit;
9690 exports.inflateInit2 = inflateInit2;
9691 exports.inflate = inflate;
9692 exports.inflateEnd = inflateEnd;
9693 exports.inflateGetHeader = inflateGetHeader;
9694 exports.inflateSetDictionary = inflateSetDictionary;
9695 exports.inflateInfo = 'pako inflate (from Nodeca project)';
9696
9697 /* Not implemented
9698 exports.inflateCopy = inflateCopy;
9699 exports.inflateGetDictionary = inflateGetDictionary;
9700 exports.inflateMark = inflateMark;
9701 exports.inflatePrime = inflatePrime;
9702 exports.inflateSync = inflateSync;
9703 exports.inflateSyncPoint = inflateSyncPoint;
9704 exports.inflateUndermine = inflateUndermine;
9705 */
9706
9707 },{"../utils/common":41,"./adler32":43,"./crc32":45,"./inffast":48,"./inftrees":50}],50:[function(require,module,exports){
9708 'use strict';
9709
9710 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
9711 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
9712 //
9713 // This software is provided 'as-is', without any express or implied
9714 // warranty. In no event will the authors be held liable for any damages
9715 // arising from the use of this software.
9716 //
9717 // Permission is granted to anyone to use this software for any purpose,
9718 // including commercial applications, and to alter it and redistribute it
9719 // freely, subject to the following restrictions:
9720 //
9721 // 1. The origin of this software must not be misrepresented; you must not
9722 // claim that you wrote the original software. If you use this software
9723 // in a product, an acknowledgment in the product documentation would be
9724 // appreciated but is not required.
9725 // 2. Altered source versions must be plainly marked as such, and must not be
9726 // misrepresented as being the original software.
9727 // 3. This notice may not be removed or altered from any source distribution.
9728
9729 var utils = require('../utils/common');
9730
9731 var MAXBITS = 15;
9732 var ENOUGH_LENS = 852;
9733 var ENOUGH_DISTS = 592;
9734 //var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
9735
9736 var CODES = 0;
9737 var LENS = 1;
9738 var DISTS = 2;
9739
9740 var lbase = [ /* Length codes 257..285 base */
9741 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
9742 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
9743 ];
9744
9745 var lext = [ /* Length codes 257..285 extra */
9746 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
9747 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78
9748 ];
9749
9750 var dbase = [ /* Distance codes 0..29 base */
9751 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
9752 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
9753 8193, 12289, 16385, 24577, 0, 0
9754 ];
9755
9756 var dext = [ /* Distance codes 0..29 extra */
9757 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
9758 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
9759 28, 28, 29, 29, 64, 64
9760 ];
9761
9762 module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts)
9763 {
9764 var bits = opts.bits;
9765 //here = opts.here; /* table entry for duplication */
9766
9767 var len = 0; /* a code's length in bits */
9768 var sym = 0; /* index of code symbols */
9769 var min = 0, max = 0; /* minimum and maximum code lengths */
9770 var root = 0; /* number of index bits for root table */
9771 var curr = 0; /* number of index bits for current table */
9772 var drop = 0; /* code bits to drop for sub-table */
9773 var left = 0; /* number of prefix codes available */
9774 var used = 0; /* code entries in table used */
9775 var huff = 0; /* Huffman code */
9776 var incr; /* for incrementing code, index */
9777 var fill; /* index for replicating entries */
9778 var low; /* low bits for current root entry */
9779 var mask; /* mask for low root bits */
9780 var next; /* next available space in table */
9781 var base = null; /* base value table to use */
9782 var base_index = 0;
9783 // var shoextra; /* extra bits table to use */
9784 var end; /* use base and extra for symbol > end */
9785 var count = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* number of codes of each length */
9786 var offs = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* offsets in table for each length */
9787 var extra = null;
9788 var extra_index = 0;
9789
9790 var here_bits, here_op, here_val;
9791
9792 /*
9793 Process a set of code lengths to create a canonical Huffman code. The
9794 code lengths are lens[0..codes-1]. Each length corresponds to the
9795 symbols 0..codes-1. The Huffman code is generated by first sorting the
9796 symbols by length from short to long, and retaining the symbol order
9797 for codes with equal lengths. Then the code starts with all zero bits
9798 for the first code of the shortest length, and the codes are integer
9799 increments for the same length, and zeros are appended as the length
9800 increases. For the deflate format, these bits are stored backwards
9801 from their more natural integer increment ordering, and so when the
9802 decoding tables are built in the large loop below, the integer codes
9803 are incremented backwards.
9804
9805 This routine assumes, but does not check, that all of the entries in
9806 lens[] are in the range 0..MAXBITS. The caller must assure this.
9807 1..MAXBITS is interpreted as that code length. zero means that that
9808 symbol does not occur in this code.
9809
9810 The codes are sorted by computing a count of codes for each length,
9811 creating from that a table of starting indices for each length in the
9812 sorted table, and then entering the symbols in order in the sorted
9813 table. The sorted table is work[], with that space being provided by
9814 the caller.
9815
9816 The length counts are used for other purposes as well, i.e. finding
9817 the minimum and maximum length codes, determining if there are any
9818 codes at all, checking for a valid set of lengths, and looking ahead
9819 at length counts to determine sub-table sizes when building the
9820 decoding tables.
9821 */
9822
9823 /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
9824 for (len = 0; len <= MAXBITS; len++) {
9825 count[len] = 0;
9826 }
9827 for (sym = 0; sym < codes; sym++) {
9828 count[lens[lens_index + sym]]++;
9829 }
9830
9831 /* bound code lengths, force root to be within code lengths */
9832 root = bits;
9833 for (max = MAXBITS; max >= 1; max--) {
9834 if (count[max] !== 0) { break; }
9835 }
9836 if (root > max) {
9837 root = max;
9838 }
9839 if (max === 0) { /* no symbols to code at all */
9840 //table.op[opts.table_index] = 64; //here.op = (var char)64; /* invalid code marker */
9841 //table.bits[opts.table_index] = 1; //here.bits = (var char)1;
9842 //table.val[opts.table_index++] = 0; //here.val = (var short)0;
9843 table[table_index++] = (1 << 24) | (64 << 16) | 0;
9844
9845
9846 //table.op[opts.table_index] = 64;
9847 //table.bits[opts.table_index] = 1;
9848 //table.val[opts.table_index++] = 0;
9849 table[table_index++] = (1 << 24) | (64 << 16) | 0;
9850
9851 opts.bits = 1;
9852 return 0; /* no symbols, but wait for decoding to report error */
9853 }
9854 for (min = 1; min < max; min++) {
9855 if (count[min] !== 0) { break; }
9856 }
9857 if (root < min) {
9858 root = min;
9859 }
9860
9861 /* check for an over-subscribed or incomplete set of lengths */
9862 left = 1;
9863 for (len = 1; len <= MAXBITS; len++) {
9864 left <<= 1;
9865 left -= count[len];
9866 if (left < 0) {
9867 return -1;
9868 } /* over-subscribed */
9869 }
9870 if (left > 0 && (type === CODES || max !== 1)) {
9871 return -1; /* incomplete set */
9872 }
9873
9874 /* generate offsets into symbol table for each length for sorting */
9875 offs[1] = 0;
9876 for (len = 1; len < MAXBITS; len++) {
9877 offs[len + 1] = offs[len] + count[len];
9878 }
9879
9880 /* sort symbols by length, by symbol order within each length */
9881 for (sym = 0; sym < codes; sym++) {
9882 if (lens[lens_index + sym] !== 0) {
9883 work[offs[lens[lens_index + sym]]++] = sym;
9884 }
9885 }
9886
9887 /*
9888 Create and fill in decoding tables. In this loop, the table being
9889 filled is at next and has curr index bits. The code being used is huff
9890 with length len. That code is converted to an index by dropping drop
9891 bits off of the bottom. For codes where len is less than drop + curr,
9892 those top drop + curr - len bits are incremented through all values to
9893 fill the table with replicated entries.
9894
9895 root is the number of index bits for the root table. When len exceeds
9896 root, sub-tables are created pointed to by the root entry with an index
9897 of the low root bits of huff. This is saved in low to check for when a
9898 new sub-table should be started. drop is zero when the root table is
9899 being filled, and drop is root when sub-tables are being filled.
9900
9901 When a new sub-table is needed, it is necessary to look ahead in the
9902 code lengths to determine what size sub-table is needed. The length
9903 counts are used for this, and so count[] is decremented as codes are
9904 entered in the tables.
9905
9906 used keeps track of how many table entries have been allocated from the
9907 provided *table space. It is checked for LENS and DIST tables against
9908 the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
9909 the initial root table size constants. See the comments in inftrees.h
9910 for more information.
9911
9912 sym increments through all symbols, and the loop terminates when
9913 all codes of length max, i.e. all codes, have been processed. This
9914 routine permits incomplete codes, so another loop after this one fills
9915 in the rest of the decoding tables with invalid code markers.
9916 */
9917
9918 /* set up for code type */
9919 // poor man optimization - use if-else instead of switch,
9920 // to avoid deopts in old v8
9921 if (type === CODES) {
9922 base = extra = work; /* dummy value--not used */
9923 end = 19;
9924
9925 } else if (type === LENS) {
9926 base = lbase;
9927 base_index -= 257;
9928 extra = lext;
9929 extra_index -= 257;
9930 end = 256;
9931
9932 } else { /* DISTS */
9933 base = dbase;
9934 extra = dext;
9935 end = -1;
9936 }
9937
9938 /* initialize opts for loop */
9939 huff = 0; /* starting code */
9940 sym = 0; /* starting code symbol */
9941 len = min; /* starting code length */
9942 next = table_index; /* current table to fill in */
9943 curr = root; /* current table index bits */
9944 drop = 0; /* current bits to drop from code for index */
9945 low = -1; /* trigger new sub-table when len > root */
9946 used = 1 << root; /* use root table entries */
9947 mask = used - 1; /* mask for comparing low */
9948
9949 /* check available table space */
9950 if ((type === LENS && used > ENOUGH_LENS) ||
9951 (type === DISTS && used > ENOUGH_DISTS)) {
9952 return 1;
9953 }
9954
9955 /* process all codes and make table entries */
9956 for (;;) {
9957 /* create table entry */
9958 here_bits = len - drop;
9959 if (work[sym] < end) {
9960 here_op = 0;
9961 here_val = work[sym];
9962 }
9963 else if (work[sym] > end) {
9964 here_op = extra[extra_index + work[sym]];
9965 here_val = base[base_index + work[sym]];
9966 }
9967 else {
9968 here_op = 32 + 64; /* end of block */
9969 here_val = 0;
9970 }
9971
9972 /* replicate for those indices with low len bits equal to huff */
9973 incr = 1 << (len - drop);
9974 fill = 1 << curr;
9975 min = fill; /* save offset to next table */
9976 do {
9977 fill -= incr;
9978 table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0;
9979 } while (fill !== 0);
9980
9981 /* backwards increment the len-bit code huff */
9982 incr = 1 << (len - 1);
9983 while (huff & incr) {
9984 incr >>= 1;
9985 }
9986 if (incr !== 0) {
9987 huff &= incr - 1;
9988 huff += incr;
9989 } else {
9990 huff = 0;
9991 }
9992
9993 /* go to next symbol, update count, len */
9994 sym++;
9995 if (--count[len] === 0) {
9996 if (len === max) { break; }
9997 len = lens[lens_index + work[sym]];
9998 }
9999
10000 /* create new sub-table if needed */
10001 if (len > root && (huff & mask) !== low) {
10002 /* if first time, transition to sub-tables */
10003 if (drop === 0) {
10004 drop = root;
10005 }
10006
10007 /* increment past last table */
10008 next += min; /* here min is 1 << curr */
10009
10010 /* determine length of next table */
10011 curr = len - drop;
10012 left = 1 << curr;
10013 while (curr + drop < max) {
10014 left -= count[curr + drop];
10015 if (left <= 0) { break; }
10016 curr++;
10017 left <<= 1;
10018 }
10019
10020 /* check for enough space */
10021 used += 1 << curr;
10022 if ((type === LENS && used > ENOUGH_LENS) ||
10023 (type === DISTS && used > ENOUGH_DISTS)) {
10024 return 1;
10025 }
10026
10027 /* point entry in root table to sub-table */
10028 low = huff & mask;
10029 /*table.op[low] = curr;
10030 table.bits[low] = root;
10031 table.val[low] = next - opts.table_index;*/
10032 table[low] = (root << 24) | (curr << 16) | (next - table_index) |0;
10033 }
10034 }
10035
10036 /* fill in remaining table entry if code is incomplete (guaranteed to have
10037 at most one remaining entry, since if the code is incomplete, the
10038 maximum code length that was allowed to get this far is one bit) */
10039 if (huff !== 0) {
10040 //table.op[next + huff] = 64; /* invalid code marker */
10041 //table.bits[next + huff] = len - drop;
10042 //table.val[next + huff] = 0;
10043 table[next + huff] = ((len - drop) << 24) | (64 << 16) |0;
10044 }
10045
10046 /* set return parameters */
10047 //opts.table_index += used;
10048 opts.bits = root;
10049 return 0;
10050 };
10051
10052 },{"../utils/common":41}],51:[function(require,module,exports){
10053 'use strict';
10054
10055 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
10056 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
10057 //
10058 // This software is provided 'as-is', without any express or implied
10059 // warranty. In no event will the authors be held liable for any damages
10060 // arising from the use of this software.
10061 //
10062 // Permission is granted to anyone to use this software for any purpose,
10063 // including commercial applications, and to alter it and redistribute it
10064 // freely, subject to the following restrictions:
10065 //
10066 // 1. The origin of this software must not be misrepresented; you must not
10067 // claim that you wrote the original software. If you use this software
10068 // in a product, an acknowledgment in the product documentation would be
10069 // appreciated but is not required.
10070 // 2. Altered source versions must be plainly marked as such, and must not be
10071 // misrepresented as being the original software.
10072 // 3. This notice may not be removed or altered from any source distribution.
10073
10074 module.exports = {
10075 2: 'need dictionary', /* Z_NEED_DICT 2 */
10076 1: 'stream end', /* Z_STREAM_END 1 */
10077 0: '', /* Z_OK 0 */
10078 '-1': 'file error', /* Z_ERRNO (-1) */
10079 '-2': 'stream error', /* Z_STREAM_ERROR (-2) */
10080 '-3': 'data error', /* Z_DATA_ERROR (-3) */
10081 '-4': 'insufficient memory', /* Z_MEM_ERROR (-4) */
10082 '-5': 'buffer error', /* Z_BUF_ERROR (-5) */
10083 '-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */
10084 };
10085
10086 },{}],52:[function(require,module,exports){
10087 'use strict';
10088
10089 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
10090 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
10091 //
10092 // This software is provided 'as-is', without any express or implied
10093 // warranty. In no event will the authors be held liable for any damages
10094 // arising from the use of this software.
10095 //
10096 // Permission is granted to anyone to use this software for any purpose,
10097 // including commercial applications, and to alter it and redistribute it
10098 // freely, subject to the following restrictions:
10099 //
10100 // 1. The origin of this software must not be misrepresented; you must not
10101 // claim that you wrote the original software. If you use this software
10102 // in a product, an acknowledgment in the product documentation would be
10103 // appreciated but is not required.
10104 // 2. Altered source versions must be plainly marked as such, and must not be
10105 // misrepresented as being the original software.
10106 // 3. This notice may not be removed or altered from any source distribution.
10107
10108 var utils = require('../utils/common');
10109
10110 /* Public constants ==========================================================*/
10111 /* ===========================================================================*/
10112
10113
10114 //var Z_FILTERED = 1;
10115 //var Z_HUFFMAN_ONLY = 2;
10116 //var Z_RLE = 3;
10117 var Z_FIXED = 4;
10118 //var Z_DEFAULT_STRATEGY = 0;
10119
10120 /* Possible values of the data_type field (though see inflate()) */
10121 var Z_BINARY = 0;
10122 var Z_TEXT = 1;
10123 //var Z_ASCII = 1; // = Z_TEXT
10124 var Z_UNKNOWN = 2;
10125
10126 /*============================================================================*/
10127
10128
10129 function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }
10130
10131 // From zutil.h
10132
10133 var STORED_BLOCK = 0;
10134 var STATIC_TREES = 1;
10135 var DYN_TREES = 2;
10136 /* The three kinds of block type */
10137
10138 var MIN_MATCH = 3;
10139 var MAX_MATCH = 258;
10140 /* The minimum and maximum match lengths */
10141
10142 // From deflate.h
10143 /* ===========================================================================
10144 * Internal compression state.
10145 */
10146
10147 var LENGTH_CODES = 29;
10148 /* number of length codes, not counting the special END_BLOCK code */
10149
10150 var LITERALS = 256;
10151 /* number of literal bytes 0..255 */
10152
10153 var L_CODES = LITERALS + 1 + LENGTH_CODES;
10154 /* number of Literal or Length codes, including the END_BLOCK code */
10155
10156 var D_CODES = 30;
10157 /* number of distance codes */
10158
10159 var BL_CODES = 19;
10160 /* number of codes used to transfer the bit lengths */
10161
10162 var HEAP_SIZE = 2 * L_CODES + 1;
10163 /* maximum heap size */
10164
10165 var MAX_BITS = 15;
10166 /* All codes must not exceed MAX_BITS bits */
10167
10168 var Buf_size = 16;
10169 /* size of bit buffer in bi_buf */
10170
10171
10172 /* ===========================================================================
10173 * Constants
10174 */
10175
10176 var MAX_BL_BITS = 7;
10177 /* Bit length codes must not exceed MAX_BL_BITS bits */
10178
10179 var END_BLOCK = 256;
10180 /* end of block literal code */
10181
10182 var REP_3_6 = 16;
10183 /* repeat previous bit length 3-6 times (2 bits of repeat count) */
10184
10185 var REPZ_3_10 = 17;
10186 /* repeat a zero length 3-10 times (3 bits of repeat count) */
10187
10188 var REPZ_11_138 = 18;
10189 /* repeat a zero length 11-138 times (7 bits of repeat count) */
10190
10191 /* eslint-disable comma-spacing,array-bracket-spacing */
10192 var extra_lbits = /* extra bits for each length code */
10193 [0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0];
10194
10195 var extra_dbits = /* extra bits for each distance code */
10196 [0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13];
10197
10198 var extra_blbits = /* extra bits for each bit length code */
10199 [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7];
10200
10201 var bl_order =
10202 [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];
10203 /* eslint-enable comma-spacing,array-bracket-spacing */
10204
10205 /* The lengths of the bit length codes are sent in order of decreasing
10206 * probability, to avoid transmitting the lengths for unused bit length codes.
10207 */
10208
10209 /* ===========================================================================
10210 * Local data. These are initialized only once.
10211 */
10212
10213 // We pre-fill arrays with 0 to avoid uninitialized gaps
10214
10215 var DIST_CODE_LEN = 512; /* see definition of array dist_code below */
10216
10217 // !!!! Use flat array insdead of structure, Freq = i*2, Len = i*2+1
10218 var static_ltree = new Array((L_CODES + 2) * 2);
10219 zero(static_ltree);
10220 /* The static literal tree. Since the bit lengths are imposed, there is no
10221 * need for the L_CODES extra codes used during heap construction. However
10222 * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
10223 * below).
10224 */
10225
10226 var static_dtree = new Array(D_CODES * 2);
10227 zero(static_dtree);
10228 /* The static distance tree. (Actually a trivial tree since all codes use
10229 * 5 bits.)
10230 */
10231
10232 var _dist_code = new Array(DIST_CODE_LEN);
10233 zero(_dist_code);
10234 /* Distance codes. The first 256 values correspond to the distances
10235 * 3 .. 258, the last 256 values correspond to the top 8 bits of
10236 * the 15 bit distances.
10237 */
10238
10239 var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);
10240 zero(_length_code);
10241 /* length code for each normalized match length (0 == MIN_MATCH) */
10242
10243 var base_length = new Array(LENGTH_CODES);
10244 zero(base_length);
10245 /* First normalized length for each code (0 = MIN_MATCH) */
10246
10247 var base_dist = new Array(D_CODES);
10248 zero(base_dist);
10249 /* First normalized distance for each code (0 = distance of 1) */
10250
10251
10252 function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {
10253
10254 this.static_tree = static_tree; /* static tree or NULL */
10255 this.extra_bits = extra_bits; /* extra bits for each code or NULL */
10256 this.extra_base = extra_base; /* base index for extra_bits */
10257 this.elems = elems; /* max number of elements in the tree */
10258 this.max_length = max_length; /* max bit length for the codes */
10259
10260 // show if `static_tree` has data or dummy - needed for monomorphic objects
10261 this.has_stree = static_tree && static_tree.length;
10262 }
10263
10264
10265 var static_l_desc;
10266 var static_d_desc;
10267 var static_bl_desc;
10268
10269
10270 function TreeDesc(dyn_tree, stat_desc) {
10271 this.dyn_tree = dyn_tree; /* the dynamic tree */
10272 this.max_code = 0; /* largest code with non zero frequency */
10273 this.stat_desc = stat_desc; /* the corresponding static tree */
10274 }
10275
10276
10277
10278 function d_code(dist) {
10279 return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
10280 }
10281
10282
10283 /* ===========================================================================
10284 * Output a short LSB first on the stream.
10285 * IN assertion: there is enough room in pendingBuf.
10286 */
10287 function put_short(s, w) {
10288 // put_byte(s, (uch)((w) & 0xff));
10289 // put_byte(s, (uch)((ush)(w) >> 8));
10290 s.pending_buf[s.pending++] = (w) & 0xff;
10291 s.pending_buf[s.pending++] = (w >>> 8) & 0xff;
10292 }
10293
10294
10295 /* ===========================================================================
10296 * Send a value on a given number of bits.
10297 * IN assertion: length <= 16 and value fits in length bits.
10298 */
10299 function send_bits(s, value, length) {
10300 if (s.bi_valid > (Buf_size - length)) {
10301 s.bi_buf |= (value << s.bi_valid) & 0xffff;
10302 put_short(s, s.bi_buf);
10303 s.bi_buf = value >> (Buf_size - s.bi_valid);
10304 s.bi_valid += length - Buf_size;
10305 } else {
10306 s.bi_buf |= (value << s.bi_valid) & 0xffff;
10307 s.bi_valid += length;
10308 }
10309 }
10310
10311
10312 function send_code(s, c, tree) {
10313 send_bits(s, tree[c * 2]/*.Code*/, tree[c * 2 + 1]/*.Len*/);
10314 }
10315
10316
10317 /* ===========================================================================
10318 * Reverse the first len bits of a code, using straightforward code (a faster
10319 * method would use a table)
10320 * IN assertion: 1 <= len <= 15
10321 */
10322 function bi_reverse(code, len) {
10323 var res = 0;
10324 do {
10325 res |= code & 1;
10326 code >>>= 1;
10327 res <<= 1;
10328 } while (--len > 0);
10329 return res >>> 1;
10330 }
10331
10332
10333 /* ===========================================================================
10334 * Flush the bit buffer, keeping at most 7 bits in it.
10335 */
10336 function bi_flush(s) {
10337 if (s.bi_valid === 16) {
10338 put_short(s, s.bi_buf);
10339 s.bi_buf = 0;
10340 s.bi_valid = 0;
10341
10342 } else if (s.bi_valid >= 8) {
10343 s.pending_buf[s.pending++] = s.bi_buf & 0xff;
10344 s.bi_buf >>= 8;
10345 s.bi_valid -= 8;
10346 }
10347 }
10348
10349
10350 /* ===========================================================================
10351 * Compute the optimal bit lengths for a tree and update the total bit length
10352 * for the current block.
10353 * IN assertion: the fields freq and dad are set, heap[heap_max] and
10354 * above are the tree nodes sorted by increasing frequency.
10355 * OUT assertions: the field len is set to the optimal bit length, the
10356 * array bl_count contains the frequencies for each bit length.
10357 * The length opt_len is updated; static_len is also updated if stree is
10358 * not null.
10359 */
10360 function gen_bitlen(s, desc)
10361 // deflate_state *s;
10362 // tree_desc *desc; /* the tree descriptor */
10363 {
10364 var tree = desc.dyn_tree;
10365 var max_code = desc.max_code;
10366 var stree = desc.stat_desc.static_tree;
10367 var has_stree = desc.stat_desc.has_stree;
10368 var extra = desc.stat_desc.extra_bits;
10369 var base = desc.stat_desc.extra_base;
10370 var max_length = desc.stat_desc.max_length;
10371 var h; /* heap index */
10372 var n, m; /* iterate over the tree elements */
10373 var bits; /* bit length */
10374 var xbits; /* extra bits */
10375 var f; /* frequency */
10376 var overflow = 0; /* number of elements with bit length too large */
10377
10378 for (bits = 0; bits <= MAX_BITS; bits++) {
10379 s.bl_count[bits] = 0;
10380 }
10381
10382 /* In a first pass, compute the optimal bit lengths (which may
10383 * overflow in the case of the bit length tree).
10384 */
10385 tree[s.heap[s.heap_max] * 2 + 1]/*.Len*/ = 0; /* root of the heap */
10386
10387 for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
10388 n = s.heap[h];
10389 bits = tree[tree[n * 2 + 1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1;
10390 if (bits > max_length) {
10391 bits = max_length;
10392 overflow++;
10393 }
10394 tree[n * 2 + 1]/*.Len*/ = bits;
10395 /* We overwrite tree[n].Dad which is no longer needed */
10396
10397 if (n > max_code) { continue; } /* not a leaf node */
10398
10399 s.bl_count[bits]++;
10400 xbits = 0;
10401 if (n >= base) {
10402 xbits = extra[n - base];
10403 }
10404 f = tree[n * 2]/*.Freq*/;
10405 s.opt_len += f * (bits + xbits);
10406 if (has_stree) {
10407 s.static_len += f * (stree[n * 2 + 1]/*.Len*/ + xbits);
10408 }
10409 }
10410 if (overflow === 0) { return; }
10411
10412 // Trace((stderr,"\nbit length overflow\n"));
10413 /* This happens for example on obj2 and pic of the Calgary corpus */
10414
10415 /* Find the first bit length which could increase: */
10416 do {
10417 bits = max_length - 1;
10418 while (s.bl_count[bits] === 0) { bits--; }
10419 s.bl_count[bits]--; /* move one leaf down the tree */
10420 s.bl_count[bits + 1] += 2; /* move one overflow item as its brother */
10421 s.bl_count[max_length]--;
10422 /* The brother of the overflow item also moves one step up,
10423 * but this does not affect bl_count[max_length]
10424 */
10425 overflow -= 2;
10426 } while (overflow > 0);
10427
10428 /* Now recompute all bit lengths, scanning in increasing frequency.
10429 * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
10430 * lengths instead of fixing only the wrong ones. This idea is taken
10431 * from 'ar' written by Haruhiko Okumura.)
10432 */
10433 for (bits = max_length; bits !== 0; bits--) {
10434 n = s.bl_count[bits];
10435 while (n !== 0) {
10436 m = s.heap[--h];
10437 if (m > max_code) { continue; }
10438 if (tree[m * 2 + 1]/*.Len*/ !== bits) {
10439 // Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
10440 s.opt_len += (bits - tree[m * 2 + 1]/*.Len*/) * tree[m * 2]/*.Freq*/;
10441 tree[m * 2 + 1]/*.Len*/ = bits;
10442 }
10443 n--;
10444 }
10445 }
10446 }
10447
10448
10449 /* ===========================================================================
10450 * Generate the codes for a given tree and bit counts (which need not be
10451 * optimal).
10452 * IN assertion: the array bl_count contains the bit length statistics for
10453 * the given tree and the field len is set for all tree elements.
10454 * OUT assertion: the field code is set for all tree elements of non
10455 * zero code length.
10456 */
10457 function gen_codes(tree, max_code, bl_count)
10458 // ct_data *tree; /* the tree to decorate */
10459 // int max_code; /* largest code with non zero frequency */
10460 // ushf *bl_count; /* number of codes at each bit length */
10461 {
10462 var next_code = new Array(MAX_BITS + 1); /* next code value for each bit length */
10463 var code = 0; /* running code value */
10464 var bits; /* bit index */
10465 var n; /* code index */
10466
10467 /* The distribution counts are first used to generate the code values
10468 * without bit reversal.
10469 */
10470 for (bits = 1; bits <= MAX_BITS; bits++) {
10471 next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
10472 }
10473 /* Check that the bit counts in bl_count are consistent. The last code
10474 * must be all ones.
10475 */
10476 //Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
10477 // "inconsistent bit counts");
10478 //Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
10479
10480 for (n = 0; n <= max_code; n++) {
10481 var len = tree[n * 2 + 1]/*.Len*/;
10482 if (len === 0) { continue; }
10483 /* Now reverse the bits */
10484 tree[n * 2]/*.Code*/ = bi_reverse(next_code[len]++, len);
10485
10486 //Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
10487 // n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
10488 }
10489 }
10490
10491
10492 /* ===========================================================================
10493 * Initialize the various 'constant' tables.
10494 */
10495 function tr_static_init() {
10496 var n; /* iterates over tree elements */
10497 var bits; /* bit counter */
10498 var length; /* length value */
10499 var code; /* code value */
10500 var dist; /* distance index */
10501 var bl_count = new Array(MAX_BITS + 1);
10502 /* number of codes at each bit length for an optimal tree */
10503
10504 // do check in _tr_init()
10505 //if (static_init_done) return;
10506
10507 /* For some embedded targets, global variables are not initialized: */
10508 /*#ifdef NO_INIT_GLOBAL_POINTERS
10509 static_l_desc.static_tree = static_ltree;
10510 static_l_desc.extra_bits = extra_lbits;
10511 static_d_desc.static_tree = static_dtree;
10512 static_d_desc.extra_bits = extra_dbits;
10513 static_bl_desc.extra_bits = extra_blbits;
10514 #endif*/
10515
10516 /* Initialize the mapping length (0..255) -> length code (0..28) */
10517 length = 0;
10518 for (code = 0; code < LENGTH_CODES - 1; code++) {
10519 base_length[code] = length;
10520 for (n = 0; n < (1 << extra_lbits[code]); n++) {
10521 _length_code[length++] = code;
10522 }
10523 }
10524 //Assert (length == 256, "tr_static_init: length != 256");
10525 /* Note that the length 255 (match length 258) can be represented
10526 * in two different ways: code 284 + 5 bits or code 285, so we
10527 * overwrite length_code[255] to use the best encoding:
10528 */
10529 _length_code[length - 1] = code;
10530
10531 /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
10532 dist = 0;
10533 for (code = 0; code < 16; code++) {
10534 base_dist[code] = dist;
10535 for (n = 0; n < (1 << extra_dbits[code]); n++) {
10536 _dist_code[dist++] = code;
10537 }
10538 }
10539 //Assert (dist == 256, "tr_static_init: dist != 256");
10540 dist >>= 7; /* from now on, all distances are divided by 128 */
10541 for (; code < D_CODES; code++) {
10542 base_dist[code] = dist << 7;
10543 for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
10544 _dist_code[256 + dist++] = code;
10545 }
10546 }
10547 //Assert (dist == 256, "tr_static_init: 256+dist != 512");
10548
10549 /* Construct the codes of the static literal tree */
10550 for (bits = 0; bits <= MAX_BITS; bits++) {
10551 bl_count[bits] = 0;
10552 }
10553
10554 n = 0;
10555 while (n <= 143) {
10556 static_ltree[n * 2 + 1]/*.Len*/ = 8;
10557 n++;
10558 bl_count[8]++;
10559 }
10560 while (n <= 255) {
10561 static_ltree[n * 2 + 1]/*.Len*/ = 9;
10562 n++;
10563 bl_count[9]++;
10564 }
10565 while (n <= 279) {
10566 static_ltree[n * 2 + 1]/*.Len*/ = 7;
10567 n++;
10568 bl_count[7]++;
10569 }
10570 while (n <= 287) {
10571 static_ltree[n * 2 + 1]/*.Len*/ = 8;
10572 n++;
10573 bl_count[8]++;
10574 }
10575 /* Codes 286 and 287 do not exist, but we must include them in the
10576 * tree construction to get a canonical Huffman tree (longest code
10577 * all ones)
10578 */
10579 gen_codes(static_ltree, L_CODES + 1, bl_count);
10580
10581 /* The static distance tree is trivial: */
10582 for (n = 0; n < D_CODES; n++) {
10583 static_dtree[n * 2 + 1]/*.Len*/ = 5;
10584 static_dtree[n * 2]/*.Code*/ = bi_reverse(n, 5);
10585 }
10586
10587 // Now data ready and we can init static trees
10588 static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
10589 static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);
10590 static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);
10591
10592 //static_init_done = true;
10593 }
10594
10595
10596 /* ===========================================================================
10597 * Initialize a new block.
10598 */
10599 function init_block(s) {
10600 var n; /* iterates over tree elements */
10601
10602 /* Initialize the trees. */
10603 for (n = 0; n < L_CODES; n++) { s.dyn_ltree[n * 2]/*.Freq*/ = 0; }
10604 for (n = 0; n < D_CODES; n++) { s.dyn_dtree[n * 2]/*.Freq*/ = 0; }
10605 for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2]/*.Freq*/ = 0; }
10606
10607 s.dyn_ltree[END_BLOCK * 2]/*.Freq*/ = 1;
10608 s.opt_len = s.static_len = 0;
10609 s.last_lit = s.matches = 0;
10610 }
10611
10612
10613 /* ===========================================================================
10614 * Flush the bit buffer and align the output on a byte boundary
10615 */
10616 function bi_windup(s)
10617 {
10618 if (s.bi_valid > 8) {
10619 put_short(s, s.bi_buf);
10620 } else if (s.bi_valid > 0) {
10621 //put_byte(s, (Byte)s->bi_buf);
10622 s.pending_buf[s.pending++] = s.bi_buf;
10623 }
10624 s.bi_buf = 0;
10625 s.bi_valid = 0;
10626 }
10627
10628 /* ===========================================================================
10629 * Copy a stored block, storing first the length and its
10630 * one's complement if requested.
10631 */
10632 function copy_block(s, buf, len, header)
10633 //DeflateState *s;
10634 //charf *buf; /* the input data */
10635 //unsigned len; /* its length */
10636 //int header; /* true if block header must be written */
10637 {
10638 bi_windup(s); /* align on byte boundary */
10639
10640 if (header) {
10641 put_short(s, len);
10642 put_short(s, ~len);
10643 }
10644 // while (len--) {
10645 // put_byte(s, *buf++);
10646 // }
10647 utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);
10648 s.pending += len;
10649 }
10650
10651 /* ===========================================================================
10652 * Compares to subtrees, using the tree depth as tie breaker when
10653 * the subtrees have equal frequency. This minimizes the worst case length.
10654 */
10655 function smaller(tree, n, m, depth) {
10656 var _n2 = n * 2;
10657 var _m2 = m * 2;
10658 return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ ||
10659 (tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m]));
10660 }
10661
10662 /* ===========================================================================
10663 * Restore the heap property by moving down the tree starting at node k,
10664 * exchanging a node with the smallest of its two sons if necessary, stopping
10665 * when the heap property is re-established (each father smaller than its
10666 * two sons).
10667 */
10668 function pqdownheap(s, tree, k)
10669 // deflate_state *s;
10670 // ct_data *tree; /* the tree to restore */
10671 // int k; /* node to move down */
10672 {
10673 var v = s.heap[k];
10674 var j = k << 1; /* left son of k */
10675 while (j <= s.heap_len) {
10676 /* Set j to the smallest of the two sons: */
10677 if (j < s.heap_len &&
10678 smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
10679 j++;
10680 }
10681 /* Exit if v is smaller than both sons */
10682 if (smaller(tree, v, s.heap[j], s.depth)) { break; }
10683
10684 /* Exchange v with the smallest son */
10685 s.heap[k] = s.heap[j];
10686 k = j;
10687
10688 /* And continue down the tree, setting j to the left son of k */
10689 j <<= 1;
10690 }
10691 s.heap[k] = v;
10692 }
10693
10694
10695 // inlined manually
10696 // var SMALLEST = 1;
10697
10698 /* ===========================================================================
10699 * Send the block data compressed using the given Huffman trees
10700 */
10701 function compress_block(s, ltree, dtree)
10702 // deflate_state *s;
10703 // const ct_data *ltree; /* literal tree */
10704 // const ct_data *dtree; /* distance tree */
10705 {
10706 var dist; /* distance of matched string */
10707 var lc; /* match length or unmatched char (if dist == 0) */
10708 var lx = 0; /* running index in l_buf */
10709 var code; /* the code to send */
10710 var extra; /* number of extra bits to send */
10711
10712 if (s.last_lit !== 0) {
10713 do {
10714 dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]);
10715 lc = s.pending_buf[s.l_buf + lx];
10716 lx++;
10717
10718 if (dist === 0) {
10719 send_code(s, lc, ltree); /* send a literal byte */
10720 //Tracecv(isgraph(lc), (stderr," '%c' ", lc));
10721 } else {
10722 /* Here, lc is the match length - MIN_MATCH */
10723 code = _length_code[lc];
10724 send_code(s, code + LITERALS + 1, ltree); /* send the length code */
10725 extra = extra_lbits[code];
10726 if (extra !== 0) {
10727 lc -= base_length[code];
10728 send_bits(s, lc, extra); /* send the extra length bits */
10729 }
10730 dist--; /* dist is now the match distance - 1 */
10731 code = d_code(dist);
10732 //Assert (code < D_CODES, "bad d_code");
10733
10734 send_code(s, code, dtree); /* send the distance code */
10735 extra = extra_dbits[code];
10736 if (extra !== 0) {
10737 dist -= base_dist[code];
10738 send_bits(s, dist, extra); /* send the extra distance bits */
10739 }
10740 } /* literal or match pair ? */
10741
10742 /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
10743 //Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
10744 // "pendingBuf overflow");
10745
10746 } while (lx < s.last_lit);
10747 }
10748
10749 send_code(s, END_BLOCK, ltree);
10750 }
10751
10752
10753 /* ===========================================================================
10754 * Construct one Huffman tree and assigns the code bit strings and lengths.
10755 * Update the total bit length for the current block.
10756 * IN assertion: the field freq is set for all tree elements.
10757 * OUT assertions: the fields len and code are set to the optimal bit length
10758 * and corresponding code. The length opt_len is updated; static_len is
10759 * also updated if stree is not null. The field max_code is set.
10760 */
10761 function build_tree(s, desc)
10762 // deflate_state *s;
10763 // tree_desc *desc; /* the tree descriptor */
10764 {
10765 var tree = desc.dyn_tree;
10766 var stree = desc.stat_desc.static_tree;
10767 var has_stree = desc.stat_desc.has_stree;
10768 var elems = desc.stat_desc.elems;
10769 var n, m; /* iterate over heap elements */
10770 var max_code = -1; /* largest code with non zero frequency */
10771 var node; /* new node being created */
10772
10773 /* Construct the initial heap, with least frequent element in
10774 * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
10775 * heap[0] is not used.
10776 */
10777 s.heap_len = 0;
10778 s.heap_max = HEAP_SIZE;
10779
10780 for (n = 0; n < elems; n++) {
10781 if (tree[n * 2]/*.Freq*/ !== 0) {
10782 s.heap[++s.heap_len] = max_code = n;
10783 s.depth[n] = 0;
10784
10785 } else {
10786 tree[n * 2 + 1]/*.Len*/ = 0;
10787 }
10788 }
10789
10790 /* The pkzip format requires that at least one distance code exists,
10791 * and that at least one bit should be sent even if there is only one
10792 * possible code. So to avoid special checks later on we force at least
10793 * two codes of non zero frequency.
10794 */
10795 while (s.heap_len < 2) {
10796 node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);
10797 tree[node * 2]/*.Freq*/ = 1;
10798 s.depth[node] = 0;
10799 s.opt_len--;
10800
10801 if (has_stree) {
10802 s.static_len -= stree[node * 2 + 1]/*.Len*/;
10803 }
10804 /* node is 0 or 1 so it does not have extra bits */
10805 }
10806 desc.max_code = max_code;
10807
10808 /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
10809 * establish sub-heaps of increasing lengths:
10810 */
10811 for (n = (s.heap_len >> 1/*int /2*/); n >= 1; n--) { pqdownheap(s, tree, n); }
10812
10813 /* Construct the Huffman tree by repeatedly combining the least two
10814 * frequent nodes.
10815 */
10816 node = elems; /* next internal node of the tree */
10817 do {
10818 //pqremove(s, tree, n); /* n = node of least frequency */
10819 /*** pqremove ***/
10820 n = s.heap[1/*SMALLEST*/];
10821 s.heap[1/*SMALLEST*/] = s.heap[s.heap_len--];
10822 pqdownheap(s, tree, 1/*SMALLEST*/);
10823 /***/
10824
10825 m = s.heap[1/*SMALLEST*/]; /* m = node of next least frequency */
10826
10827 s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */
10828 s.heap[--s.heap_max] = m;
10829
10830 /* Create a new node father of n and m */
10831 tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/;
10832 s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
10833 tree[n * 2 + 1]/*.Dad*/ = tree[m * 2 + 1]/*.Dad*/ = node;
10834
10835 /* and insert the new node in the heap */
10836 s.heap[1/*SMALLEST*/] = node++;
10837 pqdownheap(s, tree, 1/*SMALLEST*/);
10838
10839 } while (s.heap_len >= 2);
10840
10841 s.heap[--s.heap_max] = s.heap[1/*SMALLEST*/];
10842
10843 /* At this point, the fields freq and dad are set. We can now
10844 * generate the bit lengths.
10845 */
10846 gen_bitlen(s, desc);
10847
10848 /* The field len is now set, we can generate the bit codes */
10849 gen_codes(tree, max_code, s.bl_count);
10850 }
10851
10852
10853 /* ===========================================================================
10854 * Scan a literal or distance tree to determine the frequencies of the codes
10855 * in the bit length tree.
10856 */
10857 function scan_tree(s, tree, max_code)
10858 // deflate_state *s;
10859 // ct_data *tree; /* the tree to be scanned */
10860 // int max_code; /* and its largest code of non zero frequency */
10861 {
10862 var n; /* iterates over all tree elements */
10863 var prevlen = -1; /* last emitted length */
10864 var curlen; /* length of current code */
10865
10866 var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */
10867
10868 var count = 0; /* repeat count of the current code */
10869 var max_count = 7; /* max repeat count */
10870 var min_count = 4; /* min repeat count */
10871
10872 if (nextlen === 0) {
10873 max_count = 138;
10874 min_count = 3;
10875 }
10876 tree[(max_code + 1) * 2 + 1]/*.Len*/ = 0xffff; /* guard */
10877
10878 for (n = 0; n <= max_code; n++) {
10879 curlen = nextlen;
10880 nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;
10881
10882 if (++count < max_count && curlen === nextlen) {
10883 continue;
10884
10885 } else if (count < min_count) {
10886 s.bl_tree[curlen * 2]/*.Freq*/ += count;
10887
10888 } else if (curlen !== 0) {
10889
10890 if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; }
10891 s.bl_tree[REP_3_6 * 2]/*.Freq*/++;
10892
10893 } else if (count <= 10) {
10894 s.bl_tree[REPZ_3_10 * 2]/*.Freq*/++;
10895
10896 } else {
10897 s.bl_tree[REPZ_11_138 * 2]/*.Freq*/++;
10898 }
10899
10900 count = 0;
10901 prevlen = curlen;
10902
10903 if (nextlen === 0) {
10904 max_count = 138;
10905 min_count = 3;
10906
10907 } else if (curlen === nextlen) {
10908 max_count = 6;
10909 min_count = 3;
10910
10911 } else {
10912 max_count = 7;
10913 min_count = 4;
10914 }
10915 }
10916 }
10917
10918
10919 /* ===========================================================================
10920 * Send a literal or distance tree in compressed form, using the codes in
10921 * bl_tree.
10922 */
10923 function send_tree(s, tree, max_code)
10924 // deflate_state *s;
10925 // ct_data *tree; /* the tree to be scanned */
10926 // int max_code; /* and its largest code of non zero frequency */
10927 {
10928 var n; /* iterates over all tree elements */
10929 var prevlen = -1; /* last emitted length */
10930 var curlen; /* length of current code */
10931
10932 var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */
10933
10934 var count = 0; /* repeat count of the current code */
10935 var max_count = 7; /* max repeat count */
10936 var min_count = 4; /* min repeat count */
10937
10938 /* tree[max_code+1].Len = -1; */ /* guard already set */
10939 if (nextlen === 0) {
10940 max_count = 138;
10941 min_count = 3;
10942 }
10943
10944 for (n = 0; n <= max_code; n++) {
10945 curlen = nextlen;
10946 nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;
10947
10948 if (++count < max_count && curlen === nextlen) {
10949 continue;
10950
10951 } else if (count < min_count) {
10952 do { send_code(s, curlen, s.bl_tree); } while (--count !== 0);
10953
10954 } else if (curlen !== 0) {
10955 if (curlen !== prevlen) {
10956 send_code(s, curlen, s.bl_tree);
10957 count--;
10958 }
10959 //Assert(count >= 3 && count <= 6, " 3_6?");
10960 send_code(s, REP_3_6, s.bl_tree);
10961 send_bits(s, count - 3, 2);
10962
10963 } else if (count <= 10) {
10964 send_code(s, REPZ_3_10, s.bl_tree);
10965 send_bits(s, count - 3, 3);
10966
10967 } else {
10968 send_code(s, REPZ_11_138, s.bl_tree);
10969 send_bits(s, count - 11, 7);
10970 }
10971
10972 count = 0;
10973 prevlen = curlen;
10974 if (nextlen === 0) {
10975 max_count = 138;
10976 min_count = 3;
10977
10978 } else if (curlen === nextlen) {
10979 max_count = 6;
10980 min_count = 3;
10981
10982 } else {
10983 max_count = 7;
10984 min_count = 4;
10985 }
10986 }
10987 }
10988
10989
10990 /* ===========================================================================
10991 * Construct the Huffman tree for the bit lengths and return the index in
10992 * bl_order of the last bit length code to send.
10993 */
10994 function build_bl_tree(s) {
10995 var max_blindex; /* index of last bit length code of non zero freq */
10996
10997 /* Determine the bit length frequencies for literal and distance trees */
10998 scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
10999 scan_tree(s, s.dyn_dtree, s.d_desc.max_code);
11000
11001 /* Build the bit length tree: */
11002 build_tree(s, s.bl_desc);
11003 /* opt_len now includes the length of the tree representations, except
11004 * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
11005 */
11006
11007 /* Determine the number of bit length codes to send. The pkzip format
11008 * requires that at least 4 bit length codes be sent. (appnote.txt says
11009 * 3 but the actual value used is 4.)
11010 */
11011 for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
11012 if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/*.Len*/ !== 0) {
11013 break;
11014 }
11015 }
11016 /* Update opt_len to include the bit length tree and counts */
11017 s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
11018 //Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
11019 // s->opt_len, s->static_len));
11020
11021 return max_blindex;
11022 }
11023
11024
11025 /* ===========================================================================
11026 * Send the header for a block using dynamic Huffman trees: the counts, the
11027 * lengths of the bit length codes, the literal tree and the distance tree.
11028 * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
11029 */
11030 function send_all_trees(s, lcodes, dcodes, blcodes)
11031 // deflate_state *s;
11032 // int lcodes, dcodes, blcodes; /* number of codes for each tree */
11033 {
11034 var rank; /* index in bl_order */
11035
11036 //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
11037 //Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
11038 // "too many codes");
11039 //Tracev((stderr, "\nbl counts: "));
11040 send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */
11041 send_bits(s, dcodes - 1, 5);
11042 send_bits(s, blcodes - 4, 4); /* not -3 as stated in appnote.txt */
11043 for (rank = 0; rank < blcodes; rank++) {
11044 //Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
11045 send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1]/*.Len*/, 3);
11046 }
11047 //Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
11048
11049 send_tree(s, s.dyn_ltree, lcodes - 1); /* literal tree */
11050 //Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
11051
11052 send_tree(s, s.dyn_dtree, dcodes - 1); /* distance tree */
11053 //Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
11054 }
11055
11056
11057 /* ===========================================================================
11058 * Check if the data type is TEXT or BINARY, using the following algorithm:
11059 * - TEXT if the two conditions below are satisfied:
11060 * a) There are no non-portable control characters belonging to the
11061 * "black list" (0..6, 14..25, 28..31).
11062 * b) There is at least one printable character belonging to the
11063 * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
11064 * - BINARY otherwise.
11065 * - The following partially-portable control characters form a
11066 * "gray list" that is ignored in this detection algorithm:
11067 * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
11068 * IN assertion: the fields Freq of dyn_ltree are set.
11069 */
11070 function detect_data_type(s) {
11071 /* black_mask is the bit mask of black-listed bytes
11072 * set bits 0..6, 14..25, and 28..31
11073 * 0xf3ffc07f = binary 11110011111111111100000001111111
11074 */
11075 var black_mask = 0xf3ffc07f;
11076 var n;
11077
11078 /* Check for non-textual ("black-listed") bytes. */
11079 for (n = 0; n <= 31; n++, black_mask >>>= 1) {
11080 if ((black_mask & 1) && (s.dyn_ltree[n * 2]/*.Freq*/ !== 0)) {
11081 return Z_BINARY;
11082 }
11083 }
11084
11085 /* Check for textual ("white-listed") bytes. */
11086 if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 ||
11087 s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) {
11088 return Z_TEXT;
11089 }
11090 for (n = 32; n < LITERALS; n++) {
11091 if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) {
11092 return Z_TEXT;
11093 }
11094 }
11095
11096 /* There are no "black-listed" or "white-listed" bytes:
11097 * this stream either is empty or has tolerated ("gray-listed") bytes only.
11098 */
11099 return Z_BINARY;
11100 }
11101
11102
11103 var static_init_done = false;
11104
11105 /* ===========================================================================
11106 * Initialize the tree data structures for a new zlib stream.
11107 */
11108 function _tr_init(s)
11109 {
11110
11111 if (!static_init_done) {
11112 tr_static_init();
11113 static_init_done = true;
11114 }
11115
11116 s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);
11117 s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);
11118 s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
11119
11120 s.bi_buf = 0;
11121 s.bi_valid = 0;
11122
11123 /* Initialize the first block of the first file: */
11124 init_block(s);
11125 }
11126
11127
11128 /* ===========================================================================
11129 * Send a stored block
11130 */
11131 function _tr_stored_block(s, buf, stored_len, last)
11132 //DeflateState *s;
11133 //charf *buf; /* input block */
11134 //ulg stored_len; /* length of input block */
11135 //int last; /* one if this is the last block for a file */
11136 {
11137 send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3); /* send block type */
11138 copy_block(s, buf, stored_len, true); /* with header */
11139 }
11140
11141
11142 /* ===========================================================================
11143 * Send one empty static block to give enough lookahead for inflate.
11144 * This takes 10 bits, of which 7 may remain in the bit buffer.
11145 */
11146 function _tr_align(s) {
11147 send_bits(s, STATIC_TREES << 1, 3);
11148 send_code(s, END_BLOCK, static_ltree);
11149 bi_flush(s);
11150 }
11151
11152
11153 /* ===========================================================================
11154 * Determine the best encoding for the current block: dynamic trees, static
11155 * trees or store, and output the encoded block to the zip file.
11156 */
11157 function _tr_flush_block(s, buf, stored_len, last)
11158 //DeflateState *s;
11159 //charf *buf; /* input block, or NULL if too old */
11160 //ulg stored_len; /* length of input block */
11161 //int last; /* one if this is the last block for a file */
11162 {
11163 var opt_lenb, static_lenb; /* opt_len and static_len in bytes */
11164 var max_blindex = 0; /* index of last bit length code of non zero freq */
11165
11166 /* Build the Huffman trees unless a stored block is forced */
11167 if (s.level > 0) {
11168
11169 /* Check if the file is binary or text */
11170 if (s.strm.data_type === Z_UNKNOWN) {
11171 s.strm.data_type = detect_data_type(s);
11172 }
11173
11174 /* Construct the literal and distance trees */
11175 build_tree(s, s.l_desc);
11176 // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
11177 // s->static_len));
11178
11179 build_tree(s, s.d_desc);
11180 // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
11181 // s->static_len));
11182 /* At this point, opt_len and static_len are the total bit lengths of
11183 * the compressed block data, excluding the tree representations.
11184 */
11185
11186 /* Build the bit length tree for the above two trees, and get the index
11187 * in bl_order of the last bit length code to send.
11188 */
11189 max_blindex = build_bl_tree(s);
11190
11191 /* Determine the best encoding. Compute the block lengths in bytes. */
11192 opt_lenb = (s.opt_len + 3 + 7) >>> 3;
11193 static_lenb = (s.static_len + 3 + 7) >>> 3;
11194
11195 // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
11196 // opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
11197 // s->last_lit));
11198
11199 if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; }
11200
11201 } else {
11202 // Assert(buf != (char*)0, "lost buf");
11203 opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
11204 }
11205
11206 if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) {
11207 /* 4: two words for the lengths */
11208
11209 /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
11210 * Otherwise we can't have processed more than WSIZE input bytes since
11211 * the last block flush, because compression would have been
11212 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
11213 * transform a block into a stored block.
11214 */
11215 _tr_stored_block(s, buf, stored_len, last);
11216
11217 } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
11218
11219 send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
11220 compress_block(s, static_ltree, static_dtree);
11221
11222 } else {
11223 send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);
11224 send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);
11225 compress_block(s, s.dyn_ltree, s.dyn_dtree);
11226 }
11227 // Assert (s->compressed_len == s->bits_sent, "bad compressed size");
11228 /* The above check is made mod 2^32, for files larger than 512 MB
11229 * and uLong implemented on 32 bits.
11230 */
11231 init_block(s);
11232
11233 if (last) {
11234 bi_windup(s);
11235 }
11236 // Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
11237 // s->compressed_len-7*last));
11238 }
11239
11240 /* ===========================================================================
11241 * Save the match info and tally the frequency counts. Return true if
11242 * the current block must be flushed.
11243 */
11244 function _tr_tally(s, dist, lc)
11245 // deflate_state *s;
11246 // unsigned dist; /* distance of matched string */
11247 // unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */
11248 {
11249 //var out_length, in_length, dcode;
11250
11251 s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff;
11252 s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;
11253
11254 s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;
11255 s.last_lit++;
11256
11257 if (dist === 0) {
11258 /* lc is the unmatched char */
11259 s.dyn_ltree[lc * 2]/*.Freq*/++;
11260 } else {
11261 s.matches++;
11262 /* Here, lc is the match length - MIN_MATCH */
11263 dist--; /* dist = match distance - 1 */
11264 //Assert((ush)dist < (ush)MAX_DIST(s) &&
11265 // (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
11266 // (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match");
11267
11268 s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]/*.Freq*/++;
11269 s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++;
11270 }
11271
11272 // (!) This block is disabled in zlib defailts,
11273 // don't enable it for binary compatibility
11274
11275 //#ifdef TRUNCATE_BLOCK
11276 // /* Try to guess if it is profitable to stop the current block here */
11277 // if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {
11278 // /* Compute an upper bound for the compressed length */
11279 // out_length = s.last_lit*8;
11280 // in_length = s.strstart - s.block_start;
11281 //
11282 // for (dcode = 0; dcode < D_CODES; dcode++) {
11283 // out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);
11284 // }
11285 // out_length >>>= 3;
11286 // //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
11287 // // s->last_lit, in_length, out_length,
11288 // // 100L - out_length*100L/in_length));
11289 // if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {
11290 // return true;
11291 // }
11292 // }
11293 //#endif
11294
11295 return (s.last_lit === s.lit_bufsize - 1);
11296 /* We avoid equality with lit_bufsize because of wraparound at 64K
11297 * on 16 bit machines and because stored blocks are restricted to
11298 * 64K-1 bytes.
11299 */
11300 }
11301
11302 exports._tr_init = _tr_init;
11303 exports._tr_stored_block = _tr_stored_block;
11304 exports._tr_flush_block = _tr_flush_block;
11305 exports._tr_tally = _tr_tally;
11306 exports._tr_align = _tr_align;
11307
11308 },{"../utils/common":41}],53:[function(require,module,exports){
11309 'use strict';
11310
11311 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
11312 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
11313 //
11314 // This software is provided 'as-is', without any express or implied
11315 // warranty. In no event will the authors be held liable for any damages
11316 // arising from the use of this software.
11317 //
11318 // Permission is granted to anyone to use this software for any purpose,
11319 // including commercial applications, and to alter it and redistribute it
11320 // freely, subject to the following restrictions:
11321 //
11322 // 1. The origin of this software must not be misrepresented; you must not
11323 // claim that you wrote the original software. If you use this software
11324 // in a product, an acknowledgment in the product documentation would be
11325 // appreciated but is not required.
11326 // 2. Altered source versions must be plainly marked as such, and must not be
11327 // misrepresented as being the original software.
11328 // 3. This notice may not be removed or altered from any source distribution.
11329
11330 function ZStream() {
11331 /* next input byte */
11332 this.input = null; // JS specific, because we have no pointers
11333 this.next_in = 0;
11334 /* number of bytes available at input */
11335 this.avail_in = 0;
11336 /* total number of input bytes read so far */
11337 this.total_in = 0;
11338 /* next output byte should be put there */
11339 this.output = null; // JS specific, because we have no pointers
11340 this.next_out = 0;
11341 /* remaining free space at output */
11342 this.avail_out = 0;
11343 /* total number of bytes output so far */
11344 this.total_out = 0;
11345 /* last error message, NULL if no error */
11346 this.msg = ''/*Z_NULL*/;
11347 /* not visible by applications */
11348 this.state = null;
11349 /* best guess about the data type: binary or text */
11350 this.data_type = 2/*Z_UNKNOWN*/;
11351 /* adler32 value of the uncompressed data */
11352 this.adler = 0;
11353 }
11354
11355 module.exports = ZStream;
11356
11357 },{}],54:[function(require,module,exports){
11358 'use strict';
11359 module.exports = typeof setImmediate === 'function' ? setImmediate :
11360 function setImmediate() {
11361 var args = [].slice.apply(arguments);
11362 args.splice(1, 0, 0);
11363 setTimeout.apply(null, args);
11364 };
11365
11366 },{}]},{},[10])(10)
11367 });