Debian Codegraph @

java/doc/jquery/jszip/dist/jszip.js

raw
1 /*!
2
3 JSZip v3.7.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 Crc32Probe = require('./stream/Crc32Probe');
127 var DataLengthProbe = require('./stream/DataLengthProbe');
128
129 /**
130 * Represent a compressed object, with everything needed to decompress it.
131 * @constructor
132 * @param {number} compressedSize the size of the data compressed.
133 * @param {number} uncompressedSize the size of the data after decompression.
134 * @param {number} crc32 the crc32 of the decompressed file.
135 * @param {object} compression the type of compression, see lib/compressions.js.
136 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the compressed data.
137 */
138 function CompressedObject(compressedSize, uncompressedSize, crc32, compression, data) {
139 this.compressedSize = compressedSize;
140 this.uncompressedSize = uncompressedSize;
141 this.crc32 = crc32;
142 this.compression = compression;
143 this.compressedContent = data;
144 }
145
146 CompressedObject.prototype = {
147 /**
148 * Create a worker to get the uncompressed content.
149 * @return {GenericWorker} the worker.
150 */
151 getContentWorker: function () {
152 var worker = new DataWorker(external.Promise.resolve(this.compressedContent))
153 .pipe(this.compression.uncompressWorker())
154 .pipe(new DataLengthProbe("data_length"));
155
156 var that = this;
157 worker.on("end", function () {
158 if (this.streamInfo['data_length'] !== that.uncompressedSize) {
159 throw new Error("Bug : uncompressed data size mismatch");
160 }
161 });
162 return worker;
163 },
164 /**
165 * Create a worker to get the compressed content.
166 * @return {GenericWorker} the worker.
167 */
168 getCompressedWorker: function () {
169 return new DataWorker(external.Promise.resolve(this.compressedContent))
170 .withStreamInfo("compressedSize", this.compressedSize)
171 .withStreamInfo("uncompressedSize", this.uncompressedSize)
172 .withStreamInfo("crc32", this.crc32)
173 .withStreamInfo("compression", this.compression)
174 ;
175 }
176 };
177
178 /**
179 * Chain the given worker with other workers to compress the content with the
180 * given compression.
181 * @param {GenericWorker} uncompressedWorker the worker to pipe.
182 * @param {Object} compression the compression object.
183 * @param {Object} compressionOptions the options to use when compressing.
184 * @return {GenericWorker} the new worker compressing the content.
185 */
186 CompressedObject.createWorkerFrom = function (uncompressedWorker, compression, compressionOptions) {
187 return uncompressedWorker
188 .pipe(new Crc32Probe())
189 .pipe(new DataLengthProbe("uncompressedSize"))
190 .pipe(compression.compressWorker(compressionOptions))
191 .pipe(new DataLengthProbe("compressedSize"))
192 .withStreamInfo("compression", compression);
193 };
194
195 module.exports = CompressedObject;
196
197 },{"./external":6,"./stream/Crc32Probe":25,"./stream/DataLengthProbe":26,"./stream/DataWorker":27}],3:[function(require,module,exports){
198 'use strict';
199
200 var GenericWorker = require("./stream/GenericWorker");
201
202 exports.STORE = {
203 magic: "\x00\x00",
204 compressWorker : function (compressionOptions) {
205 return new GenericWorker("STORE compression");
206 },
207 uncompressWorker : function () {
208 return new GenericWorker("STORE decompression");
209 }
210 };
211 exports.DEFLATE = require('./flate');
212
213 },{"./flate":7,"./stream/GenericWorker":28}],4:[function(require,module,exports){
214 'use strict';
215
216 var utils = require('./utils');
217
218 /**
219 * The following functions come from pako, from pako/lib/zlib/crc32.js
220 * released under the MIT license, see pako https://github.com/nodeca/pako/
221 */
222
223 // Use ordinary array, since untyped makes no boost here
224 function makeTable() {
225 var c, table = [];
226
227 for(var n =0; n < 256; n++){
228 c = n;
229 for(var k =0; k < 8; k++){
230 c = ((c&1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
231 }
232 table[n] = c;
233 }
234
235 return table;
236 }
237
238 // Create table on load. Just 255 signed longs. Not a problem.
239 var crcTable = makeTable();
240
241
242 function crc32(crc, buf, len, pos) {
243 var t = crcTable, end = pos + len;
244
245 crc = crc ^ (-1);
246
247 for (var i = pos; i < end; i++ ) {
248 crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
249 }
250
251 return (crc ^ (-1)); // >>> 0;
252 }
253
254 // That's all for the pako functions.
255
256 /**
257 * Compute the crc32 of a string.
258 * This is almost the same as the function crc32, but for strings. Using the
259 * same function for the two use cases leads to horrible performances.
260 * @param {Number} crc the starting value of the crc.
261 * @param {String} str the string to use.
262 * @param {Number} len the length of the string.
263 * @param {Number} pos the starting position for the crc32 computation.
264 * @return {Number} the computed crc32.
265 */
266 function crc32str(crc, str, len, pos) {
267 var t = crcTable, end = pos + len;
268
269 crc = crc ^ (-1);
270
271 for (var i = pos; i < end; i++ ) {
272 crc = (crc >>> 8) ^ t[(crc ^ str.charCodeAt(i)) & 0xFF];
273 }
274
275 return (crc ^ (-1)); // >>> 0;
276 }
277
278 module.exports = function crc32wrapper(input, crc) {
279 if (typeof input === "undefined" || !input.length) {
280 return 0;
281 }
282
283 var isArray = utils.getTypeOf(input) !== "string";
284
285 if(isArray) {
286 return crc32(crc|0, input, input.length, 0);
287 } else {
288 return crc32str(crc|0, input, input.length, 0);
289 }
290 };
291
292 },{"./utils":32}],5:[function(require,module,exports){
293 'use strict';
294 exports.base64 = false;
295 exports.binary = false;
296 exports.dir = false;
297 exports.createFolders = true;
298 exports.date = null;
299 exports.compression = null;
300 exports.compressionOptions = null;
301 exports.comment = null;
302 exports.unixPermissions = null;
303 exports.dosPermissions = null;
304
305 },{}],6:[function(require,module,exports){
306 /* global Promise */
307 'use strict';
308
309 // load the global object first:
310 // - it should be better integrated in the system (unhandledRejection in node)
311 // - the environment may have a custom Promise implementation (see zone.js)
312 var ES6Promise = null;
313 if (typeof Promise !== "undefined") {
314 ES6Promise = Promise;
315 } else {
316 ES6Promise = require("lie");
317 }
318
319 /**
320 * Let the user use/change some implementations.
321 */
322 module.exports = {
323 Promise: ES6Promise
324 };
325
326 },{"lie":37}],7:[function(require,module,exports){
327 'use strict';
328 var USE_TYPEDARRAY = (typeof Uint8Array !== 'undefined') && (typeof Uint16Array !== 'undefined') && (typeof Uint32Array !== 'undefined');
329
330 var pako = require("pako");
331 var utils = require("./utils");
332 var GenericWorker = require("./stream/GenericWorker");
333
334 var ARRAY_TYPE = USE_TYPEDARRAY ? "uint8array" : "array";
335
336 exports.magic = "\x08\x00";
337
338 /**
339 * Create a worker that uses pako to inflate/deflate.
340 * @constructor
341 * @param {String} action the name of the pako function to call : either "Deflate" or "Inflate".
342 * @param {Object} options the options to use when (de)compressing.
343 */
344 function FlateWorker(action, options) {
345 GenericWorker.call(this, "FlateWorker/" + action);
346
347 this._pako = null;
348 this._pakoAction = action;
349 this._pakoOptions = options;
350 // the `meta` object from the last chunk received
351 // this allow this worker to pass around metadata
352 this.meta = {};
353 }
354
355 utils.inherits(FlateWorker, GenericWorker);
356
357 /**
358 * @see GenericWorker.processChunk
359 */
360 FlateWorker.prototype.processChunk = function (chunk) {
361 this.meta = chunk.meta;
362 if (this._pako === null) {
363 this._createPako();
364 }
365 this._pako.push(utils.transformTo(ARRAY_TYPE, chunk.data), false);
366 };
367
368 /**
369 * @see GenericWorker.flush
370 */
371 FlateWorker.prototype.flush = function () {
372 GenericWorker.prototype.flush.call(this);
373 if (this._pako === null) {
374 this._createPako();
375 }
376 this._pako.push([], true);
377 };
378 /**
379 * @see GenericWorker.cleanUp
380 */
381 FlateWorker.prototype.cleanUp = function () {
382 GenericWorker.prototype.cleanUp.call(this);
383 this._pako = null;
384 };
385
386 /**
387 * Create the _pako object.
388 * TODO: lazy-loading this object isn't the best solution but it's the
389 * quickest. The best solution is to lazy-load the worker list. See also the
390 * issue #446.
391 */
392 FlateWorker.prototype._createPako = function () {
393 this._pako = new pako[this._pakoAction]({
394 raw: true,
395 level: this._pakoOptions.level || -1 // default compression
396 });
397 var self = this;
398 this._pako.onData = function(data) {
399 self.push({
400 data : data,
401 meta : self.meta
402 });
403 };
404 };
405
406 exports.compressWorker = function (compressionOptions) {
407 return new FlateWorker("Deflate", compressionOptions);
408 };
409 exports.uncompressWorker = function () {
410 return new FlateWorker("Inflate", {});
411 };
412
413 },{"./stream/GenericWorker":28,"./utils":32,"pako":38}],8:[function(require,module,exports){
414 'use strict';
415
416 var utils = require('../utils');
417 var GenericWorker = require('../stream/GenericWorker');
418 var utf8 = require('../utf8');
419 var crc32 = require('../crc32');
420 var signature = require('../signature');
421
422 /**
423 * Transform an integer into a string in hexadecimal.
424 * @private
425 * @param {number} dec the number to convert.
426 * @param {number} bytes the number of bytes to generate.
427 * @returns {string} the result.
428 */
429 var decToHex = function(dec, bytes) {
430 var hex = "", i;
431 for (i = 0; i < bytes; i++) {
432 hex += String.fromCharCode(dec & 0xff);
433 dec = dec >>> 8;
434 }
435 return hex;
436 };
437
438 /**
439 * Generate the UNIX part of the external file attributes.
440 * @param {Object} unixPermissions the unix permissions or null.
441 * @param {Boolean} isDir true if the entry is a directory, false otherwise.
442 * @return {Number} a 32 bit integer.
443 *
444 * adapted from http://unix.stackexchange.com/questions/14705/the-zip-formats-external-file-attribute :
445 *
446 * TTTTsstrwxrwxrwx0000000000ADVSHR
447 * ^^^^____________________________ file type, see zipinfo.c (UNX_*)
448 * ^^^_________________________ setuid, setgid, sticky
449 * ^^^^^^^^^________________ permissions
450 * ^^^^^^^^^^______ not used ?
451 * ^^^^^^ DOS attribute bits : Archive, Directory, Volume label, System file, Hidden, Read only
452 */
453 var generateUnixExternalFileAttr = function (unixPermissions, isDir) {
454
455 var result = unixPermissions;
456 if (!unixPermissions) {
457 // I can't use octal values in strict mode, hence the hexa.
458 // 040775 => 0x41fd
459 // 0100664 => 0x81b4
460 result = isDir ? 0x41fd : 0x81b4;
461 }
462 return (result & 0xFFFF) << 16;
463 };
464
465 /**
466 * Generate the DOS part of the external file attributes.
467 * @param {Object} dosPermissions the dos permissions or null.
468 * @param {Boolean} isDir true if the entry is a directory, false otherwise.
469 * @return {Number} a 32 bit integer.
470 *
471 * Bit 0 Read-Only
472 * Bit 1 Hidden
473 * Bit 2 System
474 * Bit 3 Volume Label
475 * Bit 4 Directory
476 * Bit 5 Archive
477 */
478 var generateDosExternalFileAttr = function (dosPermissions, isDir) {
479
480 // the dir flag is already set for compatibility
481 return (dosPermissions || 0) & 0x3F;
482 };
483
484 /**
485 * Generate the various parts used in the construction of the final zip file.
486 * @param {Object} streamInfo the hash with information about the compressed file.
487 * @param {Boolean} streamedContent is the content streamed ?
488 * @param {Boolean} streamingEnded is the stream finished ?
489 * @param {number} offset the current offset from the start of the zip file.
490 * @param {String} platform let's pretend we are this platform (change platform dependents fields)
491 * @param {Function} encodeFileName the function to encode the file name / comment.
492 * @return {Object} the zip parts.
493 */
494 var generateZipParts = function(streamInfo, streamedContent, streamingEnded, offset, platform, encodeFileName) {
495 var file = streamInfo['file'],
496 compression = streamInfo['compression'],
497 useCustomEncoding = encodeFileName !== utf8.utf8encode,
498 encodedFileName = utils.transformTo("string", encodeFileName(file.name)),
499 utfEncodedFileName = utils.transformTo("string", utf8.utf8encode(file.name)),
500 comment = file.comment,
501 encodedComment = utils.transformTo("string", encodeFileName(comment)),
502 utfEncodedComment = utils.transformTo("string", utf8.utf8encode(comment)),
503 useUTF8ForFileName = utfEncodedFileName.length !== file.name.length,
504 useUTF8ForComment = utfEncodedComment.length !== comment.length,
505 dosTime,
506 dosDate,
507 extraFields = "",
508 unicodePathExtraField = "",
509 unicodeCommentExtraField = "",
510 dir = file.dir,
511 date = file.date;
512
513
514 var dataInfo = {
515 crc32 : 0,
516 compressedSize : 0,
517 uncompressedSize : 0
518 };
519
520 // if the content is streamed, the sizes/crc32 are only available AFTER
521 // the end of the stream.
522 if (!streamedContent || streamingEnded) {
523 dataInfo.crc32 = streamInfo['crc32'];
524 dataInfo.compressedSize = streamInfo['compressedSize'];
525 dataInfo.uncompressedSize = streamInfo['uncompressedSize'];
526 }
527
528 var bitflag = 0;
529 if (streamedContent) {
530 // Bit 3: the sizes/crc32 are set to zero in the local header.
531 // The correct values are put in the data descriptor immediately
532 // following the compressed data.
533 bitflag |= 0x0008;
534 }
535 if (!useCustomEncoding && (useUTF8ForFileName || useUTF8ForComment)) {
536 // Bit 11: Language encoding flag (EFS).
537 bitflag |= 0x0800;
538 }
539
540
541 var extFileAttr = 0;
542 var versionMadeBy = 0;
543 if (dir) {
544 // dos or unix, we set the dos dir flag
545 extFileAttr |= 0x00010;
546 }
547 if(platform === "UNIX") {
548 versionMadeBy = 0x031E; // UNIX, version 3.0
549 extFileAttr |= generateUnixExternalFileAttr(file.unixPermissions, dir);
550 } else { // DOS or other, fallback to DOS
551 versionMadeBy = 0x0014; // DOS, version 2.0
552 extFileAttr |= generateDosExternalFileAttr(file.dosPermissions, dir);
553 }
554
555 // date
556 // @see http://www.delorie.com/djgpp/doc/rbinter/it/52/13.html
557 // @see http://www.delorie.com/djgpp/doc/rbinter/it/65/16.html
558 // @see http://www.delorie.com/djgpp/doc/rbinter/it/66/16.html
559
560 dosTime = date.getUTCHours();
561 dosTime = dosTime << 6;
562 dosTime = dosTime | date.getUTCMinutes();
563 dosTime = dosTime << 5;
564 dosTime = dosTime | date.getUTCSeconds() / 2;
565
566 dosDate = date.getUTCFullYear() - 1980;
567 dosDate = dosDate << 4;
568 dosDate = dosDate | (date.getUTCMonth() + 1);
569 dosDate = dosDate << 5;
570 dosDate = dosDate | date.getUTCDate();
571
572 if (useUTF8ForFileName) {
573 // set the unicode path extra field. unzip needs at least one extra
574 // field to correctly handle unicode path, so using the path is as good
575 // as any other information. This could improve the situation with
576 // other archive managers too.
577 // This field is usually used without the utf8 flag, with a non
578 // unicode path in the header (winrar, winzip). This helps (a bit)
579 // with the messy Windows' default compressed folders feature but
580 // breaks on p7zip which doesn't seek the unicode path extra field.
581 // So for now, UTF-8 everywhere !
582 unicodePathExtraField =
583 // Version
584 decToHex(1, 1) +
585 // NameCRC32
586 decToHex(crc32(encodedFileName), 4) +
587 // UnicodeName
588 utfEncodedFileName;
589
590 extraFields +=
591 // Info-ZIP Unicode Path Extra Field
592 "\x75\x70" +
593 // size
594 decToHex(unicodePathExtraField.length, 2) +
595 // content
596 unicodePathExtraField;
597 }
598
599 if(useUTF8ForComment) {
600
601 unicodeCommentExtraField =
602 // Version
603 decToHex(1, 1) +
604 // CommentCRC32
605 decToHex(crc32(encodedComment), 4) +
606 // UnicodeName
607 utfEncodedComment;
608
609 extraFields +=
610 // Info-ZIP Unicode Path Extra Field
611 "\x75\x63" +
612 // size
613 decToHex(unicodeCommentExtraField.length, 2) +
614 // content
615 unicodeCommentExtraField;
616 }
617
618 var header = "";
619
620 // version needed to extract
621 header += "\x0A\x00";
622 // general purpose bit flag
623 header += decToHex(bitflag, 2);
624 // compression method
625 header += compression.magic;
626 // last mod file time
627 header += decToHex(dosTime, 2);
628 // last mod file date
629 header += decToHex(dosDate, 2);
630 // crc-32
631 header += decToHex(dataInfo.crc32, 4);
632 // compressed size
633 header += decToHex(dataInfo.compressedSize, 4);
634 // uncompressed size
635 header += decToHex(dataInfo.uncompressedSize, 4);
636 // file name length
637 header += decToHex(encodedFileName.length, 2);
638 // extra field length
639 header += decToHex(extraFields.length, 2);
640
641
642 var fileRecord = signature.LOCAL_FILE_HEADER + header + encodedFileName + extraFields;
643
644 var dirRecord = signature.CENTRAL_FILE_HEADER +
645 // version made by (00: DOS)
646 decToHex(versionMadeBy, 2) +
647 // file header (common to file and central directory)
648 header +
649 // file comment length
650 decToHex(encodedComment.length, 2) +
651 // disk number start
652 "\x00\x00" +
653 // internal file attributes TODO
654 "\x00\x00" +
655 // external file attributes
656 decToHex(extFileAttr, 4) +
657 // relative offset of local header
658 decToHex(offset, 4) +
659 // file name
660 encodedFileName +
661 // extra field
662 extraFields +
663 // file comment
664 encodedComment;
665
666 return {
667 fileRecord: fileRecord,
668 dirRecord: dirRecord
669 };
670 };
671
672 /**
673 * Generate the EOCD record.
674 * @param {Number} entriesCount the number of entries in the zip file.
675 * @param {Number} centralDirLength the length (in bytes) of the central dir.
676 * @param {Number} localDirLength the length (in bytes) of the local dir.
677 * @param {String} comment the zip file comment as a binary string.
678 * @param {Function} encodeFileName the function to encode the comment.
679 * @return {String} the EOCD record.
680 */
681 var generateCentralDirectoryEnd = function (entriesCount, centralDirLength, localDirLength, comment, encodeFileName) {
682 var dirEnd = "";
683 var encodedComment = utils.transformTo("string", encodeFileName(comment));
684
685 // end of central dir signature
686 dirEnd = signature.CENTRAL_DIRECTORY_END +
687 // number of this disk
688 "\x00\x00" +
689 // number of the disk with the start of the central directory
690 "\x00\x00" +
691 // total number of entries in the central directory on this disk
692 decToHex(entriesCount, 2) +
693 // total number of entries in the central directory
694 decToHex(entriesCount, 2) +
695 // size of the central directory 4 bytes
696 decToHex(centralDirLength, 4) +
697 // offset of start of central directory with respect to the starting disk number
698 decToHex(localDirLength, 4) +
699 // .ZIP file comment length
700 decToHex(encodedComment.length, 2) +
701 // .ZIP file comment
702 encodedComment;
703
704 return dirEnd;
705 };
706
707 /**
708 * Generate data descriptors for a file entry.
709 * @param {Object} streamInfo the hash generated by a worker, containing information
710 * on the file entry.
711 * @return {String} the data descriptors.
712 */
713 var generateDataDescriptors = function (streamInfo) {
714 var descriptor = "";
715 descriptor = signature.DATA_DESCRIPTOR +
716 // crc-32 4 bytes
717 decToHex(streamInfo['crc32'], 4) +
718 // compressed size 4 bytes
719 decToHex(streamInfo['compressedSize'], 4) +
720 // uncompressed size 4 bytes
721 decToHex(streamInfo['uncompressedSize'], 4);
722
723 return descriptor;
724 };
725
726
727 /**
728 * A worker to concatenate other workers to create a zip file.
729 * @param {Boolean} streamFiles `true` to stream the content of the files,
730 * `false` to accumulate it.
731 * @param {String} comment the comment to use.
732 * @param {String} platform the platform to use, "UNIX" or "DOS".
733 * @param {Function} encodeFileName the function to encode file names and comments.
734 */
735 function ZipFileWorker(streamFiles, comment, platform, encodeFileName) {
736 GenericWorker.call(this, "ZipFileWorker");
737 // The number of bytes written so far. This doesn't count accumulated chunks.
738 this.bytesWritten = 0;
739 // The comment of the zip file
740 this.zipComment = comment;
741 // The platform "generating" the zip file.
742 this.zipPlatform = platform;
743 // the function to encode file names and comments.
744 this.encodeFileName = encodeFileName;
745 // Should we stream the content of the files ?
746 this.streamFiles = streamFiles;
747 // If `streamFiles` is false, we will need to accumulate the content of the
748 // files to calculate sizes / crc32 (and write them *before* the content).
749 // This boolean indicates if we are accumulating chunks (it will change a lot
750 // during the lifetime of this worker).
751 this.accumulate = false;
752 // The buffer receiving chunks when accumulating content.
753 this.contentBuffer = [];
754 // The list of generated directory records.
755 this.dirRecords = [];
756 // The offset (in bytes) from the beginning of the zip file for the current source.
757 this.currentSourceOffset = 0;
758 // The total number of entries in this zip file.
759 this.entriesCount = 0;
760 // the name of the file currently being added, null when handling the end of the zip file.
761 // Used for the emitted metadata.
762 this.currentFile = null;
763
764
765
766 this._sources = [];
767 }
768 utils.inherits(ZipFileWorker, GenericWorker);
769
770 /**
771 * @see GenericWorker.push
772 */
773 ZipFileWorker.prototype.push = function (chunk) {
774
775 var currentFilePercent = chunk.meta.percent || 0;
776 var entriesCount = this.entriesCount;
777 var remainingFiles = this._sources.length;
778
779 if(this.accumulate) {
780 this.contentBuffer.push(chunk);
781 } else {
782 this.bytesWritten += chunk.data.length;
783
784 GenericWorker.prototype.push.call(this, {
785 data : chunk.data,
786 meta : {
787 currentFile : this.currentFile,
788 percent : entriesCount ? (currentFilePercent + 100 * (entriesCount - remainingFiles - 1)) / entriesCount : 100
789 }
790 });
791 }
792 };
793
794 /**
795 * The worker started a new source (an other worker).
796 * @param {Object} streamInfo the streamInfo object from the new source.
797 */
798 ZipFileWorker.prototype.openedSource = function (streamInfo) {
799 this.currentSourceOffset = this.bytesWritten;
800 this.currentFile = streamInfo['file'].name;
801
802 var streamedContent = this.streamFiles && !streamInfo['file'].dir;
803
804 // don't stream folders (because they don't have any content)
805 if(streamedContent) {
806 var record = generateZipParts(streamInfo, streamedContent, false, this.currentSourceOffset, this.zipPlatform, this.encodeFileName);
807 this.push({
808 data : record.fileRecord,
809 meta : {percent:0}
810 });
811 } else {
812 // we need to wait for the whole file before pushing anything
813 this.accumulate = true;
814 }
815 };
816
817 /**
818 * The worker finished a source (an other worker).
819 * @param {Object} streamInfo the streamInfo object from the finished source.
820 */
821 ZipFileWorker.prototype.closedSource = function (streamInfo) {
822 this.accumulate = false;
823 var streamedContent = this.streamFiles && !streamInfo['file'].dir;
824 var record = generateZipParts(streamInfo, streamedContent, true, this.currentSourceOffset, this.zipPlatform, this.encodeFileName);
825
826 this.dirRecords.push(record.dirRecord);
827 if(streamedContent) {
828 // after the streamed file, we put data descriptors
829 this.push({
830 data : generateDataDescriptors(streamInfo),
831 meta : {percent:100}
832 });
833 } else {
834 // the content wasn't streamed, we need to push everything now
835 // first the file record, then the content
836 this.push({
837 data : record.fileRecord,
838 meta : {percent:0}
839 });
840 while(this.contentBuffer.length) {
841 this.push(this.contentBuffer.shift());
842 }
843 }
844 this.currentFile = null;
845 };
846
847 /**
848 * @see GenericWorker.flush
849 */
850 ZipFileWorker.prototype.flush = function () {
851
852 var localDirLength = this.bytesWritten;
853 for(var i = 0; i < this.dirRecords.length; i++) {
854 this.push({
855 data : this.dirRecords[i],
856 meta : {percent:100}
857 });
858 }
859 var centralDirLength = this.bytesWritten - localDirLength;
860
861 var dirEnd = generateCentralDirectoryEnd(this.dirRecords.length, centralDirLength, localDirLength, this.zipComment, this.encodeFileName);
862
863 this.push({
864 data : dirEnd,
865 meta : {percent:100}
866 });
867 };
868
869 /**
870 * Prepare the next source to be read.
871 */
872 ZipFileWorker.prototype.prepareNextSource = function () {
873 this.previous = this._sources.shift();
874 this.openedSource(this.previous.streamInfo);
875 if (this.isPaused) {
876 this.previous.pause();
877 } else {
878 this.previous.resume();
879 }
880 };
881
882 /**
883 * @see GenericWorker.registerPrevious
884 */
885 ZipFileWorker.prototype.registerPrevious = function (previous) {
886 this._sources.push(previous);
887 var self = this;
888
889 previous.on('data', function (chunk) {
890 self.processChunk(chunk);
891 });
892 previous.on('end', function () {
893 self.closedSource(self.previous.streamInfo);
894 if(self._sources.length) {
895 self.prepareNextSource();
896 } else {
897 self.end();
898 }
899 });
900 previous.on('error', function (e) {
901 self.error(e);
902 });
903 return this;
904 };
905
906 /**
907 * @see GenericWorker.resume
908 */
909 ZipFileWorker.prototype.resume = function () {
910 if(!GenericWorker.prototype.resume.call(this)) {
911 return false;
912 }
913
914 if (!this.previous && this._sources.length) {
915 this.prepareNextSource();
916 return true;
917 }
918 if (!this.previous && !this._sources.length && !this.generatedError) {
919 this.end();
920 return true;
921 }
922 };
923
924 /**
925 * @see GenericWorker.error
926 */
927 ZipFileWorker.prototype.error = function (e) {
928 var sources = this._sources;
929 if(!GenericWorker.prototype.error.call(this, e)) {
930 return false;
931 }
932 for(var i = 0; i < sources.length; i++) {
933 try {
934 sources[i].error(e);
935 } catch(e) {
936 // the `error` exploded, nothing to do
937 }
938 }
939 return true;
940 };
941
942 /**
943 * @see GenericWorker.lock
944 */
945 ZipFileWorker.prototype.lock = function () {
946 GenericWorker.prototype.lock.call(this);
947 var sources = this._sources;
948 for(var i = 0; i < sources.length; i++) {
949 sources[i].lock();
950 }
951 };
952
953 module.exports = ZipFileWorker;
954
955 },{"../crc32":4,"../signature":23,"../stream/GenericWorker":28,"../utf8":31,"../utils":32}],9:[function(require,module,exports){
956 'use strict';
957
958 var compressions = require('../compressions');
959 var ZipFileWorker = require('./ZipFileWorker');
960
961 /**
962 * Find the compression to use.
963 * @param {String} fileCompression the compression defined at the file level, if any.
964 * @param {String} zipCompression the compression defined at the load() level.
965 * @return {Object} the compression object to use.
966 */
967 var getCompression = function (fileCompression, zipCompression) {
968
969 var compressionName = fileCompression || zipCompression;
970 var compression = compressions[compressionName];
971 if (!compression) {
972 throw new Error(compressionName + " is not a valid compression method !");
973 }
974 return compression;
975 };
976
977 /**
978 * Create a worker to generate a zip file.
979 * @param {JSZip} zip the JSZip instance at the right root level.
980 * @param {Object} options to generate the zip file.
981 * @param {String} comment the comment to use.
982 */
983 exports.generateWorker = function (zip, options, comment) {
984
985 var zipFileWorker = new ZipFileWorker(options.streamFiles, comment, options.platform, options.encodeFileName);
986 var entriesCount = 0;
987 try {
988
989 zip.forEach(function (relativePath, file) {
990 entriesCount++;
991 var compression = getCompression(file.options.compression, options.compression);
992 var compressionOptions = file.options.compressionOptions || options.compressionOptions || {};
993 var dir = file.dir, date = file.date;
994
995 file._compressWorker(compression, compressionOptions)
996 .withStreamInfo("file", {
997 name : relativePath,
998 dir : dir,
999 date : date,
1000 comment : file.comment || "",
1001 unixPermissions : file.unixPermissions,
1002 dosPermissions : file.dosPermissions
1003 })
1004 .pipe(zipFileWorker);
1005 });
1006 zipFileWorker.entriesCount = entriesCount;
1007 } catch (e) {
1008 zipFileWorker.error(e);
1009 }
1010
1011 return zipFileWorker;
1012 };
1013
1014 },{"../compressions":3,"./ZipFileWorker":8}],10:[function(require,module,exports){
1015 'use strict';
1016
1017 /**
1018 * Representation a of zip file in js
1019 * @constructor
1020 */
1021 function JSZip() {
1022 // if this constructor is used without `new`, it adds `new` before itself:
1023 if(!(this instanceof JSZip)) {
1024 return new JSZip();
1025 }
1026
1027 if(arguments.length) {
1028 throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");
1029 }
1030
1031 // object containing the files :
1032 // {
1033 // "folder/" : {...},
1034 // "folder/data.txt" : {...}
1035 // }
1036 // NOTE: we use a null prototype because we do not
1037 // want filenames like "toString" coming from a zip file
1038 // to overwrite methods and attributes in a normal Object.
1039 this.files = Object.create(null);
1040
1041 this.comment = null;
1042
1043 // Where we are in the hierarchy
1044 this.root = "";
1045 this.clone = function() {
1046 var newObj = new JSZip();
1047 for (var i in this) {
1048 if (typeof this[i] !== "function") {
1049 newObj[i] = this[i];
1050 }
1051 }
1052 return newObj;
1053 };
1054 }
1055 JSZip.prototype = require('./object');
1056 JSZip.prototype.loadAsync = require('./load');
1057 JSZip.support = require('./support');
1058 JSZip.defaults = require('./defaults');
1059
1060 // TODO find a better way to handle this version,
1061 // a require('package.json').version doesn't work with webpack, see #327
1062 JSZip.version = "3.7.1";
1063
1064 JSZip.loadAsync = function (content, options) {
1065 return new JSZip().loadAsync(content, options);
1066 };
1067
1068 JSZip.external = require("./external");
1069 module.exports = JSZip;
1070
1071 },{"./defaults":5,"./external":6,"./load":11,"./object":15,"./support":30}],11:[function(require,module,exports){
1072 'use strict';
1073 var utils = require('./utils');
1074 var external = require("./external");
1075 var utf8 = require('./utf8');
1076 var ZipEntries = require('./zipEntries');
1077 var Crc32Probe = require('./stream/Crc32Probe');
1078 var nodejsUtils = require("./nodejsUtils");
1079
1080 /**
1081 * Check the CRC32 of an entry.
1082 * @param {ZipEntry} zipEntry the zip entry to check.
1083 * @return {Promise} the result.
1084 */
1085 function checkEntryCRC32(zipEntry) {
1086 return new external.Promise(function (resolve, reject) {
1087 var worker = zipEntry.decompressed.getContentWorker().pipe(new Crc32Probe());
1088 worker.on("error", function (e) {
1089 reject(e);
1090 })
1091 .on("end", function () {
1092 if (worker.streamInfo.crc32 !== zipEntry.decompressed.crc32) {
1093 reject(new Error("Corrupted zip : CRC32 mismatch"));
1094 } else {
1095 resolve();
1096 }
1097 })
1098 .resume();
1099 });
1100 }
1101
1102 module.exports = function (data, options) {
1103 var zip = this;
1104 options = utils.extend(options || {}, {
1105 base64: false,
1106 checkCRC32: false,
1107 optimizedBinaryString: false,
1108 createFolders: false,
1109 decodeFileName: utf8.utf8decode
1110 });
1111
1112 if (nodejsUtils.isNode && nodejsUtils.isStream(data)) {
1113 return external.Promise.reject(new Error("JSZip can't accept a stream when loading a zip file."));
1114 }
1115
1116 return utils.prepareContent("the loaded zip file", data, true, options.optimizedBinaryString, options.base64)
1117 .then(function (data) {
1118 var zipEntries = new ZipEntries(options);
1119 zipEntries.load(data);
1120 return zipEntries;
1121 }).then(function checkCRC32(zipEntries) {
1122 var promises = [external.Promise.resolve(zipEntries)];
1123 var files = zipEntries.files;
1124 if (options.checkCRC32) {
1125 for (var i = 0; i < files.length; i++) {
1126 promises.push(checkEntryCRC32(files[i]));
1127 }
1128 }
1129 return external.Promise.all(promises);
1130 }).then(function addFiles(results) {
1131 var zipEntries = results.shift();
1132 var files = zipEntries.files;
1133 for (var i = 0; i < files.length; i++) {
1134 var input = files[i];
1135 zip.file(input.fileNameStr, input.decompressed, {
1136 binary: true,
1137 optimizedBinaryString: true,
1138 date: input.date,
1139 dir: input.dir,
1140 comment: input.fileCommentStr.length ? input.fileCommentStr : null,
1141 unixPermissions: input.unixPermissions,
1142 dosPermissions: input.dosPermissions,
1143 createFolders: options.createFolders
1144 });
1145 }
1146 if (zipEntries.zipComment.length) {
1147 zip.comment = zipEntries.zipComment;
1148 }
1149
1150 return zip;
1151 });
1152 };
1153
1154 },{"./external":6,"./nodejsUtils":14,"./stream/Crc32Probe":25,"./utf8":31,"./utils":32,"./zipEntries":33}],12:[function(require,module,exports){
1155 "use strict";
1156
1157 var utils = require('../utils');
1158 var GenericWorker = require('../stream/GenericWorker');
1159
1160 /**
1161 * A worker that use a nodejs stream as source.
1162 * @constructor
1163 * @param {String} filename the name of the file entry for this stream.
1164 * @param {Readable} stream the nodejs stream.
1165 */
1166 function NodejsStreamInputAdapter(filename, stream) {
1167 GenericWorker.call(this, "Nodejs stream input adapter for " + filename);
1168 this._upstreamEnded = false;
1169 this._bindStream(stream);
1170 }
1171
1172 utils.inherits(NodejsStreamInputAdapter, GenericWorker);
1173
1174 /**
1175 * Prepare the stream and bind the callbacks on it.
1176 * Do this ASAP on node 0.10 ! A lazy binding doesn't always work.
1177 * @param {Stream} stream the nodejs stream to use.
1178 */
1179 NodejsStreamInputAdapter.prototype._bindStream = function (stream) {
1180 var self = this;
1181 this._stream = stream;
1182 stream.pause();
1183 stream
1184 .on("data", function (chunk) {
1185 self.push({
1186 data: chunk,
1187 meta : {
1188 percent : 0
1189 }
1190 });
1191 })
1192 .on("error", function (e) {
1193 if(self.isPaused) {
1194 this.generatedError = e;
1195 } else {
1196 self.error(e);
1197 }
1198 })
1199 .on("end", function () {
1200 if(self.isPaused) {
1201 self._upstreamEnded = true;
1202 } else {
1203 self.end();
1204 }
1205 });
1206 };
1207 NodejsStreamInputAdapter.prototype.pause = function () {
1208 if(!GenericWorker.prototype.pause.call(this)) {
1209 return false;
1210 }
1211 this._stream.pause();
1212 return true;
1213 };
1214 NodejsStreamInputAdapter.prototype.resume = function () {
1215 if(!GenericWorker.prototype.resume.call(this)) {
1216 return false;
1217 }
1218
1219 if(this._upstreamEnded) {
1220 this.end();
1221 } else {
1222 this._stream.resume();
1223 }
1224
1225 return true;
1226 };
1227
1228 module.exports = NodejsStreamInputAdapter;
1229
1230 },{"../stream/GenericWorker":28,"../utils":32}],13:[function(require,module,exports){
1231 'use strict';
1232
1233 var Readable = require('readable-stream').Readable;
1234
1235 var utils = require('../utils');
1236 utils.inherits(NodejsStreamOutputAdapter, Readable);
1237
1238 /**
1239 * A nodejs stream using a worker as source.
1240 * @see the SourceWrapper in http://nodejs.org/api/stream.html
1241 * @constructor
1242 * @param {StreamHelper} helper the helper wrapping the worker
1243 * @param {Object} options the nodejs stream options
1244 * @param {Function} updateCb the update callback.
1245 */
1246 function NodejsStreamOutputAdapter(helper, options, updateCb) {
1247 Readable.call(this, options);
1248 this._helper = helper;
1249
1250 var self = this;
1251 helper.on("data", function (data, meta) {
1252 if (!self.push(data)) {
1253 self._helper.pause();
1254 }
1255 if(updateCb) {
1256 updateCb(meta);
1257 }
1258 })
1259 .on("error", function(e) {
1260 self.emit('error', e);
1261 })
1262 .on("end", function () {
1263 self.push(null);
1264 });
1265 }
1266
1267
1268 NodejsStreamOutputAdapter.prototype._read = function() {
1269 this._helper.resume();
1270 };
1271
1272 module.exports = NodejsStreamOutputAdapter;
1273
1274 },{"../utils":32,"readable-stream":16}],14:[function(require,module,exports){
1275 'use strict';
1276
1277 module.exports = {
1278 /**
1279 * True if this is running in Nodejs, will be undefined in a browser.
1280 * In a browser, browserify won't include this file and the whole module
1281 * will be resolved an empty object.
1282 */
1283 isNode : typeof Buffer !== "undefined",
1284 /**
1285 * Create a new nodejs Buffer from an existing content.
1286 * @param {Object} data the data to pass to the constructor.
1287 * @param {String} encoding the encoding to use.
1288 * @return {Buffer} a new Buffer.
1289 */
1290 newBufferFrom: function(data, encoding) {
1291 if (Buffer.from && Buffer.from !== Uint8Array.from) {
1292 return Buffer.from(data, encoding);
1293 } else {
1294 if (typeof data === "number") {
1295 // Safeguard for old Node.js versions. On newer versions,
1296 // Buffer.from(number) / Buffer(number, encoding) already throw.
1297 throw new Error("The \"data\" argument must not be a number");
1298 }
1299 return new Buffer(data, encoding);
1300 }
1301 },
1302 /**
1303 * Create a new nodejs Buffer with the specified size.
1304 * @param {Integer} size the size of the buffer.
1305 * @return {Buffer} a new Buffer.
1306 */
1307 allocBuffer: function (size) {
1308 if (Buffer.alloc) {
1309 return Buffer.alloc(size);
1310 } else {
1311 var buf = new Buffer(size);
1312 buf.fill(0);
1313 return buf;
1314 }
1315 },
1316 /**
1317 * Find out if an object is a Buffer.
1318 * @param {Object} b the object to test.
1319 * @return {Boolean} true if the object is a Buffer, false otherwise.
1320 */
1321 isBuffer : function(b){
1322 return Buffer.isBuffer(b);
1323 },
1324
1325 isStream : function (obj) {
1326 return obj &&
1327 typeof obj.on === "function" &&
1328 typeof obj.pause === "function" &&
1329 typeof obj.resume === "function";
1330 }
1331 };
1332
1333 },{}],15:[function(require,module,exports){
1334 'use strict';
1335 var utf8 = require('./utf8');
1336 var utils = require('./utils');
1337 var GenericWorker = require('./stream/GenericWorker');
1338 var StreamHelper = require('./stream/StreamHelper');
1339 var defaults = require('./defaults');
1340 var CompressedObject = require('./compressedObject');
1341 var ZipObject = require('./zipObject');
1342 var generate = require("./generate");
1343 var nodejsUtils = require("./nodejsUtils");
1344 var NodejsStreamInputAdapter = require("./nodejs/NodejsStreamInputAdapter");
1345
1346
1347 /**
1348 * Add a file in the current folder.
1349 * @private
1350 * @param {string} name the name of the file
1351 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data of the file
1352 * @param {Object} originalOptions the options of the file
1353 * @return {Object} the new file.
1354 */
1355 var fileAdd = function(name, data, originalOptions) {
1356 // be sure sub folders exist
1357 var dataType = utils.getTypeOf(data),
1358 parent;
1359
1360
1361 /*
1362 * Correct options.
1363 */
1364
1365 var o = utils.extend(originalOptions || {}, defaults);
1366 o.date = o.date || new Date();
1367 if (o.compression !== null) {
1368 o.compression = o.compression.toUpperCase();
1369 }
1370
1371 if (typeof o.unixPermissions === "string") {
1372 o.unixPermissions = parseInt(o.unixPermissions, 8);
1373 }
1374
1375 // UNX_IFDIR 0040000 see zipinfo.c
1376 if (o.unixPermissions && (o.unixPermissions & 0x4000)) {
1377 o.dir = true;
1378 }
1379 // Bit 4 Directory
1380 if (o.dosPermissions && (o.dosPermissions & 0x0010)) {
1381 o.dir = true;
1382 }
1383
1384 if (o.dir) {
1385 name = forceTrailingSlash(name);
1386 }
1387 if (o.createFolders && (parent = parentFolder(name))) {
1388 folderAdd.call(this, parent, true);
1389 }
1390
1391 var isUnicodeString = dataType === "string" && o.binary === false && o.base64 === false;
1392 if (!originalOptions || typeof originalOptions.binary === "undefined") {
1393 o.binary = !isUnicodeString;
1394 }
1395
1396
1397 var isCompressedEmpty = (data instanceof CompressedObject) && data.uncompressedSize === 0;
1398
1399 if (isCompressedEmpty || o.dir || !data || data.length === 0) {
1400 o.base64 = false;
1401 o.binary = true;
1402 data = "";
1403 o.compression = "STORE";
1404 dataType = "string";
1405 }
1406
1407 /*
1408 * Convert content to fit.
1409 */
1410
1411 var zipObjectContent = null;
1412 if (data instanceof CompressedObject || data instanceof GenericWorker) {
1413 zipObjectContent = data;
1414 } else if (nodejsUtils.isNode && nodejsUtils.isStream(data)) {
1415 zipObjectContent = new NodejsStreamInputAdapter(name, data);
1416 } else {
1417 zipObjectContent = utils.prepareContent(name, data, o.binary, o.optimizedBinaryString, o.base64);
1418 }
1419
1420 var object = new ZipObject(name, zipObjectContent, o);
1421 this.files[name] = object;
1422 /*
1423 TODO: we can't throw an exception because we have async promises
1424 (we can have a promise of a Date() for example) but returning a
1425 promise is useless because file(name, data) returns the JSZip
1426 object for chaining. Should we break that to allow the user
1427 to catch the error ?
1428
1429 return external.Promise.resolve(zipObjectContent)
1430 .then(function () {
1431 return object;
1432 });
1433 */
1434 };
1435
1436 /**
1437 * Find the parent folder of the path.
1438 * @private
1439 * @param {string} path the path to use
1440 * @return {string} the parent folder, or ""
1441 */
1442 var parentFolder = function (path) {
1443 if (path.slice(-1) === '/') {
1444 path = path.substring(0, path.length - 1);
1445 }
1446 var lastSlash = path.lastIndexOf('/');
1447 return (lastSlash > 0) ? path.substring(0, lastSlash) : "";
1448 };
1449
1450 /**
1451 * Returns the path with a slash at the end.
1452 * @private
1453 * @param {String} path the path to check.
1454 * @return {String} the path with a trailing slash.
1455 */
1456 var forceTrailingSlash = function(path) {
1457 // Check the name ends with a /
1458 if (path.slice(-1) !== "/") {
1459 path += "/"; // IE doesn't like substr(-1)
1460 }
1461 return path;
1462 };
1463
1464 /**
1465 * Add a (sub) folder in the current folder.
1466 * @private
1467 * @param {string} name the folder's name
1468 * @param {boolean=} [createFolders] If true, automatically create sub
1469 * folders. Defaults to false.
1470 * @return {Object} the new folder.
1471 */
1472 var folderAdd = function(name, createFolders) {
1473 createFolders = (typeof createFolders !== 'undefined') ? createFolders : defaults.createFolders;
1474
1475 name = forceTrailingSlash(name);
1476
1477 // Does this folder already exist?
1478 if (!this.files[name]) {
1479 fileAdd.call(this, name, null, {
1480 dir: true,
1481 createFolders: createFolders
1482 });
1483 }
1484 return this.files[name];
1485 };
1486
1487 /**
1488 * Cross-window, cross-Node-context regular expression detection
1489 * @param {Object} object Anything
1490 * @return {Boolean} true if the object is a regular expression,
1491 * false otherwise
1492 */
1493 function isRegExp(object) {
1494 return Object.prototype.toString.call(object) === "[object RegExp]";
1495 }
1496
1497 // return the actual prototype of JSZip
1498 var out = {
1499 /**
1500 * @see loadAsync
1501 */
1502 load: function() {
1503 throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
1504 },
1505
1506
1507 /**
1508 * Call a callback function for each entry at this folder level.
1509 * @param {Function} cb the callback function:
1510 * function (relativePath, file) {...}
1511 * It takes 2 arguments : the relative path and the file.
1512 */
1513 forEach: function(cb) {
1514 var filename, relativePath, file;
1515 /* jshint ignore:start */
1516 // ignore warning about unwanted properties because this.files is a null prototype object
1517 for (filename in this.files) {
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 /* jshint ignore:end */
1525 },
1526
1527 /**
1528 * Filter nested files/folders with the specified function.
1529 * @param {Function} search the predicate to use :
1530 * function (relativePath, file) {...}
1531 * It takes 2 arguments : the relative path and the file.
1532 * @return {Array} An array of matching elements.
1533 */
1534 filter: function(search) {
1535 var result = [];
1536 this.forEach(function (relativePath, entry) {
1537 if (search(relativePath, entry)) { // the file matches the function
1538 result.push(entry);
1539 }
1540
1541 });
1542 return result;
1543 },
1544
1545 /**
1546 * Add a file to the zip file, or search a file.
1547 * @param {string|RegExp} name The name of the file to add (if data is defined),
1548 * the name of the file to find (if no data) or a regex to match files.
1549 * @param {String|ArrayBuffer|Uint8Array|Buffer} data The file data, either raw or base64 encoded
1550 * @param {Object} o File options
1551 * @return {JSZip|Object|Array} this JSZip object (when adding a file),
1552 * a file (when searching by string) or an array of files (when searching by regex).
1553 */
1554 file: function(name, data, o) {
1555 if (arguments.length === 1) {
1556 if (isRegExp(name)) {
1557 var regexp = name;
1558 return this.filter(function(relativePath, file) {
1559 return !file.dir && regexp.test(relativePath);
1560 });
1561 }
1562 else { // text
1563 var obj = this.files[this.root + name];
1564 if (obj && !obj.dir) {
1565 return obj;
1566 } else {
1567 return null;
1568 }
1569 }
1570 }
1571 else { // more than one argument : we have data !
1572 name = this.root + name;
1573 fileAdd.call(this, name, data, o);
1574 }
1575 return this;
1576 },
1577
1578 /**
1579 * Add a directory to the zip file, or search.
1580 * @param {String|RegExp} arg The name of the directory to add, or a regex to search folders.
1581 * @return {JSZip} an object with the new directory as the root, or an array containing matching folders.
1582 */
1583 folder: function(arg) {
1584 if (!arg) {
1585 return this;
1586 }
1587
1588 if (isRegExp(arg)) {
1589 return this.filter(function(relativePath, file) {
1590 return file.dir && arg.test(relativePath);
1591 });
1592 }
1593
1594 // else, name is a new folder
1595 var name = this.root + arg;
1596 var newFolder = folderAdd.call(this, name);
1597
1598 // Allow chaining by returning a new object with this folder as the root
1599 var ret = this.clone();
1600 ret.root = newFolder.name;
1601 return ret;
1602 },
1603
1604 /**
1605 * Delete a file, or a directory and all sub-files, from the zip
1606 * @param {string} name the name of the file to delete
1607 * @return {JSZip} this JSZip object
1608 */
1609 remove: function(name) {
1610 name = this.root + name;
1611 var file = this.files[name];
1612 if (!file) {
1613 // Look for any folders
1614 if (name.slice(-1) !== "/") {
1615 name += "/";
1616 }
1617 file = this.files[name];
1618 }
1619
1620 if (file && !file.dir) {
1621 // file
1622 delete this.files[name];
1623 } else {
1624 // maybe a folder, delete recursively
1625 var kids = this.filter(function(relativePath, file) {
1626 return file.name.slice(0, name.length) === name;
1627 });
1628 for (var i = 0; i < kids.length; i++) {
1629 delete this.files[kids[i].name];
1630 }
1631 }
1632
1633 return this;
1634 },
1635
1636 /**
1637 * Generate the complete zip file
1638 * @param {Object} options the options to generate the zip file :
1639 * - compression, "STORE" by default.
1640 * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
1641 * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the zip file
1642 */
1643 generate: function(options) {
1644 throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
1645 },
1646
1647 /**
1648 * Generate the complete zip file as an internal stream.
1649 * @param {Object} options the options to generate the zip file :
1650 * - compression, "STORE" by default.
1651 * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
1652 * @return {StreamHelper} the streamed zip file.
1653 */
1654 generateInternalStream: function(options) {
1655 var worker, opts = {};
1656 try {
1657 opts = utils.extend(options || {}, {
1658 streamFiles: false,
1659 compression: "STORE",
1660 compressionOptions : null,
1661 type: "",
1662 platform: "DOS",
1663 comment: null,
1664 mimeType: 'application/zip',
1665 encodeFileName: utf8.utf8encode
1666 });
1667
1668 opts.type = opts.type.toLowerCase();
1669 opts.compression = opts.compression.toUpperCase();
1670
1671 // "binarystring" is preferred but the internals use "string".
1672 if(opts.type === "binarystring") {
1673 opts.type = "string";
1674 }
1675
1676 if (!opts.type) {
1677 throw new Error("No output type specified.");
1678 }
1679
1680 utils.checkSupport(opts.type);
1681
1682 // accept nodejs `process.platform`
1683 if(
1684 opts.platform === 'darwin' ||
1685 opts.platform === 'freebsd' ||
1686 opts.platform === 'linux' ||
1687 opts.platform === 'sunos'
1688 ) {
1689 opts.platform = "UNIX";
1690 }
1691 if (opts.platform === 'win32') {
1692 opts.platform = "DOS";
1693 }
1694
1695 var comment = opts.comment || this.comment || "";
1696 worker = generate.generateWorker(this, opts, comment);
1697 } catch (e) {
1698 worker = new GenericWorker("error");
1699 worker.error(e);
1700 }
1701 return new StreamHelper(worker, opts.type || "string", opts.mimeType);
1702 },
1703 /**
1704 * Generate the complete zip file asynchronously.
1705 * @see generateInternalStream
1706 */
1707 generateAsync: function(options, onUpdate) {
1708 return this.generateInternalStream(options).accumulate(onUpdate);
1709 },
1710 /**
1711 * Generate the complete zip file asynchronously.
1712 * @see generateInternalStream
1713 */
1714 generateNodeStream: function(options, onUpdate) {
1715 options = options || {};
1716 if (!options.type) {
1717 options.type = "nodebuffer";
1718 }
1719 return this.generateInternalStream(options).toNodejsStream(onUpdate);
1720 }
1721 };
1722 module.exports = out;
1723
1724 },{"./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){
1725 /*
1726 * This file is used by module bundlers (browserify/webpack/etc) when
1727 * including a stream implementation. We use "readable-stream" to get a
1728 * consistent behavior between nodejs versions but bundlers often have a shim
1729 * for "stream". Using this shim greatly improve the compatibility and greatly
1730 * reduce the final size of the bundle (only one stream implementation, not
1731 * two).
1732 */
1733 module.exports = require("stream");
1734
1735 },{"stream":undefined}],17:[function(require,module,exports){
1736 'use strict';
1737 var DataReader = require('./DataReader');
1738 var utils = require('../utils');
1739
1740 function ArrayReader(data) {
1741 DataReader.call(this, data);
1742 for(var i = 0; i < this.data.length; i++) {
1743 data[i] = data[i] & 0xFF;
1744 }
1745 }
1746 utils.inherits(ArrayReader, DataReader);
1747 /**
1748 * @see DataReader.byteAt
1749 */
1750 ArrayReader.prototype.byteAt = function(i) {
1751 return this.data[this.zero + i];
1752 };
1753 /**
1754 * @see DataReader.lastIndexOfSignature
1755 */
1756 ArrayReader.prototype.lastIndexOfSignature = function(sig) {
1757 var sig0 = sig.charCodeAt(0),
1758 sig1 = sig.charCodeAt(1),
1759 sig2 = sig.charCodeAt(2),
1760 sig3 = sig.charCodeAt(3);
1761 for (var i = this.length - 4; i >= 0; --i) {
1762 if (this.data[i] === sig0 && this.data[i + 1] === sig1 && this.data[i + 2] === sig2 && this.data[i + 3] === sig3) {
1763 return i - this.zero;
1764 }
1765 }
1766
1767 return -1;
1768 };
1769 /**
1770 * @see DataReader.readAndCheckSignature
1771 */
1772 ArrayReader.prototype.readAndCheckSignature = function (sig) {
1773 var sig0 = sig.charCodeAt(0),
1774 sig1 = sig.charCodeAt(1),
1775 sig2 = sig.charCodeAt(2),
1776 sig3 = sig.charCodeAt(3),
1777 data = this.readData(4);
1778 return sig0 === data[0] && sig1 === data[1] && sig2 === data[2] && sig3 === data[3];
1779 };
1780 /**
1781 * @see DataReader.readData
1782 */
1783 ArrayReader.prototype.readData = function(size) {
1784 this.checkOffset(size);
1785 if(size === 0) {
1786 return [];
1787 }
1788 var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
1789 this.index += size;
1790 return result;
1791 };
1792 module.exports = ArrayReader;
1793
1794 },{"../utils":32,"./DataReader":18}],18:[function(require,module,exports){
1795 'use strict';
1796 var utils = require('../utils');
1797
1798 function DataReader(data) {
1799 this.data = data; // type : see implementation
1800 this.length = data.length;
1801 this.index = 0;
1802 this.zero = 0;
1803 }
1804 DataReader.prototype = {
1805 /**
1806 * Check that the offset will not go too far.
1807 * @param {string} offset the additional offset to check.
1808 * @throws {Error} an Error if the offset is out of bounds.
1809 */
1810 checkOffset: function(offset) {
1811 this.checkIndex(this.index + offset);
1812 },
1813 /**
1814 * Check that the specified index will not be too far.
1815 * @param {string} newIndex the index to check.
1816 * @throws {Error} an Error if the index is out of bounds.
1817 */
1818 checkIndex: function(newIndex) {
1819 if (this.length < this.zero + newIndex || newIndex < 0) {
1820 throw new Error("End of data reached (data length = " + this.length + ", asked index = " + (newIndex) + "). Corrupted zip ?");
1821 }
1822 },
1823 /**
1824 * Change the index.
1825 * @param {number} newIndex The new index.
1826 * @throws {Error} if the new index is out of the data.
1827 */
1828 setIndex: function(newIndex) {
1829 this.checkIndex(newIndex);
1830 this.index = newIndex;
1831 },
1832 /**
1833 * Skip the next n bytes.
1834 * @param {number} n the number of bytes to skip.
1835 * @throws {Error} if the new index is out of the data.
1836 */
1837 skip: function(n) {
1838 this.setIndex(this.index + n);
1839 },
1840 /**
1841 * Get the byte at the specified index.
1842 * @param {number} i the index to use.
1843 * @return {number} a byte.
1844 */
1845 byteAt: function(i) {
1846 // see implementations
1847 },
1848 /**
1849 * Get the next number with a given byte size.
1850 * @param {number} size the number of bytes to read.
1851 * @return {number} the corresponding number.
1852 */
1853 readInt: function(size) {
1854 var result = 0,
1855 i;
1856 this.checkOffset(size);
1857 for (i = this.index + size - 1; i >= this.index; i--) {
1858 result = (result << 8) + this.byteAt(i);
1859 }
1860 this.index += size;
1861 return result;
1862 },
1863 /**
1864 * Get the next string with a given byte size.
1865 * @param {number} size the number of bytes to read.
1866 * @return {string} the corresponding string.
1867 */
1868 readString: function(size) {
1869 return utils.transformTo("string", this.readData(size));
1870 },
1871 /**
1872 * Get raw data without conversion, <size> bytes.
1873 * @param {number} size the number of bytes to read.
1874 * @return {Object} the raw data, implementation specific.
1875 */
1876 readData: function(size) {
1877 // see implementations
1878 },
1879 /**
1880 * Find the last occurrence of a zip signature (4 bytes).
1881 * @param {string} sig the signature to find.
1882 * @return {number} the index of the last occurrence, -1 if not found.
1883 */
1884 lastIndexOfSignature: function(sig) {
1885 // see implementations
1886 },
1887 /**
1888 * Read the signature (4 bytes) at the current position and compare it with sig.
1889 * @param {string} sig the expected signature
1890 * @return {boolean} true if the signature matches, false otherwise.
1891 */
1892 readAndCheckSignature: function(sig) {
1893 // see implementations
1894 },
1895 /**
1896 * Get the next date.
1897 * @return {Date} the date.
1898 */
1899 readDate: function() {
1900 var dostime = this.readInt(4);
1901 return new Date(Date.UTC(
1902 ((dostime >> 25) & 0x7f) + 1980, // year
1903 ((dostime >> 21) & 0x0f) - 1, // month
1904 (dostime >> 16) & 0x1f, // day
1905 (dostime >> 11) & 0x1f, // hour
1906 (dostime >> 5) & 0x3f, // minute
1907 (dostime & 0x1f) << 1)); // second
1908 }
1909 };
1910 module.exports = DataReader;
1911
1912 },{"../utils":32}],19:[function(require,module,exports){
1913 'use strict';
1914 var Uint8ArrayReader = require('./Uint8ArrayReader');
1915 var utils = require('../utils');
1916
1917 function NodeBufferReader(data) {
1918 Uint8ArrayReader.call(this, data);
1919 }
1920 utils.inherits(NodeBufferReader, Uint8ArrayReader);
1921
1922 /**
1923 * @see DataReader.readData
1924 */
1925 NodeBufferReader.prototype.readData = function(size) {
1926 this.checkOffset(size);
1927 var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
1928 this.index += size;
1929 return result;
1930 };
1931 module.exports = NodeBufferReader;
1932
1933 },{"../utils":32,"./Uint8ArrayReader":21}],20:[function(require,module,exports){
1934 'use strict';
1935 var DataReader = require('./DataReader');
1936 var utils = require('../utils');
1937
1938 function StringReader(data) {
1939 DataReader.call(this, data);
1940 }
1941 utils.inherits(StringReader, DataReader);
1942 /**
1943 * @see DataReader.byteAt
1944 */
1945 StringReader.prototype.byteAt = function(i) {
1946 return this.data.charCodeAt(this.zero + i);
1947 };
1948 /**
1949 * @see DataReader.lastIndexOfSignature
1950 */
1951 StringReader.prototype.lastIndexOfSignature = function(sig) {
1952 return this.data.lastIndexOf(sig) - this.zero;
1953 };
1954 /**
1955 * @see DataReader.readAndCheckSignature
1956 */
1957 StringReader.prototype.readAndCheckSignature = function (sig) {
1958 var data = this.readData(4);
1959 return sig === data;
1960 };
1961 /**
1962 * @see DataReader.readData
1963 */
1964 StringReader.prototype.readData = function(size) {
1965 this.checkOffset(size);
1966 // this will work because the constructor applied the "& 0xff" mask.
1967 var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
1968 this.index += size;
1969 return result;
1970 };
1971 module.exports = StringReader;
1972
1973 },{"../utils":32,"./DataReader":18}],21:[function(require,module,exports){
1974 'use strict';
1975 var ArrayReader = require('./ArrayReader');
1976 var utils = require('../utils');
1977
1978 function Uint8ArrayReader(data) {
1979 ArrayReader.call(this, data);
1980 }
1981 utils.inherits(Uint8ArrayReader, ArrayReader);
1982 /**
1983 * @see DataReader.readData
1984 */
1985 Uint8ArrayReader.prototype.readData = function(size) {
1986 this.checkOffset(size);
1987 if(size === 0) {
1988 // in IE10, when using subarray(idx, idx), we get the array [0x00] instead of [].
1989 return new Uint8Array(0);
1990 }
1991 var result = this.data.subarray(this.zero + this.index, this.zero + this.index + size);
1992 this.index += size;
1993 return result;
1994 };
1995 module.exports = Uint8ArrayReader;
1996
1997 },{"../utils":32,"./ArrayReader":17}],22:[function(require,module,exports){
1998 'use strict';
1999
2000 var utils = require('../utils');
2001 var support = require('../support');
2002 var ArrayReader = require('./ArrayReader');
2003 var StringReader = require('./StringReader');
2004 var NodeBufferReader = require('./NodeBufferReader');
2005 var Uint8ArrayReader = require('./Uint8ArrayReader');
2006
2007 /**
2008 * Create a reader adapted to the data.
2009 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data to read.
2010 * @return {DataReader} the data reader.
2011 */
2012 module.exports = function (data) {
2013 var type = utils.getTypeOf(data);
2014 utils.checkSupport(type);
2015 if (type === "string" && !support.uint8array) {
2016 return new StringReader(data);
2017 }
2018 if (type === "nodebuffer") {
2019 return new NodeBufferReader(data);
2020 }
2021 if (support.uint8array) {
2022 return new Uint8ArrayReader(utils.transformTo("uint8array", data));
2023 }
2024 return new ArrayReader(utils.transformTo("array", data));
2025 };
2026
2027 },{"../support":30,"../utils":32,"./ArrayReader":17,"./NodeBufferReader":19,"./StringReader":20,"./Uint8ArrayReader":21}],23:[function(require,module,exports){
2028 'use strict';
2029 exports.LOCAL_FILE_HEADER = "PK\x03\x04";
2030 exports.CENTRAL_FILE_HEADER = "PK\x01\x02";
2031 exports.CENTRAL_DIRECTORY_END = "PK\x05\x06";
2032 exports.ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x06\x07";
2033 exports.ZIP64_CENTRAL_DIRECTORY_END = "PK\x06\x06";
2034 exports.DATA_DESCRIPTOR = "PK\x07\x08";
2035
2036 },{}],24:[function(require,module,exports){
2037 'use strict';
2038
2039 var GenericWorker = require('./GenericWorker');
2040 var utils = require('../utils');
2041
2042 /**
2043 * A worker which convert chunks to a specified type.
2044 * @constructor
2045 * @param {String} destType the destination type.
2046 */
2047 function ConvertWorker(destType) {
2048 GenericWorker.call(this, "ConvertWorker to " + destType);
2049 this.destType = destType;
2050 }
2051 utils.inherits(ConvertWorker, GenericWorker);
2052
2053 /**
2054 * @see GenericWorker.processChunk
2055 */
2056 ConvertWorker.prototype.processChunk = function (chunk) {
2057 this.push({
2058 data : utils.transformTo(this.destType, chunk.data),
2059 meta : chunk.meta
2060 });
2061 };
2062 module.exports = ConvertWorker;
2063
2064 },{"../utils":32,"./GenericWorker":28}],25:[function(require,module,exports){
2065 'use strict';
2066
2067 var GenericWorker = require('./GenericWorker');
2068 var crc32 = require('../crc32');
2069 var utils = require('../utils');
2070
2071 /**
2072 * A worker which calculate the crc32 of the data flowing through.
2073 * @constructor
2074 */
2075 function Crc32Probe() {
2076 GenericWorker.call(this, "Crc32Probe");
2077 this.withStreamInfo("crc32", 0);
2078 }
2079 utils.inherits(Crc32Probe, GenericWorker);
2080
2081 /**
2082 * @see GenericWorker.processChunk
2083 */
2084 Crc32Probe.prototype.processChunk = function (chunk) {
2085 this.streamInfo.crc32 = crc32(chunk.data, this.streamInfo.crc32 || 0);
2086 this.push(chunk);
2087 };
2088 module.exports = Crc32Probe;
2089
2090 },{"../crc32":4,"../utils":32,"./GenericWorker":28}],26:[function(require,module,exports){
2091 'use strict';
2092
2093 var utils = require('../utils');
2094 var GenericWorker = require('./GenericWorker');
2095
2096 /**
2097 * A worker which calculate the total length of the data flowing through.
2098 * @constructor
2099 * @param {String} propName the name used to expose the length
2100 */
2101 function DataLengthProbe(propName) {
2102 GenericWorker.call(this, "DataLengthProbe for " + propName);
2103 this.propName = propName;
2104 this.withStreamInfo(propName, 0);
2105 }
2106 utils.inherits(DataLengthProbe, GenericWorker);
2107
2108 /**
2109 * @see GenericWorker.processChunk
2110 */
2111 DataLengthProbe.prototype.processChunk = function (chunk) {
2112 if(chunk) {
2113 var length = this.streamInfo[this.propName] || 0;
2114 this.streamInfo[this.propName] = length + chunk.data.length;
2115 }
2116 GenericWorker.prototype.processChunk.call(this, chunk);
2117 };
2118 module.exports = DataLengthProbe;
2119
2120
2121 },{"../utils":32,"./GenericWorker":28}],27:[function(require,module,exports){
2122 'use strict';
2123
2124 var utils = require('../utils');
2125 var GenericWorker = require('./GenericWorker');
2126
2127 // the size of the generated chunks
2128 // TODO expose this as a public variable
2129 var DEFAULT_BLOCK_SIZE = 16 * 1024;
2130
2131 /**
2132 * A worker that reads a content and emits chunks.
2133 * @constructor
2134 * @param {Promise} dataP the promise of the data to split
2135 */
2136 function DataWorker(dataP) {
2137 GenericWorker.call(this, "DataWorker");
2138 var self = this;
2139 this.dataIsReady = false;
2140 this.index = 0;
2141 this.max = 0;
2142 this.data = null;
2143 this.type = "";
2144
2145 this._tickScheduled = false;
2146
2147 dataP.then(function (data) {
2148 self.dataIsReady = true;
2149 self.data = data;
2150 self.max = data && data.length || 0;
2151 self.type = utils.getTypeOf(data);
2152 if(!self.isPaused) {
2153 self._tickAndRepeat();
2154 }
2155 }, function (e) {
2156 self.error(e);
2157 });
2158 }
2159
2160 utils.inherits(DataWorker, GenericWorker);
2161
2162 /**
2163 * @see GenericWorker.cleanUp
2164 */
2165 DataWorker.prototype.cleanUp = function () {
2166 GenericWorker.prototype.cleanUp.call(this);
2167 this.data = null;
2168 };
2169
2170 /**
2171 * @see GenericWorker.resume
2172 */
2173 DataWorker.prototype.resume = function () {
2174 if(!GenericWorker.prototype.resume.call(this)) {
2175 return false;
2176 }
2177
2178 if (!this._tickScheduled && this.dataIsReady) {
2179 this._tickScheduled = true;
2180 utils.delay(this._tickAndRepeat, [], this);
2181 }
2182 return true;
2183 };
2184
2185 /**
2186 * Trigger a tick a schedule an other call to this function.
2187 */
2188 DataWorker.prototype._tickAndRepeat = function() {
2189 this._tickScheduled = false;
2190 if(this.isPaused || this.isFinished) {
2191 return;
2192 }
2193 this._tick();
2194 if(!this.isFinished) {
2195 utils.delay(this._tickAndRepeat, [], this);
2196 this._tickScheduled = true;
2197 }
2198 };
2199
2200 /**
2201 * Read and push a chunk.
2202 */
2203 DataWorker.prototype._tick = function() {
2204
2205 if(this.isPaused || this.isFinished) {
2206 return false;
2207 }
2208
2209 var size = DEFAULT_BLOCK_SIZE;
2210 var data = null, nextIndex = Math.min(this.max, this.index + size);
2211 if (this.index >= this.max) {
2212 // EOF
2213 return this.end();
2214 } else {
2215 switch(this.type) {
2216 case "string":
2217 data = this.data.substring(this.index, nextIndex);
2218 break;
2219 case "uint8array":
2220 data = this.data.subarray(this.index, nextIndex);
2221 break;
2222 case "array":
2223 case "nodebuffer":
2224 data = this.data.slice(this.index, nextIndex);
2225 break;
2226 }
2227 this.index = nextIndex;
2228 return this.push({
2229 data : data,
2230 meta : {
2231 percent : this.max ? this.index / this.max * 100 : 0
2232 }
2233 });
2234 }
2235 };
2236
2237 module.exports = DataWorker;
2238
2239 },{"../utils":32,"./GenericWorker":28}],28:[function(require,module,exports){
2240 'use strict';
2241
2242 /**
2243 * A worker that does nothing but passing chunks to the next one. This is like
2244 * a nodejs stream but with some differences. On the good side :
2245 * - it works on IE 6-9 without any issue / polyfill
2246 * - it weights less than the full dependencies bundled with browserify
2247 * - it forwards errors (no need to declare an error handler EVERYWHERE)
2248 *
2249 * A chunk is an object with 2 attributes : `meta` and `data`. The former is an
2250 * object containing anything (`percent` for example), see each worker for more
2251 * details. The latter is the real data (String, Uint8Array, etc).
2252 *
2253 * @constructor
2254 * @param {String} name the name of the stream (mainly used for debugging purposes)
2255 */
2256 function GenericWorker(name) {
2257 // the name of the worker
2258 this.name = name || "default";
2259 // an object containing metadata about the workers chain
2260 this.streamInfo = {};
2261 // an error which happened when the worker was paused
2262 this.generatedError = null;
2263 // an object containing metadata to be merged by this worker into the general metadata
2264 this.extraStreamInfo = {};
2265 // true if the stream is paused (and should not do anything), false otherwise
2266 this.isPaused = true;
2267 // true if the stream is finished (and should not do anything), false otherwise
2268 this.isFinished = false;
2269 // true if the stream is locked to prevent further structure updates (pipe), false otherwise
2270 this.isLocked = false;
2271 // the event listeners
2272 this._listeners = {
2273 'data':[],
2274 'end':[],
2275 'error':[]
2276 };
2277 // the previous worker, if any
2278 this.previous = null;
2279 }
2280
2281 GenericWorker.prototype = {
2282 /**
2283 * Push a chunk to the next workers.
2284 * @param {Object} chunk the chunk to push
2285 */
2286 push : function (chunk) {
2287 this.emit("data", chunk);
2288 },
2289 /**
2290 * End the stream.
2291 * @return {Boolean} true if this call ended the worker, false otherwise.
2292 */
2293 end : function () {
2294 if (this.isFinished) {
2295 return false;
2296 }
2297
2298 this.flush();
2299 try {
2300 this.emit("end");
2301 this.cleanUp();
2302 this.isFinished = true;
2303 } catch (e) {
2304 this.emit("error", e);
2305 }
2306 return true;
2307 },
2308 /**
2309 * End the stream with an error.
2310 * @param {Error} e the error which caused the premature end.
2311 * @return {Boolean} true if this call ended the worker with an error, false otherwise.
2312 */
2313 error : function (e) {
2314 if (this.isFinished) {
2315 return false;
2316 }
2317
2318 if(this.isPaused) {
2319 this.generatedError = e;
2320 } else {
2321 this.isFinished = true;
2322
2323 this.emit("error", e);
2324
2325 // in the workers chain exploded in the middle of the chain,
2326 // the error event will go downward but we also need to notify
2327 // workers upward that there has been an error.
2328 if(this.previous) {
2329 this.previous.error(e);
2330 }
2331
2332 this.cleanUp();
2333 }
2334 return true;
2335 },
2336 /**
2337 * Add a callback on an event.
2338 * @param {String} name the name of the event (data, end, error)
2339 * @param {Function} listener the function to call when the event is triggered
2340 * @return {GenericWorker} the current object for chainability
2341 */
2342 on : function (name, listener) {
2343 this._listeners[name].push(listener);
2344 return this;
2345 },
2346 /**
2347 * Clean any references when a worker is ending.
2348 */
2349 cleanUp : function () {
2350 this.streamInfo = this.generatedError = this.extraStreamInfo = null;
2351 this._listeners = [];
2352 },
2353 /**
2354 * Trigger an event. This will call registered callback with the provided arg.
2355 * @param {String} name the name of the event (data, end, error)
2356 * @param {Object} arg the argument to call the callback with.
2357 */
2358 emit : function (name, arg) {
2359 if (this._listeners[name]) {
2360 for(var i = 0; i < this._listeners[name].length; i++) {
2361 this._listeners[name][i].call(this, arg);
2362 }
2363 }
2364 },
2365 /**
2366 * Chain a worker with an other.
2367 * @param {Worker} next the worker receiving events from the current one.
2368 * @return {worker} the next worker for chainability
2369 */
2370 pipe : function (next) {
2371 return next.registerPrevious(this);
2372 },
2373 /**
2374 * Same as `pipe` in the other direction.
2375 * Using an API with `pipe(next)` is very easy.
2376 * Implementing the API with the point of view of the next one registering
2377 * a source is easier, see the ZipFileWorker.
2378 * @param {Worker} previous the previous worker, sending events to this one
2379 * @return {Worker} the current worker for chainability
2380 */
2381 registerPrevious : function (previous) {
2382 if (this.isLocked) {
2383 throw new Error("The stream '" + this + "' has already been used.");
2384 }
2385
2386 // sharing the streamInfo...
2387 this.streamInfo = previous.streamInfo;
2388 // ... and adding our own bits
2389 this.mergeStreamInfo();
2390 this.previous = previous;
2391 var self = this;
2392 previous.on('data', function (chunk) {
2393 self.processChunk(chunk);
2394 });
2395 previous.on('end', function () {
2396 self.end();
2397 });
2398 previous.on('error', function (e) {
2399 self.error(e);
2400 });
2401 return this;
2402 },
2403 /**
2404 * Pause the stream so it doesn't send events anymore.
2405 * @return {Boolean} true if this call paused the worker, false otherwise.
2406 */
2407 pause : function () {
2408 if(this.isPaused || this.isFinished) {
2409 return false;
2410 }
2411 this.isPaused = true;
2412
2413 if(this.previous) {
2414 this.previous.pause();
2415 }
2416 return true;
2417 },
2418 /**
2419 * Resume a paused stream.
2420 * @return {Boolean} true if this call resumed the worker, false otherwise.
2421 */
2422 resume : function () {
2423 if(!this.isPaused || this.isFinished) {
2424 return false;
2425 }
2426 this.isPaused = false;
2427
2428 // if true, the worker tried to resume but failed
2429 var withError = false;
2430 if(this.generatedError) {
2431 this.error(this.generatedError);
2432 withError = true;
2433 }
2434 if(this.previous) {
2435 this.previous.resume();
2436 }
2437
2438 return !withError;
2439 },
2440 /**
2441 * Flush any remaining bytes as the stream is ending.
2442 */
2443 flush : function () {},
2444 /**
2445 * Process a chunk. This is usually the method overridden.
2446 * @param {Object} chunk the chunk to process.
2447 */
2448 processChunk : function(chunk) {
2449 this.push(chunk);
2450 },
2451 /**
2452 * Add a key/value to be added in the workers chain streamInfo once activated.
2453 * @param {String} key the key to use
2454 * @param {Object} value the associated value
2455 * @return {Worker} the current worker for chainability
2456 */
2457 withStreamInfo : function (key, value) {
2458 this.extraStreamInfo[key] = value;
2459 this.mergeStreamInfo();
2460 return this;
2461 },
2462 /**
2463 * Merge this worker's streamInfo into the chain's streamInfo.
2464 */
2465 mergeStreamInfo : function () {
2466 for(var key in this.extraStreamInfo) {
2467 if (!this.extraStreamInfo.hasOwnProperty(key)) {
2468 continue;
2469 }
2470 this.streamInfo[key] = this.extraStreamInfo[key];
2471 }
2472 },
2473
2474 /**
2475 * Lock the stream to prevent further updates on the workers chain.
2476 * After calling this method, all calls to pipe will fail.
2477 */
2478 lock: function () {
2479 if (this.isLocked) {
2480 throw new Error("The stream '" + this + "' has already been used.");
2481 }
2482 this.isLocked = true;
2483 if (this.previous) {
2484 this.previous.lock();
2485 }
2486 },
2487
2488 /**
2489 *
2490 * Pretty print the workers chain.
2491 */
2492 toString : function () {
2493 var me = "Worker " + this.name;
2494 if (this.previous) {
2495 return this.previous + " -> " + me;
2496 } else {
2497 return me;
2498 }
2499 }
2500 };
2501
2502 module.exports = GenericWorker;
2503
2504 },{}],29:[function(require,module,exports){
2505 'use strict';
2506
2507 var utils = require('../utils');
2508 var ConvertWorker = require('./ConvertWorker');
2509 var GenericWorker = require('./GenericWorker');
2510 var base64 = require('../base64');
2511 var support = require("../support");
2512 var external = require("../external");
2513
2514 var NodejsStreamOutputAdapter = null;
2515 if (support.nodestream) {
2516 try {
2517 NodejsStreamOutputAdapter = require('../nodejs/NodejsStreamOutputAdapter');
2518 } catch(e) {}
2519 }
2520
2521 /**
2522 * Apply the final transformation of the data. If the user wants a Blob for
2523 * example, it's easier to work with an U8intArray and finally do the
2524 * ArrayBuffer/Blob conversion.
2525 * @param {String} type the name of the final type
2526 * @param {String|Uint8Array|Buffer} content the content to transform
2527 * @param {String} mimeType the mime type of the content, if applicable.
2528 * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the content in the right format.
2529 */
2530 function transformZipOutput(type, content, mimeType) {
2531 switch(type) {
2532 case "blob" :
2533 return utils.newBlob(utils.transformTo("arraybuffer", content), mimeType);
2534 case "base64" :
2535 return base64.encode(content);
2536 default :
2537 return utils.transformTo(type, content);
2538 }
2539 }
2540
2541 /**
2542 * Concatenate an array of data of the given type.
2543 * @param {String} type the type of the data in the given array.
2544 * @param {Array} dataArray the array containing the data chunks to concatenate
2545 * @return {String|Uint8Array|Buffer} the concatenated data
2546 * @throws Error if the asked type is unsupported
2547 */
2548 function concat (type, dataArray) {
2549 var i, index = 0, res = null, totalLength = 0;
2550 for(i = 0; i < dataArray.length; i++) {
2551 totalLength += dataArray[i].length;
2552 }
2553 switch(type) {
2554 case "string":
2555 return dataArray.join("");
2556 case "array":
2557 return Array.prototype.concat.apply([], dataArray);
2558 case "uint8array":
2559 res = new Uint8Array(totalLength);
2560 for(i = 0; i < dataArray.length; i++) {
2561 res.set(dataArray[i], index);
2562 index += dataArray[i].length;
2563 }
2564 return res;
2565 case "nodebuffer":
2566 return Buffer.concat(dataArray);
2567 default:
2568 throw new Error("concat : unsupported type '" + type + "'");
2569 }
2570 }
2571
2572 /**
2573 * Listen a StreamHelper, accumulate its content and concatenate it into a
2574 * complete block.
2575 * @param {StreamHelper} helper the helper to use.
2576 * @param {Function} updateCallback a callback called on each update. Called
2577 * with one arg :
2578 * - the metadata linked to the update received.
2579 * @return Promise the promise for the accumulation.
2580 */
2581 function accumulate(helper, updateCallback) {
2582 return new external.Promise(function (resolve, reject){
2583 var dataArray = [];
2584 var chunkType = helper._internalType,
2585 resultType = helper._outputType,
2586 mimeType = helper._mimeType;
2587 helper
2588 .on('data', function (data, meta) {
2589 dataArray.push(data);
2590 if(updateCallback) {
2591 updateCallback(meta);
2592 }
2593 })
2594 .on('error', function(err) {
2595 dataArray = [];
2596 reject(err);
2597 })
2598 .on('end', function (){
2599 try {
2600 var result = transformZipOutput(resultType, concat(chunkType, dataArray), mimeType);
2601 resolve(result);
2602 } catch (e) {
2603 reject(e);
2604 }
2605 dataArray = [];
2606 })
2607 .resume();
2608 });
2609 }
2610
2611 /**
2612 * An helper to easily use workers outside of JSZip.
2613 * @constructor
2614 * @param {Worker} worker the worker to wrap
2615 * @param {String} outputType the type of data expected by the use
2616 * @param {String} mimeType the mime type of the content, if applicable.
2617 */
2618 function StreamHelper(worker, outputType, mimeType) {
2619 var internalType = outputType;
2620 switch(outputType) {
2621 case "blob":
2622 case "arraybuffer":
2623 internalType = "uint8array";
2624 break;
2625 case "base64":
2626 internalType = "string";
2627 break;
2628 }
2629
2630 try {
2631 // the type used internally
2632 this._internalType = internalType;
2633 // the type used to output results
2634 this._outputType = outputType;
2635 // the mime type
2636 this._mimeType = mimeType;
2637 utils.checkSupport(internalType);
2638 this._worker = worker.pipe(new ConvertWorker(internalType));
2639 // the last workers can be rewired without issues but we need to
2640 // prevent any updates on previous workers.
2641 worker.lock();
2642 } catch(e) {
2643 this._worker = new GenericWorker("error");
2644 this._worker.error(e);
2645 }
2646 }
2647
2648 StreamHelper.prototype = {
2649 /**
2650 * Listen a StreamHelper, accumulate its content and concatenate it into a
2651 * complete block.
2652 * @param {Function} updateCb the update callback.
2653 * @return Promise the promise for the accumulation.
2654 */
2655 accumulate : function (updateCb) {
2656 return accumulate(this, updateCb);
2657 },
2658 /**
2659 * Add a listener on an event triggered on a stream.
2660 * @param {String} evt the name of the event
2661 * @param {Function} fn the listener
2662 * @return {StreamHelper} the current helper.
2663 */
2664 on : function (evt, fn) {
2665 var self = this;
2666
2667 if(evt === "data") {
2668 this._worker.on(evt, function (chunk) {
2669 fn.call(self, chunk.data, chunk.meta);
2670 });
2671 } else {
2672 this._worker.on(evt, function () {
2673 utils.delay(fn, arguments, self);
2674 });
2675 }
2676 return this;
2677 },
2678 /**
2679 * Resume the flow of chunks.
2680 * @return {StreamHelper} the current helper.
2681 */
2682 resume : function () {
2683 utils.delay(this._worker.resume, [], this._worker);
2684 return this;
2685 },
2686 /**
2687 * Pause the flow of chunks.
2688 * @return {StreamHelper} the current helper.
2689 */
2690 pause : function () {
2691 this._worker.pause();
2692 return this;
2693 },
2694 /**
2695 * Return a nodejs stream for this helper.
2696 * @param {Function} updateCb the update callback.
2697 * @return {NodejsStreamOutputAdapter} the nodejs stream.
2698 */
2699 toNodejsStream : function (updateCb) {
2700 utils.checkSupport("nodestream");
2701 if (this._outputType !== "nodebuffer") {
2702 // an object stream containing blob/arraybuffer/uint8array/string
2703 // is strange and I don't know if it would be useful.
2704 // I you find this comment and have a good usecase, please open a
2705 // bug report !
2706 throw new Error(this._outputType + " is not supported by this method");
2707 }
2708
2709 return new NodejsStreamOutputAdapter(this, {
2710 objectMode : this._outputType !== "nodebuffer"
2711 }, updateCb);
2712 }
2713 };
2714
2715
2716 module.exports = StreamHelper;
2717
2718 },{"../base64":1,"../external":6,"../nodejs/NodejsStreamOutputAdapter":13,"../support":30,"../utils":32,"./ConvertWorker":24,"./GenericWorker":28}],30:[function(require,module,exports){
2719 'use strict';
2720
2721 exports.base64 = true;
2722 exports.array = true;
2723 exports.string = true;
2724 exports.arraybuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
2725 exports.nodebuffer = typeof Buffer !== "undefined";
2726 // contains true if JSZip can read/generate Uint8Array, false otherwise.
2727 exports.uint8array = typeof Uint8Array !== "undefined";
2728
2729 if (typeof ArrayBuffer === "undefined") {
2730 exports.blob = false;
2731 }
2732 else {
2733 var buffer = new ArrayBuffer(0);
2734 try {
2735 exports.blob = new Blob([buffer], {
2736 type: "application/zip"
2737 }).size === 0;
2738 }
2739 catch (e) {
2740 try {
2741 var Builder = self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder || self.MSBlobBuilder;
2742 var builder = new Builder();
2743 builder.append(buffer);
2744 exports.blob = builder.getBlob('application/zip').size === 0;
2745 }
2746 catch (e) {
2747 exports.blob = false;
2748 }
2749 }
2750 }
2751
2752 try {
2753 exports.nodestream = !!require('readable-stream').Readable;
2754 } catch(e) {
2755 exports.nodestream = false;
2756 }
2757
2758 },{"readable-stream":16}],31:[function(require,module,exports){
2759 'use strict';
2760
2761 var utils = require('./utils');
2762 var support = require('./support');
2763 var nodejsUtils = require('./nodejsUtils');
2764 var GenericWorker = require('./stream/GenericWorker');
2765
2766 /**
2767 * The following functions come from pako, from pako/lib/utils/strings
2768 * released under the MIT license, see pako https://github.com/nodeca/pako/
2769 */
2770
2771 // Table with utf8 lengths (calculated by first byte of sequence)
2772 // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
2773 // because max possible codepoint is 0x10ffff
2774 var _utf8len = new Array(256);
2775 for (var i=0; i<256; i++) {
2776 _utf8len[i] = (i >= 252 ? 6 : i >= 248 ? 5 : i >= 240 ? 4 : i >= 224 ? 3 : i >= 192 ? 2 : 1);
2777 }
2778 _utf8len[254]=_utf8len[254]=1; // Invalid sequence start
2779
2780 // convert string to array (typed, when possible)
2781 var string2buf = function (str) {
2782 var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
2783
2784 // count binary size
2785 for (m_pos = 0; m_pos < str_len; m_pos++) {
2786 c = str.charCodeAt(m_pos);
2787 if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) {
2788 c2 = str.charCodeAt(m_pos+1);
2789 if ((c2 & 0xfc00) === 0xdc00) {
2790 c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
2791 m_pos++;
2792 }
2793 }
2794 buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
2795 }
2796
2797 // allocate buffer
2798 if (support.uint8array) {
2799 buf = new Uint8Array(buf_len);
2800 } else {
2801 buf = new Array(buf_len);
2802 }
2803
2804 // convert
2805 for (i=0, m_pos = 0; i < buf_len; m_pos++) {
2806 c = str.charCodeAt(m_pos);
2807 if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) {
2808 c2 = str.charCodeAt(m_pos+1);
2809 if ((c2 & 0xfc00) === 0xdc00) {
2810 c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
2811 m_pos++;
2812 }
2813 }
2814 if (c < 0x80) {
2815 /* one byte */
2816 buf[i++] = c;
2817 } else if (c < 0x800) {
2818 /* two bytes */
2819 buf[i++] = 0xC0 | (c >>> 6);
2820 buf[i++] = 0x80 | (c & 0x3f);
2821 } else if (c < 0x10000) {
2822 /* three bytes */
2823 buf[i++] = 0xE0 | (c >>> 12);
2824 buf[i++] = 0x80 | (c >>> 6 & 0x3f);
2825 buf[i++] = 0x80 | (c & 0x3f);
2826 } else {
2827 /* four bytes */
2828 buf[i++] = 0xf0 | (c >>> 18);
2829 buf[i++] = 0x80 | (c >>> 12 & 0x3f);
2830 buf[i++] = 0x80 | (c >>> 6 & 0x3f);
2831 buf[i++] = 0x80 | (c & 0x3f);
2832 }
2833 }
2834
2835 return buf;
2836 };
2837
2838 // Calculate max possible position in utf8 buffer,
2839 // that will not break sequence. If that's not possible
2840 // - (very small limits) return max size as is.
2841 //
2842 // buf[] - utf8 bytes array
2843 // max - length limit (mandatory);
2844 var utf8border = function(buf, max) {
2845 var pos;
2846
2847 max = max || buf.length;
2848 if (max > buf.length) { max = buf.length; }
2849
2850 // go back from last position, until start of sequence found
2851 pos = max-1;
2852 while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }
2853
2854 // Fuckup - very small and broken sequence,
2855 // return max, because we should return something anyway.
2856 if (pos < 0) { return max; }
2857
2858 // If we came to start of buffer - that means vuffer is too small,
2859 // return max too.
2860 if (pos === 0) { return max; }
2861
2862 return (pos + _utf8len[buf[pos]] > max) ? pos : max;
2863 };
2864
2865 // convert array to string
2866 var buf2string = function (buf) {
2867 var str, i, out, c, c_len;
2868 var len = buf.length;
2869
2870 // Reserve max possible length (2 words per char)
2871 // NB: by unknown reasons, Array is significantly faster for
2872 // String.fromCharCode.apply than Uint16Array.
2873 var utf16buf = new Array(len*2);
2874
2875 for (out=0, i=0; i<len;) {
2876 c = buf[i++];
2877 // quick process ascii
2878 if (c < 0x80) { utf16buf[out++] = c; continue; }
2879
2880 c_len = _utf8len[c];
2881 // skip 5 & 6 byte codes
2882 if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len-1; continue; }
2883
2884 // apply mask on first byte
2885 c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
2886 // join the rest
2887 while (c_len > 1 && i < len) {
2888 c = (c << 6) | (buf[i++] & 0x3f);
2889 c_len--;
2890 }
2891
2892 // terminated by end of string?
2893 if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }
2894
2895 if (c < 0x10000) {
2896 utf16buf[out++] = c;
2897 } else {
2898 c -= 0x10000;
2899 utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);
2900 utf16buf[out++] = 0xdc00 | (c & 0x3ff);
2901 }
2902 }
2903
2904 // shrinkBuf(utf16buf, out)
2905 if (utf16buf.length !== out) {
2906 if(utf16buf.subarray) {
2907 utf16buf = utf16buf.subarray(0, out);
2908 } else {
2909 utf16buf.length = out;
2910 }
2911 }
2912
2913 // return String.fromCharCode.apply(null, utf16buf);
2914 return utils.applyFromCharCode(utf16buf);
2915 };
2916
2917
2918 // That's all for the pako functions.
2919
2920
2921 /**
2922 * Transform a javascript string into an array (typed if possible) of bytes,
2923 * UTF-8 encoded.
2924 * @param {String} str the string to encode
2925 * @return {Array|Uint8Array|Buffer} the UTF-8 encoded string.
2926 */
2927 exports.utf8encode = function utf8encode(str) {
2928 if (support.nodebuffer) {
2929 return nodejsUtils.newBufferFrom(str, "utf-8");
2930 }
2931
2932 return string2buf(str);
2933 };
2934
2935
2936 /**
2937 * Transform a bytes array (or a representation) representing an UTF-8 encoded
2938 * string into a javascript string.
2939 * @param {Array|Uint8Array|Buffer} buf the data de decode
2940 * @return {String} the decoded string.
2941 */
2942 exports.utf8decode = function utf8decode(buf) {
2943 if (support.nodebuffer) {
2944 return utils.transformTo("nodebuffer", buf).toString("utf-8");
2945 }
2946
2947 buf = utils.transformTo(support.uint8array ? "uint8array" : "array", buf);
2948
2949 return buf2string(buf);
2950 };
2951
2952 /**
2953 * A worker to decode utf8 encoded binary chunks into string chunks.
2954 * @constructor
2955 */
2956 function Utf8DecodeWorker() {
2957 GenericWorker.call(this, "utf-8 decode");
2958 // the last bytes if a chunk didn't end with a complete codepoint.
2959 this.leftOver = null;
2960 }
2961 utils.inherits(Utf8DecodeWorker, GenericWorker);
2962
2963 /**
2964 * @see GenericWorker.processChunk
2965 */
2966 Utf8DecodeWorker.prototype.processChunk = function (chunk) {
2967
2968 var data = utils.transformTo(support.uint8array ? "uint8array" : "array", chunk.data);
2969
2970 // 1st step, re-use what's left of the previous chunk
2971 if (this.leftOver && this.leftOver.length) {
2972 if(support.uint8array) {
2973 var previousData = data;
2974 data = new Uint8Array(previousData.length + this.leftOver.length);
2975 data.set(this.leftOver, 0);
2976 data.set(previousData, this.leftOver.length);
2977 } else {
2978 data = this.leftOver.concat(data);
2979 }
2980 this.leftOver = null;
2981 }
2982
2983 var nextBoundary = utf8border(data);
2984 var usableData = data;
2985 if (nextBoundary !== data.length) {
2986 if (support.uint8array) {
2987 usableData = data.subarray(0, nextBoundary);
2988 this.leftOver = data.subarray(nextBoundary, data.length);
2989 } else {
2990 usableData = data.slice(0, nextBoundary);
2991 this.leftOver = data.slice(nextBoundary, data.length);
2992 }
2993 }
2994
2995 this.push({
2996 data : exports.utf8decode(usableData),
2997 meta : chunk.meta
2998 });
2999 };
3000
3001 /**
3002 * @see GenericWorker.flush
3003 */
3004 Utf8DecodeWorker.prototype.flush = function () {
3005 if(this.leftOver && this.leftOver.length) {
3006 this.push({
3007 data : exports.utf8decode(this.leftOver),
3008 meta : {}
3009 });
3010 this.leftOver = null;
3011 }
3012 };
3013 exports.Utf8DecodeWorker = Utf8DecodeWorker;
3014
3015 /**
3016 * A worker to endcode string chunks into utf8 encoded binary chunks.
3017 * @constructor
3018 */
3019 function Utf8EncodeWorker() {
3020 GenericWorker.call(this, "utf-8 encode");
3021 }
3022 utils.inherits(Utf8EncodeWorker, GenericWorker);
3023
3024 /**
3025 * @see GenericWorker.processChunk
3026 */
3027 Utf8EncodeWorker.prototype.processChunk = function (chunk) {
3028 this.push({
3029 data : exports.utf8encode(chunk.data),
3030 meta : chunk.meta
3031 });
3032 };
3033 exports.Utf8EncodeWorker = Utf8EncodeWorker;
3034
3035 },{"./nodejsUtils":14,"./stream/GenericWorker":28,"./support":30,"./utils":32}],32:[function(require,module,exports){
3036 'use strict';
3037
3038 var support = require('./support');
3039 var base64 = require('./base64');
3040 var nodejsUtils = require('./nodejsUtils');
3041 var setImmediate = require('set-immediate-shim');
3042 var external = require("./external");
3043
3044
3045 /**
3046 * Convert a string that pass as a "binary string": it should represent a byte
3047 * array but may have > 255 char codes. Be sure to take only the first byte
3048 * and returns the byte array.
3049 * @param {String} str the string to transform.
3050 * @return {Array|Uint8Array} the string in a binary format.
3051 */
3052 function string2binary(str) {
3053 var result = null;
3054 if (support.uint8array) {
3055 result = new Uint8Array(str.length);
3056 } else {
3057 result = new Array(str.length);
3058 }
3059 return stringToArrayLike(str, result);
3060 }
3061
3062 /**
3063 * Create a new blob with the given content and the given type.
3064 * @param {String|ArrayBuffer} part the content to put in the blob. DO NOT use
3065 * an Uint8Array because the stock browser of android 4 won't accept it (it
3066 * will be silently converted to a string, "[object Uint8Array]").
3067 *
3068 * Use only ONE part to build the blob to avoid a memory leak in IE11 / Edge:
3069 * when a large amount of Array is used to create the Blob, the amount of
3070 * memory consumed is nearly 100 times the original data amount.
3071 *
3072 * @param {String} type the mime type of the blob.
3073 * @return {Blob} the created blob.
3074 */
3075 exports.newBlob = function(part, type) {
3076 exports.checkSupport("blob");
3077
3078 try {
3079 // Blob constructor
3080 return new Blob([part], {
3081 type: type
3082 });
3083 }
3084 catch (e) {
3085
3086 try {
3087 // deprecated, browser only, old way
3088 var Builder = self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder || self.MSBlobBuilder;
3089 var builder = new Builder();
3090 builder.append(part);
3091 return builder.getBlob(type);
3092 }
3093 catch (e) {
3094
3095 // well, fuck ?!
3096 throw new Error("Bug : can't construct the Blob.");
3097 }
3098 }
3099
3100
3101 };
3102 /**
3103 * The identity function.
3104 * @param {Object} input the input.
3105 * @return {Object} the same input.
3106 */
3107 function identity(input) {
3108 return input;
3109 }
3110
3111 /**
3112 * Fill in an array with a string.
3113 * @param {String} str the string to use.
3114 * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to fill in (will be mutated).
3115 * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated array.
3116 */
3117 function stringToArrayLike(str, array) {
3118 for (var i = 0; i < str.length; ++i) {
3119 array[i] = str.charCodeAt(i) & 0xFF;
3120 }
3121 return array;
3122 }
3123
3124 /**
3125 * An helper for the function arrayLikeToString.
3126 * This contains static information and functions that
3127 * can be optimized by the browser JIT compiler.
3128 */
3129 var arrayToStringHelper = {
3130 /**
3131 * Transform an array of int into a string, chunk by chunk.
3132 * See the performances notes on arrayLikeToString.
3133 * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
3134 * @param {String} type the type of the array.
3135 * @param {Integer} chunk the chunk size.
3136 * @return {String} the resulting string.
3137 * @throws Error if the chunk is too big for the stack.
3138 */
3139 stringifyByChunk: function(array, type, chunk) {
3140 var result = [], k = 0, len = array.length;
3141 // shortcut
3142 if (len <= chunk) {
3143 return String.fromCharCode.apply(null, array);
3144 }
3145 while (k < len) {
3146 if (type === "array" || type === "nodebuffer") {
3147 result.push(String.fromCharCode.apply(null, array.slice(k, Math.min(k + chunk, len))));
3148 }
3149 else {
3150 result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len))));
3151 }
3152 k += chunk;
3153 }
3154 return result.join("");
3155 },
3156 /**
3157 * Call String.fromCharCode on every item in the array.
3158 * This is the naive implementation, which generate A LOT of intermediate string.
3159 * This should be used when everything else fail.
3160 * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
3161 * @return {String} the result.
3162 */
3163 stringifyByChar: function(array){
3164 var resultStr = "";
3165 for(var i = 0; i < array.length; i++) {
3166 resultStr += String.fromCharCode(array[i]);
3167 }
3168 return resultStr;
3169 },
3170 applyCanBeUsed : {
3171 /**
3172 * true if the browser accepts to use String.fromCharCode on Uint8Array
3173 */
3174 uint8array : (function () {
3175 try {
3176 return support.uint8array && String.fromCharCode.apply(null, new Uint8Array(1)).length === 1;
3177 } catch (e) {
3178 return false;
3179 }
3180 })(),
3181 /**
3182 * true if the browser accepts to use String.fromCharCode on nodejs Buffer.
3183 */
3184 nodebuffer : (function () {
3185 try {
3186 return support.nodebuffer && String.fromCharCode.apply(null, nodejsUtils.allocBuffer(1)).length === 1;
3187 } catch (e) {
3188 return false;
3189 }
3190 })()
3191 }
3192 };
3193
3194 /**
3195 * Transform an array-like object to a string.
3196 * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
3197 * @return {String} the result.
3198 */
3199 function arrayLikeToString(array) {
3200 // Performances notes :
3201 // --------------------
3202 // String.fromCharCode.apply(null, array) is the fastest, see
3203 // see http://jsperf.com/converting-a-uint8array-to-a-string/2
3204 // but the stack is limited (and we can get huge arrays !).
3205 //
3206 // result += String.fromCharCode(array[i]); generate too many strings !
3207 //
3208 // This code is inspired by http://jsperf.com/arraybuffer-to-string-apply-performance/2
3209 // TODO : we now have workers that split the work. Do we still need that ?
3210 var chunk = 65536,
3211 type = exports.getTypeOf(array),
3212 canUseApply = true;
3213 if (type === "uint8array") {
3214 canUseApply = arrayToStringHelper.applyCanBeUsed.uint8array;
3215 } else if (type === "nodebuffer") {
3216 canUseApply = arrayToStringHelper.applyCanBeUsed.nodebuffer;
3217 }
3218
3219 if (canUseApply) {
3220 while (chunk > 1) {
3221 try {
3222 return arrayToStringHelper.stringifyByChunk(array, type, chunk);
3223 } catch (e) {
3224 chunk = Math.floor(chunk / 2);
3225 }
3226 }
3227 }
3228
3229 // no apply or chunk error : slow and painful algorithm
3230 // default browser on android 4.*
3231 return arrayToStringHelper.stringifyByChar(array);
3232 }
3233
3234 exports.applyFromCharCode = arrayLikeToString;
3235
3236
3237 /**
3238 * Copy the data from an array-like to an other array-like.
3239 * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayFrom the origin array.
3240 * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayTo the destination array which will be mutated.
3241 * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated destination array.
3242 */
3243 function arrayLikeToArrayLike(arrayFrom, arrayTo) {
3244 for (var i = 0; i < arrayFrom.length; i++) {
3245 arrayTo[i] = arrayFrom[i];
3246 }
3247 return arrayTo;
3248 }
3249
3250 // a matrix containing functions to transform everything into everything.
3251 var transform = {};
3252
3253 // string to ?
3254 transform["string"] = {
3255 "string": identity,
3256 "array": function(input) {
3257 return stringToArrayLike(input, new Array(input.length));
3258 },
3259 "arraybuffer": function(input) {
3260 return transform["string"]["uint8array"](input).buffer;
3261 },
3262 "uint8array": function(input) {
3263 return stringToArrayLike(input, new Uint8Array(input.length));
3264 },
3265 "nodebuffer": function(input) {
3266 return stringToArrayLike(input, nodejsUtils.allocBuffer(input.length));
3267 }
3268 };
3269
3270 // array to ?
3271 transform["array"] = {
3272 "string": arrayLikeToString,
3273 "array": identity,
3274 "arraybuffer": function(input) {
3275 return (new Uint8Array(input)).buffer;
3276 },
3277 "uint8array": function(input) {
3278 return new Uint8Array(input);
3279 },
3280 "nodebuffer": function(input) {
3281 return nodejsUtils.newBufferFrom(input);
3282 }
3283 };
3284
3285 // arraybuffer to ?
3286 transform["arraybuffer"] = {
3287 "string": function(input) {
3288 return arrayLikeToString(new Uint8Array(input));
3289 },
3290 "array": function(input) {
3291 return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength));
3292 },
3293 "arraybuffer": identity,
3294 "uint8array": function(input) {
3295 return new Uint8Array(input);
3296 },
3297 "nodebuffer": function(input) {
3298 return nodejsUtils.newBufferFrom(new Uint8Array(input));
3299 }
3300 };
3301
3302 // uint8array to ?
3303 transform["uint8array"] = {
3304 "string": arrayLikeToString,
3305 "array": function(input) {
3306 return arrayLikeToArrayLike(input, new Array(input.length));
3307 },
3308 "arraybuffer": function(input) {
3309 return input.buffer;
3310 },
3311 "uint8array": identity,
3312 "nodebuffer": function(input) {
3313 return nodejsUtils.newBufferFrom(input);
3314 }
3315 };
3316
3317 // nodebuffer to ?
3318 transform["nodebuffer"] = {
3319 "string": arrayLikeToString,
3320 "array": function(input) {
3321 return arrayLikeToArrayLike(input, new Array(input.length));
3322 },
3323 "arraybuffer": function(input) {
3324 return transform["nodebuffer"]["uint8array"](input).buffer;
3325 },
3326 "uint8array": function(input) {
3327 return arrayLikeToArrayLike(input, new Uint8Array(input.length));
3328 },
3329 "nodebuffer": identity
3330 };
3331
3332 /**
3333 * Transform an input into any type.
3334 * The supported output type are : string, array, uint8array, arraybuffer, nodebuffer.
3335 * If no output type is specified, the unmodified input will be returned.
3336 * @param {String} outputType the output type.
3337 * @param {String|Array|ArrayBuffer|Uint8Array|Buffer} input the input to convert.
3338 * @throws {Error} an Error if the browser doesn't support the requested output type.
3339 */
3340 exports.transformTo = function(outputType, input) {
3341 if (!input) {
3342 // undefined, null, etc
3343 // an empty string won't harm.
3344 input = "";
3345 }
3346 if (!outputType) {
3347 return input;
3348 }
3349 exports.checkSupport(outputType);
3350 var inputType = exports.getTypeOf(input);
3351 var result = transform[inputType][outputType](input);
3352 return result;
3353 };
3354
3355 /**
3356 * Return the type of the input.
3357 * The type will be in a format valid for JSZip.utils.transformTo : string, array, uint8array, arraybuffer.
3358 * @param {Object} input the input to identify.
3359 * @return {String} the (lowercase) type of the input.
3360 */
3361 exports.getTypeOf = function(input) {
3362 if (typeof input === "string") {
3363 return "string";
3364 }
3365 if (Object.prototype.toString.call(input) === "[object Array]") {
3366 return "array";
3367 }
3368 if (support.nodebuffer && nodejsUtils.isBuffer(input)) {
3369 return "nodebuffer";
3370 }
3371 if (support.uint8array && input instanceof Uint8Array) {
3372 return "uint8array";
3373 }
3374 if (support.arraybuffer && input instanceof ArrayBuffer) {
3375 return "arraybuffer";
3376 }
3377 };
3378
3379 /**
3380 * Throw an exception if the type is not supported.
3381 * @param {String} type the type to check.
3382 * @throws {Error} an Error if the browser doesn't support the requested type.
3383 */
3384 exports.checkSupport = function(type) {
3385 var supported = support[type.toLowerCase()];
3386 if (!supported) {
3387 throw new Error(type + " is not supported by this platform");
3388 }
3389 };
3390
3391 exports.MAX_VALUE_16BITS = 65535;
3392 exports.MAX_VALUE_32BITS = -1; // well, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF" is parsed as -1
3393
3394 /**
3395 * Prettify a string read as binary.
3396 * @param {string} str the string to prettify.
3397 * @return {string} a pretty string.
3398 */
3399 exports.pretty = function(str) {
3400 var res = '',
3401 code, i;
3402 for (i = 0; i < (str || "").length; i++) {
3403 code = str.charCodeAt(i);
3404 res += '\\x' + (code < 16 ? "0" : "") + code.toString(16).toUpperCase();
3405 }
3406 return res;
3407 };
3408
3409 /**
3410 * Defer the call of a function.
3411 * @param {Function} callback the function to call asynchronously.
3412 * @param {Array} args the arguments to give to the callback.
3413 */
3414 exports.delay = function(callback, args, self) {
3415 setImmediate(function () {
3416 callback.apply(self || null, args || []);
3417 });
3418 };
3419
3420 /**
3421 * Extends a prototype with an other, without calling a constructor with
3422 * side effects. Inspired by nodejs' `utils.inherits`
3423 * @param {Function} ctor the constructor to augment
3424 * @param {Function} superCtor the parent constructor to use
3425 */
3426 exports.inherits = function (ctor, superCtor) {
3427 var Obj = function() {};
3428 Obj.prototype = superCtor.prototype;
3429 ctor.prototype = new Obj();
3430 };
3431
3432 /**
3433 * Merge the objects passed as parameters into a new one.
3434 * @private
3435 * @param {...Object} var_args All objects to merge.
3436 * @return {Object} a new object with the data of the others.
3437 */
3438 exports.extend = function() {
3439 var result = {}, i, attr;
3440 for (i = 0; i < arguments.length; i++) { // arguments is not enumerable in some browsers
3441 for (attr in arguments[i]) {
3442 if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") {
3443 result[attr] = arguments[i][attr];
3444 }
3445 }
3446 }
3447 return result;
3448 };
3449
3450 /**
3451 * Transform arbitrary content into a Promise.
3452 * @param {String} name a name for the content being processed.
3453 * @param {Object} inputData the content to process.
3454 * @param {Boolean} isBinary true if the content is not an unicode string
3455 * @param {Boolean} isOptimizedBinaryString true if the string content only has one byte per character.
3456 * @param {Boolean} isBase64 true if the string content is encoded with base64.
3457 * @return {Promise} a promise in a format usable by JSZip.
3458 */
3459 exports.prepareContent = function(name, inputData, isBinary, isOptimizedBinaryString, isBase64) {
3460
3461 // if inputData is already a promise, this flatten it.
3462 var promise = external.Promise.resolve(inputData).then(function(data) {
3463
3464
3465 var isBlob = support.blob && (data instanceof Blob || ['[object File]', '[object Blob]'].indexOf(Object.prototype.toString.call(data)) !== -1);
3466
3467 if (isBlob && typeof FileReader !== "undefined") {
3468 return new external.Promise(function (resolve, reject) {
3469 var reader = new FileReader();
3470
3471 reader.onload = function(e) {
3472 resolve(e.target.result);
3473 };
3474 reader.onerror = function(e) {
3475 reject(e.target.error);
3476 };
3477 reader.readAsArrayBuffer(data);
3478 });
3479 } else {
3480 return data;
3481 }
3482 });
3483
3484 return promise.then(function(data) {
3485 var dataType = exports.getTypeOf(data);
3486
3487 if (!dataType) {
3488 return external.Promise.reject(
3489 new Error("Can't read the data of '" + name + "'. Is it " +
3490 "in a supported JavaScript type (String, Blob, ArrayBuffer, etc) ?")
3491 );
3492 }
3493 // special case : it's way easier to work with Uint8Array than with ArrayBuffer
3494 if (dataType === "arraybuffer") {
3495 data = exports.transformTo("uint8array", data);
3496 } else if (dataType === "string") {
3497 if (isBase64) {
3498 data = base64.decode(data);
3499 }
3500 else if (isBinary) {
3501 // optimizedBinaryString === true means that the file has already been filtered with a 0xFF mask
3502 if (isOptimizedBinaryString !== true) {
3503 // this is a string, not in a base64 format.
3504 // Be sure that this is a correct "binary string"
3505 data = string2binary(data);
3506 }
3507 }
3508 }
3509 return data;
3510 });
3511 };
3512
3513 },{"./base64":1,"./external":6,"./nodejsUtils":14,"./support":30,"set-immediate-shim":54}],33:[function(require,module,exports){
3514 'use strict';
3515 var readerFor = require('./reader/readerFor');
3516 var utils = require('./utils');
3517 var sig = require('./signature');
3518 var ZipEntry = require('./zipEntry');
3519 var utf8 = require('./utf8');
3520 var support = require('./support');
3521 // class ZipEntries {{{
3522 /**
3523 * All the entries in the zip file.
3524 * @constructor
3525 * @param {Object} loadOptions Options for loading the stream.
3526 */
3527 function ZipEntries(loadOptions) {
3528 this.files = [];
3529 this.loadOptions = loadOptions;
3530 }
3531 ZipEntries.prototype = {
3532 /**
3533 * Check that the reader is on the specified signature.
3534 * @param {string} expectedSignature the expected signature.
3535 * @throws {Error} if it is an other signature.
3536 */
3537 checkSignature: function(expectedSignature) {
3538 if (!this.reader.readAndCheckSignature(expectedSignature)) {
3539 this.reader.index -= 4;
3540 var signature = this.reader.readString(4);
3541 throw new Error("Corrupted zip or bug: unexpected signature " + "(" + utils.pretty(signature) + ", expected " + utils.pretty(expectedSignature) + ")");
3542 }
3543 },
3544 /**
3545 * Check if the given signature is at the given index.
3546 * @param {number} askedIndex the index to check.
3547 * @param {string} expectedSignature the signature to expect.
3548 * @return {boolean} true if the signature is here, false otherwise.
3549 */
3550 isSignature: function(askedIndex, expectedSignature) {
3551 var currentIndex = this.reader.index;
3552 this.reader.setIndex(askedIndex);
3553 var signature = this.reader.readString(4);
3554 var result = signature === expectedSignature;
3555 this.reader.setIndex(currentIndex);
3556 return result;
3557 },
3558 /**
3559 * Read the end of the central directory.
3560 */
3561 readBlockEndOfCentral: function() {
3562 this.diskNumber = this.reader.readInt(2);
3563 this.diskWithCentralDirStart = this.reader.readInt(2);
3564 this.centralDirRecordsOnThisDisk = this.reader.readInt(2);
3565 this.centralDirRecords = this.reader.readInt(2);
3566 this.centralDirSize = this.reader.readInt(4);
3567 this.centralDirOffset = this.reader.readInt(4);
3568
3569 this.zipCommentLength = this.reader.readInt(2);
3570 // warning : the encoding depends of the system locale
3571 // On a linux machine with LANG=en_US.utf8, this field is utf8 encoded.
3572 // On a windows machine, this field is encoded with the localized windows code page.
3573 var zipComment = this.reader.readData(this.zipCommentLength);
3574 var decodeParamType = support.uint8array ? "uint8array" : "array";
3575 // To get consistent behavior with the generation part, we will assume that
3576 // this is utf8 encoded unless specified otherwise.
3577 var decodeContent = utils.transformTo(decodeParamType, zipComment);
3578 this.zipComment = this.loadOptions.decodeFileName(decodeContent);
3579 },
3580 /**
3581 * Read the end of the Zip 64 central directory.
3582 * Not merged with the method readEndOfCentral :
3583 * The end of central can coexist with its Zip64 brother,
3584 * I don't want to read the wrong number of bytes !
3585 */
3586 readBlockZip64EndOfCentral: function() {
3587 this.zip64EndOfCentralSize = this.reader.readInt(8);
3588 this.reader.skip(4);
3589 // this.versionMadeBy = this.reader.readString(2);
3590 // this.versionNeeded = this.reader.readInt(2);
3591 this.diskNumber = this.reader.readInt(4);
3592 this.diskWithCentralDirStart = this.reader.readInt(4);
3593 this.centralDirRecordsOnThisDisk = this.reader.readInt(8);
3594 this.centralDirRecords = this.reader.readInt(8);
3595 this.centralDirSize = this.reader.readInt(8);
3596 this.centralDirOffset = this.reader.readInt(8);
3597
3598 this.zip64ExtensibleData = {};
3599 var extraDataSize = this.zip64EndOfCentralSize - 44,
3600 index = 0,
3601 extraFieldId,
3602 extraFieldLength,
3603 extraFieldValue;
3604 while (index < extraDataSize) {
3605 extraFieldId = this.reader.readInt(2);
3606 extraFieldLength = this.reader.readInt(4);
3607 extraFieldValue = this.reader.readData(extraFieldLength);
3608 this.zip64ExtensibleData[extraFieldId] = {
3609 id: extraFieldId,
3610 length: extraFieldLength,
3611 value: extraFieldValue
3612 };
3613 }
3614 },
3615 /**
3616 * Read the end of the Zip 64 central directory locator.
3617 */
3618 readBlockZip64EndOfCentralLocator: function() {
3619 this.diskWithZip64CentralDirStart = this.reader.readInt(4);
3620 this.relativeOffsetEndOfZip64CentralDir = this.reader.readInt(8);
3621 this.disksCount = this.reader.readInt(4);
3622 if (this.disksCount > 1) {
3623 throw new Error("Multi-volumes zip are not supported");
3624 }
3625 },
3626 /**
3627 * Read the local files, based on the offset read in the central part.
3628 */
3629 readLocalFiles: function() {
3630 var i, file;
3631 for (i = 0; i < this.files.length; i++) {
3632 file = this.files[i];
3633 this.reader.setIndex(file.localHeaderOffset);
3634 this.checkSignature(sig.LOCAL_FILE_HEADER);
3635 file.readLocalPart(this.reader);
3636 file.handleUTF8();
3637 file.processAttributes();
3638 }
3639 },
3640 /**
3641 * Read the central directory.
3642 */
3643 readCentralDir: function() {
3644 var file;
3645
3646 this.reader.setIndex(this.centralDirOffset);
3647 while (this.reader.readAndCheckSignature(sig.CENTRAL_FILE_HEADER)) {
3648 file = new ZipEntry({
3649 zip64: this.zip64
3650 }, this.loadOptions);
3651 file.readCentralPart(this.reader);
3652 this.files.push(file);
3653 }
3654
3655 if (this.centralDirRecords !== this.files.length) {
3656 if (this.centralDirRecords !== 0 && this.files.length === 0) {
3657 // We expected some records but couldn't find ANY.
3658 // This is really suspicious, as if something went wrong.
3659 throw new Error("Corrupted zip or bug: expected " + this.centralDirRecords + " records in central dir, got " + this.files.length);
3660 } else {
3661 // We found some records but not all.
3662 // Something is wrong but we got something for the user: no error here.
3663 // console.warn("expected", this.centralDirRecords, "records in central dir, got", this.files.length);
3664 }
3665 }
3666 },
3667 /**
3668 * Read the end of central directory.
3669 */
3670 readEndOfCentral: function() {
3671 var offset = this.reader.lastIndexOfSignature(sig.CENTRAL_DIRECTORY_END);
3672 if (offset < 0) {
3673 // Check if the content is a truncated zip or complete garbage.
3674 // A "LOCAL_FILE_HEADER" is not required at the beginning (auto
3675 // extractible zip for example) but it can give a good hint.
3676 // If an ajax request was used without responseType, we will also
3677 // get unreadable data.
3678 var isGarbage = !this.isSignature(0, sig.LOCAL_FILE_HEADER);
3679
3680 if (isGarbage) {
3681 throw new Error("Can't find end of central directory : is this a zip file ? " +
3682 "If it is, see https://stuk.github.io/jszip/documentation/howto/read_zip.html");
3683 } else {
3684 throw new Error("Corrupted zip: can't find end of central directory");
3685 }
3686
3687 }
3688 this.reader.setIndex(offset);
3689 var endOfCentralDirOffset = offset;
3690 this.checkSignature(sig.CENTRAL_DIRECTORY_END);
3691 this.readBlockEndOfCentral();
3692
3693
3694 /* extract from the zip spec :
3695 4) If one of the fields in the end of central directory
3696 record is too small to hold required data, the field
3697 should be set to -1 (0xFFFF or 0xFFFFFFFF) and the
3698 ZIP64 format record should be created.
3699 5) The end of central directory record and the
3700 Zip64 end of central directory locator record must
3701 reside on the same disk when splitting or spanning
3702 an archive.
3703 */
3704 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) {
3705 this.zip64 = true;
3706
3707 /*
3708 Warning : the zip64 extension is supported, but ONLY if the 64bits integer read from
3709 the zip file can fit into a 32bits integer. This cannot be solved : JavaScript represents
3710 all numbers as 64-bit double precision IEEE 754 floating point numbers.
3711 So, we have 53bits for integers and bitwise operations treat everything as 32bits.
3712 see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/Bitwise_Operators
3713 and http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf section 8.5
3714 */
3715
3716 // should look for a zip64 EOCD locator
3717 offset = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
3718 if (offset < 0) {
3719 throw new Error("Corrupted zip: can't find the ZIP64 end of central directory locator");
3720 }
3721 this.reader.setIndex(offset);
3722 this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
3723 this.readBlockZip64EndOfCentralLocator();
3724
3725 // now the zip64 EOCD record
3726 if (!this.isSignature(this.relativeOffsetEndOfZip64CentralDir, sig.ZIP64_CENTRAL_DIRECTORY_END)) {
3727 // console.warn("ZIP64 end of central directory not where expected.");
3728 this.relativeOffsetEndOfZip64CentralDir = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
3729 if (this.relativeOffsetEndOfZip64CentralDir < 0) {
3730 throw new Error("Corrupted zip: can't find the ZIP64 end of central directory");
3731 }
3732 }
3733 this.reader.setIndex(this.relativeOffsetEndOfZip64CentralDir);
3734 this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
3735 this.readBlockZip64EndOfCentral();
3736 }
3737
3738 var expectedEndOfCentralDirOffset = this.centralDirOffset + this.centralDirSize;
3739 if (this.zip64) {
3740 expectedEndOfCentralDirOffset += 20; // end of central dir 64 locator
3741 expectedEndOfCentralDirOffset += 12 /* should not include the leading 12 bytes */ + this.zip64EndOfCentralSize;
3742 }
3743
3744 var extraBytes = endOfCentralDirOffset - expectedEndOfCentralDirOffset;
3745
3746 if (extraBytes > 0) {
3747 // console.warn(extraBytes, "extra bytes at beginning or within zipfile");
3748 if (this.isSignature(endOfCentralDirOffset, sig.CENTRAL_FILE_HEADER)) {
3749 // The offsets seem wrong, but we have something at the specified offset.
3750 // So… we keep it.
3751 } else {
3752 // the offset is wrong, update the "zero" of the reader
3753 // this happens if data has been prepended (crx files for example)
3754 this.reader.zero = extraBytes;
3755 }
3756 } else if (extraBytes < 0) {
3757 throw new Error("Corrupted zip: missing " + Math.abs(extraBytes) + " bytes.");
3758 }
3759 },
3760 prepareReader: function(data) {
3761 this.reader = readerFor(data);
3762 },
3763 /**
3764 * Read a zip file and create ZipEntries.
3765 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the binary string representing a zip file.
3766 */
3767 load: function(data) {
3768 this.prepareReader(data);
3769 this.readEndOfCentral();
3770 this.readCentralDir();
3771 this.readLocalFiles();
3772 }
3773 };
3774 // }}} end of ZipEntries
3775 module.exports = ZipEntries;
3776
3777 },{"./reader/readerFor":22,"./signature":23,"./support":30,"./utf8":31,"./utils":32,"./zipEntry":34}],34:[function(require,module,exports){
3778 'use strict';
3779 var readerFor = require('./reader/readerFor');
3780 var utils = require('./utils');
3781 var CompressedObject = require('./compressedObject');
3782 var crc32fn = require('./crc32');
3783 var utf8 = require('./utf8');
3784 var compressions = require('./compressions');
3785 var support = require('./support');
3786
3787 var MADE_BY_DOS = 0x00;
3788 var MADE_BY_UNIX = 0x03;
3789
3790 /**
3791 * Find a compression registered in JSZip.
3792 * @param {string} compressionMethod the method magic to find.
3793 * @return {Object|null} the JSZip compression object, null if none found.
3794 */
3795 var findCompression = function(compressionMethod) {
3796 for (var method in compressions) {
3797 if (!compressions.hasOwnProperty(method)) {
3798 continue;
3799 }
3800 if (compressions[method].magic === compressionMethod) {
3801 return compressions[method];
3802 }
3803 }
3804 return null;
3805 };
3806
3807 // class ZipEntry {{{
3808 /**
3809 * An entry in the zip file.
3810 * @constructor
3811 * @param {Object} options Options of the current file.
3812 * @param {Object} loadOptions Options for loading the stream.
3813 */
3814 function ZipEntry(options, loadOptions) {
3815 this.options = options;
3816 this.loadOptions = loadOptions;
3817 }
3818 ZipEntry.prototype = {
3819 /**
3820 * say if the file is encrypted.
3821 * @return {boolean} true if the file is encrypted, false otherwise.
3822 */
3823 isEncrypted: function() {
3824 // bit 1 is set
3825 return (this.bitFlag & 0x0001) === 0x0001;
3826 },
3827 /**
3828 * say if the file has utf-8 filename/comment.
3829 * @return {boolean} true if the filename/comment is in utf-8, false otherwise.
3830 */
3831 useUTF8: function() {
3832 // bit 11 is set
3833 return (this.bitFlag & 0x0800) === 0x0800;
3834 },
3835 /**
3836 * Read the local part of a zip file and add the info in this object.
3837 * @param {DataReader} reader the reader to use.
3838 */
3839 readLocalPart: function(reader) {
3840 var compression, localExtraFieldsLength;
3841
3842 // we already know everything from the central dir !
3843 // If the central dir data are false, we are doomed.
3844 // On the bright side, the local part is scary : zip64, data descriptors, both, etc.
3845 // The less data we get here, the more reliable this should be.
3846 // Let's skip the whole header and dash to the data !
3847 reader.skip(22);
3848 // in some zip created on windows, the filename stored in the central dir contains \ instead of /.
3849 // Strangely, the filename here is OK.
3850 // I would love to treat these zip files as corrupted (see http://www.info-zip.org/FAQ.html#backslashes
3851 // or APPNOTE#4.4.17.1, "All slashes MUST be forward slashes '/'") but there are a lot of bad zip generators...
3852 // Search "unzip mismatching "local" filename continuing with "central" filename version" on
3853 // the internet.
3854 //
3855 // I think I see the logic here : the central directory is used to display
3856 // content and the local directory is used to extract the files. Mixing / and \
3857 // may be used to display \ to windows users and use / when extracting the files.
3858 // Unfortunately, this lead also to some issues : http://seclists.org/fulldisclosure/2009/Sep/394
3859 this.fileNameLength = reader.readInt(2);
3860 localExtraFieldsLength = reader.readInt(2); // can't be sure this will be the same as the central dir
3861 // the fileName is stored as binary data, the handleUTF8 method will take care of the encoding.
3862 this.fileName = reader.readData(this.fileNameLength);
3863 reader.skip(localExtraFieldsLength);
3864
3865 if (this.compressedSize === -1 || this.uncompressedSize === -1) {
3866 throw new Error("Bug or corrupted zip : didn't get enough information from the central directory " + "(compressedSize === -1 || uncompressedSize === -1)");
3867 }
3868
3869 compression = findCompression(this.compressionMethod);
3870 if (compression === null) { // no compression found
3871 throw new Error("Corrupted zip : compression " + utils.pretty(this.compressionMethod) + " unknown (inner file : " + utils.transformTo("string", this.fileName) + ")");
3872 }
3873 this.decompressed = new CompressedObject(this.compressedSize, this.uncompressedSize, this.crc32, compression, reader.readData(this.compressedSize));
3874 },
3875
3876 /**
3877 * Read the central part of a zip file and add the info in this object.
3878 * @param {DataReader} reader the reader to use.
3879 */
3880 readCentralPart: function(reader) {
3881 this.versionMadeBy = reader.readInt(2);
3882 reader.skip(2);
3883 // this.versionNeeded = reader.readInt(2);
3884 this.bitFlag = reader.readInt(2);
3885 this.compressionMethod = reader.readString(2);
3886 this.date = reader.readDate();
3887 this.crc32 = reader.readInt(4);
3888 this.compressedSize = reader.readInt(4);
3889 this.uncompressedSize = reader.readInt(4);
3890 var fileNameLength = reader.readInt(2);
3891 this.extraFieldsLength = reader.readInt(2);
3892 this.fileCommentLength = reader.readInt(2);
3893 this.diskNumberStart = reader.readInt(2);
3894 this.internalFileAttributes = reader.readInt(2);
3895 this.externalFileAttributes = reader.readInt(4);
3896 this.localHeaderOffset = reader.readInt(4);
3897
3898 if (this.isEncrypted()) {
3899 throw new Error("Encrypted zip are not supported");
3900 }
3901
3902 // will be read in the local part, see the comments there
3903 reader.skip(fileNameLength);
3904 this.readExtraFields(reader);
3905 this.parseZIP64ExtraField(reader);
3906 this.fileComment = reader.readData(this.fileCommentLength);
3907 },
3908
3909 /**
3910 * Parse the external file attributes and get the unix/dos permissions.
3911 */
3912 processAttributes: function () {
3913 this.unixPermissions = null;
3914 this.dosPermissions = null;
3915 var madeBy = this.versionMadeBy >> 8;
3916
3917 // Check if we have the DOS directory flag set.
3918 // We look for it in the DOS and UNIX permissions
3919 // but some unknown platform could set it as a compatibility flag.
3920 this.dir = this.externalFileAttributes & 0x0010 ? true : false;
3921
3922 if(madeBy === MADE_BY_DOS) {
3923 // first 6 bits (0 to 5)
3924 this.dosPermissions = this.externalFileAttributes & 0x3F;
3925 }
3926
3927 if(madeBy === MADE_BY_UNIX) {
3928 this.unixPermissions = (this.externalFileAttributes >> 16) & 0xFFFF;
3929 // the octal permissions are in (this.unixPermissions & 0x01FF).toString(8);
3930 }
3931
3932 // fail safe : if the name ends with a / it probably means a folder
3933 if (!this.dir && this.fileNameStr.slice(-1) === '/') {
3934 this.dir = true;
3935 }
3936 },
3937
3938 /**
3939 * Parse the ZIP64 extra field and merge the info in the current ZipEntry.
3940 * @param {DataReader} reader the reader to use.
3941 */
3942 parseZIP64ExtraField: function(reader) {
3943
3944 if (!this.extraFields[0x0001]) {
3945 return;
3946 }
3947
3948 // should be something, preparing the extra reader
3949 var extraReader = readerFor(this.extraFields[0x0001].value);
3950
3951 // I really hope that these 64bits integer can fit in 32 bits integer, because js
3952 // won't let us have more.
3953 if (this.uncompressedSize === utils.MAX_VALUE_32BITS) {
3954 this.uncompressedSize = extraReader.readInt(8);
3955 }
3956 if (this.compressedSize === utils.MAX_VALUE_32BITS) {
3957 this.compressedSize = extraReader.readInt(8);
3958 }
3959 if (this.localHeaderOffset === utils.MAX_VALUE_32BITS) {
3960 this.localHeaderOffset = extraReader.readInt(8);
3961 }
3962 if (this.diskNumberStart === utils.MAX_VALUE_32BITS) {
3963 this.diskNumberStart = extraReader.readInt(4);
3964 }
3965 },
3966 /**
3967 * Read the central part of a zip file and add the info in this object.
3968 * @param {DataReader} reader the reader to use.
3969 */
3970 readExtraFields: function(reader) {
3971 var end = reader.index + this.extraFieldsLength,
3972 extraFieldId,
3973 extraFieldLength,
3974 extraFieldValue;
3975
3976 if (!this.extraFields) {
3977 this.extraFields = {};
3978 }
3979
3980 while (reader.index + 4 < end) {
3981 extraFieldId = reader.readInt(2);
3982 extraFieldLength = reader.readInt(2);
3983 extraFieldValue = reader.readData(extraFieldLength);
3984
3985 this.extraFields[extraFieldId] = {
3986 id: extraFieldId,
3987 length: extraFieldLength,
3988 value: extraFieldValue
3989 };
3990 }
3991
3992 reader.setIndex(end);
3993 },
3994 /**
3995 * Apply an UTF8 transformation if needed.
3996 */
3997 handleUTF8: function() {
3998 var decodeParamType = support.uint8array ? "uint8array" : "array";
3999 if (this.useUTF8()) {
4000 this.fileNameStr = utf8.utf8decode(this.fileName);
4001 this.fileCommentStr = utf8.utf8decode(this.fileComment);
4002 } else {
4003 var upath = this.findExtraFieldUnicodePath();
4004 if (upath !== null) {
4005 this.fileNameStr = upath;
4006 } else {
4007 // ASCII text or unsupported code page
4008 var fileNameByteArray = utils.transformTo(decodeParamType, this.fileName);
4009 this.fileNameStr = this.loadOptions.decodeFileName(fileNameByteArray);
4010 }
4011
4012 var ucomment = this.findExtraFieldUnicodeComment();
4013 if (ucomment !== null) {
4014 this.fileCommentStr = ucomment;
4015 } else {
4016 // ASCII text or unsupported code page
4017 var commentByteArray = utils.transformTo(decodeParamType, this.fileComment);
4018 this.fileCommentStr = this.loadOptions.decodeFileName(commentByteArray);
4019 }
4020 }
4021 },
4022
4023 /**
4024 * Find the unicode path declared in the extra field, if any.
4025 * @return {String} the unicode path, null otherwise.
4026 */
4027 findExtraFieldUnicodePath: function() {
4028 var upathField = this.extraFields[0x7075];
4029 if (upathField) {
4030 var extraReader = readerFor(upathField.value);
4031
4032 // wrong version
4033 if (extraReader.readInt(1) !== 1) {
4034 return null;
4035 }
4036
4037 // the crc of the filename changed, this field is out of date.
4038 if (crc32fn(this.fileName) !== extraReader.readInt(4)) {
4039 return null;
4040 }
4041
4042 return utf8.utf8decode(extraReader.readData(upathField.length - 5));
4043 }
4044 return null;
4045 },
4046
4047 /**
4048 * Find the unicode comment declared in the extra field, if any.
4049 * @return {String} the unicode comment, null otherwise.
4050 */
4051 findExtraFieldUnicodeComment: function() {
4052 var ucommentField = this.extraFields[0x6375];
4053 if (ucommentField) {
4054 var extraReader = readerFor(ucommentField.value);
4055
4056 // wrong version
4057 if (extraReader.readInt(1) !== 1) {
4058 return null;
4059 }
4060
4061 // the crc of the comment changed, this field is out of date.
4062 if (crc32fn(this.fileComment) !== extraReader.readInt(4)) {
4063 return null;
4064 }
4065
4066 return utf8.utf8decode(extraReader.readData(ucommentField.length - 5));
4067 }
4068 return null;
4069 }
4070 };
4071 module.exports = ZipEntry;
4072
4073 },{"./compressedObject":2,"./compressions":3,"./crc32":4,"./reader/readerFor":22,"./support":30,"./utf8":31,"./utils":32}],35:[function(require,module,exports){
4074 'use strict';
4075
4076 var StreamHelper = require('./stream/StreamHelper');
4077 var DataWorker = require('./stream/DataWorker');
4078 var utf8 = require('./utf8');
4079 var CompressedObject = require('./compressedObject');
4080 var GenericWorker = require('./stream/GenericWorker');
4081
4082 /**
4083 * A simple object representing a file in the zip file.
4084 * @constructor
4085 * @param {string} name the name of the file
4086 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data
4087 * @param {Object} options the options of the file
4088 */
4089 var ZipObject = function(name, data, options) {
4090 this.name = name;
4091 this.dir = options.dir;
4092 this.date = options.date;
4093 this.comment = options.comment;
4094 this.unixPermissions = options.unixPermissions;
4095 this.dosPermissions = options.dosPermissions;
4096
4097 this._data = data;
4098 this._dataBinary = options.binary;
4099 // keep only the compression
4100 this.options = {
4101 compression : options.compression,
4102 compressionOptions : options.compressionOptions
4103 };
4104 };
4105
4106 ZipObject.prototype = {
4107 /**
4108 * Create an internal stream for the content of this object.
4109 * @param {String} type the type of each chunk.
4110 * @return StreamHelper the stream.
4111 */
4112 internalStream: function (type) {
4113 var result = null, outputType = "string";
4114 try {
4115 if (!type) {
4116 throw new Error("No output type specified.");
4117 }
4118 outputType = type.toLowerCase();
4119 var askUnicodeString = outputType === "string" || outputType === "text";
4120 if (outputType === "binarystring" || outputType === "text") {
4121 outputType = "string";
4122 }
4123 result = this._decompressWorker();
4124
4125 var isUnicodeString = !this._dataBinary;
4126
4127 if (isUnicodeString && !askUnicodeString) {
4128 result = result.pipe(new utf8.Utf8EncodeWorker());
4129 }
4130 if (!isUnicodeString && askUnicodeString) {
4131 result = result.pipe(new utf8.Utf8DecodeWorker());
4132 }
4133 } catch (e) {
4134 result = new GenericWorker("error");
4135 result.error(e);
4136 }
4137
4138 return new StreamHelper(result, outputType, "");
4139 },
4140
4141 /**
4142 * Prepare the content in the asked type.
4143 * @param {String} type the type of the result.
4144 * @param {Function} onUpdate a function to call on each internal update.
4145 * @return Promise the promise of the result.
4146 */
4147 async: function (type, onUpdate) {
4148 return this.internalStream(type).accumulate(onUpdate);
4149 },
4150
4151 /**
4152 * Prepare the content as a nodejs stream.
4153 * @param {String} type the type of each chunk.
4154 * @param {Function} onUpdate a function to call on each internal update.
4155 * @return Stream the stream.
4156 */
4157 nodeStream: function (type, onUpdate) {
4158 return this.internalStream(type || "nodebuffer").toNodejsStream(onUpdate);
4159 },
4160
4161 /**
4162 * Return a worker for the compressed content.
4163 * @private
4164 * @param {Object} compression the compression object to use.
4165 * @param {Object} compressionOptions the options to use when compressing.
4166 * @return Worker the worker.
4167 */
4168 _compressWorker: function (compression, compressionOptions) {
4169 if (
4170 this._data instanceof CompressedObject &&
4171 this._data.compression.magic === compression.magic
4172 ) {
4173 return this._data.getCompressedWorker();
4174 } else {
4175 var result = this._decompressWorker();
4176 if(!this._dataBinary) {
4177 result = result.pipe(new utf8.Utf8EncodeWorker());
4178 }
4179 return CompressedObject.createWorkerFrom(result, compression, compressionOptions);
4180 }
4181 },
4182 /**
4183 * Return a worker for the decompressed content.
4184 * @private
4185 * @return Worker the worker.
4186 */
4187 _decompressWorker : function () {
4188 if (this._data instanceof CompressedObject) {
4189 return this._data.getContentWorker();
4190 } else if (this._data instanceof GenericWorker) {
4191 return this._data;
4192 } else {
4193 return new DataWorker(this._data);
4194 }
4195 }
4196 };
4197
4198 var removedMethods = ["asText", "asBinary", "asNodeBuffer", "asUint8Array", "asArrayBuffer"];
4199 var removedFn = function () {
4200 throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
4201 };
4202
4203 for(var i = 0; i < removedMethods.length; i++) {
4204 ZipObject.prototype[removedMethods[i]] = removedFn;
4205 }
4206 module.exports = ZipObject;
4207
4208 },{"./compressedObject":2,"./stream/DataWorker":27,"./stream/GenericWorker":28,"./stream/StreamHelper":29,"./utf8":31}],36:[function(require,module,exports){
4209 (function (global){
4210 'use strict';
4211 var Mutation = global.MutationObserver || global.WebKitMutationObserver;
4212
4213 var scheduleDrain;
4214
4215 {
4216 if (Mutation) {
4217 var called = 0;
4218 var observer = new Mutation(nextTick);
4219 var element = global.document.createTextNode('');
4220 observer.observe(element, {
4221 characterData: true
4222 });
4223 scheduleDrain = function () {
4224 element.data = (called = ++called % 2);
4225 };
4226 } else if (!global.setImmediate && typeof global.MessageChannel !== 'undefined') {
4227 var channel = new global.MessageChannel();
4228 channel.port1.onmessage = nextTick;
4229 scheduleDrain = function () {
4230 channel.port2.postMessage(0);
4231 };
4232 } else if ('document' in global && 'onreadystatechange' in global.document.createElement('script')) {
4233 scheduleDrain = function () {
4234
4235 // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
4236 // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
4237 var scriptEl = global.document.createElement('script');
4238 scriptEl.onreadystatechange = function () {
4239 nextTick();
4240
4241 scriptEl.onreadystatechange = null;
4242 scriptEl.parentNode.removeChild(scriptEl);
4243 scriptEl = null;
4244 };
4245 global.document.documentElement.appendChild(scriptEl);
4246 };
4247 } else {
4248 scheduleDrain = function () {
4249 setTimeout(nextTick, 0);
4250 };
4251 }
4252 }
4253
4254 var draining;
4255 var queue = [];
4256 //named nextTick for less confusing stack traces
4257 function nextTick() {
4258 draining = true;
4259 var i, oldQueue;
4260 var len = queue.length;
4261 while (len) {
4262 oldQueue = queue;
4263 queue = [];
4264 i = -1;
4265 while (++i < len) {
4266 oldQueue[i]();
4267 }
4268 len = queue.length;
4269 }
4270 draining = false;
4271 }
4272
4273 module.exports = immediate;
4274 function immediate(task) {
4275 if (queue.push(task) === 1 && !draining) {
4276 scheduleDrain();
4277 }
4278 }
4279
4280 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
4281 },{}],37:[function(require,module,exports){
4282 'use strict';
4283 var immediate = require('immediate');
4284
4285 /* istanbul ignore next */
4286 function INTERNAL() {}
4287
4288 var handlers = {};
4289
4290 var REJECTED = ['REJECTED'];
4291 var FULFILLED = ['FULFILLED'];
4292 var PENDING = ['PENDING'];
4293
4294 module.exports = Promise;
4295
4296 function Promise(resolver) {
4297 if (typeof resolver !== 'function') {
4298 throw new TypeError('resolver must be a function');
4299 }
4300 this.state = PENDING;
4301 this.queue = [];
4302 this.outcome = void 0;
4303 if (resolver !== INTERNAL) {
4304 safelyResolveThenable(this, resolver);
4305 }
4306 }
4307
4308 Promise.prototype["finally"] = function (callback) {
4309 if (typeof callback !== 'function') {
4310 return this;
4311 }
4312 var p = this.constructor;
4313 return this.then(resolve, reject);
4314
4315 function resolve(value) {
4316 function yes () {
4317 return value;
4318 }
4319 return p.resolve(callback()).then(yes);
4320 }
4321 function reject(reason) {
4322 function no () {
4323 throw reason;
4324 }
4325 return p.resolve(callback()).then(no);
4326 }
4327 };
4328 Promise.prototype["catch"] = function (onRejected) {
4329 return this.then(null, onRejected);
4330 };
4331 Promise.prototype.then = function (onFulfilled, onRejected) {
4332 if (typeof onFulfilled !== 'function' && this.state === FULFILLED ||
4333 typeof onRejected !== 'function' && this.state === REJECTED) {
4334 return this;
4335 }
4336 var promise = new this.constructor(INTERNAL);
4337 if (this.state !== PENDING) {
4338 var resolver = this.state === FULFILLED ? onFulfilled : onRejected;
4339 unwrap(promise, resolver, this.outcome);
4340 } else {
4341 this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
4342 }
4343
4344 return promise;
4345 };
4346 function QueueItem(promise, onFulfilled, onRejected) {
4347 this.promise = promise;
4348 if (typeof onFulfilled === 'function') {
4349 this.onFulfilled = onFulfilled;
4350 this.callFulfilled = this.otherCallFulfilled;
4351 }
4352 if (typeof onRejected === 'function') {
4353 this.onRejected = onRejected;
4354 this.callRejected = this.otherCallRejected;
4355 }
4356 }
4357 QueueItem.prototype.callFulfilled = function (value) {
4358 handlers.resolve(this.promise, value);
4359 };
4360 QueueItem.prototype.otherCallFulfilled = function (value) {
4361 unwrap(this.promise, this.onFulfilled, value);
4362 };
4363 QueueItem.prototype.callRejected = function (value) {
4364 handlers.reject(this.promise, value);
4365 };
4366 QueueItem.prototype.otherCallRejected = function (value) {
4367 unwrap(this.promise, this.onRejected, value);
4368 };
4369
4370 function unwrap(promise, func, value) {
4371 immediate(function () {
4372 var returnValue;
4373 try {
4374 returnValue = func(value);
4375 } catch (e) {
4376 return handlers.reject(promise, e);
4377 }
4378 if (returnValue === promise) {
4379 handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
4380 } else {
4381 handlers.resolve(promise, returnValue);
4382 }
4383 });
4384 }
4385
4386 handlers.resolve = function (self, value) {
4387 var result = tryCatch(getThen, value);
4388 if (result.status === 'error') {
4389 return handlers.reject(self, result.value);
4390 }
4391 var thenable = result.value;
4392
4393 if (thenable) {
4394 safelyResolveThenable(self, thenable);
4395 } else {
4396 self.state = FULFILLED;
4397 self.outcome = value;
4398 var i = -1;
4399 var len = self.queue.length;
4400 while (++i < len) {
4401 self.queue[i].callFulfilled(value);
4402 }
4403 }
4404 return self;
4405 };
4406 handlers.reject = function (self, error) {
4407 self.state = REJECTED;
4408 self.outcome = error;
4409 var i = -1;
4410 var len = self.queue.length;
4411 while (++i < len) {
4412 self.queue[i].callRejected(error);
4413 }
4414 return self;
4415 };
4416
4417 function getThen(obj) {
4418 // Make sure we only access the accessor once as required by the spec
4419 var then = obj && obj.then;
4420 if (obj && (typeof obj === 'object' || typeof obj === 'function') && typeof then === 'function') {
4421 return function appyThen() {
4422 then.apply(obj, arguments);
4423 };
4424 }
4425 }
4426
4427 function safelyResolveThenable(self, thenable) {
4428 // Either fulfill, reject or reject with error
4429 var called = false;
4430 function onError(value) {
4431 if (called) {
4432 return;
4433 }
4434 called = true;
4435 handlers.reject(self, value);
4436 }
4437
4438 function onSuccess(value) {
4439 if (called) {
4440 return;
4441 }
4442 called = true;
4443 handlers.resolve(self, value);
4444 }
4445
4446 function tryToUnwrap() {
4447 thenable(onSuccess, onError);
4448 }
4449
4450 var result = tryCatch(tryToUnwrap);
4451 if (result.status === 'error') {
4452 onError(result.value);
4453 }
4454 }
4455
4456 function tryCatch(func, value) {
4457 var out = {};
4458 try {
4459 out.value = func(value);
4460 out.status = 'success';
4461 } catch (e) {
4462 out.status = 'error';
4463 out.value = e;
4464 }
4465 return out;
4466 }
4467
4468 Promise.resolve = resolve;
4469 function resolve(value) {
4470 if (value instanceof this) {
4471 return value;
4472 }
4473 return handlers.resolve(new this(INTERNAL), value);
4474 }
4475
4476 Promise.reject = reject;
4477 function reject(reason) {
4478 var promise = new this(INTERNAL);
4479 return handlers.reject(promise, reason);
4480 }
4481
4482 Promise.all = all;
4483 function all(iterable) {
4484 var self = this;
4485 if (Object.prototype.toString.call(iterable) !== '[object Array]') {
4486 return this.reject(new TypeError('must be an array'));
4487 }
4488
4489 var len = iterable.length;
4490 var called = false;
4491 if (!len) {
4492 return this.resolve([]);
4493 }
4494
4495 var values = new Array(len);
4496 var resolved = 0;
4497 var i = -1;
4498 var promise = new this(INTERNAL);
4499
4500 while (++i < len) {
4501 allResolver(iterable[i], i);
4502 }
4503 return promise;
4504 function allResolver(value, i) {
4505 self.resolve(value).then(resolveFromAll, function (error) {
4506 if (!called) {
4507 called = true;
4508 handlers.reject(promise, error);
4509 }
4510 });
4511 function resolveFromAll(outValue) {
4512 values[i] = outValue;
4513 if (++resolved === len && !called) {
4514 called = true;
4515 handlers.resolve(promise, values);
4516 }
4517 }
4518 }
4519 }
4520
4521 Promise.race = race;
4522 function race(iterable) {
4523 var self = this;
4524 if (Object.prototype.toString.call(iterable) !== '[object Array]') {
4525 return this.reject(new TypeError('must be an array'));
4526 }
4527
4528 var len = iterable.length;
4529 var called = false;
4530 if (!len) {
4531 return this.resolve([]);
4532 }
4533
4534 var i = -1;
4535 var promise = new this(INTERNAL);
4536
4537 while (++i < len) {
4538 resolver(iterable[i]);
4539 }
4540 return promise;
4541 function resolver(value) {
4542 self.resolve(value).then(function (response) {
4543 if (!called) {
4544 called = true;
4545 handlers.resolve(promise, response);
4546 }
4547 }, function (error) {
4548 if (!called) {
4549 called = true;
4550 handlers.reject(promise, error);
4551 }
4552 });
4553 }
4554 }
4555
4556 },{"immediate":36}],38:[function(require,module,exports){
4557 // Top level file is just a mixin of submodules & constants
4558 'use strict';
4559
4560 var assign = require('./lib/utils/common').assign;
4561
4562 var deflate = require('./lib/deflate');
4563 var inflate = require('./lib/inflate');
4564 var constants = require('./lib/zlib/constants');
4565
4566 var pako = {};
4567
4568 assign(pako, deflate, inflate, constants);
4569
4570 module.exports = pako;
4571
4572 },{"./lib/deflate":39,"./lib/inflate":40,"./lib/utils/common":41,"./lib/zlib/constants":44}],39:[function(require,module,exports){
4573 'use strict';
4574
4575
4576 var zlib_deflate = require('./zlib/deflate');
4577 var utils = require('./utils/common');
4578 var strings = require('./utils/strings');
4579 var msg = require('./zlib/messages');
4580 var ZStream = require('./zlib/zstream');
4581
4582 var toString = Object.prototype.toString;
4583
4584 /* Public constants ==========================================================*/
4585 /* ===========================================================================*/
4586
4587 var Z_NO_FLUSH = 0;
4588 var Z_FINISH = 4;
4589
4590 var Z_OK = 0;
4591 var Z_STREAM_END = 1;
4592 var Z_SYNC_FLUSH = 2;
4593
4594 var Z_DEFAULT_COMPRESSION = -1;
4595
4596 var Z_DEFAULT_STRATEGY = 0;
4597
4598 var Z_DEFLATED = 8;
4599
4600 /* ===========================================================================*/
4601
4602
4603 /**
4604 * class Deflate
4605 *
4606 * Generic JS-style wrapper for zlib calls. If you don't need
4607 * streaming behaviour - use more simple functions: [[deflate]],
4608 * [[deflateRaw]] and [[gzip]].
4609 **/
4610
4611 /* internal
4612 * Deflate.chunks -> Array
4613 *
4614 * Chunks of output data, if [[Deflate#onData]] not overriden.
4615 **/
4616
4617 /**
4618 * Deflate.result -> Uint8Array|Array
4619 *
4620 * Compressed result, generated by default [[Deflate#onData]]
4621 * and [[Deflate#onEnd]] handlers. Filled after you push last chunk
4622 * (call [[Deflate#push]] with `Z_FINISH` / `true` param) or if you
4623 * push a chunk with explicit flush (call [[Deflate#push]] with
4624 * `Z_SYNC_FLUSH` param).
4625 **/
4626
4627 /**
4628 * Deflate.err -> Number
4629 *
4630 * Error code after deflate finished. 0 (Z_OK) on success.
4631 * You will not need it in real life, because deflate errors
4632 * are possible only on wrong options or bad `onData` / `onEnd`
4633 * custom handlers.
4634 **/
4635
4636 /**
4637 * Deflate.msg -> String
4638 *
4639 * Error message, if [[Deflate.err]] != 0
4640 **/
4641
4642
4643 /**
4644 * new Deflate(options)
4645 * - options (Object): zlib deflate options.
4646 *
4647 * Creates new deflator instance with specified params. Throws exception
4648 * on bad params. Supported options:
4649 *
4650 * - `level`
4651 * - `windowBits`
4652 * - `memLevel`
4653 * - `strategy`
4654 * - `dictionary`
4655 *
4656 * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
4657 * for more information on these.
4658 *
4659 * Additional options, for internal needs:
4660 *
4661 * - `chunkSize` - size of generated data chunks (16K by default)
4662 * - `raw` (Boolean) - do raw deflate
4663 * - `gzip` (Boolean) - create gzip wrapper
4664 * - `to` (String) - if equal to 'string', then result will be "binary string"
4665 * (each char code [0..255])
4666 * - `header` (Object) - custom header for gzip
4667 * - `text` (Boolean) - true if compressed data believed to be text
4668 * - `time` (Number) - modification time, unix timestamp
4669 * - `os` (Number) - operation system code
4670 * - `extra` (Array) - array of bytes with extra data (max 65536)
4671 * - `name` (String) - file name (binary string)
4672 * - `comment` (String) - comment (binary string)
4673 * - `hcrc` (Boolean) - true if header crc should be added
4674 *
4675 * ##### Example:
4676 *
4677 * ```javascript
4678 * var pako = require('pako')
4679 * , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
4680 * , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
4681 *
4682 * var deflate = new pako.Deflate({ level: 3});
4683 *
4684 * deflate.push(chunk1, false);
4685 * deflate.push(chunk2, true); // true -> last chunk
4686 *
4687 * if (deflate.err) { throw new Error(deflate.err); }
4688 *
4689 * console.log(deflate.result);
4690 * ```
4691 **/
4692 function Deflate(options) {
4693 if (!(this instanceof Deflate)) return new Deflate(options);
4694
4695 this.options = utils.assign({
4696 level: Z_DEFAULT_COMPRESSION,
4697 method: Z_DEFLATED,
4698 chunkSize: 16384,
4699 windowBits: 15,
4700 memLevel: 8,
4701 strategy: Z_DEFAULT_STRATEGY,
4702 to: ''
4703 }, options || {});
4704
4705 var opt = this.options;
4706
4707 if (opt.raw && (opt.windowBits > 0)) {
4708 opt.windowBits = -opt.windowBits;
4709 }
4710
4711 else if (opt.gzip && (opt.windowBits > 0) && (opt.windowBits < 16)) {
4712 opt.windowBits += 16;
4713 }
4714
4715 this.err = 0; // error code, if happens (0 = Z_OK)
4716 this.msg = ''; // error message
4717 this.ended = false; // used to avoid multiple onEnd() calls
4718 this.chunks = []; // chunks of compressed data
4719
4720 this.strm = new ZStream();
4721 this.strm.avail_out = 0;
4722
4723 var status = zlib_deflate.deflateInit2(
4724 this.strm,
4725 opt.level,
4726 opt.method,
4727 opt.windowBits,
4728 opt.memLevel,
4729 opt.strategy
4730 );
4731
4732 if (status !== Z_OK) {
4733 throw new Error(msg[status]);
4734 }
4735
4736 if (opt.header) {
4737 zlib_deflate.deflateSetHeader(this.strm, opt.header);
4738 }
4739
4740 if (opt.dictionary) {
4741 var dict;
4742 // Convert data if needed
4743 if (typeof opt.dictionary === 'string') {
4744 // If we need to compress text, change encoding to utf8.
4745 dict = strings.string2buf(opt.dictionary);
4746 } else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {
4747 dict = new Uint8Array(opt.dictionary);
4748 } else {
4749 dict = opt.dictionary;
4750 }
4751
4752 status = zlib_deflate.deflateSetDictionary(this.strm, dict);
4753
4754 if (status !== Z_OK) {
4755 throw new Error(msg[status]);
4756 }
4757
4758 this._dict_set = true;
4759 }
4760 }
4761
4762 /**
4763 * Deflate#push(data[, mode]) -> Boolean
4764 * - data (Uint8Array|Array|ArrayBuffer|String): input data. Strings will be
4765 * converted to utf8 byte sequence.
4766 * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
4767 * See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH.
4768 *
4769 * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with
4770 * new compressed chunks. Returns `true` on success. The last data block must have
4771 * mode Z_FINISH (or `true`). That will flush internal pending buffers and call
4772 * [[Deflate#onEnd]]. For interim explicit flushes (without ending the stream) you
4773 * can use mode Z_SYNC_FLUSH, keeping the compression context.
4774 *
4775 * On fail call [[Deflate#onEnd]] with error code and return false.
4776 *
4777 * We strongly recommend to use `Uint8Array` on input for best speed (output
4778 * array format is detected automatically). Also, don't skip last param and always
4779 * use the same type in your code (boolean or number). That will improve JS speed.
4780 *
4781 * For regular `Array`-s make sure all elements are [0..255].
4782 *
4783 * ##### Example
4784 *
4785 * ```javascript
4786 * push(chunk, false); // push one of data chunks
4787 * ...
4788 * push(chunk, true); // push last chunk
4789 * ```
4790 **/
4791 Deflate.prototype.push = function (data, mode) {
4792 var strm = this.strm;
4793 var chunkSize = this.options.chunkSize;
4794 var status, _mode;
4795
4796 if (this.ended) { return false; }
4797
4798 _mode = (mode === ~~mode) ? mode : ((mode === true) ? Z_FINISH : Z_NO_FLUSH);
4799
4800 // Convert data if needed
4801 if (typeof data === 'string') {
4802 // If we need to compress text, change encoding to utf8.
4803 strm.input = strings.string2buf(data);
4804 } else if (toString.call(data) === '[object ArrayBuffer]') {
4805 strm.input = new Uint8Array(data);
4806 } else {
4807 strm.input = data;
4808 }
4809
4810 strm.next_in = 0;
4811 strm.avail_in = strm.input.length;
4812
4813 do {
4814 if (strm.avail_out === 0) {
4815 strm.output = new utils.Buf8(chunkSize);
4816 strm.next_out = 0;
4817 strm.avail_out = chunkSize;
4818 }
4819 status = zlib_deflate.deflate(strm, _mode); /* no bad return value */
4820
4821 if (status !== Z_STREAM_END && status !== Z_OK) {
4822 this.onEnd(status);
4823 this.ended = true;
4824 return false;
4825 }
4826 if (strm.avail_out === 0 || (strm.avail_in === 0 && (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH))) {
4827 if (this.options.to === 'string') {
4828 this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out)));
4829 } else {
4830 this.onData(utils.shrinkBuf(strm.output, strm.next_out));
4831 }
4832 }
4833 } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END);
4834
4835 // Finalize on the last chunk.
4836 if (_mode === Z_FINISH) {
4837 status = zlib_deflate.deflateEnd(this.strm);
4838 this.onEnd(status);
4839 this.ended = true;
4840 return status === Z_OK;
4841 }
4842
4843 // callback interim results if Z_SYNC_FLUSH.
4844 if (_mode === Z_SYNC_FLUSH) {
4845 this.onEnd(Z_OK);
4846 strm.avail_out = 0;
4847 return true;
4848 }
4849
4850 return true;
4851 };
4852
4853
4854 /**
4855 * Deflate#onData(chunk) -> Void
4856 * - chunk (Uint8Array|Array|String): ouput data. Type of array depends
4857 * on js engine support. When string output requested, each chunk
4858 * will be string.
4859 *
4860 * By default, stores data blocks in `chunks[]` property and glue
4861 * those in `onEnd`. Override this handler, if you need another behaviour.
4862 **/
4863 Deflate.prototype.onData = function (chunk) {
4864 this.chunks.push(chunk);
4865 };
4866
4867
4868 /**
4869 * Deflate#onEnd(status) -> Void
4870 * - status (Number): deflate status. 0 (Z_OK) on success,
4871 * other if not.
4872 *
4873 * Called once after you tell deflate that the input stream is
4874 * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)
4875 * or if an error happened. By default - join collected chunks,
4876 * free memory and fill `results` / `err` properties.
4877 **/
4878 Deflate.prototype.onEnd = function (status) {
4879 // On success - join
4880 if (status === Z_OK) {
4881 if (this.options.to === 'string') {
4882 this.result = this.chunks.join('');
4883 } else {
4884 this.result = utils.flattenChunks(this.chunks);
4885 }
4886 }
4887 this.chunks = [];
4888 this.err = status;
4889 this.msg = this.strm.msg;
4890 };
4891
4892
4893 /**
4894 * deflate(data[, options]) -> Uint8Array|Array|String
4895 * - data (Uint8Array|Array|String): input data to compress.
4896 * - options (Object): zlib deflate options.
4897 *
4898 * Compress `data` with deflate algorithm and `options`.
4899 *
4900 * Supported options are:
4901 *
4902 * - level
4903 * - windowBits
4904 * - memLevel
4905 * - strategy
4906 * - dictionary
4907 *
4908 * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
4909 * for more information on these.
4910 *
4911 * Sugar (options):
4912 *
4913 * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
4914 * negative windowBits implicitly.
4915 * - `to` (String) - if equal to 'string', then result will be "binary string"
4916 * (each char code [0..255])
4917 *
4918 * ##### Example:
4919 *
4920 * ```javascript
4921 * var pako = require('pako')
4922 * , data = Uint8Array([1,2,3,4,5,6,7,8,9]);
4923 *
4924 * console.log(pako.deflate(data));
4925 * ```
4926 **/
4927 function deflate(input, options) {
4928 var deflator = new Deflate(options);
4929
4930 deflator.push(input, true);
4931
4932 // That will never happens, if you don't cheat with options :)
4933 if (deflator.err) { throw deflator.msg || msg[deflator.err]; }
4934
4935 return deflator.result;
4936 }
4937
4938
4939 /**
4940 * deflateRaw(data[, options]) -> Uint8Array|Array|String
4941 * - data (Uint8Array|Array|String): input data to compress.
4942 * - options (Object): zlib deflate options.
4943 *
4944 * The same as [[deflate]], but creates raw data, without wrapper
4945 * (header and adler32 crc).
4946 **/
4947 function deflateRaw(input, options) {
4948 options = options || {};
4949 options.raw = true;
4950 return deflate(input, options);
4951 }
4952
4953
4954 /**
4955 * gzip(data[, options]) -> Uint8Array|Array|String
4956 * - data (Uint8Array|Array|String): input data to compress.
4957 * - options (Object): zlib deflate options.
4958 *
4959 * The same as [[deflate]], but create gzip wrapper instead of
4960 * deflate one.
4961 **/
4962 function gzip(input, options) {
4963 options = options || {};
4964 options.gzip = true;
4965 return deflate(input, options);
4966 }
4967
4968
4969 exports.Deflate = Deflate;
4970 exports.deflate = deflate;
4971 exports.deflateRaw = deflateRaw;
4972 exports.gzip = gzip;
4973
4974 },{"./utils/common":41,"./utils/strings":42,"./zlib/deflate":46,"./zlib/messages":51,"./zlib/zstream":53}],40:[function(require,module,exports){
4975 'use strict';
4976
4977
4978 var zlib_inflate = require('./zlib/inflate');
4979 var utils = require('./utils/common');
4980 var strings = require('./utils/strings');
4981 var c = require('./zlib/constants');
4982 var msg = require('./zlib/messages');
4983 var ZStream = require('./zlib/zstream');
4984 var GZheader = require('./zlib/gzheader');
4985
4986 var toString = Object.prototype.toString;
4987
4988 /**
4989 * class Inflate
4990 *
4991 * Generic JS-style wrapper for zlib calls. If you don't need
4992 * streaming behaviour - use more simple functions: [[inflate]]
4993 * and [[inflateRaw]].
4994 **/
4995
4996 /* internal
4997 * inflate.chunks -> Array
4998 *
4999 * Chunks of output data, if [[Inflate#onData]] not overriden.
5000 **/
5001
5002 /**
5003 * Inflate.result -> Uint8Array|Array|String
5004 *
5005 * Uncompressed result, generated by default [[Inflate#onData]]
5006 * and [[Inflate#onEnd]] handlers. Filled after you push last chunk
5007 * (call [[Inflate#push]] with `Z_FINISH` / `true` param) or if you
5008 * push a chunk with explicit flush (call [[Inflate#push]] with
5009 * `Z_SYNC_FLUSH` param).
5010 **/
5011
5012 /**
5013 * Inflate.err -> Number
5014 *
5015 * Error code after inflate finished. 0 (Z_OK) on success.
5016 * Should be checked if broken data possible.
5017 **/
5018
5019 /**
5020 * Inflate.msg -> String
5021 *
5022 * Error message, if [[Inflate.err]] != 0
5023 **/
5024
5025
5026 /**
5027 * new Inflate(options)
5028 * - options (Object): zlib inflate options.
5029 *
5030 * Creates new inflator instance with specified params. Throws exception
5031 * on bad params. Supported options:
5032 *
5033 * - `windowBits`
5034 * - `dictionary`
5035 *
5036 * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
5037 * for more information on these.
5038 *
5039 * Additional options, for internal needs:
5040 *
5041 * - `chunkSize` - size of generated data chunks (16K by default)
5042 * - `raw` (Boolean) - do raw inflate
5043 * - `to` (String) - if equal to 'string', then result will be converted
5044 * from utf8 to utf16 (javascript) string. When string output requested,
5045 * chunk length can differ from `chunkSize`, depending on content.
5046 *
5047 * By default, when no options set, autodetect deflate/gzip data format via
5048 * wrapper header.
5049 *
5050 * ##### Example:
5051 *
5052 * ```javascript
5053 * var pako = require('pako')
5054 * , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
5055 * , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
5056 *
5057 * var inflate = new pako.Inflate({ level: 3});
5058 *
5059 * inflate.push(chunk1, false);
5060 * inflate.push(chunk2, true); // true -> last chunk
5061 *
5062 * if (inflate.err) { throw new Error(inflate.err); }
5063 *
5064 * console.log(inflate.result);
5065 * ```
5066 **/
5067 function Inflate(options) {
5068 if (!(this instanceof Inflate)) return new Inflate(options);
5069
5070 this.options = utils.assign({
5071 chunkSize: 16384,
5072 windowBits: 0,
5073 to: ''
5074 }, options || {});
5075
5076 var opt = this.options;
5077
5078 // Force window size for `raw` data, if not set directly,
5079 // because we have no header for autodetect.
5080 if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {
5081 opt.windowBits = -opt.windowBits;
5082 if (opt.windowBits === 0) { opt.windowBits = -15; }
5083 }
5084
5085 // If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate
5086 if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&
5087 !(options && options.windowBits)) {
5088 opt.windowBits += 32;
5089 }
5090
5091 // Gzip header has no info about windows size, we can do autodetect only
5092 // for deflate. So, if window size not set, force it to max when gzip possible
5093 if ((opt.windowBits > 15) && (opt.windowBits < 48)) {
5094 // bit 3 (16) -> gzipped data
5095 // bit 4 (32) -> autodetect gzip/deflate
5096 if ((opt.windowBits & 15) === 0) {
5097 opt.windowBits |= 15;
5098 }
5099 }
5100
5101 this.err = 0; // error code, if happens (0 = Z_OK)
5102 this.msg = ''; // error message
5103 this.ended = false; // used to avoid multiple onEnd() calls
5104 this.chunks = []; // chunks of compressed data
5105
5106 this.strm = new ZStream();
5107 this.strm.avail_out = 0;
5108
5109 var status = zlib_inflate.inflateInit2(
5110 this.strm,
5111 opt.windowBits
5112 );
5113
5114 if (status !== c.Z_OK) {
5115 throw new Error(msg[status]);
5116 }
5117
5118 this.header = new GZheader();
5119
5120 zlib_inflate.inflateGetHeader(this.strm, this.header);
5121 }
5122
5123 /**
5124 * Inflate#push(data[, mode]) -> Boolean
5125 * - data (Uint8Array|Array|ArrayBuffer|String): input data
5126 * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
5127 * See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH.
5128 *
5129 * Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
5130 * new output chunks. Returns `true` on success. The last data block must have
5131 * mode Z_FINISH (or `true`). That will flush internal pending buffers and call
5132 * [[Inflate#onEnd]]. For interim explicit flushes (without ending the stream) you
5133 * can use mode Z_SYNC_FLUSH, keeping the decompression context.
5134 *
5135 * On fail call [[Inflate#onEnd]] with error code and return false.
5136 *
5137 * We strongly recommend to use `Uint8Array` on input for best speed (output
5138 * format is detected automatically). Also, don't skip last param and always
5139 * use the same type in your code (boolean or number). That will improve JS speed.
5140 *
5141 * For regular `Array`-s make sure all elements are [0..255].
5142 *
5143 * ##### Example
5144 *
5145 * ```javascript
5146 * push(chunk, false); // push one of data chunks
5147 * ...
5148 * push(chunk, true); // push last chunk
5149 * ```
5150 **/
5151 Inflate.prototype.push = function (data, mode) {
5152 var strm = this.strm;
5153 var chunkSize = this.options.chunkSize;
5154 var dictionary = this.options.dictionary;
5155 var status, _mode;
5156 var next_out_utf8, tail, utf8str;
5157 var dict;
5158
5159 // Flag to properly process Z_BUF_ERROR on testing inflate call
5160 // when we check that all output data was flushed.
5161 var allowBufError = false;
5162
5163 if (this.ended) { return false; }
5164 _mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH);
5165
5166 // Convert data if needed
5167 if (typeof data === 'string') {
5168 // Only binary strings can be decompressed on practice
5169 strm.input = strings.binstring2buf(data);
5170 } else if (toString.call(data) === '[object ArrayBuffer]') {
5171 strm.input = new Uint8Array(data);
5172 } else {
5173 strm.input = data;
5174 }
5175
5176 strm.next_in = 0;
5177 strm.avail_in = strm.input.length;
5178
5179 do {
5180 if (strm.avail_out === 0) {
5181 strm.output = new utils.Buf8(chunkSize);
5182 strm.next_out = 0;
5183 strm.avail_out = chunkSize;
5184 }
5185
5186 status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH); /* no bad return value */
5187
5188 if (status === c.Z_NEED_DICT && dictionary) {
5189 // Convert data if needed
5190 if (typeof dictionary === 'string') {
5191 dict = strings.string2buf(dictionary);
5192 } else if (toString.call(dictionary) === '[object ArrayBuffer]') {
5193 dict = new Uint8Array(dictionary);
5194 } else {
5195 dict = dictionary;
5196 }
5197
5198 status = zlib_inflate.inflateSetDictionary(this.strm, dict);
5199
5200 }
5201
5202 if (status === c.Z_BUF_ERROR && allowBufError === true) {
5203 status = c.Z_OK;
5204 allowBufError = false;
5205 }
5206
5207 if (status !== c.Z_STREAM_END && status !== c.Z_OK) {
5208 this.onEnd(status);
5209 this.ended = true;
5210 return false;
5211 }
5212
5213 if (strm.next_out) {
5214 if (strm.avail_out === 0 || status === c.Z_STREAM_END || (strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH))) {
5215
5216 if (this.options.to === 'string') {
5217
5218 next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
5219
5220 tail = strm.next_out - next_out_utf8;
5221 utf8str = strings.buf2string(strm.output, next_out_utf8);
5222
5223 // move tail
5224 strm.next_out = tail;
5225 strm.avail_out = chunkSize - tail;
5226 if (tail) { utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); }
5227
5228 this.onData(utf8str);
5229
5230 } else {
5231 this.onData(utils.shrinkBuf(strm.output, strm.next_out));
5232 }
5233 }
5234 }
5235
5236 // When no more input data, we should check that internal inflate buffers
5237 // are flushed. The only way to do it when avail_out = 0 - run one more
5238 // inflate pass. But if output data not exists, inflate return Z_BUF_ERROR.
5239 // Here we set flag to process this error properly.
5240 //
5241 // NOTE. Deflate does not return error in this case and does not needs such
5242 // logic.
5243 if (strm.avail_in === 0 && strm.avail_out === 0) {
5244 allowBufError = true;
5245 }
5246
5247 } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END);
5248
5249 if (status === c.Z_STREAM_END) {
5250 _mode = c.Z_FINISH;
5251 }
5252
5253 // Finalize on the last chunk.
5254 if (_mode === c.Z_FINISH) {
5255 status = zlib_inflate.inflateEnd(this.strm);
5256 this.onEnd(status);
5257 this.ended = true;
5258 return status === c.Z_OK;
5259 }
5260
5261 // callback interim results if Z_SYNC_FLUSH.
5262 if (_mode === c.Z_SYNC_FLUSH) {
5263 this.onEnd(c.Z_OK);
5264 strm.avail_out = 0;
5265 return true;
5266 }
5267
5268 return true;
5269 };
5270
5271
5272 /**
5273 * Inflate#onData(chunk) -> Void
5274 * - chunk (Uint8Array|Array|String): ouput data. Type of array depends
5275 * on js engine support. When string output requested, each chunk
5276 * will be string.
5277 *
5278 * By default, stores data blocks in `chunks[]` property and glue
5279 * those in `onEnd`. Override this handler, if you need another behaviour.
5280 **/
5281 Inflate.prototype.onData = function (chunk) {
5282 this.chunks.push(chunk);
5283 };
5284
5285
5286 /**
5287 * Inflate#onEnd(status) -> Void
5288 * - status (Number): inflate status. 0 (Z_OK) on success,
5289 * other if not.
5290 *
5291 * Called either after you tell inflate that the input stream is
5292 * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)
5293 * or if an error happened. By default - join collected chunks,
5294 * free memory and fill `results` / `err` properties.
5295 **/
5296 Inflate.prototype.onEnd = function (status) {
5297 // On success - join
5298 if (status === c.Z_OK) {
5299 if (this.options.to === 'string') {
5300 // Glue & convert here, until we teach pako to send
5301 // utf8 alligned strings to onData
5302 this.result = this.chunks.join('');
5303 } else {
5304 this.result = utils.flattenChunks(this.chunks);
5305 }
5306 }
5307 this.chunks = [];
5308 this.err = status;
5309 this.msg = this.strm.msg;
5310 };
5311
5312
5313 /**
5314 * inflate(data[, options]) -> Uint8Array|Array|String
5315 * - data (Uint8Array|Array|String): input data to decompress.
5316 * - options (Object): zlib inflate options.
5317 *
5318 * Decompress `data` with inflate/ungzip and `options`. Autodetect
5319 * format via wrapper header by default. That's why we don't provide
5320 * separate `ungzip` method.
5321 *
5322 * Supported options are:
5323 *
5324 * - windowBits
5325 *
5326 * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
5327 * for more information.
5328 *
5329 * Sugar (options):
5330 *
5331 * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
5332 * negative windowBits implicitly.
5333 * - `to` (String) - if equal to 'string', then result will be converted
5334 * from utf8 to utf16 (javascript) string. When string output requested,
5335 * chunk length can differ from `chunkSize`, depending on content.
5336 *
5337 *
5338 * ##### Example:
5339 *
5340 * ```javascript
5341 * var pako = require('pako')
5342 * , input = pako.deflate([1,2,3,4,5,6,7,8,9])
5343 * , output;
5344 *
5345 * try {
5346 * output = pako.inflate(input);
5347 * } catch (err)
5348 * console.log(err);
5349 * }
5350 * ```
5351 **/
5352 function inflate(input, options) {
5353 var inflator = new Inflate(options);
5354
5355 inflator.push(input, true);
5356
5357 // That will never happens, if you don't cheat with options :)
5358 if (inflator.err) { throw inflator.msg || msg[inflator.err]; }
5359
5360 return inflator.result;
5361 }
5362
5363
5364 /**
5365 * inflateRaw(data[, options]) -> Uint8Array|Array|String
5366 * - data (Uint8Array|Array|String): input data to decompress.
5367 * - options (Object): zlib inflate options.
5368 *
5369 * The same as [[inflate]], but creates raw data, without wrapper
5370 * (header and adler32 crc).
5371 **/
5372 function inflateRaw(input, options) {
5373 options = options || {};
5374 options.raw = true;
5375 return inflate(input, options);
5376 }
5377
5378
5379 /**
5380 * ungzip(data[, options]) -> Uint8Array|Array|String
5381 * - data (Uint8Array|Array|String): input data to decompress.
5382 * - options (Object): zlib inflate options.
5383 *
5384 * Just shortcut to [[inflate]], because it autodetects format
5385 * by header.content. Done for convenience.
5386 **/
5387
5388
5389 exports.Inflate = Inflate;
5390 exports.inflate = inflate;
5391 exports.inflateRaw = inflateRaw;
5392 exports.ungzip = inflate;
5393
5394 },{"./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){
5395 'use strict';
5396
5397
5398 var TYPED_OK = (typeof Uint8Array !== 'undefined') &&
5399 (typeof Uint16Array !== 'undefined') &&
5400 (typeof Int32Array !== 'undefined');
5401
5402
5403 exports.assign = function (obj /*from1, from2, from3, ...*/) {
5404 var sources = Array.prototype.slice.call(arguments, 1);
5405 while (sources.length) {
5406 var source = sources.shift();
5407 if (!source) { continue; }
5408
5409 if (typeof source !== 'object') {
5410 throw new TypeError(source + 'must be non-object');
5411 }
5412
5413 for (var p in source) {
5414 if (source.hasOwnProperty(p)) {
5415 obj[p] = source[p];
5416 }
5417 }
5418 }
5419
5420 return obj;
5421 };
5422
5423
5424 // reduce buffer size, avoiding mem copy
5425 exports.shrinkBuf = function (buf, size) {
5426 if (buf.length === size) { return buf; }
5427 if (buf.subarray) { return buf.subarray(0, size); }
5428 buf.length = size;
5429 return buf;
5430 };
5431
5432
5433 var fnTyped = {
5434 arraySet: function (dest, src, src_offs, len, dest_offs) {
5435 if (src.subarray && dest.subarray) {
5436 dest.set(src.subarray(src_offs, src_offs + len), dest_offs);
5437 return;
5438 }
5439 // Fallback to ordinary array
5440 for (var i = 0; i < len; i++) {
5441 dest[dest_offs + i] = src[src_offs + i];
5442 }
5443 },
5444 // Join array of chunks to single array.
5445 flattenChunks: function (chunks) {
5446 var i, l, len, pos, chunk, result;
5447
5448 // calculate data length
5449 len = 0;
5450 for (i = 0, l = chunks.length; i < l; i++) {
5451 len += chunks[i].length;
5452 }
5453
5454 // join chunks
5455 result = new Uint8Array(len);
5456 pos = 0;
5457 for (i = 0, l = chunks.length; i < l; i++) {
5458 chunk = chunks[i];
5459 result.set(chunk, pos);
5460 pos += chunk.length;
5461 }
5462
5463 return result;
5464 }
5465 };
5466
5467 var fnUntyped = {
5468 arraySet: function (dest, src, src_offs, len, dest_offs) {
5469 for (var i = 0; i < len; i++) {
5470 dest[dest_offs + i] = src[src_offs + i];
5471 }
5472 },
5473 // Join array of chunks to single array.
5474 flattenChunks: function (chunks) {
5475 return [].concat.apply([], chunks);
5476 }
5477 };
5478
5479
5480 // Enable/Disable typed arrays use, for testing
5481 //
5482 exports.setTyped = function (on) {
5483 if (on) {
5484 exports.Buf8 = Uint8Array;
5485 exports.Buf16 = Uint16Array;
5486 exports.Buf32 = Int32Array;
5487 exports.assign(exports, fnTyped);
5488 } else {
5489 exports.Buf8 = Array;
5490 exports.Buf16 = Array;
5491 exports.Buf32 = Array;
5492 exports.assign(exports, fnUntyped);
5493 }
5494 };
5495
5496 exports.setTyped(TYPED_OK);
5497
5498 },{}],42:[function(require,module,exports){
5499 // String encode/decode helpers
5500 'use strict';
5501
5502
5503 var utils = require('./common');
5504
5505
5506 // Quick check if we can use fast array to bin string conversion
5507 //
5508 // - apply(Array) can fail on Android 2.2
5509 // - apply(Uint8Array) can fail on iOS 5.1 Safary
5510 //
5511 var STR_APPLY_OK = true;
5512 var STR_APPLY_UIA_OK = true;
5513
5514 try { String.fromCharCode.apply(null, [ 0 ]); } catch (__) { STR_APPLY_OK = false; }
5515 try { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; }
5516
5517
5518 // Table with utf8 lengths (calculated by first byte of sequence)
5519 // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
5520 // because max possible codepoint is 0x10ffff
5521 var _utf8len = new utils.Buf8(256);
5522 for (var q = 0; q < 256; q++) {
5523 _utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);
5524 }
5525 _utf8len[254] = _utf8len[254] = 1; // Invalid sequence start
5526
5527
5528 // convert string to array (typed, when possible)
5529 exports.string2buf = function (str) {
5530 var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
5531
5532 // count binary size
5533 for (m_pos = 0; m_pos < str_len; m_pos++) {
5534 c = str.charCodeAt(m_pos);
5535 if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
5536 c2 = str.charCodeAt(m_pos + 1);
5537 if ((c2 & 0xfc00) === 0xdc00) {
5538 c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
5539 m_pos++;
5540 }
5541 }
5542 buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
5543 }
5544
5545 // allocate buffer
5546 buf = new utils.Buf8(buf_len);
5547
5548 // convert
5549 for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
5550 c = str.charCodeAt(m_pos);
5551 if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
5552 c2 = str.charCodeAt(m_pos + 1);
5553 if ((c2 & 0xfc00) === 0xdc00) {
5554 c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
5555 m_pos++;
5556 }
5557 }
5558 if (c < 0x80) {
5559 /* one byte */
5560 buf[i++] = c;
5561 } else if (c < 0x800) {
5562 /* two bytes */
5563 buf[i++] = 0xC0 | (c >>> 6);
5564 buf[i++] = 0x80 | (c & 0x3f);
5565 } else if (c < 0x10000) {
5566 /* three bytes */
5567 buf[i++] = 0xE0 | (c >>> 12);
5568 buf[i++] = 0x80 | (c >>> 6 & 0x3f);
5569 buf[i++] = 0x80 | (c & 0x3f);
5570 } else {
5571 /* four bytes */
5572 buf[i++] = 0xf0 | (c >>> 18);
5573 buf[i++] = 0x80 | (c >>> 12 & 0x3f);
5574 buf[i++] = 0x80 | (c >>> 6 & 0x3f);
5575 buf[i++] = 0x80 | (c & 0x3f);
5576 }
5577 }
5578
5579 return buf;
5580 };
5581
5582 // Helper (used in 2 places)
5583 function buf2binstring(buf, len) {
5584 // use fallback for big arrays to avoid stack overflow
5585 if (len < 65537) {
5586 if ((buf.subarray && STR_APPLY_UIA_OK) || (!buf.subarray && STR_APPLY_OK)) {
5587 return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len));
5588 }
5589 }
5590
5591 var result = '';
5592 for (var i = 0; i < len; i++) {
5593 result += String.fromCharCode(buf[i]);
5594 }
5595 return result;
5596 }
5597
5598
5599 // Convert byte array to binary string
5600 exports.buf2binstring = function (buf) {
5601 return buf2binstring(buf, buf.length);
5602 };
5603
5604
5605 // Convert binary string (typed, when possible)
5606 exports.binstring2buf = function (str) {
5607 var buf = new utils.Buf8(str.length);
5608 for (var i = 0, len = buf.length; i < len; i++) {
5609 buf[i] = str.charCodeAt(i);
5610 }
5611 return buf;
5612 };
5613
5614
5615 // convert array to string
5616 exports.buf2string = function (buf, max) {
5617 var i, out, c, c_len;
5618 var len = max || buf.length;
5619
5620 // Reserve max possible length (2 words per char)
5621 // NB: by unknown reasons, Array is significantly faster for
5622 // String.fromCharCode.apply than Uint16Array.
5623 var utf16buf = new Array(len * 2);
5624
5625 for (out = 0, i = 0; i < len;) {
5626 c = buf[i++];
5627 // quick process ascii
5628 if (c < 0x80) { utf16buf[out++] = c; continue; }
5629
5630 c_len = _utf8len[c];
5631 // skip 5 & 6 byte codes
5632 if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; }
5633
5634 // apply mask on first byte
5635 c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
5636 // join the rest
5637 while (c_len > 1 && i < len) {
5638 c = (c << 6) | (buf[i++] & 0x3f);
5639 c_len--;
5640 }
5641
5642 // terminated by end of string?
5643 if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }
5644
5645 if (c < 0x10000) {
5646 utf16buf[out++] = c;
5647 } else {
5648 c -= 0x10000;
5649 utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);
5650 utf16buf[out++] = 0xdc00 | (c & 0x3ff);
5651 }
5652 }
5653
5654 return buf2binstring(utf16buf, out);
5655 };
5656
5657
5658 // Calculate max possible position in utf8 buffer,
5659 // that will not break sequence. If that's not possible
5660 // - (very small limits) return max size as is.
5661 //
5662 // buf[] - utf8 bytes array
5663 // max - length limit (mandatory);
5664 exports.utf8border = function (buf, max) {
5665 var pos;
5666
5667 max = max || buf.length;
5668 if (max > buf.length) { max = buf.length; }
5669
5670 // go back from last position, until start of sequence found
5671 pos = max - 1;
5672 while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }
5673
5674 // Fuckup - very small and broken sequence,
5675 // return max, because we should return something anyway.
5676 if (pos < 0) { return max; }
5677
5678 // If we came to start of buffer - that means vuffer is too small,
5679 // return max too.
5680 if (pos === 0) { return max; }
5681
5682 return (pos + _utf8len[buf[pos]] > max) ? pos : max;
5683 };
5684
5685 },{"./common":41}],43:[function(require,module,exports){
5686 'use strict';
5687
5688 // Note: adler32 takes 12% for level 0 and 2% for level 6.
5689 // It doesn't worth to make additional optimizationa as in original.
5690 // Small size is preferable.
5691
5692 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
5693 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
5694 //
5695 // This software is provided 'as-is', without any express or implied
5696 // warranty. In no event will the authors be held liable for any damages
5697 // arising from the use of this software.
5698 //
5699 // Permission is granted to anyone to use this software for any purpose,
5700 // including commercial applications, and to alter it and redistribute it
5701 // freely, subject to the following restrictions:
5702 //
5703 // 1. The origin of this software must not be misrepresented; you must not
5704 // claim that you wrote the original software. If you use this software
5705 // in a product, an acknowledgment in the product documentation would be
5706 // appreciated but is not required.
5707 // 2. Altered source versions must be plainly marked as such, and must not be
5708 // misrepresented as being the original software.
5709 // 3. This notice may not be removed or altered from any source distribution.
5710
5711 function adler32(adler, buf, len, pos) {
5712 var s1 = (adler & 0xffff) |0,
5713 s2 = ((adler >>> 16) & 0xffff) |0,
5714 n = 0;
5715
5716 while (len !== 0) {
5717 // Set limit ~ twice less than 5552, to keep
5718 // s2 in 31-bits, because we force signed ints.
5719 // in other case %= will fail.
5720 n = len > 2000 ? 2000 : len;
5721 len -= n;
5722
5723 do {
5724 s1 = (s1 + buf[pos++]) |0;
5725 s2 = (s2 + s1) |0;
5726 } while (--n);
5727
5728 s1 %= 65521;
5729 s2 %= 65521;
5730 }
5731
5732 return (s1 | (s2 << 16)) |0;
5733 }
5734
5735
5736 module.exports = adler32;
5737
5738 },{}],44:[function(require,module,exports){
5739 'use strict';
5740
5741 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
5742 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
5743 //
5744 // This software is provided 'as-is', without any express or implied
5745 // warranty. In no event will the authors be held liable for any damages
5746 // arising from the use of this software.
5747 //
5748 // Permission is granted to anyone to use this software for any purpose,
5749 // including commercial applications, and to alter it and redistribute it
5750 // freely, subject to the following restrictions:
5751 //
5752 // 1. The origin of this software must not be misrepresented; you must not
5753 // claim that you wrote the original software. If you use this software
5754 // in a product, an acknowledgment in the product documentation would be
5755 // appreciated but is not required.
5756 // 2. Altered source versions must be plainly marked as such, and must not be
5757 // misrepresented as being the original software.
5758 // 3. This notice may not be removed or altered from any source distribution.
5759
5760 module.exports = {
5761
5762 /* Allowed flush values; see deflate() and inflate() below for details */
5763 Z_NO_FLUSH: 0,
5764 Z_PARTIAL_FLUSH: 1,
5765 Z_SYNC_FLUSH: 2,
5766 Z_FULL_FLUSH: 3,
5767 Z_FINISH: 4,
5768 Z_BLOCK: 5,
5769 Z_TREES: 6,
5770
5771 /* Return codes for the compression/decompression functions. Negative values
5772 * are errors, positive values are used for special but normal events.
5773 */
5774 Z_OK: 0,
5775 Z_STREAM_END: 1,
5776 Z_NEED_DICT: 2,
5777 Z_ERRNO: -1,
5778 Z_STREAM_ERROR: -2,
5779 Z_DATA_ERROR: -3,
5780 //Z_MEM_ERROR: -4,
5781 Z_BUF_ERROR: -5,
5782 //Z_VERSION_ERROR: -6,
5783
5784 /* compression levels */
5785 Z_NO_COMPRESSION: 0,
5786 Z_BEST_SPEED: 1,
5787 Z_BEST_COMPRESSION: 9,
5788 Z_DEFAULT_COMPRESSION: -1,
5789
5790
5791 Z_FILTERED: 1,
5792 Z_HUFFMAN_ONLY: 2,
5793 Z_RLE: 3,
5794 Z_FIXED: 4,
5795 Z_DEFAULT_STRATEGY: 0,
5796
5797 /* Possible values of the data_type field (though see inflate()) */
5798 Z_BINARY: 0,
5799 Z_TEXT: 1,
5800 //Z_ASCII: 1, // = Z_TEXT (deprecated)
5801 Z_UNKNOWN: 2,
5802
5803 /* The deflate compression method */
5804 Z_DEFLATED: 8
5805 //Z_NULL: null // Use -1 or null inline, depending on var type
5806 };
5807
5808 },{}],45:[function(require,module,exports){
5809 'use strict';
5810
5811 // Note: we can't get significant speed boost here.
5812 // So write code to minimize size - no pregenerated tables
5813 // and array tools dependencies.
5814
5815 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
5816 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
5817 //
5818 // This software is provided 'as-is', without any express or implied
5819 // warranty. In no event will the authors be held liable for any damages
5820 // arising from the use of this software.
5821 //
5822 // Permission is granted to anyone to use this software for any purpose,
5823 // including commercial applications, and to alter it and redistribute it
5824 // freely, subject to the following restrictions:
5825 //
5826 // 1. The origin of this software must not be misrepresented; you must not
5827 // claim that you wrote the original software. If you use this software
5828 // in a product, an acknowledgment in the product documentation would be
5829 // appreciated but is not required.
5830 // 2. Altered source versions must be plainly marked as such, and must not be
5831 // misrepresented as being the original software.
5832 // 3. This notice may not be removed or altered from any source distribution.
5833
5834 // Use ordinary array, since untyped makes no boost here
5835 function makeTable() {
5836 var c, table = [];
5837
5838 for (var n = 0; n < 256; n++) {
5839 c = n;
5840 for (var k = 0; k < 8; k++) {
5841 c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
5842 }
5843 table[n] = c;
5844 }
5845
5846 return table;
5847 }
5848
5849 // Create table on load. Just 255 signed longs. Not a problem.
5850 var crcTable = makeTable();
5851
5852
5853 function crc32(crc, buf, len, pos) {
5854 var t = crcTable,
5855 end = pos + len;
5856
5857 crc ^= -1;
5858
5859 for (var i = pos; i < end; i++) {
5860 crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
5861 }
5862
5863 return (crc ^ (-1)); // >>> 0;
5864 }
5865
5866
5867 module.exports = crc32;
5868
5869 },{}],46:[function(require,module,exports){
5870 'use strict';
5871
5872 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
5873 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
5874 //
5875 // This software is provided 'as-is', without any express or implied
5876 // warranty. In no event will the authors be held liable for any damages
5877 // arising from the use of this software.
5878 //
5879 // Permission is granted to anyone to use this software for any purpose,
5880 // including commercial applications, and to alter it and redistribute it
5881 // freely, subject to the following restrictions:
5882 //
5883 // 1. The origin of this software must not be misrepresented; you must not
5884 // claim that you wrote the original software. If you use this software
5885 // in a product, an acknowledgment in the product documentation would be
5886 // appreciated but is not required.
5887 // 2. Altered source versions must be plainly marked as such, and must not be
5888 // misrepresented as being the original software.
5889 // 3. This notice may not be removed or altered from any source distribution.
5890
5891 var utils = require('../utils/common');
5892 var trees = require('./trees');
5893 var adler32 = require('./adler32');
5894 var crc32 = require('./crc32');
5895 var msg = require('./messages');
5896
5897 /* Public constants ==========================================================*/
5898 /* ===========================================================================*/
5899
5900
5901 /* Allowed flush values; see deflate() and inflate() below for details */
5902 var Z_NO_FLUSH = 0;
5903 var Z_PARTIAL_FLUSH = 1;
5904 //var Z_SYNC_FLUSH = 2;
5905 var Z_FULL_FLUSH = 3;
5906 var Z_FINISH = 4;
5907 var Z_BLOCK = 5;
5908 //var Z_TREES = 6;
5909
5910
5911 /* Return codes for the compression/decompression functions. Negative values
5912 * are errors, positive values are used for special but normal events.
5913 */
5914 var Z_OK = 0;
5915 var Z_STREAM_END = 1;
5916 //var Z_NEED_DICT = 2;
5917 //var Z_ERRNO = -1;
5918 var Z_STREAM_ERROR = -2;
5919 var Z_DATA_ERROR = -3;
5920 //var Z_MEM_ERROR = -4;
5921 var Z_BUF_ERROR = -5;
5922 //var Z_VERSION_ERROR = -6;
5923
5924
5925 /* compression levels */
5926 //var Z_NO_COMPRESSION = 0;
5927 //var Z_BEST_SPEED = 1;
5928 //var Z_BEST_COMPRESSION = 9;
5929 var Z_DEFAULT_COMPRESSION = -1;
5930
5931
5932 var Z_FILTERED = 1;
5933 var Z_HUFFMAN_ONLY = 2;
5934 var Z_RLE = 3;
5935 var Z_FIXED = 4;
5936 var Z_DEFAULT_STRATEGY = 0;
5937
5938 /* Possible values of the data_type field (though see inflate()) */
5939 //var Z_BINARY = 0;
5940 //var Z_TEXT = 1;
5941 //var Z_ASCII = 1; // = Z_TEXT
5942 var Z_UNKNOWN = 2;
5943
5944
5945 /* The deflate compression method */
5946 var Z_DEFLATED = 8;
5947
5948 /*============================================================================*/
5949
5950
5951 var MAX_MEM_LEVEL = 9;
5952 /* Maximum value for memLevel in deflateInit2 */
5953 var MAX_WBITS = 15;
5954 /* 32K LZ77 window */
5955 var DEF_MEM_LEVEL = 8;
5956
5957
5958 var LENGTH_CODES = 29;
5959 /* number of length codes, not counting the special END_BLOCK code */
5960 var LITERALS = 256;
5961 /* number of literal bytes 0..255 */
5962 var L_CODES = LITERALS + 1 + LENGTH_CODES;
5963 /* number of Literal or Length codes, including the END_BLOCK code */
5964 var D_CODES = 30;
5965 /* number of distance codes */
5966 var BL_CODES = 19;
5967 /* number of codes used to transfer the bit lengths */
5968 var HEAP_SIZE = 2 * L_CODES + 1;
5969 /* maximum heap size */
5970 var MAX_BITS = 15;
5971 /* All codes must not exceed MAX_BITS bits */
5972
5973 var MIN_MATCH = 3;
5974 var MAX_MATCH = 258;
5975 var MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);
5976
5977 var PRESET_DICT = 0x20;
5978
5979 var INIT_STATE = 42;
5980 var EXTRA_STATE = 69;
5981 var NAME_STATE = 73;
5982 var COMMENT_STATE = 91;
5983 var HCRC_STATE = 103;
5984 var BUSY_STATE = 113;
5985 var FINISH_STATE = 666;
5986
5987 var BS_NEED_MORE = 1; /* block not completed, need more input or more output */
5988 var BS_BLOCK_DONE = 2; /* block flush performed */
5989 var BS_FINISH_STARTED = 3; /* finish started, need only more output at next deflate */
5990 var BS_FINISH_DONE = 4; /* finish done, accept no more input or output */
5991
5992 var OS_CODE = 0x03; // Unix :) . Don't detect, use this default.
5993
5994 function err(strm, errorCode) {
5995 strm.msg = msg[errorCode];
5996 return errorCode;
5997 }
5998
5999 function rank(f) {
6000 return ((f) << 1) - ((f) > 4 ? 9 : 0);
6001 }
6002
6003 function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }
6004
6005
6006 /* =========================================================================
6007 * Flush as much pending output as possible. All deflate() output goes
6008 * through this function so some applications may wish to modify it
6009 * to avoid allocating a large strm->output buffer and copying into it.
6010 * (See also read_buf()).
6011 */
6012 function flush_pending(strm) {
6013 var s = strm.state;
6014
6015 //_tr_flush_bits(s);
6016 var len = s.pending;
6017 if (len > strm.avail_out) {
6018 len = strm.avail_out;
6019 }
6020 if (len === 0) { return; }
6021
6022 utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out);
6023 strm.next_out += len;
6024 s.pending_out += len;
6025 strm.total_out += len;
6026 strm.avail_out -= len;
6027 s.pending -= len;
6028 if (s.pending === 0) {
6029 s.pending_out = 0;
6030 }
6031 }
6032
6033
6034 function flush_block_only(s, last) {
6035 trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last);
6036 s.block_start = s.strstart;
6037 flush_pending(s.strm);
6038 }
6039
6040
6041 function put_byte(s, b) {
6042 s.pending_buf[s.pending++] = b;
6043 }
6044
6045
6046 /* =========================================================================
6047 * Put a short in the pending buffer. The 16-bit value is put in MSB order.
6048 * IN assertion: the stream state is correct and there is enough room in
6049 * pending_buf.
6050 */
6051 function putShortMSB(s, b) {
6052 // put_byte(s, (Byte)(b >> 8));
6053 // put_byte(s, (Byte)(b & 0xff));
6054 s.pending_buf[s.pending++] = (b >>> 8) & 0xff;
6055 s.pending_buf[s.pending++] = b & 0xff;
6056 }
6057
6058
6059 /* ===========================================================================
6060 * Read a new buffer from the current input stream, update the adler32
6061 * and total number of bytes read. All deflate() input goes through
6062 * this function so some applications may wish to modify it to avoid
6063 * allocating a large strm->input buffer and copying from it.
6064 * (See also flush_pending()).
6065 */
6066 function read_buf(strm, buf, start, size) {
6067 var len = strm.avail_in;
6068
6069 if (len > size) { len = size; }
6070 if (len === 0) { return 0; }
6071
6072 strm.avail_in -= len;
6073
6074 // zmemcpy(buf, strm->next_in, len);
6075 utils.arraySet(buf, strm.input, strm.next_in, len, start);
6076 if (strm.state.wrap === 1) {
6077 strm.adler = adler32(strm.adler, buf, len, start);
6078 }
6079
6080 else if (strm.state.wrap === 2) {
6081 strm.adler = crc32(strm.adler, buf, len, start);
6082 }
6083
6084 strm.next_in += len;
6085 strm.total_in += len;
6086
6087 return len;
6088 }
6089
6090
6091 /* ===========================================================================
6092 * Set match_start to the longest match starting at the given string and
6093 * return its length. Matches shorter or equal to prev_length are discarded,
6094 * in which case the result is equal to prev_length and match_start is
6095 * garbage.
6096 * IN assertions: cur_match is the head of the hash chain for the current
6097 * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
6098 * OUT assertion: the match length is not greater than s->lookahead.
6099 */
6100 function longest_match(s, cur_match) {
6101 var chain_length = s.max_chain_length; /* max hash chain length */
6102 var scan = s.strstart; /* current string */
6103 var match; /* matched string */
6104 var len; /* length of current match */
6105 var best_len = s.prev_length; /* best match length so far */
6106 var nice_match = s.nice_match; /* stop if match long enough */
6107 var limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ?
6108 s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0/*NIL*/;
6109
6110 var _win = s.window; // shortcut
6111
6112 var wmask = s.w_mask;
6113 var prev = s.prev;
6114
6115 /* Stop when cur_match becomes <= limit. To simplify the code,
6116 * we prevent matches with the string of window index 0.
6117 */
6118
6119 var strend = s.strstart + MAX_MATCH;
6120 var scan_end1 = _win[scan + best_len - 1];
6121 var scan_end = _win[scan + best_len];
6122
6123 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
6124 * It is easy to get rid of this optimization if necessary.
6125 */
6126 // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
6127
6128 /* Do not waste too much time if we already have a good match: */
6129 if (s.prev_length >= s.good_match) {
6130 chain_length >>= 2;
6131 }
6132 /* Do not look for matches beyond the end of the input. This is necessary
6133 * to make deflate deterministic.
6134 */
6135 if (nice_match > s.lookahead) { nice_match = s.lookahead; }
6136
6137 // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
6138
6139 do {
6140 // Assert(cur_match < s->strstart, "no future");
6141 match = cur_match;
6142
6143 /* Skip to next match if the match length cannot increase
6144 * or if the match length is less than 2. Note that the checks below
6145 * for insufficient lookahead only occur occasionally for performance
6146 * reasons. Therefore uninitialized memory will be accessed, and
6147 * conditional jumps will be made that depend on those values.
6148 * However the length of the match is limited to the lookahead, so
6149 * the output of deflate is not affected by the uninitialized values.
6150 */
6151
6152 if (_win[match + best_len] !== scan_end ||
6153 _win[match + best_len - 1] !== scan_end1 ||
6154 _win[match] !== _win[scan] ||
6155 _win[++match] !== _win[scan + 1]) {
6156 continue;
6157 }
6158
6159 /* The check at best_len-1 can be removed because it will be made
6160 * again later. (This heuristic is not always a win.)
6161 * It is not necessary to compare scan[2] and match[2] since they
6162 * are always equal when the other bytes match, given that
6163 * the hash keys are equal and that HASH_BITS >= 8.
6164 */
6165 scan += 2;
6166 match++;
6167 // Assert(*scan == *match, "match[2]?");
6168
6169 /* We check for insufficient lookahead only every 8th comparison;
6170 * the 256th check will be made at strstart+258.
6171 */
6172 do {
6173 /*jshint noempty:false*/
6174 } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
6175 _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
6176 _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
6177 _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
6178 scan < strend);
6179
6180 // Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
6181
6182 len = MAX_MATCH - (strend - scan);
6183 scan = strend - MAX_MATCH;
6184
6185 if (len > best_len) {
6186 s.match_start = cur_match;
6187 best_len = len;
6188 if (len >= nice_match) {
6189 break;
6190 }
6191 scan_end1 = _win[scan + best_len - 1];
6192 scan_end = _win[scan + best_len];
6193 }
6194 } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);
6195
6196 if (best_len <= s.lookahead) {
6197 return best_len;
6198 }
6199 return s.lookahead;
6200 }
6201
6202
6203 /* ===========================================================================
6204 * Fill the window when the lookahead becomes insufficient.
6205 * Updates strstart and lookahead.
6206 *
6207 * IN assertion: lookahead < MIN_LOOKAHEAD
6208 * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
6209 * At least one byte has been read, or avail_in == 0; reads are
6210 * performed for at least two bytes (required for the zip translate_eol
6211 * option -- not supported here).
6212 */
6213 function fill_window(s) {
6214 var _w_size = s.w_size;
6215 var p, n, m, more, str;
6216
6217 //Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
6218
6219 do {
6220 more = s.window_size - s.lookahead - s.strstart;
6221
6222 // JS ints have 32 bit, block below not needed
6223 /* Deal with !@#$% 64K limit: */
6224 //if (sizeof(int) <= 2) {
6225 // if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
6226 // more = wsize;
6227 //
6228 // } else if (more == (unsigned)(-1)) {
6229 // /* Very unlikely, but possible on 16 bit machine if
6230 // * strstart == 0 && lookahead == 1 (input done a byte at time)
6231 // */
6232 // more--;
6233 // }
6234 //}
6235
6236
6237 /* If the window is almost full and there is insufficient lookahead,
6238 * move the upper half to the lower one to make room in the upper half.
6239 */
6240 if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {
6241
6242 utils.arraySet(s.window, s.window, _w_size, _w_size, 0);
6243 s.match_start -= _w_size;
6244 s.strstart -= _w_size;
6245 /* we now have strstart >= MAX_DIST */
6246 s.block_start -= _w_size;
6247
6248 /* Slide the hash table (could be avoided with 32 bit values
6249 at the expense of memory usage). We slide even when level == 0
6250 to keep the hash table consistent if we switch back to level > 0
6251 later. (Using level 0 permanently is not an optimal usage of
6252 zlib, so we don't care about this pathological case.)
6253 */
6254
6255 n = s.hash_size;
6256 p = n;
6257 do {
6258 m = s.head[--p];
6259 s.head[p] = (m >= _w_size ? m - _w_size : 0);
6260 } while (--n);
6261
6262 n = _w_size;
6263 p = n;
6264 do {
6265 m = s.prev[--p];
6266 s.prev[p] = (m >= _w_size ? m - _w_size : 0);
6267 /* If n is not on any hash chain, prev[n] is garbage but
6268 * its value will never be used.
6269 */
6270 } while (--n);
6271
6272 more += _w_size;
6273 }
6274 if (s.strm.avail_in === 0) {
6275 break;
6276 }
6277
6278 /* If there was no sliding:
6279 * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
6280 * more == window_size - lookahead - strstart
6281 * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
6282 * => more >= window_size - 2*WSIZE + 2
6283 * In the BIG_MEM or MMAP case (not yet supported),
6284 * window_size == input_size + MIN_LOOKAHEAD &&
6285 * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
6286 * Otherwise, window_size == 2*WSIZE so more >= 2.
6287 * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
6288 */
6289 //Assert(more >= 2, "more < 2");
6290 n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);
6291 s.lookahead += n;
6292
6293 /* Initialize the hash value now that we have some input: */
6294 if (s.lookahead + s.insert >= MIN_MATCH) {
6295 str = s.strstart - s.insert;
6296 s.ins_h = s.window[str];
6297
6298 /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */
6299 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + 1]) & s.hash_mask;
6300 //#if MIN_MATCH != 3
6301 // Call update_hash() MIN_MATCH-3 more times
6302 //#endif
6303 while (s.insert) {
6304 /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
6305 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
6306
6307 s.prev[str & s.w_mask] = s.head[s.ins_h];
6308 s.head[s.ins_h] = str;
6309 str++;
6310 s.insert--;
6311 if (s.lookahead + s.insert < MIN_MATCH) {
6312 break;
6313 }
6314 }
6315 }
6316 /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
6317 * but this is not important since only literal bytes will be emitted.
6318 */
6319
6320 } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);
6321
6322 /* If the WIN_INIT bytes after the end of the current data have never been
6323 * written, then zero those bytes in order to avoid memory check reports of
6324 * the use of uninitialized (or uninitialised as Julian writes) bytes by
6325 * the longest match routines. Update the high water mark for the next
6326 * time through here. WIN_INIT is set to MAX_MATCH since the longest match
6327 * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
6328 */
6329 // if (s.high_water < s.window_size) {
6330 // var curr = s.strstart + s.lookahead;
6331 // var init = 0;
6332 //
6333 // if (s.high_water < curr) {
6334 // /* Previous high water mark below current data -- zero WIN_INIT
6335 // * bytes or up to end of window, whichever is less.
6336 // */
6337 // init = s.window_size - curr;
6338 // if (init > WIN_INIT)
6339 // init = WIN_INIT;
6340 // zmemzero(s->window + curr, (unsigned)init);
6341 // s->high_water = curr + init;
6342 // }
6343 // else if (s->high_water < (ulg)curr + WIN_INIT) {
6344 // /* High water mark at or above current data, but below current data
6345 // * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
6346 // * to end of window, whichever is less.
6347 // */
6348 // init = (ulg)curr + WIN_INIT - s->high_water;
6349 // if (init > s->window_size - s->high_water)
6350 // init = s->window_size - s->high_water;
6351 // zmemzero(s->window + s->high_water, (unsigned)init);
6352 // s->high_water += init;
6353 // }
6354 // }
6355 //
6356 // Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
6357 // "not enough room for search");
6358 }
6359
6360 /* ===========================================================================
6361 * Copy without compression as much as possible from the input stream, return
6362 * the current block state.
6363 * This function does not insert new strings in the dictionary since
6364 * uncompressible data is probably not useful. This function is used
6365 * only for the level=0 compression option.
6366 * NOTE: this function should be optimized to avoid extra copying from
6367 * window to pending_buf.
6368 */
6369 function deflate_stored(s, flush) {
6370 /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
6371 * to pending_buf_size, and each stored block has a 5 byte header:
6372 */
6373 var max_block_size = 0xffff;
6374
6375 if (max_block_size > s.pending_buf_size - 5) {
6376 max_block_size = s.pending_buf_size - 5;
6377 }
6378
6379 /* Copy as much as possible from input to output: */
6380 for (;;) {
6381 /* Fill the window as much as possible: */
6382 if (s.lookahead <= 1) {
6383
6384 //Assert(s->strstart < s->w_size+MAX_DIST(s) ||
6385 // s->block_start >= (long)s->w_size, "slide too late");
6386 // if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||
6387 // s.block_start >= s.w_size)) {
6388 // throw new Error("slide too late");
6389 // }
6390
6391 fill_window(s);
6392 if (s.lookahead === 0 && flush === Z_NO_FLUSH) {
6393 return BS_NEED_MORE;
6394 }
6395
6396 if (s.lookahead === 0) {
6397 break;
6398 }
6399 /* flush the current block */
6400 }
6401 //Assert(s->block_start >= 0L, "block gone");
6402 // if (s.block_start < 0) throw new Error("block gone");
6403
6404 s.strstart += s.lookahead;
6405 s.lookahead = 0;
6406
6407 /* Emit a stored block if pending_buf will be full: */
6408 var max_start = s.block_start + max_block_size;
6409
6410 if (s.strstart === 0 || s.strstart >= max_start) {
6411 /* strstart == 0 is possible when wraparound on 16-bit machine */
6412 s.lookahead = s.strstart - max_start;
6413 s.strstart = max_start;
6414 /*** FLUSH_BLOCK(s, 0); ***/
6415 flush_block_only(s, false);
6416 if (s.strm.avail_out === 0) {
6417 return BS_NEED_MORE;
6418 }
6419 /***/
6420
6421
6422 }
6423 /* Flush if we may have to slide, otherwise block_start may become
6424 * negative and the data will be gone:
6425 */
6426 if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) {
6427 /*** FLUSH_BLOCK(s, 0); ***/
6428 flush_block_only(s, false);
6429 if (s.strm.avail_out === 0) {
6430 return BS_NEED_MORE;
6431 }
6432 /***/
6433 }
6434 }
6435
6436 s.insert = 0;
6437
6438 if (flush === Z_FINISH) {
6439 /*** FLUSH_BLOCK(s, 1); ***/
6440 flush_block_only(s, true);
6441 if (s.strm.avail_out === 0) {
6442 return BS_FINISH_STARTED;
6443 }
6444 /***/
6445 return BS_FINISH_DONE;
6446 }
6447
6448 if (s.strstart > s.block_start) {
6449 /*** FLUSH_BLOCK(s, 0); ***/
6450 flush_block_only(s, false);
6451 if (s.strm.avail_out === 0) {
6452 return BS_NEED_MORE;
6453 }
6454 /***/
6455 }
6456
6457 return BS_NEED_MORE;
6458 }
6459
6460 /* ===========================================================================
6461 * Compress as much as possible from the input stream, return the current
6462 * block state.
6463 * This function does not perform lazy evaluation of matches and inserts
6464 * new strings in the dictionary only for unmatched strings or for short
6465 * matches. It is used only for the fast compression options.
6466 */
6467 function deflate_fast(s, flush) {
6468 var hash_head; /* head of the hash chain */
6469 var bflush; /* set if current block must be flushed */
6470
6471 for (;;) {
6472 /* Make sure that we always have enough lookahead, except
6473 * at the end of the input file. We need MAX_MATCH bytes
6474 * for the next match, plus MIN_MATCH bytes to insert the
6475 * string following the next match.
6476 */
6477 if (s.lookahead < MIN_LOOKAHEAD) {
6478 fill_window(s);
6479 if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
6480 return BS_NEED_MORE;
6481 }
6482 if (s.lookahead === 0) {
6483 break; /* flush the current block */
6484 }
6485 }
6486
6487 /* Insert the string window[strstart .. strstart+2] in the
6488 * dictionary, and set hash_head to the head of the hash chain:
6489 */
6490 hash_head = 0/*NIL*/;
6491 if (s.lookahead >= MIN_MATCH) {
6492 /*** INSERT_STRING(s, s.strstart, hash_head); ***/
6493 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
6494 hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
6495 s.head[s.ins_h] = s.strstart;
6496 /***/
6497 }
6498
6499 /* Find the longest match, discarding those <= prev_length.
6500 * At this point we have always match_length < MIN_MATCH
6501 */
6502 if (hash_head !== 0/*NIL*/ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) {
6503 /* To simplify the code, we prevent matches with the string
6504 * of window index 0 (in particular we have to avoid a match
6505 * of the string with itself at the start of the input file).
6506 */
6507 s.match_length = longest_match(s, hash_head);
6508 /* longest_match() sets match_start */
6509 }
6510 if (s.match_length >= MIN_MATCH) {
6511 // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only
6512
6513 /*** _tr_tally_dist(s, s.strstart - s.match_start,
6514 s.match_length - MIN_MATCH, bflush); ***/
6515 bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);
6516
6517 s.lookahead -= s.match_length;
6518
6519 /* Insert new strings in the hash table only if the match length
6520 * is not too large. This saves time but degrades compression.
6521 */
6522 if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH) {
6523 s.match_length--; /* string at strstart already in table */
6524 do {
6525 s.strstart++;
6526 /*** INSERT_STRING(s, s.strstart, hash_head); ***/
6527 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
6528 hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
6529 s.head[s.ins_h] = s.strstart;
6530 /***/
6531 /* strstart never exceeds WSIZE-MAX_MATCH, so there are
6532 * always MIN_MATCH bytes ahead.
6533 */
6534 } while (--s.match_length !== 0);
6535 s.strstart++;
6536 } else
6537 {
6538 s.strstart += s.match_length;
6539 s.match_length = 0;
6540 s.ins_h = s.window[s.strstart];
6541 /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */
6542 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + 1]) & s.hash_mask;
6543
6544 //#if MIN_MATCH != 3
6545 // Call UPDATE_HASH() MIN_MATCH-3 more times
6546 //#endif
6547 /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
6548 * matter since it will be recomputed at next deflate call.
6549 */
6550 }
6551 } else {
6552 /* No match, output a literal byte */
6553 //Tracevv((stderr,"%c", s.window[s.strstart]));
6554 /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
6555 bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
6556
6557 s.lookahead--;
6558 s.strstart++;
6559 }
6560 if (bflush) {
6561 /*** FLUSH_BLOCK(s, 0); ***/
6562 flush_block_only(s, false);
6563 if (s.strm.avail_out === 0) {
6564 return BS_NEED_MORE;
6565 }
6566 /***/
6567 }
6568 }
6569 s.insert = ((s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1);
6570 if (flush === Z_FINISH) {
6571 /*** FLUSH_BLOCK(s, 1); ***/
6572 flush_block_only(s, true);
6573 if (s.strm.avail_out === 0) {
6574 return BS_FINISH_STARTED;
6575 }
6576 /***/
6577 return BS_FINISH_DONE;
6578 }
6579 if (s.last_lit) {
6580 /*** FLUSH_BLOCK(s, 0); ***/
6581 flush_block_only(s, false);
6582 if (s.strm.avail_out === 0) {
6583 return BS_NEED_MORE;
6584 }
6585 /***/
6586 }
6587 return BS_BLOCK_DONE;
6588 }
6589
6590 /* ===========================================================================
6591 * Same as above, but achieves better compression. We use a lazy
6592 * evaluation for matches: a match is finally adopted only if there is
6593 * no better match at the next window position.
6594 */
6595 function deflate_slow(s, flush) {
6596 var hash_head; /* head of hash chain */
6597 var bflush; /* set if current block must be flushed */
6598
6599 var max_insert;
6600
6601 /* Process the input block. */
6602 for (;;) {
6603 /* Make sure that we always have enough lookahead, except
6604 * at the end of the input file. We need MAX_MATCH bytes
6605 * for the next match, plus MIN_MATCH bytes to insert the
6606 * string following the next match.
6607 */
6608 if (s.lookahead < MIN_LOOKAHEAD) {
6609 fill_window(s);
6610 if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
6611 return BS_NEED_MORE;
6612 }
6613 if (s.lookahead === 0) { break; } /* flush the current block */
6614 }
6615
6616 /* Insert the string window[strstart .. strstart+2] in the
6617 * dictionary, and set hash_head to the head of the hash chain:
6618 */
6619 hash_head = 0/*NIL*/;
6620 if (s.lookahead >= MIN_MATCH) {
6621 /*** INSERT_STRING(s, s.strstart, hash_head); ***/
6622 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
6623 hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
6624 s.head[s.ins_h] = s.strstart;
6625 /***/
6626 }
6627
6628 /* Find the longest match, discarding those <= prev_length.
6629 */
6630 s.prev_length = s.match_length;
6631 s.prev_match = s.match_start;
6632 s.match_length = MIN_MATCH - 1;
6633
6634 if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match &&
6635 s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)/*MAX_DIST(s)*/) {
6636 /* To simplify the code, we prevent matches with the string
6637 * of window index 0 (in particular we have to avoid a match
6638 * of the string with itself at the start of the input file).
6639 */
6640 s.match_length = longest_match(s, hash_head);
6641 /* longest_match() sets match_start */
6642
6643 if (s.match_length <= 5 &&
6644 (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/*TOO_FAR*/))) {
6645
6646 /* If prev_match is also MIN_MATCH, match_start is garbage
6647 * but we will ignore the current match anyway.
6648 */
6649 s.match_length = MIN_MATCH - 1;
6650 }
6651 }
6652 /* If there was a match at the previous step and the current
6653 * match is not better, output the previous match:
6654 */
6655 if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {
6656 max_insert = s.strstart + s.lookahead - MIN_MATCH;
6657 /* Do not insert strings in hash table beyond this. */
6658
6659 //check_match(s, s.strstart-1, s.prev_match, s.prev_length);
6660
6661 /***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,
6662 s.prev_length - MIN_MATCH, bflush);***/
6663 bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);
6664 /* Insert in hash table all strings up to the end of the match.
6665 * strstart-1 and strstart are already inserted. If there is not
6666 * enough lookahead, the last two strings are not inserted in
6667 * the hash table.
6668 */
6669 s.lookahead -= s.prev_length - 1;
6670 s.prev_length -= 2;
6671 do {
6672 if (++s.strstart <= max_insert) {
6673 /*** INSERT_STRING(s, s.strstart, hash_head); ***/
6674 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
6675 hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
6676 s.head[s.ins_h] = s.strstart;
6677 /***/
6678 }
6679 } while (--s.prev_length !== 0);
6680 s.match_available = 0;
6681 s.match_length = MIN_MATCH - 1;
6682 s.strstart++;
6683
6684 if (bflush) {
6685 /*** FLUSH_BLOCK(s, 0); ***/
6686 flush_block_only(s, false);
6687 if (s.strm.avail_out === 0) {
6688 return BS_NEED_MORE;
6689 }
6690 /***/
6691 }
6692
6693 } else if (s.match_available) {
6694 /* If there was no match at the previous position, output a
6695 * single literal. If there was a match but the current match
6696 * is longer, truncate the previous match to a single literal.
6697 */
6698 //Tracevv((stderr,"%c", s->window[s->strstart-1]));
6699 /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
6700 bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
6701
6702 if (bflush) {
6703 /*** FLUSH_BLOCK_ONLY(s, 0) ***/
6704 flush_block_only(s, false);
6705 /***/
6706 }
6707 s.strstart++;
6708 s.lookahead--;
6709 if (s.strm.avail_out === 0) {
6710 return BS_NEED_MORE;
6711 }
6712 } else {
6713 /* There is no previous match to compare with, wait for
6714 * the next step to decide.
6715 */
6716 s.match_available = 1;
6717 s.strstart++;
6718 s.lookahead--;
6719 }
6720 }
6721 //Assert (flush != Z_NO_FLUSH, "no flush?");
6722 if (s.match_available) {
6723 //Tracevv((stderr,"%c", s->window[s->strstart-1]));
6724 /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
6725 bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
6726
6727 s.match_available = 0;
6728 }
6729 s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
6730 if (flush === Z_FINISH) {
6731 /*** FLUSH_BLOCK(s, 1); ***/
6732 flush_block_only(s, true);
6733 if (s.strm.avail_out === 0) {
6734 return BS_FINISH_STARTED;
6735 }
6736 /***/
6737 return BS_FINISH_DONE;
6738 }
6739 if (s.last_lit) {
6740 /*** FLUSH_BLOCK(s, 0); ***/
6741 flush_block_only(s, false);
6742 if (s.strm.avail_out === 0) {
6743 return BS_NEED_MORE;
6744 }
6745 /***/
6746 }
6747
6748 return BS_BLOCK_DONE;
6749 }
6750
6751
6752 /* ===========================================================================
6753 * For Z_RLE, simply look for runs of bytes, generate matches only of distance
6754 * one. Do not maintain a hash table. (It will be regenerated if this run of
6755 * deflate switches away from Z_RLE.)
6756 */
6757 function deflate_rle(s, flush) {
6758 var bflush; /* set if current block must be flushed */
6759 var prev; /* byte at distance one to match */
6760 var scan, strend; /* scan goes up to strend for length of run */
6761
6762 var _win = s.window;
6763
6764 for (;;) {
6765 /* Make sure that we always have enough lookahead, except
6766 * at the end of the input file. We need MAX_MATCH bytes
6767 * for the longest run, plus one for the unrolled loop.
6768 */
6769 if (s.lookahead <= MAX_MATCH) {
6770 fill_window(s);
6771 if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) {
6772 return BS_NEED_MORE;
6773 }
6774 if (s.lookahead === 0) { break; } /* flush the current block */
6775 }
6776
6777 /* See how many times the previous byte repeats */
6778 s.match_length = 0;
6779 if (s.lookahead >= MIN_MATCH && s.strstart > 0) {
6780 scan = s.strstart - 1;
6781 prev = _win[scan];
6782 if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {
6783 strend = s.strstart + MAX_MATCH;
6784 do {
6785 /*jshint noempty:false*/
6786 } while (prev === _win[++scan] && prev === _win[++scan] &&
6787 prev === _win[++scan] && prev === _win[++scan] &&
6788 prev === _win[++scan] && prev === _win[++scan] &&
6789 prev === _win[++scan] && prev === _win[++scan] &&
6790 scan < strend);
6791 s.match_length = MAX_MATCH - (strend - scan);
6792 if (s.match_length > s.lookahead) {
6793 s.match_length = s.lookahead;
6794 }
6795 }
6796 //Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
6797 }
6798
6799 /* Emit match if have run of MIN_MATCH or longer, else emit literal */
6800 if (s.match_length >= MIN_MATCH) {
6801 //check_match(s, s.strstart, s.strstart - 1, s.match_length);
6802
6803 /*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/
6804 bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH);
6805
6806 s.lookahead -= s.match_length;
6807 s.strstart += s.match_length;
6808 s.match_length = 0;
6809 } else {
6810 /* No match, output a literal byte */
6811 //Tracevv((stderr,"%c", s->window[s->strstart]));
6812 /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
6813 bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
6814
6815 s.lookahead--;
6816 s.strstart++;
6817 }
6818 if (bflush) {
6819 /*** FLUSH_BLOCK(s, 0); ***/
6820 flush_block_only(s, false);
6821 if (s.strm.avail_out === 0) {
6822 return BS_NEED_MORE;
6823 }
6824 /***/
6825 }
6826 }
6827 s.insert = 0;
6828 if (flush === Z_FINISH) {
6829 /*** FLUSH_BLOCK(s, 1); ***/
6830 flush_block_only(s, true);
6831 if (s.strm.avail_out === 0) {
6832 return BS_FINISH_STARTED;
6833 }
6834 /***/
6835 return BS_FINISH_DONE;
6836 }
6837 if (s.last_lit) {
6838 /*** FLUSH_BLOCK(s, 0); ***/
6839 flush_block_only(s, false);
6840 if (s.strm.avail_out === 0) {
6841 return BS_NEED_MORE;
6842 }
6843 /***/
6844 }
6845 return BS_BLOCK_DONE;
6846 }
6847
6848 /* ===========================================================================
6849 * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table.
6850 * (It will be regenerated if this run of deflate switches away from Huffman.)
6851 */
6852 function deflate_huff(s, flush) {
6853 var bflush; /* set if current block must be flushed */
6854
6855 for (;;) {
6856 /* Make sure that we have a literal to write. */
6857 if (s.lookahead === 0) {
6858 fill_window(s);
6859 if (s.lookahead === 0) {
6860 if (flush === Z_NO_FLUSH) {
6861 return BS_NEED_MORE;
6862 }
6863 break; /* flush the current block */
6864 }
6865 }
6866
6867 /* Output a literal byte */
6868 s.match_length = 0;
6869 //Tracevv((stderr,"%c", s->window[s->strstart]));
6870 /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
6871 bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
6872 s.lookahead--;
6873 s.strstart++;
6874 if (bflush) {
6875 /*** FLUSH_BLOCK(s, 0); ***/
6876 flush_block_only(s, false);
6877 if (s.strm.avail_out === 0) {
6878 return BS_NEED_MORE;
6879 }
6880 /***/
6881 }
6882 }
6883 s.insert = 0;
6884 if (flush === Z_FINISH) {
6885 /*** FLUSH_BLOCK(s, 1); ***/
6886 flush_block_only(s, true);
6887 if (s.strm.avail_out === 0) {
6888 return BS_FINISH_STARTED;
6889 }
6890 /***/
6891 return BS_FINISH_DONE;
6892 }
6893 if (s.last_lit) {
6894 /*** FLUSH_BLOCK(s, 0); ***/
6895 flush_block_only(s, false);
6896 if (s.strm.avail_out === 0) {
6897 return BS_NEED_MORE;
6898 }
6899 /***/
6900 }
6901 return BS_BLOCK_DONE;
6902 }
6903
6904 /* Values for max_lazy_match, good_match and max_chain_length, depending on
6905 * the desired pack level (0..9). The values given below have been tuned to
6906 * exclude worst case performance for pathological files. Better values may be
6907 * found for specific files.
6908 */
6909 function Config(good_length, max_lazy, nice_length, max_chain, func) {
6910 this.good_length = good_length;
6911 this.max_lazy = max_lazy;
6912 this.nice_length = nice_length;
6913 this.max_chain = max_chain;
6914 this.func = func;
6915 }
6916
6917 var configuration_table;
6918
6919 configuration_table = [
6920 /* good lazy nice chain */
6921 new Config(0, 0, 0, 0, deflate_stored), /* 0 store only */
6922 new Config(4, 4, 8, 4, deflate_fast), /* 1 max speed, no lazy matches */
6923 new Config(4, 5, 16, 8, deflate_fast), /* 2 */
6924 new Config(4, 6, 32, 32, deflate_fast), /* 3 */
6925
6926 new Config(4, 4, 16, 16, deflate_slow), /* 4 lazy matches */
6927 new Config(8, 16, 32, 32, deflate_slow), /* 5 */
6928 new Config(8, 16, 128, 128, deflate_slow), /* 6 */
6929 new Config(8, 32, 128, 256, deflate_slow), /* 7 */
6930 new Config(32, 128, 258, 1024, deflate_slow), /* 8 */
6931 new Config(32, 258, 258, 4096, deflate_slow) /* 9 max compression */
6932 ];
6933
6934
6935 /* ===========================================================================
6936 * Initialize the "longest match" routines for a new zlib stream
6937 */
6938 function lm_init(s) {
6939 s.window_size = 2 * s.w_size;
6940
6941 /*** CLEAR_HASH(s); ***/
6942 zero(s.head); // Fill with NIL (= 0);
6943
6944 /* Set the default configuration parameters:
6945 */
6946 s.max_lazy_match = configuration_table[s.level].max_lazy;
6947 s.good_match = configuration_table[s.level].good_length;
6948 s.nice_match = configuration_table[s.level].nice_length;
6949 s.max_chain_length = configuration_table[s.level].max_chain;
6950
6951 s.strstart = 0;
6952 s.block_start = 0;
6953 s.lookahead = 0;
6954 s.insert = 0;
6955 s.match_length = s.prev_length = MIN_MATCH - 1;
6956 s.match_available = 0;
6957 s.ins_h = 0;
6958 }
6959
6960
6961 function DeflateState() {
6962 this.strm = null; /* pointer back to this zlib stream */
6963 this.status = 0; /* as the name implies */
6964 this.pending_buf = null; /* output still pending */
6965 this.pending_buf_size = 0; /* size of pending_buf */
6966 this.pending_out = 0; /* next pending byte to output to the stream */
6967 this.pending = 0; /* nb of bytes in the pending buffer */
6968 this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */
6969 this.gzhead = null; /* gzip header information to write */
6970 this.gzindex = 0; /* where in extra, name, or comment */
6971 this.method = Z_DEFLATED; /* can only be DEFLATED */
6972 this.last_flush = -1; /* value of flush param for previous deflate call */
6973
6974 this.w_size = 0; /* LZ77 window size (32K by default) */
6975 this.w_bits = 0; /* log2(w_size) (8..16) */
6976 this.w_mask = 0; /* w_size - 1 */
6977
6978 this.window = null;
6979 /* Sliding window. Input bytes are read into the second half of the window,
6980 * and move to the first half later to keep a dictionary of at least wSize
6981 * bytes. With this organization, matches are limited to a distance of
6982 * wSize-MAX_MATCH bytes, but this ensures that IO is always
6983 * performed with a length multiple of the block size.
6984 */
6985
6986 this.window_size = 0;
6987 /* Actual size of window: 2*wSize, except when the user input buffer
6988 * is directly used as sliding window.
6989 */
6990
6991 this.prev = null;
6992 /* Link to older string with same hash index. To limit the size of this
6993 * array to 64K, this link is maintained only for the last 32K strings.
6994 * An index in this array is thus a window index modulo 32K.
6995 */
6996
6997 this.head = null; /* Heads of the hash chains or NIL. */
6998
6999 this.ins_h = 0; /* hash index of string to be inserted */
7000 this.hash_size = 0; /* number of elements in hash table */
7001 this.hash_bits = 0; /* log2(hash_size) */
7002 this.hash_mask = 0; /* hash_size-1 */
7003
7004 this.hash_shift = 0;
7005 /* Number of bits by which ins_h must be shifted at each input
7006 * step. It must be such that after MIN_MATCH steps, the oldest
7007 * byte no longer takes part in the hash key, that is:
7008 * hash_shift * MIN_MATCH >= hash_bits
7009 */
7010
7011 this.block_start = 0;
7012 /* Window position at the beginning of the current output block. Gets
7013 * negative when the window is moved backwards.
7014 */
7015
7016 this.match_length = 0; /* length of best match */
7017 this.prev_match = 0; /* previous match */
7018 this.match_available = 0; /* set if previous match exists */
7019 this.strstart = 0; /* start of string to insert */
7020 this.match_start = 0; /* start of matching string */
7021 this.lookahead = 0; /* number of valid bytes ahead in window */
7022
7023 this.prev_length = 0;
7024 /* Length of the best match at previous step. Matches not greater than this
7025 * are discarded. This is used in the lazy match evaluation.
7026 */
7027
7028 this.max_chain_length = 0;
7029 /* To speed up deflation, hash chains are never searched beyond this
7030 * length. A higher limit improves compression ratio but degrades the
7031 * speed.
7032 */
7033
7034 this.max_lazy_match = 0;
7035 /* Attempt to find a better match only when the current match is strictly
7036 * smaller than this value. This mechanism is used only for compression
7037 * levels >= 4.
7038 */
7039 // That's alias to max_lazy_match, don't use directly
7040 //this.max_insert_length = 0;
7041 /* Insert new strings in the hash table only if the match length is not
7042 * greater than this length. This saves time but degrades compression.
7043 * max_insert_length is used only for compression levels <= 3.
7044 */
7045
7046 this.level = 0; /* compression level (1..9) */
7047 this.strategy = 0; /* favor or force Huffman coding*/
7048
7049 this.good_match = 0;
7050 /* Use a faster search when the previous match is longer than this */
7051
7052 this.nice_match = 0; /* Stop searching when current match exceeds this */
7053
7054 /* used by trees.c: */
7055
7056 /* Didn't use ct_data typedef below to suppress compiler warning */
7057
7058 // struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */
7059 // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
7060 // struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */
7061
7062 // Use flat array of DOUBLE size, with interleaved fata,
7063 // because JS does not support effective
7064 this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2);
7065 this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2);
7066 this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2);
7067 zero(this.dyn_ltree);
7068 zero(this.dyn_dtree);
7069 zero(this.bl_tree);
7070
7071 this.l_desc = null; /* desc. for literal tree */
7072 this.d_desc = null; /* desc. for distance tree */
7073 this.bl_desc = null; /* desc. for bit length tree */
7074
7075 //ush bl_count[MAX_BITS+1];
7076 this.bl_count = new utils.Buf16(MAX_BITS + 1);
7077 /* number of codes at each bit length for an optimal tree */
7078
7079 //int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
7080 this.heap = new utils.Buf16(2 * L_CODES + 1); /* heap used to build the Huffman trees */
7081 zero(this.heap);
7082
7083 this.heap_len = 0; /* number of elements in the heap */
7084 this.heap_max = 0; /* element of largest frequency */
7085 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
7086 * The same heap array is used to build all trees.
7087 */
7088
7089 this.depth = new utils.Buf16(2 * L_CODES + 1); //uch depth[2*L_CODES+1];
7090 zero(this.depth);
7091 /* Depth of each subtree used as tie breaker for trees of equal frequency
7092 */
7093
7094 this.l_buf = 0; /* buffer index for literals or lengths */
7095
7096 this.lit_bufsize = 0;
7097 /* Size of match buffer for literals/lengths. There are 4 reasons for
7098 * limiting lit_bufsize to 64K:
7099 * - frequencies can be kept in 16 bit counters
7100 * - if compression is not successful for the first block, all input
7101 * data is still in the window so we can still emit a stored block even
7102 * when input comes from standard input. (This can also be done for
7103 * all blocks if lit_bufsize is not greater than 32K.)
7104 * - if compression is not successful for a file smaller than 64K, we can
7105 * even emit a stored file instead of a stored block (saving 5 bytes).
7106 * This is applicable only for zip (not gzip or zlib).
7107 * - creating new Huffman trees less frequently may not provide fast
7108 * adaptation to changes in the input data statistics. (Take for
7109 * example a binary file with poorly compressible code followed by
7110 * a highly compressible string table.) Smaller buffer sizes give
7111 * fast adaptation but have of course the overhead of transmitting
7112 * trees more frequently.
7113 * - I can't count above 4
7114 */
7115
7116 this.last_lit = 0; /* running index in l_buf */
7117
7118 this.d_buf = 0;
7119 /* Buffer index for distances. To simplify the code, d_buf and l_buf have
7120 * the same number of elements. To use different lengths, an extra flag
7121 * array would be necessary.
7122 */
7123
7124 this.opt_len = 0; /* bit length of current block with optimal trees */
7125 this.static_len = 0; /* bit length of current block with static trees */
7126 this.matches = 0; /* number of string matches in current block */
7127 this.insert = 0; /* bytes at end of window left to insert */
7128
7129
7130 this.bi_buf = 0;
7131 /* Output buffer. bits are inserted starting at the bottom (least
7132 * significant bits).
7133 */
7134 this.bi_valid = 0;
7135 /* Number of valid bits in bi_buf. All bits above the last valid bit
7136 * are always zero.
7137 */
7138
7139 // Used for window memory init. We safely ignore it for JS. That makes
7140 // sense only for pointers and memory check tools.
7141 //this.high_water = 0;
7142 /* High water mark offset in window for initialized bytes -- bytes above
7143 * this are set to zero in order to avoid memory check warnings when
7144 * longest match routines access bytes past the input. This is then
7145 * updated to the new high water mark.
7146 */
7147 }
7148
7149
7150 function deflateResetKeep(strm) {
7151 var s;
7152
7153 if (!strm || !strm.state) {
7154 return err(strm, Z_STREAM_ERROR);
7155 }
7156
7157 strm.total_in = strm.total_out = 0;
7158 strm.data_type = Z_UNKNOWN;
7159
7160 s = strm.state;
7161 s.pending = 0;
7162 s.pending_out = 0;
7163
7164 if (s.wrap < 0) {
7165 s.wrap = -s.wrap;
7166 /* was made negative by deflate(..., Z_FINISH); */
7167 }
7168 s.status = (s.wrap ? INIT_STATE : BUSY_STATE);
7169 strm.adler = (s.wrap === 2) ?
7170 0 // crc32(0, Z_NULL, 0)
7171 :
7172 1; // adler32(0, Z_NULL, 0)
7173 s.last_flush = Z_NO_FLUSH;
7174 trees._tr_init(s);
7175 return Z_OK;
7176 }
7177
7178
7179 function deflateReset(strm) {
7180 var ret = deflateResetKeep(strm);
7181 if (ret === Z_OK) {
7182 lm_init(strm.state);
7183 }
7184 return ret;
7185 }
7186
7187
7188 function deflateSetHeader(strm, head) {
7189 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
7190 if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; }
7191 strm.state.gzhead = head;
7192 return Z_OK;
7193 }
7194
7195
7196 function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {
7197 if (!strm) { // === Z_NULL
7198 return Z_STREAM_ERROR;
7199 }
7200 var wrap = 1;
7201
7202 if (level === Z_DEFAULT_COMPRESSION) {
7203 level = 6;
7204 }
7205
7206 if (windowBits < 0) { /* suppress zlib wrapper */
7207 wrap = 0;
7208 windowBits = -windowBits;
7209 }
7210
7211 else if (windowBits > 15) {
7212 wrap = 2; /* write gzip wrapper instead */
7213 windowBits -= 16;
7214 }
7215
7216
7217 if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED ||
7218 windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
7219 strategy < 0 || strategy > Z_FIXED) {
7220 return err(strm, Z_STREAM_ERROR);
7221 }
7222
7223
7224 if (windowBits === 8) {
7225 windowBits = 9;
7226 }
7227 /* until 256-byte window bug fixed */
7228
7229 var s = new DeflateState();
7230
7231 strm.state = s;
7232 s.strm = strm;
7233
7234 s.wrap = wrap;
7235 s.gzhead = null;
7236 s.w_bits = windowBits;
7237 s.w_size = 1 << s.w_bits;
7238 s.w_mask = s.w_size - 1;
7239
7240 s.hash_bits = memLevel + 7;
7241 s.hash_size = 1 << s.hash_bits;
7242 s.hash_mask = s.hash_size - 1;
7243 s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
7244
7245 s.window = new utils.Buf8(s.w_size * 2);
7246 s.head = new utils.Buf16(s.hash_size);
7247 s.prev = new utils.Buf16(s.w_size);
7248
7249 // Don't need mem init magic for JS.
7250 //s.high_water = 0; /* nothing written to s->window yet */
7251
7252 s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
7253
7254 s.pending_buf_size = s.lit_bufsize * 4;
7255
7256 //overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
7257 //s->pending_buf = (uchf *) overlay;
7258 s.pending_buf = new utils.Buf8(s.pending_buf_size);
7259
7260 // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)
7261 //s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
7262 s.d_buf = 1 * s.lit_bufsize;
7263
7264 //s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
7265 s.l_buf = (1 + 2) * s.lit_bufsize;
7266
7267 s.level = level;
7268 s.strategy = strategy;
7269 s.method = method;
7270
7271 return deflateReset(strm);
7272 }
7273
7274 function deflateInit(strm, level) {
7275 return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
7276 }
7277
7278
7279 function deflate(strm, flush) {
7280 var old_flush, s;
7281 var beg, val; // for gzip header write only
7282
7283 if (!strm || !strm.state ||
7284 flush > Z_BLOCK || flush < 0) {
7285 return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;
7286 }
7287
7288 s = strm.state;
7289
7290 if (!strm.output ||
7291 (!strm.input && strm.avail_in !== 0) ||
7292 (s.status === FINISH_STATE && flush !== Z_FINISH)) {
7293 return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR);
7294 }
7295
7296 s.strm = strm; /* just in case */
7297 old_flush = s.last_flush;
7298 s.last_flush = flush;
7299
7300 /* Write the header */
7301 if (s.status === INIT_STATE) {
7302
7303 if (s.wrap === 2) { // GZIP header
7304 strm.adler = 0; //crc32(0L, Z_NULL, 0);
7305 put_byte(s, 31);
7306 put_byte(s, 139);
7307 put_byte(s, 8);
7308 if (!s.gzhead) { // s->gzhead == Z_NULL
7309 put_byte(s, 0);
7310 put_byte(s, 0);
7311 put_byte(s, 0);
7312 put_byte(s, 0);
7313 put_byte(s, 0);
7314 put_byte(s, s.level === 9 ? 2 :
7315 (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
7316 4 : 0));
7317 put_byte(s, OS_CODE);
7318 s.status = BUSY_STATE;
7319 }
7320 else {
7321 put_byte(s, (s.gzhead.text ? 1 : 0) +
7322 (s.gzhead.hcrc ? 2 : 0) +
7323 (!s.gzhead.extra ? 0 : 4) +
7324 (!s.gzhead.name ? 0 : 8) +
7325 (!s.gzhead.comment ? 0 : 16)
7326 );
7327 put_byte(s, s.gzhead.time & 0xff);
7328 put_byte(s, (s.gzhead.time >> 8) & 0xff);
7329 put_byte(s, (s.gzhead.time >> 16) & 0xff);
7330 put_byte(s, (s.gzhead.time >> 24) & 0xff);
7331 put_byte(s, s.level === 9 ? 2 :
7332 (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
7333 4 : 0));
7334 put_byte(s, s.gzhead.os & 0xff);
7335 if (s.gzhead.extra && s.gzhead.extra.length) {
7336 put_byte(s, s.gzhead.extra.length & 0xff);
7337 put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);
7338 }
7339 if (s.gzhead.hcrc) {
7340 strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0);
7341 }
7342 s.gzindex = 0;
7343 s.status = EXTRA_STATE;
7344 }
7345 }
7346 else // DEFLATE header
7347 {
7348 var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;
7349 var level_flags = -1;
7350
7351 if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
7352 level_flags = 0;
7353 } else if (s.level < 6) {
7354 level_flags = 1;
7355 } else if (s.level === 6) {
7356 level_flags = 2;
7357 } else {
7358 level_flags = 3;
7359 }
7360 header |= (level_flags << 6);
7361 if (s.strstart !== 0) { header |= PRESET_DICT; }
7362 header += 31 - (header % 31);
7363
7364 s.status = BUSY_STATE;
7365 putShortMSB(s, header);
7366
7367 /* Save the adler32 of the preset dictionary: */
7368 if (s.strstart !== 0) {
7369 putShortMSB(s, strm.adler >>> 16);
7370 putShortMSB(s, strm.adler & 0xffff);
7371 }
7372 strm.adler = 1; // adler32(0L, Z_NULL, 0);
7373 }
7374 }
7375
7376 //#ifdef GZIP
7377 if (s.status === EXTRA_STATE) {
7378 if (s.gzhead.extra/* != Z_NULL*/) {
7379 beg = s.pending; /* start of bytes to update crc */
7380
7381 while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {
7382 if (s.pending === s.pending_buf_size) {
7383 if (s.gzhead.hcrc && s.pending > beg) {
7384 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
7385 }
7386 flush_pending(strm);
7387 beg = s.pending;
7388 if (s.pending === s.pending_buf_size) {
7389 break;
7390 }
7391 }
7392 put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);
7393 s.gzindex++;
7394 }
7395 if (s.gzhead.hcrc && s.pending > beg) {
7396 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
7397 }
7398 if (s.gzindex === s.gzhead.extra.length) {
7399 s.gzindex = 0;
7400 s.status = NAME_STATE;
7401 }
7402 }
7403 else {
7404 s.status = NAME_STATE;
7405 }
7406 }
7407 if (s.status === NAME_STATE) {
7408 if (s.gzhead.name/* != Z_NULL*/) {
7409 beg = s.pending; /* start of bytes to update crc */
7410 //int val;
7411
7412 do {
7413 if (s.pending === s.pending_buf_size) {
7414 if (s.gzhead.hcrc && s.pending > beg) {
7415 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
7416 }
7417 flush_pending(strm);
7418 beg = s.pending;
7419 if (s.pending === s.pending_buf_size) {
7420 val = 1;
7421 break;
7422 }
7423 }
7424 // JS specific: little magic to add zero terminator to end of string
7425 if (s.gzindex < s.gzhead.name.length) {
7426 val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;
7427 } else {
7428 val = 0;
7429 }
7430 put_byte(s, val);
7431 } while (val !== 0);
7432
7433 if (s.gzhead.hcrc && s.pending > beg) {
7434 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
7435 }
7436 if (val === 0) {
7437 s.gzindex = 0;
7438 s.status = COMMENT_STATE;
7439 }
7440 }
7441 else {
7442 s.status = COMMENT_STATE;
7443 }
7444 }
7445 if (s.status === COMMENT_STATE) {
7446 if (s.gzhead.comment/* != Z_NULL*/) {
7447 beg = s.pending; /* start of bytes to update crc */
7448 //int val;
7449
7450 do {
7451 if (s.pending === s.pending_buf_size) {
7452 if (s.gzhead.hcrc && s.pending > beg) {
7453 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
7454 }
7455 flush_pending(strm);
7456 beg = s.pending;
7457 if (s.pending === s.pending_buf_size) {
7458 val = 1;
7459 break;
7460 }
7461 }
7462 // JS specific: little magic to add zero terminator to end of string
7463 if (s.gzindex < s.gzhead.comment.length) {
7464 val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;
7465 } else {
7466 val = 0;
7467 }
7468 put_byte(s, val);
7469 } while (val !== 0);
7470
7471 if (s.gzhead.hcrc && s.pending > beg) {
7472 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
7473 }
7474 if (val === 0) {
7475 s.status = HCRC_STATE;
7476 }
7477 }
7478 else {
7479 s.status = HCRC_STATE;
7480 }
7481 }
7482 if (s.status === HCRC_STATE) {
7483 if (s.gzhead.hcrc) {
7484 if (s.pending + 2 > s.pending_buf_size) {
7485 flush_pending(strm);
7486 }
7487 if (s.pending + 2 <= s.pending_buf_size) {
7488 put_byte(s, strm.adler & 0xff);
7489 put_byte(s, (strm.adler >> 8) & 0xff);
7490 strm.adler = 0; //crc32(0L, Z_NULL, 0);
7491 s.status = BUSY_STATE;
7492 }
7493 }
7494 else {
7495 s.status = BUSY_STATE;
7496 }
7497 }
7498 //#endif
7499
7500 /* Flush as much pending output as possible */
7501 if (s.pending !== 0) {
7502 flush_pending(strm);
7503 if (strm.avail_out === 0) {
7504 /* Since avail_out is 0, deflate will be called again with
7505 * more output space, but possibly with both pending and
7506 * avail_in equal to zero. There won't be anything to do,
7507 * but this is not an error situation so make sure we
7508 * return OK instead of BUF_ERROR at next call of deflate:
7509 */
7510 s.last_flush = -1;
7511 return Z_OK;
7512 }
7513
7514 /* Make sure there is something to do and avoid duplicate consecutive
7515 * flushes. For repeated and useless calls with Z_FINISH, we keep
7516 * returning Z_STREAM_END instead of Z_BUF_ERROR.
7517 */
7518 } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&
7519 flush !== Z_FINISH) {
7520 return err(strm, Z_BUF_ERROR);
7521 }
7522
7523 /* User must not provide more input after the first FINISH: */
7524 if (s.status === FINISH_STATE && strm.avail_in !== 0) {
7525 return err(strm, Z_BUF_ERROR);
7526 }
7527
7528 /* Start a new block or continue the current one.
7529 */
7530 if (strm.avail_in !== 0 || s.lookahead !== 0 ||
7531 (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {
7532 var bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) :
7533 (s.strategy === Z_RLE ? deflate_rle(s, flush) :
7534 configuration_table[s.level].func(s, flush));
7535
7536 if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {
7537 s.status = FINISH_STATE;
7538 }
7539 if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {
7540 if (strm.avail_out === 0) {
7541 s.last_flush = -1;
7542 /* avoid BUF_ERROR next call, see above */
7543 }
7544 return Z_OK;
7545 /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
7546 * of deflate should use the same flush parameter to make sure
7547 * that the flush is complete. So we don't have to output an
7548 * empty block here, this will be done at next call. This also
7549 * ensures that for a very small output buffer, we emit at most
7550 * one empty block.
7551 */
7552 }
7553 if (bstate === BS_BLOCK_DONE) {
7554 if (flush === Z_PARTIAL_FLUSH) {
7555 trees._tr_align(s);
7556 }
7557 else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */
7558
7559 trees._tr_stored_block(s, 0, 0, false);
7560 /* For a full flush, this empty block will be recognized
7561 * as a special marker by inflate_sync().
7562 */
7563 if (flush === Z_FULL_FLUSH) {
7564 /*** CLEAR_HASH(s); ***/ /* forget history */
7565 zero(s.head); // Fill with NIL (= 0);
7566
7567 if (s.lookahead === 0) {
7568 s.strstart = 0;
7569 s.block_start = 0;
7570 s.insert = 0;
7571 }
7572 }
7573 }
7574 flush_pending(strm);
7575 if (strm.avail_out === 0) {
7576 s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */
7577 return Z_OK;
7578 }
7579 }
7580 }
7581 //Assert(strm->avail_out > 0, "bug2");
7582 //if (strm.avail_out <= 0) { throw new Error("bug2");}
7583
7584 if (flush !== Z_FINISH) { return Z_OK; }
7585 if (s.wrap <= 0) { return Z_STREAM_END; }
7586
7587 /* Write the trailer */
7588 if (s.wrap === 2) {
7589 put_byte(s, strm.adler & 0xff);
7590 put_byte(s, (strm.adler >> 8) & 0xff);
7591 put_byte(s, (strm.adler >> 16) & 0xff);
7592 put_byte(s, (strm.adler >> 24) & 0xff);
7593 put_byte(s, strm.total_in & 0xff);
7594 put_byte(s, (strm.total_in >> 8) & 0xff);
7595 put_byte(s, (strm.total_in >> 16) & 0xff);
7596 put_byte(s, (strm.total_in >> 24) & 0xff);
7597 }
7598 else
7599 {
7600 putShortMSB(s, strm.adler >>> 16);
7601 putShortMSB(s, strm.adler & 0xffff);
7602 }
7603
7604 flush_pending(strm);
7605 /* If avail_out is zero, the application will call deflate again
7606 * to flush the rest.
7607 */
7608 if (s.wrap > 0) { s.wrap = -s.wrap; }
7609 /* write the trailer only once! */
7610 return s.pending !== 0 ? Z_OK : Z_STREAM_END;
7611 }
7612
7613 function deflateEnd(strm) {
7614 var status;
7615
7616 if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
7617 return Z_STREAM_ERROR;
7618 }
7619
7620 status = strm.state.status;
7621 if (status !== INIT_STATE &&
7622 status !== EXTRA_STATE &&
7623 status !== NAME_STATE &&
7624 status !== COMMENT_STATE &&
7625 status !== HCRC_STATE &&
7626 status !== BUSY_STATE &&
7627 status !== FINISH_STATE
7628 ) {
7629 return err(strm, Z_STREAM_ERROR);
7630 }
7631
7632 strm.state = null;
7633
7634 return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;
7635 }
7636
7637
7638 /* =========================================================================
7639 * Initializes the compression dictionary from the given byte
7640 * sequence without producing any compressed output.
7641 */
7642 function deflateSetDictionary(strm, dictionary) {
7643 var dictLength = dictionary.length;
7644
7645 var s;
7646 var str, n;
7647 var wrap;
7648 var avail;
7649 var next;
7650 var input;
7651 var tmpDict;
7652
7653 if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
7654 return Z_STREAM_ERROR;
7655 }
7656
7657 s = strm.state;
7658 wrap = s.wrap;
7659
7660 if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {
7661 return Z_STREAM_ERROR;
7662 }
7663
7664 /* when using zlib wrappers, compute Adler-32 for provided dictionary */
7665 if (wrap === 1) {
7666 /* adler32(strm->adler, dictionary, dictLength); */
7667 strm.adler = adler32(strm.adler, dictionary, dictLength, 0);
7668 }
7669
7670 s.wrap = 0; /* avoid computing Adler-32 in read_buf */
7671
7672 /* if dictionary would fill window, just replace the history */
7673 if (dictLength >= s.w_size) {
7674 if (wrap === 0) { /* already empty otherwise */
7675 /*** CLEAR_HASH(s); ***/
7676 zero(s.head); // Fill with NIL (= 0);
7677 s.strstart = 0;
7678 s.block_start = 0;
7679 s.insert = 0;
7680 }
7681 /* use the tail */
7682 // dictionary = dictionary.slice(dictLength - s.w_size);
7683 tmpDict = new utils.Buf8(s.w_size);
7684 utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0);
7685 dictionary = tmpDict;
7686 dictLength = s.w_size;
7687 }
7688 /* insert dictionary into window and hash */
7689 avail = strm.avail_in;
7690 next = strm.next_in;
7691 input = strm.input;
7692 strm.avail_in = dictLength;
7693 strm.next_in = 0;
7694 strm.input = dictionary;
7695 fill_window(s);
7696 while (s.lookahead >= MIN_MATCH) {
7697 str = s.strstart;
7698 n = s.lookahead - (MIN_MATCH - 1);
7699 do {
7700 /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
7701 s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
7702
7703 s.prev[str & s.w_mask] = s.head[s.ins_h];
7704
7705 s.head[s.ins_h] = str;
7706 str++;
7707 } while (--n);
7708 s.strstart = str;
7709 s.lookahead = MIN_MATCH - 1;
7710 fill_window(s);
7711 }
7712 s.strstart += s.lookahead;
7713 s.block_start = s.strstart;
7714 s.insert = s.lookahead;
7715 s.lookahead = 0;
7716 s.match_length = s.prev_length = MIN_MATCH - 1;
7717 s.match_available = 0;
7718 strm.next_in = next;
7719 strm.input = input;
7720 strm.avail_in = avail;
7721 s.wrap = wrap;
7722 return Z_OK;
7723 }
7724
7725
7726 exports.deflateInit = deflateInit;
7727 exports.deflateInit2 = deflateInit2;
7728 exports.deflateReset = deflateReset;
7729 exports.deflateResetKeep = deflateResetKeep;
7730 exports.deflateSetHeader = deflateSetHeader;
7731 exports.deflate = deflate;
7732 exports.deflateEnd = deflateEnd;
7733 exports.deflateSetDictionary = deflateSetDictionary;
7734 exports.deflateInfo = 'pako deflate (from Nodeca project)';
7735
7736 /* Not implemented
7737 exports.deflateBound = deflateBound;
7738 exports.deflateCopy = deflateCopy;
7739 exports.deflateParams = deflateParams;
7740 exports.deflatePending = deflatePending;
7741 exports.deflatePrime = deflatePrime;
7742 exports.deflateTune = deflateTune;
7743 */
7744
7745 },{"../utils/common":41,"./adler32":43,"./crc32":45,"./messages":51,"./trees":52}],47:[function(require,module,exports){
7746 'use strict';
7747
7748 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
7749 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
7750 //
7751 // This software is provided 'as-is', without any express or implied
7752 // warranty. In no event will the authors be held liable for any damages
7753 // arising from the use of this software.
7754 //
7755 // Permission is granted to anyone to use this software for any purpose,
7756 // including commercial applications, and to alter it and redistribute it
7757 // freely, subject to the following restrictions:
7758 //
7759 // 1. The origin of this software must not be misrepresented; you must not
7760 // claim that you wrote the original software. If you use this software
7761 // in a product, an acknowledgment in the product documentation would be
7762 // appreciated but is not required.
7763 // 2. Altered source versions must be plainly marked as such, and must not be
7764 // misrepresented as being the original software.
7765 // 3. This notice may not be removed or altered from any source distribution.
7766
7767 function GZheader() {
7768 /* true if compressed data believed to be text */
7769 this.text = 0;
7770 /* modification time */
7771 this.time = 0;
7772 /* extra flags (not used when writing a gzip file) */
7773 this.xflags = 0;
7774 /* operating system */
7775 this.os = 0;
7776 /* pointer to extra field or Z_NULL if none */
7777 this.extra = null;
7778 /* extra field length (valid if extra != Z_NULL) */
7779 this.extra_len = 0; // Actually, we don't need it in JS,
7780 // but leave for few code modifications
7781
7782 //
7783 // Setup limits is not necessary because in js we should not preallocate memory
7784 // for inflate use constant limit in 65536 bytes
7785 //
7786
7787 /* space at extra (only when reading header) */
7788 // this.extra_max = 0;
7789 /* pointer to zero-terminated file name or Z_NULL */
7790 this.name = '';
7791 /* space at name (only when reading header) */
7792 // this.name_max = 0;
7793 /* pointer to zero-terminated comment or Z_NULL */
7794 this.comment = '';
7795 /* space at comment (only when reading header) */
7796 // this.comm_max = 0;
7797 /* true if there was or will be a header crc */
7798 this.hcrc = 0;
7799 /* true when done reading gzip header (not used when writing a gzip file) */
7800 this.done = false;
7801 }
7802
7803 module.exports = GZheader;
7804
7805 },{}],48:[function(require,module,exports){
7806 'use strict';
7807
7808 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
7809 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
7810 //
7811 // This software is provided 'as-is', without any express or implied
7812 // warranty. In no event will the authors be held liable for any damages
7813 // arising from the use of this software.
7814 //
7815 // Permission is granted to anyone to use this software for any purpose,
7816 // including commercial applications, and to alter it and redistribute it
7817 // freely, subject to the following restrictions:
7818 //
7819 // 1. The origin of this software must not be misrepresented; you must not
7820 // claim that you wrote the original software. If you use this software
7821 // in a product, an acknowledgment in the product documentation would be
7822 // appreciated but is not required.
7823 // 2. Altered source versions must be plainly marked as such, and must not be
7824 // misrepresented as being the original software.
7825 // 3. This notice may not be removed or altered from any source distribution.
7826
7827 // See state defs from inflate.js
7828 var BAD = 30; /* got a data error -- remain here until reset */
7829 var TYPE = 12; /* i: waiting for type bits, including last-flag bit */
7830
7831 /*
7832 Decode literal, length, and distance codes and write out the resulting
7833 literal and match bytes until either not enough input or output is
7834 available, an end-of-block is encountered, or a data error is encountered.
7835 When large enough input and output buffers are supplied to inflate(), for
7836 example, a 16K input buffer and a 64K output buffer, more than 95% of the
7837 inflate execution time is spent in this routine.
7838
7839 Entry assumptions:
7840
7841 state.mode === LEN
7842 strm.avail_in >= 6
7843 strm.avail_out >= 258
7844 start >= strm.avail_out
7845 state.bits < 8
7846
7847 On return, state.mode is one of:
7848
7849 LEN -- ran out of enough output space or enough available input
7850 TYPE -- reached end of block code, inflate() to interpret next block
7851 BAD -- error in block data
7852
7853 Notes:
7854
7855 - The maximum input bits used by a length/distance pair is 15 bits for the
7856 length code, 5 bits for the length extra, 15 bits for the distance code,
7857 and 13 bits for the distance extra. This totals 48 bits, or six bytes.
7858 Therefore if strm.avail_in >= 6, then there is enough input to avoid
7859 checking for available input while decoding.
7860
7861 - The maximum bytes that a single length/distance pair can output is 258
7862 bytes, which is the maximum length that can be coded. inflate_fast()
7863 requires strm.avail_out >= 258 for each loop to avoid checking for
7864 output space.
7865 */
7866 module.exports = function inflate_fast(strm, start) {
7867 var state;
7868 var _in; /* local strm.input */
7869 var last; /* have enough input while in < last */
7870 var _out; /* local strm.output */
7871 var beg; /* inflate()'s initial strm.output */
7872 var end; /* while out < end, enough space available */
7873 //#ifdef INFLATE_STRICT
7874 var dmax; /* maximum distance from zlib header */
7875 //#endif
7876 var wsize; /* window size or zero if not using window */
7877 var whave; /* valid bytes in the window */
7878 var wnext; /* window write index */
7879 // Use `s_window` instead `window`, avoid conflict with instrumentation tools
7880 var s_window; /* allocated sliding window, if wsize != 0 */
7881 var hold; /* local strm.hold */
7882 var bits; /* local strm.bits */
7883 var lcode; /* local strm.lencode */
7884 var dcode; /* local strm.distcode */
7885 var lmask; /* mask for first level of length codes */
7886 var dmask; /* mask for first level of distance codes */
7887 var here; /* retrieved table entry */
7888 var op; /* code bits, operation, extra bits, or */
7889 /* window position, window bytes to copy */
7890 var len; /* match length, unused bytes */
7891 var dist; /* match distance */
7892 var from; /* where to copy match from */
7893 var from_source;
7894
7895
7896 var input, output; // JS specific, because we have no pointers
7897
7898 /* copy state to local variables */
7899 state = strm.state;
7900 //here = state.here;
7901 _in = strm.next_in;
7902 input = strm.input;
7903 last = _in + (strm.avail_in - 5);
7904 _out = strm.next_out;
7905 output = strm.output;
7906 beg = _out - (start - strm.avail_out);
7907 end = _out + (strm.avail_out - 257);
7908 //#ifdef INFLATE_STRICT
7909 dmax = state.dmax;
7910 //#endif
7911 wsize = state.wsize;
7912 whave = state.whave;
7913 wnext = state.wnext;
7914 s_window = state.window;
7915 hold = state.hold;
7916 bits = state.bits;
7917 lcode = state.lencode;
7918 dcode = state.distcode;
7919 lmask = (1 << state.lenbits) - 1;
7920 dmask = (1 << state.distbits) - 1;
7921
7922
7923 /* decode literals and length/distances until end-of-block or not enough
7924 input data or output space */
7925
7926 top:
7927 do {
7928 if (bits < 15) {
7929 hold += input[_in++] << bits;
7930 bits += 8;
7931 hold += input[_in++] << bits;
7932 bits += 8;
7933 }
7934
7935 here = lcode[hold & lmask];
7936
7937 dolen:
7938 for (;;) { // Goto emulation
7939 op = here >>> 24/*here.bits*/;
7940 hold >>>= op;
7941 bits -= op;
7942 op = (here >>> 16) & 0xff/*here.op*/;
7943 if (op === 0) { /* literal */
7944 //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
7945 // "inflate: literal '%c'\n" :
7946 // "inflate: literal 0x%02x\n", here.val));
7947 output[_out++] = here & 0xffff/*here.val*/;
7948 }
7949 else if (op & 16) { /* length base */
7950 len = here & 0xffff/*here.val*/;
7951 op &= 15; /* number of extra bits */
7952 if (op) {
7953 if (bits < op) {
7954 hold += input[_in++] << bits;
7955 bits += 8;
7956 }
7957 len += hold & ((1 << op) - 1);
7958 hold >>>= op;
7959 bits -= op;
7960 }
7961 //Tracevv((stderr, "inflate: length %u\n", len));
7962 if (bits < 15) {
7963 hold += input[_in++] << bits;
7964 bits += 8;
7965 hold += input[_in++] << bits;
7966 bits += 8;
7967 }
7968 here = dcode[hold & dmask];
7969
7970 dodist:
7971 for (;;) { // goto emulation
7972 op = here >>> 24/*here.bits*/;
7973 hold >>>= op;
7974 bits -= op;
7975 op = (here >>> 16) & 0xff/*here.op*/;
7976
7977 if (op & 16) { /* distance base */
7978 dist = here & 0xffff/*here.val*/;
7979 op &= 15; /* number of extra bits */
7980 if (bits < op) {
7981 hold += input[_in++] << bits;
7982 bits += 8;
7983 if (bits < op) {
7984 hold += input[_in++] << bits;
7985 bits += 8;
7986 }
7987 }
7988 dist += hold & ((1 << op) - 1);
7989 //#ifdef INFLATE_STRICT
7990 if (dist > dmax) {
7991 strm.msg = 'invalid distance too far back';
7992 state.mode = BAD;
7993 break top;
7994 }
7995 //#endif
7996 hold >>>= op;
7997 bits -= op;
7998 //Tracevv((stderr, "inflate: distance %u\n", dist));
7999 op = _out - beg; /* max distance in output */
8000 if (dist > op) { /* see if copy from window */
8001 op = dist - op; /* distance back in window */
8002 if (op > whave) {
8003 if (state.sane) {
8004 strm.msg = 'invalid distance too far back';
8005 state.mode = BAD;
8006 break top;
8007 }
8008
8009 // (!) This block is disabled in zlib defailts,
8010 // don't enable it for binary compatibility
8011 //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
8012 // if (len <= op - whave) {
8013 // do {
8014 // output[_out++] = 0;
8015 // } while (--len);
8016 // continue top;
8017 // }
8018 // len -= op - whave;
8019 // do {
8020 // output[_out++] = 0;
8021 // } while (--op > whave);
8022 // if (op === 0) {
8023 // from = _out - dist;
8024 // do {
8025 // output[_out++] = output[from++];
8026 // } while (--len);
8027 // continue top;
8028 // }
8029 //#endif
8030 }
8031 from = 0; // window index
8032 from_source = s_window;
8033 if (wnext === 0) { /* very common case */
8034 from += wsize - op;
8035 if (op < len) { /* some from window */
8036 len -= op;
8037 do {
8038 output[_out++] = s_window[from++];
8039 } while (--op);
8040 from = _out - dist; /* rest from output */
8041 from_source = output;
8042 }
8043 }
8044 else if (wnext < op) { /* wrap around window */
8045 from += wsize + wnext - op;
8046 op -= wnext;
8047 if (op < len) { /* some from end of window */
8048 len -= op;
8049 do {
8050 output[_out++] = s_window[from++];
8051 } while (--op);
8052 from = 0;
8053 if (wnext < len) { /* some from start of window */
8054 op = wnext;
8055 len -= op;
8056 do {
8057 output[_out++] = s_window[from++];
8058 } while (--op);
8059 from = _out - dist; /* rest from output */
8060 from_source = output;
8061 }
8062 }
8063 }
8064 else { /* contiguous in window */
8065 from += wnext - op;
8066 if (op < len) { /* some from window */
8067 len -= op;
8068 do {
8069 output[_out++] = s_window[from++];
8070 } while (--op);
8071 from = _out - dist; /* rest from output */
8072 from_source = output;
8073 }
8074 }
8075 while (len > 2) {
8076 output[_out++] = from_source[from++];
8077 output[_out++] = from_source[from++];
8078 output[_out++] = from_source[from++];
8079 len -= 3;
8080 }
8081 if (len) {
8082 output[_out++] = from_source[from++];
8083 if (len > 1) {
8084 output[_out++] = from_source[from++];
8085 }
8086 }
8087 }
8088 else {
8089 from = _out - dist; /* copy direct from output */
8090 do { /* minimum length is three */
8091 output[_out++] = output[from++];
8092 output[_out++] = output[from++];
8093 output[_out++] = output[from++];
8094 len -= 3;
8095 } while (len > 2);
8096 if (len) {
8097 output[_out++] = output[from++];
8098 if (len > 1) {
8099 output[_out++] = output[from++];
8100 }
8101 }
8102 }
8103 }
8104 else if ((op & 64) === 0) { /* 2nd level distance code */
8105 here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
8106 continue dodist;
8107 }
8108 else {
8109 strm.msg = 'invalid distance code';
8110 state.mode = BAD;
8111 break top;
8112 }
8113
8114 break; // need to emulate goto via "continue"
8115 }
8116 }
8117 else if ((op & 64) === 0) { /* 2nd level length code */
8118 here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
8119 continue dolen;
8120 }
8121 else if (op & 32) { /* end-of-block */
8122 //Tracevv((stderr, "inflate: end of block\n"));
8123 state.mode = TYPE;
8124 break top;
8125 }
8126 else {
8127 strm.msg = 'invalid literal/length code';
8128 state.mode = BAD;
8129 break top;
8130 }
8131
8132 break; // need to emulate goto via "continue"
8133 }
8134 } while (_in < last && _out < end);
8135
8136 /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
8137 len = bits >> 3;
8138 _in -= len;
8139 bits -= len << 3;
8140 hold &= (1 << bits) - 1;
8141
8142 /* update state and return */
8143 strm.next_in = _in;
8144 strm.next_out = _out;
8145 strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));
8146 strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));
8147 state.hold = hold;
8148 state.bits = bits;
8149 return;
8150 };
8151
8152 },{}],49:[function(require,module,exports){
8153 'use strict';
8154
8155 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
8156 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
8157 //
8158 // This software is provided 'as-is', without any express or implied
8159 // warranty. In no event will the authors be held liable for any damages
8160 // arising from the use of this software.
8161 //
8162 // Permission is granted to anyone to use this software for any purpose,
8163 // including commercial applications, and to alter it and redistribute it
8164 // freely, subject to the following restrictions:
8165 //
8166 // 1. The origin of this software must not be misrepresented; you must not
8167 // claim that you wrote the original software. If you use this software
8168 // in a product, an acknowledgment in the product documentation would be
8169 // appreciated but is not required.
8170 // 2. Altered source versions must be plainly marked as such, and must not be
8171 // misrepresented as being the original software.
8172 // 3. This notice may not be removed or altered from any source distribution.
8173
8174 var utils = require('../utils/common');
8175 var adler32 = require('./adler32');
8176 var crc32 = require('./crc32');
8177 var inflate_fast = require('./inffast');
8178 var inflate_table = require('./inftrees');
8179
8180 var CODES = 0;
8181 var LENS = 1;
8182 var DISTS = 2;
8183
8184 /* Public constants ==========================================================*/
8185 /* ===========================================================================*/
8186
8187
8188 /* Allowed flush values; see deflate() and inflate() below for details */
8189 //var Z_NO_FLUSH = 0;
8190 //var Z_PARTIAL_FLUSH = 1;
8191 //var Z_SYNC_FLUSH = 2;
8192 //var Z_FULL_FLUSH = 3;
8193 var Z_FINISH = 4;
8194 var Z_BLOCK = 5;
8195 var Z_TREES = 6;
8196
8197
8198 /* Return codes for the compression/decompression functions. Negative values
8199 * are errors, positive values are used for special but normal events.
8200 */
8201 var Z_OK = 0;
8202 var Z_STREAM_END = 1;
8203 var Z_NEED_DICT = 2;
8204 //var Z_ERRNO = -1;
8205 var Z_STREAM_ERROR = -2;
8206 var Z_DATA_ERROR = -3;
8207 var Z_MEM_ERROR = -4;
8208 var Z_BUF_ERROR = -5;
8209 //var Z_VERSION_ERROR = -6;
8210
8211 /* The deflate compression method */
8212 var Z_DEFLATED = 8;
8213
8214
8215 /* STATES ====================================================================*/
8216 /* ===========================================================================*/
8217
8218
8219 var HEAD = 1; /* i: waiting for magic header */
8220 var FLAGS = 2; /* i: waiting for method and flags (gzip) */
8221 var TIME = 3; /* i: waiting for modification time (gzip) */
8222 var OS = 4; /* i: waiting for extra flags and operating system (gzip) */
8223 var EXLEN = 5; /* i: waiting for extra length (gzip) */
8224 var EXTRA = 6; /* i: waiting for extra bytes (gzip) */
8225 var NAME = 7; /* i: waiting for end of file name (gzip) */
8226 var COMMENT = 8; /* i: waiting for end of comment (gzip) */
8227 var HCRC = 9; /* i: waiting for header crc (gzip) */
8228 var DICTID = 10; /* i: waiting for dictionary check value */
8229 var DICT = 11; /* waiting for inflateSetDictionary() call */
8230 var TYPE = 12; /* i: waiting for type bits, including last-flag bit */
8231 var TYPEDO = 13; /* i: same, but skip check to exit inflate on new block */
8232 var STORED = 14; /* i: waiting for stored size (length and complement) */
8233 var COPY_ = 15; /* i/o: same as COPY below, but only first time in */
8234 var COPY = 16; /* i/o: waiting for input or output to copy stored block */
8235 var TABLE = 17; /* i: waiting for dynamic block table lengths */
8236 var LENLENS = 18; /* i: waiting for code length code lengths */
8237 var CODELENS = 19; /* i: waiting for length/lit and distance code lengths */
8238 var LEN_ = 20; /* i: same as LEN below, but only first time in */
8239 var LEN = 21; /* i: waiting for length/lit/eob code */
8240 var LENEXT = 22; /* i: waiting for length extra bits */
8241 var DIST = 23; /* i: waiting for distance code */
8242 var DISTEXT = 24; /* i: waiting for distance extra bits */
8243 var MATCH = 25; /* o: waiting for output space to copy string */
8244 var LIT = 26; /* o: waiting for output space to write literal */
8245 var CHECK = 27; /* i: waiting for 32-bit check value */
8246 var LENGTH = 28; /* i: waiting for 32-bit length (gzip) */
8247 var DONE = 29; /* finished check, done -- remain here until reset */
8248 var BAD = 30; /* got a data error -- remain here until reset */
8249 var MEM = 31; /* got an inflate() memory error -- remain here until reset */
8250 var SYNC = 32; /* looking for synchronization bytes to restart inflate() */
8251
8252 /* ===========================================================================*/
8253
8254
8255
8256 var ENOUGH_LENS = 852;
8257 var ENOUGH_DISTS = 592;
8258 //var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
8259
8260 var MAX_WBITS = 15;
8261 /* 32K LZ77 window */
8262 var DEF_WBITS = MAX_WBITS;
8263
8264
8265 function zswap32(q) {
8266 return (((q >>> 24) & 0xff) +
8267 ((q >>> 8) & 0xff00) +
8268 ((q & 0xff00) << 8) +
8269 ((q & 0xff) << 24));
8270 }
8271
8272
8273 function InflateState() {
8274 this.mode = 0; /* current inflate mode */
8275 this.last = false; /* true if processing last block */
8276 this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */
8277 this.havedict = false; /* true if dictionary provided */
8278 this.flags = 0; /* gzip header method and flags (0 if zlib) */
8279 this.dmax = 0; /* zlib header max distance (INFLATE_STRICT) */
8280 this.check = 0; /* protected copy of check value */
8281 this.total = 0; /* protected copy of output count */
8282 // TODO: may be {}
8283 this.head = null; /* where to save gzip header information */
8284
8285 /* sliding window */
8286 this.wbits = 0; /* log base 2 of requested window size */
8287 this.wsize = 0; /* window size or zero if not using window */
8288 this.whave = 0; /* valid bytes in the window */
8289 this.wnext = 0; /* window write index */
8290 this.window = null; /* allocated sliding window, if needed */
8291
8292 /* bit accumulator */
8293 this.hold = 0; /* input bit accumulator */
8294 this.bits = 0; /* number of bits in "in" */
8295
8296 /* for string and stored block copying */
8297 this.length = 0; /* literal or length of data to copy */
8298 this.offset = 0; /* distance back to copy string from */
8299
8300 /* for table and code decoding */
8301 this.extra = 0; /* extra bits needed */
8302
8303 /* fixed and dynamic code tables */
8304 this.lencode = null; /* starting table for length/literal codes */
8305 this.distcode = null; /* starting table for distance codes */
8306 this.lenbits = 0; /* index bits for lencode */
8307 this.distbits = 0; /* index bits for distcode */
8308
8309 /* dynamic table building */
8310 this.ncode = 0; /* number of code length code lengths */
8311 this.nlen = 0; /* number of length code lengths */
8312 this.ndist = 0; /* number of distance code lengths */
8313 this.have = 0; /* number of code lengths in lens[] */
8314 this.next = null; /* next available space in codes[] */
8315
8316 this.lens = new utils.Buf16(320); /* temporary storage for code lengths */
8317 this.work = new utils.Buf16(288); /* work area for code table building */
8318
8319 /*
8320 because we don't have pointers in js, we use lencode and distcode directly
8321 as buffers so we don't need codes
8322 */
8323 //this.codes = new utils.Buf32(ENOUGH); /* space for code tables */
8324 this.lendyn = null; /* dynamic table for length/literal codes (JS specific) */
8325 this.distdyn = null; /* dynamic table for distance codes (JS specific) */
8326 this.sane = 0; /* if false, allow invalid distance too far */
8327 this.back = 0; /* bits back of last unprocessed length/lit */
8328 this.was = 0; /* initial length of match */
8329 }
8330
8331 function inflateResetKeep(strm) {
8332 var state;
8333
8334 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
8335 state = strm.state;
8336 strm.total_in = strm.total_out = state.total = 0;
8337 strm.msg = ''; /*Z_NULL*/
8338 if (state.wrap) { /* to support ill-conceived Java test suite */
8339 strm.adler = state.wrap & 1;
8340 }
8341 state.mode = HEAD;
8342 state.last = 0;
8343 state.havedict = 0;
8344 state.dmax = 32768;
8345 state.head = null/*Z_NULL*/;
8346 state.hold = 0;
8347 state.bits = 0;
8348 //state.lencode = state.distcode = state.next = state.codes;
8349 state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);
8350 state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);
8351
8352 state.sane = 1;
8353 state.back = -1;
8354 //Tracev((stderr, "inflate: reset\n"));
8355 return Z_OK;
8356 }
8357
8358 function inflateReset(strm) {
8359 var state;
8360
8361 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
8362 state = strm.state;
8363 state.wsize = 0;
8364 state.whave = 0;
8365 state.wnext = 0;
8366 return inflateResetKeep(strm);
8367
8368 }
8369
8370 function inflateReset2(strm, windowBits) {
8371 var wrap;
8372 var state;
8373
8374 /* get the state */
8375 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
8376 state = strm.state;
8377
8378 /* extract wrap request from windowBits parameter */
8379 if (windowBits < 0) {
8380 wrap = 0;
8381 windowBits = -windowBits;
8382 }
8383 else {
8384 wrap = (windowBits >> 4) + 1;
8385 if (windowBits < 48) {
8386 windowBits &= 15;
8387 }
8388 }
8389
8390 /* set number of window bits, free window if different */
8391 if (windowBits && (windowBits < 8 || windowBits > 15)) {
8392 return Z_STREAM_ERROR;
8393 }
8394 if (state.window !== null && state.wbits !== windowBits) {
8395 state.window = null;
8396 }
8397
8398 /* update state and reset the rest of it */
8399 state.wrap = wrap;
8400 state.wbits = windowBits;
8401 return inflateReset(strm);
8402 }
8403
8404 function inflateInit2(strm, windowBits) {
8405 var ret;
8406 var state;
8407
8408 if (!strm) { return Z_STREAM_ERROR; }
8409 //strm.msg = Z_NULL; /* in case we return an error */
8410
8411 state = new InflateState();
8412
8413 //if (state === Z_NULL) return Z_MEM_ERROR;
8414 //Tracev((stderr, "inflate: allocated\n"));
8415 strm.state = state;
8416 state.window = null/*Z_NULL*/;
8417 ret = inflateReset2(strm, windowBits);
8418 if (ret !== Z_OK) {
8419 strm.state = null/*Z_NULL*/;
8420 }
8421 return ret;
8422 }
8423
8424 function inflateInit(strm) {
8425 return inflateInit2(strm, DEF_WBITS);
8426 }
8427
8428
8429 /*
8430 Return state with length and distance decoding tables and index sizes set to
8431 fixed code decoding. Normally this returns fixed tables from inffixed.h.
8432 If BUILDFIXED is defined, then instead this routine builds the tables the
8433 first time it's called, and returns those tables the first time and
8434 thereafter. This reduces the size of the code by about 2K bytes, in
8435 exchange for a little execution time. However, BUILDFIXED should not be
8436 used for threaded applications, since the rewriting of the tables and virgin
8437 may not be thread-safe.
8438 */
8439 var virgin = true;
8440
8441 var lenfix, distfix; // We have no pointers in JS, so keep tables separate
8442
8443 function fixedtables(state) {
8444 /* build fixed huffman tables if first call (may not be thread safe) */
8445 if (virgin) {
8446 var sym;
8447
8448 lenfix = new utils.Buf32(512);
8449 distfix = new utils.Buf32(32);
8450
8451 /* literal/length table */
8452 sym = 0;
8453 while (sym < 144) { state.lens[sym++] = 8; }
8454 while (sym < 256) { state.lens[sym++] = 9; }
8455 while (sym < 280) { state.lens[sym++] = 7; }
8456 while (sym < 288) { state.lens[sym++] = 8; }
8457
8458 inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });
8459
8460 /* distance table */
8461 sym = 0;
8462 while (sym < 32) { state.lens[sym++] = 5; }
8463
8464 inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });
8465
8466 /* do this just once */
8467 virgin = false;
8468 }
8469
8470 state.lencode = lenfix;
8471 state.lenbits = 9;
8472 state.distcode = distfix;
8473 state.distbits = 5;
8474 }
8475
8476
8477 /*
8478 Update the window with the last wsize (normally 32K) bytes written before
8479 returning. If window does not exist yet, create it. This is only called
8480 when a window is already in use, or when output has been written during this
8481 inflate call, but the end of the deflate stream has not been reached yet.
8482 It is also called to create a window for dictionary data when a dictionary
8483 is loaded.
8484
8485 Providing output buffers larger than 32K to inflate() should provide a speed
8486 advantage, since only the last 32K of output is copied to the sliding window
8487 upon return from inflate(), and since all distances after the first 32K of
8488 output will fall in the output data, making match copies simpler and faster.
8489 The advantage may be dependent on the size of the processor's data caches.
8490 */
8491 function updatewindow(strm, src, end, copy) {
8492 var dist;
8493 var state = strm.state;
8494
8495 /* if it hasn't been done already, allocate space for the window */
8496 if (state.window === null) {
8497 state.wsize = 1 << state.wbits;
8498 state.wnext = 0;
8499 state.whave = 0;
8500
8501 state.window = new utils.Buf8(state.wsize);
8502 }
8503
8504 /* copy state->wsize or less output bytes into the circular window */
8505 if (copy >= state.wsize) {
8506 utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0);
8507 state.wnext = 0;
8508 state.whave = state.wsize;
8509 }
8510 else {
8511 dist = state.wsize - state.wnext;
8512 if (dist > copy) {
8513 dist = copy;
8514 }
8515 //zmemcpy(state->window + state->wnext, end - copy, dist);
8516 utils.arraySet(state.window, src, end - copy, dist, state.wnext);
8517 copy -= dist;
8518 if (copy) {
8519 //zmemcpy(state->window, end - copy, copy);
8520 utils.arraySet(state.window, src, end - copy, copy, 0);
8521 state.wnext = copy;
8522 state.whave = state.wsize;
8523 }
8524 else {
8525 state.wnext += dist;
8526 if (state.wnext === state.wsize) { state.wnext = 0; }
8527 if (state.whave < state.wsize) { state.whave += dist; }
8528 }
8529 }
8530 return 0;
8531 }
8532
8533 function inflate(strm, flush) {
8534 var state;
8535 var input, output; // input/output buffers
8536 var next; /* next input INDEX */
8537 var put; /* next output INDEX */
8538 var have, left; /* available input and output */
8539 var hold; /* bit buffer */
8540 var bits; /* bits in bit buffer */
8541 var _in, _out; /* save starting available input and output */
8542 var copy; /* number of stored or match bytes to copy */
8543 var from; /* where to copy match bytes from */
8544 var from_source;
8545 var here = 0; /* current decoding table entry */
8546 var here_bits, here_op, here_val; // paked "here" denormalized (JS specific)
8547 //var last; /* parent table entry */
8548 var last_bits, last_op, last_val; // paked "last" denormalized (JS specific)
8549 var len; /* length to copy for repeats, bits to drop */
8550 var ret; /* return code */
8551 var hbuf = new utils.Buf8(4); /* buffer for gzip header crc calculation */
8552 var opts;
8553
8554 var n; // temporary var for NEED_BITS
8555
8556 var order = /* permutation of code lengths */
8557 [ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ];
8558
8559
8560 if (!strm || !strm.state || !strm.output ||
8561 (!strm.input && strm.avail_in !== 0)) {
8562 return Z_STREAM_ERROR;
8563 }
8564
8565 state = strm.state;
8566 if (state.mode === TYPE) { state.mode = TYPEDO; } /* skip check */
8567
8568
8569 //--- LOAD() ---
8570 put = strm.next_out;
8571 output = strm.output;
8572 left = strm.avail_out;
8573 next = strm.next_in;
8574 input = strm.input;
8575 have = strm.avail_in;
8576 hold = state.hold;
8577 bits = state.bits;
8578 //---
8579
8580 _in = have;
8581 _out = left;
8582 ret = Z_OK;
8583
8584 inf_leave: // goto emulation
8585 for (;;) {
8586 switch (state.mode) {
8587 case HEAD:
8588 if (state.wrap === 0) {
8589 state.mode = TYPEDO;
8590 break;
8591 }
8592 //=== NEEDBITS(16);
8593 while (bits < 16) {
8594 if (have === 0) { break inf_leave; }
8595 have--;
8596 hold += input[next++] << bits;
8597 bits += 8;
8598 }
8599 //===//
8600 if ((state.wrap & 2) && hold === 0x8b1f) { /* gzip header */
8601 state.check = 0/*crc32(0L, Z_NULL, 0)*/;
8602 //=== CRC2(state.check, hold);
8603 hbuf[0] = hold & 0xff;
8604 hbuf[1] = (hold >>> 8) & 0xff;
8605 state.check = crc32(state.check, hbuf, 2, 0);
8606 //===//
8607
8608 //=== INITBITS();
8609 hold = 0;
8610 bits = 0;
8611 //===//
8612 state.mode = FLAGS;
8613 break;
8614 }
8615 state.flags = 0; /* expect zlib header */
8616 if (state.head) {
8617 state.head.done = false;
8618 }
8619 if (!(state.wrap & 1) || /* check if zlib header allowed */
8620 (((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) {
8621 strm.msg = 'incorrect header check';
8622 state.mode = BAD;
8623 break;
8624 }
8625 if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) {
8626 strm.msg = 'unknown compression method';
8627 state.mode = BAD;
8628 break;
8629 }
8630 //--- DROPBITS(4) ---//
8631 hold >>>= 4;
8632 bits -= 4;
8633 //---//
8634 len = (hold & 0x0f)/*BITS(4)*/ + 8;
8635 if (state.wbits === 0) {
8636 state.wbits = len;
8637 }
8638 else if (len > state.wbits) {
8639 strm.msg = 'invalid window size';
8640 state.mode = BAD;
8641 break;
8642 }
8643 state.dmax = 1 << len;
8644 //Tracev((stderr, "inflate: zlib header ok\n"));
8645 strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
8646 state.mode = hold & 0x200 ? DICTID : TYPE;
8647 //=== INITBITS();
8648 hold = 0;
8649 bits = 0;
8650 //===//
8651 break;
8652 case FLAGS:
8653 //=== NEEDBITS(16); */
8654 while (bits < 16) {
8655 if (have === 0) { break inf_leave; }
8656 have--;
8657 hold += input[next++] << bits;
8658 bits += 8;
8659 }
8660 //===//
8661 state.flags = hold;
8662 if ((state.flags & 0xff) !== Z_DEFLATED) {
8663 strm.msg = 'unknown compression method';
8664 state.mode = BAD;
8665 break;
8666 }
8667 if (state.flags & 0xe000) {
8668 strm.msg = 'unknown header flags set';
8669 state.mode = BAD;
8670 break;
8671 }
8672 if (state.head) {
8673 state.head.text = ((hold >> 8) & 1);
8674 }
8675 if (state.flags & 0x0200) {
8676 //=== CRC2(state.check, hold);
8677 hbuf[0] = hold & 0xff;
8678 hbuf[1] = (hold >>> 8) & 0xff;
8679 state.check = crc32(state.check, hbuf, 2, 0);
8680 //===//
8681 }
8682 //=== INITBITS();
8683 hold = 0;
8684 bits = 0;
8685 //===//
8686 state.mode = TIME;
8687 /* falls through */
8688 case TIME:
8689 //=== NEEDBITS(32); */
8690 while (bits < 32) {
8691 if (have === 0) { break inf_leave; }
8692 have--;
8693 hold += input[next++] << bits;
8694 bits += 8;
8695 }
8696 //===//
8697 if (state.head) {
8698 state.head.time = hold;
8699 }
8700 if (state.flags & 0x0200) {
8701 //=== CRC4(state.check, hold)
8702 hbuf[0] = hold & 0xff;
8703 hbuf[1] = (hold >>> 8) & 0xff;
8704 hbuf[2] = (hold >>> 16) & 0xff;
8705 hbuf[3] = (hold >>> 24) & 0xff;
8706 state.check = crc32(state.check, hbuf, 4, 0);
8707 //===
8708 }
8709 //=== INITBITS();
8710 hold = 0;
8711 bits = 0;
8712 //===//
8713 state.mode = OS;
8714 /* falls through */
8715 case OS:
8716 //=== NEEDBITS(16); */
8717 while (bits < 16) {
8718 if (have === 0) { break inf_leave; }
8719 have--;
8720 hold += input[next++] << bits;
8721 bits += 8;
8722 }
8723 //===//
8724 if (state.head) {
8725 state.head.xflags = (hold & 0xff);
8726 state.head.os = (hold >> 8);
8727 }
8728 if (state.flags & 0x0200) {
8729 //=== CRC2(state.check, hold);
8730 hbuf[0] = hold & 0xff;
8731 hbuf[1] = (hold >>> 8) & 0xff;
8732 state.check = crc32(state.check, hbuf, 2, 0);
8733 //===//
8734 }
8735 //=== INITBITS();
8736 hold = 0;
8737 bits = 0;
8738 //===//
8739 state.mode = EXLEN;
8740 /* falls through */
8741 case EXLEN:
8742 if (state.flags & 0x0400) {
8743 //=== NEEDBITS(16); */
8744 while (bits < 16) {
8745 if (have === 0) { break inf_leave; }
8746 have--;
8747 hold += input[next++] << bits;
8748 bits += 8;
8749 }
8750 //===//
8751 state.length = hold;
8752 if (state.head) {
8753 state.head.extra_len = hold;
8754 }
8755 if (state.flags & 0x0200) {
8756 //=== CRC2(state.check, hold);
8757 hbuf[0] = hold & 0xff;
8758 hbuf[1] = (hold >>> 8) & 0xff;
8759 state.check = crc32(state.check, hbuf, 2, 0);
8760 //===//
8761 }
8762 //=== INITBITS();
8763 hold = 0;
8764 bits = 0;
8765 //===//
8766 }
8767 else if (state.head) {
8768 state.head.extra = null/*Z_NULL*/;
8769 }
8770 state.mode = EXTRA;
8771 /* falls through */
8772 case EXTRA:
8773 if (state.flags & 0x0400) {
8774 copy = state.length;
8775 if (copy > have) { copy = have; }
8776 if (copy) {
8777 if (state.head) {
8778 len = state.head.extra_len - state.length;
8779 if (!state.head.extra) {
8780 // Use untyped array for more conveniend processing later
8781 state.head.extra = new Array(state.head.extra_len);
8782 }
8783 utils.arraySet(
8784 state.head.extra,
8785 input,
8786 next,
8787 // extra field is limited to 65536 bytes
8788 // - no need for additional size check
8789 copy,
8790 /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
8791 len
8792 );
8793 //zmemcpy(state.head.extra + len, next,
8794 // len + copy > state.head.extra_max ?
8795 // state.head.extra_max - len : copy);
8796 }
8797 if (state.flags & 0x0200) {
8798 state.check = crc32(state.check, input, copy, next);
8799 }
8800 have -= copy;
8801 next += copy;
8802 state.length -= copy;
8803 }
8804 if (state.length) { break inf_leave; }
8805 }
8806 state.length = 0;
8807 state.mode = NAME;
8808 /* falls through */
8809 case NAME:
8810 if (state.flags & 0x0800) {
8811 if (have === 0) { break inf_leave; }
8812 copy = 0;
8813 do {
8814 // TODO: 2 or 1 bytes?
8815 len = input[next + copy++];
8816 /* use constant limit because in js we should not preallocate memory */
8817 if (state.head && len &&
8818 (state.length < 65536 /*state.head.name_max*/)) {
8819 state.head.name += String.fromCharCode(len);
8820 }
8821 } while (len && copy < have);
8822
8823 if (state.flags & 0x0200) {
8824 state.check = crc32(state.check, input, copy, next);
8825 }
8826 have -= copy;
8827 next += copy;
8828 if (len) { break inf_leave; }
8829 }
8830 else if (state.head) {
8831 state.head.name = null;
8832 }
8833 state.length = 0;
8834 state.mode = COMMENT;
8835 /* falls through */
8836 case COMMENT:
8837 if (state.flags & 0x1000) {
8838 if (have === 0) { break inf_leave; }
8839 copy = 0;
8840 do {
8841 len = input[next + copy++];
8842 /* use constant limit because in js we should not preallocate memory */
8843 if (state.head && len &&
8844 (state.length < 65536 /*state.head.comm_max*/)) {
8845 state.head.comment += String.fromCharCode(len);
8846 }
8847 } while (len && copy < have);
8848 if (state.flags & 0x0200) {
8849 state.check = crc32(state.check, input, copy, next);
8850 }
8851 have -= copy;
8852 next += copy;
8853 if (len) { break inf_leave; }
8854 }
8855 else if (state.head) {
8856 state.head.comment = null;
8857 }
8858 state.mode = HCRC;
8859 /* falls through */
8860 case HCRC:
8861 if (state.flags & 0x0200) {
8862 //=== NEEDBITS(16); */
8863 while (bits < 16) {
8864 if (have === 0) { break inf_leave; }
8865 have--;
8866 hold += input[next++] << bits;
8867 bits += 8;
8868 }
8869 //===//
8870 if (hold !== (state.check & 0xffff)) {
8871 strm.msg = 'header crc mismatch';
8872 state.mode = BAD;
8873 break;
8874 }
8875 //=== INITBITS();
8876 hold = 0;
8877 bits = 0;
8878 //===//
8879 }
8880 if (state.head) {
8881 state.head.hcrc = ((state.flags >> 9) & 1);
8882 state.head.done = true;
8883 }
8884 strm.adler = state.check = 0;
8885 state.mode = TYPE;
8886 break;
8887 case DICTID:
8888 //=== NEEDBITS(32); */
8889 while (bits < 32) {
8890 if (have === 0) { break inf_leave; }
8891 have--;
8892 hold += input[next++] << bits;
8893 bits += 8;
8894 }
8895 //===//
8896 strm.adler = state.check = zswap32(hold);
8897 //=== INITBITS();
8898 hold = 0;
8899 bits = 0;
8900 //===//
8901 state.mode = DICT;
8902 /* falls through */
8903 case DICT:
8904 if (state.havedict === 0) {
8905 //--- RESTORE() ---
8906 strm.next_out = put;
8907 strm.avail_out = left;
8908 strm.next_in = next;
8909 strm.avail_in = have;
8910 state.hold = hold;
8911 state.bits = bits;
8912 //---
8913 return Z_NEED_DICT;
8914 }
8915 strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
8916 state.mode = TYPE;
8917 /* falls through */
8918 case TYPE:
8919 if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; }
8920 /* falls through */
8921 case TYPEDO:
8922 if (state.last) {
8923 //--- BYTEBITS() ---//
8924 hold >>>= bits & 7;
8925 bits -= bits & 7;
8926 //---//
8927 state.mode = CHECK;
8928 break;
8929 }
8930 //=== NEEDBITS(3); */
8931 while (bits < 3) {
8932 if (have === 0) { break inf_leave; }
8933 have--;
8934 hold += input[next++] << bits;
8935 bits += 8;
8936 }
8937 //===//
8938 state.last = (hold & 0x01)/*BITS(1)*/;
8939 //--- DROPBITS(1) ---//
8940 hold >>>= 1;
8941 bits -= 1;
8942 //---//
8943
8944 switch ((hold & 0x03)/*BITS(2)*/) {
8945 case 0: /* stored block */
8946 //Tracev((stderr, "inflate: stored block%s\n",
8947 // state.last ? " (last)" : ""));
8948 state.mode = STORED;
8949 break;
8950 case 1: /* fixed block */
8951 fixedtables(state);
8952 //Tracev((stderr, "inflate: fixed codes block%s\n",
8953 // state.last ? " (last)" : ""));
8954 state.mode = LEN_; /* decode codes */
8955 if (flush === Z_TREES) {
8956 //--- DROPBITS(2) ---//
8957 hold >>>= 2;
8958 bits -= 2;
8959 //---//
8960 break inf_leave;
8961 }
8962 break;
8963 case 2: /* dynamic block */
8964 //Tracev((stderr, "inflate: dynamic codes block%s\n",
8965 // state.last ? " (last)" : ""));
8966 state.mode = TABLE;
8967 break;
8968 case 3:
8969 strm.msg = 'invalid block type';
8970 state.mode = BAD;
8971 }
8972 //--- DROPBITS(2) ---//
8973 hold >>>= 2;
8974 bits -= 2;
8975 //---//
8976 break;
8977 case STORED:
8978 //--- BYTEBITS() ---// /* go to byte boundary */
8979 hold >>>= bits & 7;
8980 bits -= bits & 7;
8981 //---//
8982 //=== NEEDBITS(32); */
8983 while (bits < 32) {
8984 if (have === 0) { break inf_leave; }
8985 have--;
8986 hold += input[next++] << bits;
8987 bits += 8;
8988 }
8989 //===//
8990 if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {
8991 strm.msg = 'invalid stored block lengths';
8992 state.mode = BAD;
8993 break;
8994 }
8995 state.length = hold & 0xffff;
8996 //Tracev((stderr, "inflate: stored length %u\n",
8997 // state.length));
8998 //=== INITBITS();
8999 hold = 0;
9000 bits = 0;
9001 //===//
9002 state.mode = COPY_;
9003 if (flush === Z_TREES) { break inf_leave; }
9004 /* falls through */
9005 case COPY_:
9006 state.mode = COPY;
9007 /* falls through */
9008 case COPY:
9009 copy = state.length;
9010 if (copy) {
9011 if (copy > have) { copy = have; }
9012 if (copy > left) { copy = left; }
9013 if (copy === 0) { break inf_leave; }
9014 //--- zmemcpy(put, next, copy); ---
9015 utils.arraySet(output, input, next, copy, put);
9016 //---//
9017 have -= copy;
9018 next += copy;
9019 left -= copy;
9020 put += copy;
9021 state.length -= copy;
9022 break;
9023 }
9024 //Tracev((stderr, "inflate: stored end\n"));
9025 state.mode = TYPE;
9026 break;
9027 case TABLE:
9028 //=== NEEDBITS(14); */
9029 while (bits < 14) {
9030 if (have === 0) { break inf_leave; }
9031 have--;
9032 hold += input[next++] << bits;
9033 bits += 8;
9034 }
9035 //===//
9036 state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257;
9037 //--- DROPBITS(5) ---//
9038 hold >>>= 5;
9039 bits -= 5;
9040 //---//
9041 state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1;
9042 //--- DROPBITS(5) ---//
9043 hold >>>= 5;
9044 bits -= 5;
9045 //---//
9046 state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4;
9047 //--- DROPBITS(4) ---//
9048 hold >>>= 4;
9049 bits -= 4;
9050 //---//
9051 //#ifndef PKZIP_BUG_WORKAROUND
9052 if (state.nlen > 286 || state.ndist > 30) {
9053 strm.msg = 'too many length or distance symbols';
9054 state.mode = BAD;
9055 break;
9056 }
9057 //#endif
9058 //Tracev((stderr, "inflate: table sizes ok\n"));
9059 state.have = 0;
9060 state.mode = LENLENS;
9061 /* falls through */
9062 case LENLENS:
9063 while (state.have < state.ncode) {
9064 //=== NEEDBITS(3);
9065 while (bits < 3) {
9066 if (have === 0) { break inf_leave; }
9067 have--;
9068 hold += input[next++] << bits;
9069 bits += 8;
9070 }
9071 //===//
9072 state.lens[order[state.have++]] = (hold & 0x07);//BITS(3);
9073 //--- DROPBITS(3) ---//
9074 hold >>>= 3;
9075 bits -= 3;
9076 //---//
9077 }
9078 while (state.have < 19) {
9079 state.lens[order[state.have++]] = 0;
9080 }
9081 // We have separate tables & no pointers. 2 commented lines below not needed.
9082 //state.next = state.codes;
9083 //state.lencode = state.next;
9084 // Switch to use dynamic table
9085 state.lencode = state.lendyn;
9086 state.lenbits = 7;
9087
9088 opts = { bits: state.lenbits };
9089 ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);
9090 state.lenbits = opts.bits;
9091
9092 if (ret) {
9093 strm.msg = 'invalid code lengths set';
9094 state.mode = BAD;
9095 break;
9096 }
9097 //Tracev((stderr, "inflate: code lengths ok\n"));
9098 state.have = 0;
9099 state.mode = CODELENS;
9100 /* falls through */
9101 case CODELENS:
9102 while (state.have < state.nlen + state.ndist) {
9103 for (;;) {
9104 here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/
9105 here_bits = here >>> 24;
9106 here_op = (here >>> 16) & 0xff;
9107 here_val = here & 0xffff;
9108
9109 if ((here_bits) <= bits) { break; }
9110 //--- PULLBYTE() ---//
9111 if (have === 0) { break inf_leave; }
9112 have--;
9113 hold += input[next++] << bits;
9114 bits += 8;
9115 //---//
9116 }
9117 if (here_val < 16) {
9118 //--- DROPBITS(here.bits) ---//
9119 hold >>>= here_bits;
9120 bits -= here_bits;
9121 //---//
9122 state.lens[state.have++] = here_val;
9123 }
9124 else {
9125 if (here_val === 16) {
9126 //=== NEEDBITS(here.bits + 2);
9127 n = here_bits + 2;
9128 while (bits < n) {
9129 if (have === 0) { break inf_leave; }
9130 have--;
9131 hold += input[next++] << bits;
9132 bits += 8;
9133 }
9134 //===//
9135 //--- DROPBITS(here.bits) ---//
9136 hold >>>= here_bits;
9137 bits -= here_bits;
9138 //---//
9139 if (state.have === 0) {
9140 strm.msg = 'invalid bit length repeat';
9141 state.mode = BAD;
9142 break;
9143 }
9144 len = state.lens[state.have - 1];
9145 copy = 3 + (hold & 0x03);//BITS(2);
9146 //--- DROPBITS(2) ---//
9147 hold >>>= 2;
9148 bits -= 2;
9149 //---//
9150 }
9151 else if (here_val === 17) {
9152 //=== NEEDBITS(here.bits + 3);
9153 n = here_bits + 3;
9154 while (bits < n) {
9155 if (have === 0) { break inf_leave; }
9156 have--;
9157 hold += input[next++] << bits;
9158 bits += 8;
9159 }
9160 //===//
9161 //--- DROPBITS(here.bits) ---//
9162 hold >>>= here_bits;
9163 bits -= here_bits;
9164 //---//
9165 len = 0;
9166 copy = 3 + (hold & 0x07);//BITS(3);
9167 //--- DROPBITS(3) ---//
9168 hold >>>= 3;
9169 bits -= 3;
9170 //---//
9171 }
9172 else {
9173 //=== NEEDBITS(here.bits + 7);
9174 n = here_bits + 7;
9175 while (bits < n) {
9176 if (have === 0) { break inf_leave; }
9177 have--;
9178 hold += input[next++] << bits;
9179 bits += 8;
9180 }
9181 //===//
9182 //--- DROPBITS(here.bits) ---//
9183 hold >>>= here_bits;
9184 bits -= here_bits;
9185 //---//
9186 len = 0;
9187 copy = 11 + (hold & 0x7f);//BITS(7);
9188 //--- DROPBITS(7) ---//
9189 hold >>>= 7;
9190 bits -= 7;
9191 //---//
9192 }
9193 if (state.have + copy > state.nlen + state.ndist) {
9194 strm.msg = 'invalid bit length repeat';
9195 state.mode = BAD;
9196 break;
9197 }
9198 while (copy--) {
9199 state.lens[state.have++] = len;
9200 }
9201 }
9202 }
9203
9204 /* handle error breaks in while */
9205 if (state.mode === BAD) { break; }
9206
9207 /* check for end-of-block code (better have one) */
9208 if (state.lens[256] === 0) {
9209 strm.msg = 'invalid code -- missing end-of-block';
9210 state.mode = BAD;
9211 break;
9212 }
9213
9214 /* build code tables -- note: do not change the lenbits or distbits
9215 values here (9 and 6) without reading the comments in inftrees.h
9216 concerning the ENOUGH constants, which depend on those values */
9217 state.lenbits = 9;
9218
9219 opts = { bits: state.lenbits };
9220 ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
9221 // We have separate tables & no pointers. 2 commented lines below not needed.
9222 // state.next_index = opts.table_index;
9223 state.lenbits = opts.bits;
9224 // state.lencode = state.next;
9225
9226 if (ret) {
9227 strm.msg = 'invalid literal/lengths set';
9228 state.mode = BAD;
9229 break;
9230 }
9231
9232 state.distbits = 6;
9233 //state.distcode.copy(state.codes);
9234 // Switch to use dynamic table
9235 state.distcode = state.distdyn;
9236 opts = { bits: state.distbits };
9237 ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
9238 // We have separate tables & no pointers. 2 commented lines below not needed.
9239 // state.next_index = opts.table_index;
9240 state.distbits = opts.bits;
9241 // state.distcode = state.next;
9242
9243 if (ret) {
9244 strm.msg = 'invalid distances set';
9245 state.mode = BAD;
9246 break;
9247 }
9248 //Tracev((stderr, 'inflate: codes ok\n'));
9249 state.mode = LEN_;
9250 if (flush === Z_TREES) { break inf_leave; }
9251 /* falls through */
9252 case LEN_:
9253 state.mode = LEN;
9254 /* falls through */
9255 case LEN:
9256 if (have >= 6 && left >= 258) {
9257 //--- RESTORE() ---
9258 strm.next_out = put;
9259 strm.avail_out = left;
9260 strm.next_in = next;
9261 strm.avail_in = have;
9262 state.hold = hold;
9263 state.bits = bits;
9264 //---
9265 inflate_fast(strm, _out);
9266 //--- LOAD() ---
9267 put = strm.next_out;
9268 output = strm.output;
9269 left = strm.avail_out;
9270 next = strm.next_in;
9271 input = strm.input;
9272 have = strm.avail_in;
9273 hold = state.hold;
9274 bits = state.bits;
9275 //---
9276
9277 if (state.mode === TYPE) {
9278 state.back = -1;
9279 }
9280 break;
9281 }
9282 state.back = 0;
9283 for (;;) {
9284 here = state.lencode[hold & ((1 << state.lenbits) - 1)]; /*BITS(state.lenbits)*/
9285 here_bits = here >>> 24;
9286 here_op = (here >>> 16) & 0xff;
9287 here_val = here & 0xffff;
9288
9289 if (here_bits <= bits) { break; }
9290 //--- PULLBYTE() ---//
9291 if (have === 0) { break inf_leave; }
9292 have--;
9293 hold += input[next++] << bits;
9294 bits += 8;
9295 //---//
9296 }
9297 if (here_op && (here_op & 0xf0) === 0) {
9298 last_bits = here_bits;
9299 last_op = here_op;
9300 last_val = here_val;
9301 for (;;) {
9302 here = state.lencode[last_val +
9303 ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
9304 here_bits = here >>> 24;
9305 here_op = (here >>> 16) & 0xff;
9306 here_val = here & 0xffff;
9307
9308 if ((last_bits + here_bits) <= bits) { break; }
9309 //--- PULLBYTE() ---//
9310 if (have === 0) { break inf_leave; }
9311 have--;
9312 hold += input[next++] << bits;
9313 bits += 8;
9314 //---//
9315 }
9316 //--- DROPBITS(last.bits) ---//
9317 hold >>>= last_bits;
9318 bits -= last_bits;
9319 //---//
9320 state.back += last_bits;
9321 }
9322 //--- DROPBITS(here.bits) ---//
9323 hold >>>= here_bits;
9324 bits -= here_bits;
9325 //---//
9326 state.back += here_bits;
9327 state.length = here_val;
9328 if (here_op === 0) {
9329 //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
9330 // "inflate: literal '%c'\n" :
9331 // "inflate: literal 0x%02x\n", here.val));
9332 state.mode = LIT;
9333 break;
9334 }
9335 if (here_op & 32) {
9336 //Tracevv((stderr, "inflate: end of block\n"));
9337 state.back = -1;
9338 state.mode = TYPE;
9339 break;
9340 }
9341 if (here_op & 64) {
9342 strm.msg = 'invalid literal/length code';
9343 state.mode = BAD;
9344 break;
9345 }
9346 state.extra = here_op & 15;
9347 state.mode = LENEXT;
9348 /* falls through */
9349 case LENEXT:
9350 if (state.extra) {
9351 //=== NEEDBITS(state.extra);
9352 n = state.extra;
9353 while (bits < n) {
9354 if (have === 0) { break inf_leave; }
9355 have--;
9356 hold += input[next++] << bits;
9357 bits += 8;
9358 }
9359 //===//
9360 state.length += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
9361 //--- DROPBITS(state.extra) ---//
9362 hold >>>= state.extra;
9363 bits -= state.extra;
9364 //---//
9365 state.back += state.extra;
9366 }
9367 //Tracevv((stderr, "inflate: length %u\n", state.length));
9368 state.was = state.length;
9369 state.mode = DIST;
9370 /* falls through */
9371 case DIST:
9372 for (;;) {
9373 here = state.distcode[hold & ((1 << state.distbits) - 1)];/*BITS(state.distbits)*/
9374 here_bits = here >>> 24;
9375 here_op = (here >>> 16) & 0xff;
9376 here_val = here & 0xffff;
9377
9378 if ((here_bits) <= bits) { break; }
9379 //--- PULLBYTE() ---//
9380 if (have === 0) { break inf_leave; }
9381 have--;
9382 hold += input[next++] << bits;
9383 bits += 8;
9384 //---//
9385 }
9386 if ((here_op & 0xf0) === 0) {
9387 last_bits = here_bits;
9388 last_op = here_op;
9389 last_val = here_val;
9390 for (;;) {
9391 here = state.distcode[last_val +
9392 ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
9393 here_bits = here >>> 24;
9394 here_op = (here >>> 16) & 0xff;
9395 here_val = here & 0xffff;
9396
9397 if ((last_bits + here_bits) <= bits) { break; }
9398 //--- PULLBYTE() ---//
9399 if (have === 0) { break inf_leave; }
9400 have--;
9401 hold += input[next++] << bits;
9402 bits += 8;
9403 //---//
9404 }
9405 //--- DROPBITS(last.bits) ---//
9406 hold >>>= last_bits;
9407 bits -= last_bits;
9408 //---//
9409 state.back += last_bits;
9410 }
9411 //--- DROPBITS(here.bits) ---//
9412 hold >>>= here_bits;
9413 bits -= here_bits;
9414 //---//
9415 state.back += here_bits;
9416 if (here_op & 64) {
9417 strm.msg = 'invalid distance code';
9418 state.mode = BAD;
9419 break;
9420 }
9421 state.offset = here_val;
9422 state.extra = (here_op) & 15;
9423 state.mode = DISTEXT;
9424 /* falls through */
9425 case DISTEXT:
9426 if (state.extra) {
9427 //=== NEEDBITS(state.extra);
9428 n = state.extra;
9429 while (bits < n) {
9430 if (have === 0) { break inf_leave; }
9431 have--;
9432 hold += input[next++] << bits;
9433 bits += 8;
9434 }
9435 //===//
9436 state.offset += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
9437 //--- DROPBITS(state.extra) ---//
9438 hold >>>= state.extra;
9439 bits -= state.extra;
9440 //---//
9441 state.back += state.extra;
9442 }
9443 //#ifdef INFLATE_STRICT
9444 if (state.offset > state.dmax) {
9445 strm.msg = 'invalid distance too far back';
9446 state.mode = BAD;
9447 break;
9448 }
9449 //#endif
9450 //Tracevv((stderr, "inflate: distance %u\n", state.offset));
9451 state.mode = MATCH;
9452 /* falls through */
9453 case MATCH:
9454 if (left === 0) { break inf_leave; }
9455 copy = _out - left;
9456 if (state.offset > copy) { /* copy from window */
9457 copy = state.offset - copy;
9458 if (copy > state.whave) {
9459 if (state.sane) {
9460 strm.msg = 'invalid distance too far back';
9461 state.mode = BAD;
9462 break;
9463 }
9464 // (!) This block is disabled in zlib defailts,
9465 // don't enable it for binary compatibility
9466 //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
9467 // Trace((stderr, "inflate.c too far\n"));
9468 // copy -= state.whave;
9469 // if (copy > state.length) { copy = state.length; }
9470 // if (copy > left) { copy = left; }
9471 // left -= copy;
9472 // state.length -= copy;
9473 // do {
9474 // output[put++] = 0;
9475 // } while (--copy);
9476 // if (state.length === 0) { state.mode = LEN; }
9477 // break;
9478 //#endif
9479 }
9480 if (copy > state.wnext) {
9481 copy -= state.wnext;
9482 from = state.wsize - copy;
9483 }
9484 else {
9485 from = state.wnext - copy;
9486 }
9487 if (copy > state.length) { copy = state.length; }
9488 from_source = state.window;
9489 }
9490 else { /* copy from output */
9491 from_source = output;
9492 from = put - state.offset;
9493 copy = state.length;
9494 }
9495 if (copy > left) { copy = left; }
9496 left -= copy;
9497 state.length -= copy;
9498 do {
9499 output[put++] = from_source[from++];
9500 } while (--copy);
9501 if (state.length === 0) { state.mode = LEN; }
9502 break;
9503 case LIT:
9504 if (left === 0) { break inf_leave; }
9505 output[put++] = state.length;
9506 left--;
9507 state.mode = LEN;
9508 break;
9509 case CHECK:
9510 if (state.wrap) {
9511 //=== NEEDBITS(32);
9512 while (bits < 32) {
9513 if (have === 0) { break inf_leave; }
9514 have--;
9515 // Use '|' insdead of '+' to make sure that result is signed
9516 hold |= input[next++] << bits;
9517 bits += 8;
9518 }
9519 //===//
9520 _out -= left;
9521 strm.total_out += _out;
9522 state.total += _out;
9523 if (_out) {
9524 strm.adler = state.check =
9525 /*UPDATE(state.check, put - _out, _out);*/
9526 (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));
9527
9528 }
9529 _out = left;
9530 // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
9531 if ((state.flags ? hold : zswap32(hold)) !== state.check) {
9532 strm.msg = 'incorrect data check';
9533 state.mode = BAD;
9534 break;
9535 }
9536 //=== INITBITS();
9537 hold = 0;
9538 bits = 0;
9539 //===//
9540 //Tracev((stderr, "inflate: check matches trailer\n"));
9541 }
9542 state.mode = LENGTH;
9543 /* falls through */
9544 case LENGTH:
9545 if (state.wrap && state.flags) {
9546 //=== NEEDBITS(32);
9547 while (bits < 32) {
9548 if (have === 0) { break inf_leave; }
9549 have--;
9550 hold += input[next++] << bits;
9551 bits += 8;
9552 }
9553 //===//
9554 if (hold !== (state.total & 0xffffffff)) {
9555 strm.msg = 'incorrect length check';
9556 state.mode = BAD;
9557 break;
9558 }
9559 //=== INITBITS();
9560 hold = 0;
9561 bits = 0;
9562 //===//
9563 //Tracev((stderr, "inflate: length matches trailer\n"));
9564 }
9565 state.mode = DONE;
9566 /* falls through */
9567 case DONE:
9568 ret = Z_STREAM_END;
9569 break inf_leave;
9570 case BAD:
9571 ret = Z_DATA_ERROR;
9572 break inf_leave;
9573 case MEM:
9574 return Z_MEM_ERROR;
9575 case SYNC:
9576 /* falls through */
9577 default:
9578 return Z_STREAM_ERROR;
9579 }
9580 }
9581
9582 // inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave"
9583
9584 /*
9585 Return from inflate(), updating the total counts and the check value.
9586 If there was no progress during the inflate() call, return a buffer
9587 error. Call updatewindow() to create and/or update the window state.
9588 Note: a memory error from inflate() is non-recoverable.
9589 */
9590
9591 //--- RESTORE() ---
9592 strm.next_out = put;
9593 strm.avail_out = left;
9594 strm.next_in = next;
9595 strm.avail_in = have;
9596 state.hold = hold;
9597 state.bits = bits;
9598 //---
9599
9600 if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&
9601 (state.mode < CHECK || flush !== Z_FINISH))) {
9602 if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {
9603 state.mode = MEM;
9604 return Z_MEM_ERROR;
9605 }
9606 }
9607 _in -= strm.avail_in;
9608 _out -= strm.avail_out;
9609 strm.total_in += _in;
9610 strm.total_out += _out;
9611 state.total += _out;
9612 if (state.wrap && _out) {
9613 strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
9614 (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));
9615 }
9616 strm.data_type = state.bits + (state.last ? 64 : 0) +
9617 (state.mode === TYPE ? 128 : 0) +
9618 (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
9619 if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) {
9620 ret = Z_BUF_ERROR;
9621 }
9622 return ret;
9623 }
9624
9625 function inflateEnd(strm) {
9626
9627 if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) {
9628 return Z_STREAM_ERROR;
9629 }
9630
9631 var state = strm.state;
9632 if (state.window) {
9633 state.window = null;
9634 }
9635 strm.state = null;
9636 return Z_OK;
9637 }
9638
9639 function inflateGetHeader(strm, head) {
9640 var state;
9641
9642 /* check state */
9643 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
9644 state = strm.state;
9645 if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; }
9646
9647 /* save header structure */
9648 state.head = head;
9649 head.done = false;
9650 return Z_OK;
9651 }
9652
9653 function inflateSetDictionary(strm, dictionary) {
9654 var dictLength = dictionary.length;
9655
9656 var state;
9657 var dictid;
9658 var ret;
9659
9660 /* check state */
9661 if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR; }
9662 state = strm.state;
9663
9664 if (state.wrap !== 0 && state.mode !== DICT) {
9665 return Z_STREAM_ERROR;
9666 }
9667
9668 /* check for correct dictionary identifier */
9669 if (state.mode === DICT) {
9670 dictid = 1; /* adler32(0, null, 0)*/
9671 /* dictid = adler32(dictid, dictionary, dictLength); */
9672 dictid = adler32(dictid, dictionary, dictLength, 0);
9673 if (dictid !== state.check) {
9674 return Z_DATA_ERROR;
9675 }
9676 }
9677 /* copy dictionary to window using updatewindow(), which will amend the
9678 existing dictionary if appropriate */
9679 ret = updatewindow(strm, dictionary, dictLength, dictLength);
9680 if (ret) {
9681 state.mode = MEM;
9682 return Z_MEM_ERROR;
9683 }
9684 state.havedict = 1;
9685 // Tracev((stderr, "inflate: dictionary set\n"));
9686 return Z_OK;
9687 }
9688
9689 exports.inflateReset = inflateReset;
9690 exports.inflateReset2 = inflateReset2;
9691 exports.inflateResetKeep = inflateResetKeep;
9692 exports.inflateInit = inflateInit;
9693 exports.inflateInit2 = inflateInit2;
9694 exports.inflate = inflate;
9695 exports.inflateEnd = inflateEnd;
9696 exports.inflateGetHeader = inflateGetHeader;
9697 exports.inflateSetDictionary = inflateSetDictionary;
9698 exports.inflateInfo = 'pako inflate (from Nodeca project)';
9699
9700 /* Not implemented
9701 exports.inflateCopy = inflateCopy;
9702 exports.inflateGetDictionary = inflateGetDictionary;
9703 exports.inflateMark = inflateMark;
9704 exports.inflatePrime = inflatePrime;
9705 exports.inflateSync = inflateSync;
9706 exports.inflateSyncPoint = inflateSyncPoint;
9707 exports.inflateUndermine = inflateUndermine;
9708 */
9709
9710 },{"../utils/common":41,"./adler32":43,"./crc32":45,"./inffast":48,"./inftrees":50}],50:[function(require,module,exports){
9711 'use strict';
9712
9713 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
9714 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
9715 //
9716 // This software is provided 'as-is', without any express or implied
9717 // warranty. In no event will the authors be held liable for any damages
9718 // arising from the use of this software.
9719 //
9720 // Permission is granted to anyone to use this software for any purpose,
9721 // including commercial applications, and to alter it and redistribute it
9722 // freely, subject to the following restrictions:
9723 //
9724 // 1. The origin of this software must not be misrepresented; you must not
9725 // claim that you wrote the original software. If you use this software
9726 // in a product, an acknowledgment in the product documentation would be
9727 // appreciated but is not required.
9728 // 2. Altered source versions must be plainly marked as such, and must not be
9729 // misrepresented as being the original software.
9730 // 3. This notice may not be removed or altered from any source distribution.
9731
9732 var utils = require('../utils/common');
9733
9734 var MAXBITS = 15;
9735 var ENOUGH_LENS = 852;
9736 var ENOUGH_DISTS = 592;
9737 //var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
9738
9739 var CODES = 0;
9740 var LENS = 1;
9741 var DISTS = 2;
9742
9743 var lbase = [ /* Length codes 257..285 base */
9744 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
9745 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
9746 ];
9747
9748 var lext = [ /* Length codes 257..285 extra */
9749 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
9750 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78
9751 ];
9752
9753 var dbase = [ /* Distance codes 0..29 base */
9754 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
9755 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
9756 8193, 12289, 16385, 24577, 0, 0
9757 ];
9758
9759 var dext = [ /* Distance codes 0..29 extra */
9760 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
9761 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
9762 28, 28, 29, 29, 64, 64
9763 ];
9764
9765 module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts)
9766 {
9767 var bits = opts.bits;
9768 //here = opts.here; /* table entry for duplication */
9769
9770 var len = 0; /* a code's length in bits */
9771 var sym = 0; /* index of code symbols */
9772 var min = 0, max = 0; /* minimum and maximum code lengths */
9773 var root = 0; /* number of index bits for root table */
9774 var curr = 0; /* number of index bits for current table */
9775 var drop = 0; /* code bits to drop for sub-table */
9776 var left = 0; /* number of prefix codes available */
9777 var used = 0; /* code entries in table used */
9778 var huff = 0; /* Huffman code */
9779 var incr; /* for incrementing code, index */
9780 var fill; /* index for replicating entries */
9781 var low; /* low bits for current root entry */
9782 var mask; /* mask for low root bits */
9783 var next; /* next available space in table */
9784 var base = null; /* base value table to use */
9785 var base_index = 0;
9786 // var shoextra; /* extra bits table to use */
9787 var end; /* use base and extra for symbol > end */
9788 var count = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* number of codes of each length */
9789 var offs = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* offsets in table for each length */
9790 var extra = null;
9791 var extra_index = 0;
9792
9793 var here_bits, here_op, here_val;
9794
9795 /*
9796 Process a set of code lengths to create a canonical Huffman code. The
9797 code lengths are lens[0..codes-1]. Each length corresponds to the
9798 symbols 0..codes-1. The Huffman code is generated by first sorting the
9799 symbols by length from short to long, and retaining the symbol order
9800 for codes with equal lengths. Then the code starts with all zero bits
9801 for the first code of the shortest length, and the codes are integer
9802 increments for the same length, and zeros are appended as the length
9803 increases. For the deflate format, these bits are stored backwards
9804 from their more natural integer increment ordering, and so when the
9805 decoding tables are built in the large loop below, the integer codes
9806 are incremented backwards.
9807
9808 This routine assumes, but does not check, that all of the entries in
9809 lens[] are in the range 0..MAXBITS. The caller must assure this.
9810 1..MAXBITS is interpreted as that code length. zero means that that
9811 symbol does not occur in this code.
9812
9813 The codes are sorted by computing a count of codes for each length,
9814 creating from that a table of starting indices for each length in the
9815 sorted table, and then entering the symbols in order in the sorted
9816 table. The sorted table is work[], with that space being provided by
9817 the caller.
9818
9819 The length counts are used for other purposes as well, i.e. finding
9820 the minimum and maximum length codes, determining if there are any
9821 codes at all, checking for a valid set of lengths, and looking ahead
9822 at length counts to determine sub-table sizes when building the
9823 decoding tables.
9824 */
9825
9826 /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
9827 for (len = 0; len <= MAXBITS; len++) {
9828 count[len] = 0;
9829 }
9830 for (sym = 0; sym < codes; sym++) {
9831 count[lens[lens_index + sym]]++;
9832 }
9833
9834 /* bound code lengths, force root to be within code lengths */
9835 root = bits;
9836 for (max = MAXBITS; max >= 1; max--) {
9837 if (count[max] !== 0) { break; }
9838 }
9839 if (root > max) {
9840 root = max;
9841 }
9842 if (max === 0) { /* no symbols to code at all */
9843 //table.op[opts.table_index] = 64; //here.op = (var char)64; /* invalid code marker */
9844 //table.bits[opts.table_index] = 1; //here.bits = (var char)1;
9845 //table.val[opts.table_index++] = 0; //here.val = (var short)0;
9846 table[table_index++] = (1 << 24) | (64 << 16) | 0;
9847
9848
9849 //table.op[opts.table_index] = 64;
9850 //table.bits[opts.table_index] = 1;
9851 //table.val[opts.table_index++] = 0;
9852 table[table_index++] = (1 << 24) | (64 << 16) | 0;
9853
9854 opts.bits = 1;
9855 return 0; /* no symbols, but wait for decoding to report error */
9856 }
9857 for (min = 1; min < max; min++) {
9858 if (count[min] !== 0) { break; }
9859 }
9860 if (root < min) {
9861 root = min;
9862 }
9863
9864 /* check for an over-subscribed or incomplete set of lengths */
9865 left = 1;
9866 for (len = 1; len <= MAXBITS; len++) {
9867 left <<= 1;
9868 left -= count[len];
9869 if (left < 0) {
9870 return -1;
9871 } /* over-subscribed */
9872 }
9873 if (left > 0 && (type === CODES || max !== 1)) {
9874 return -1; /* incomplete set */
9875 }
9876
9877 /* generate offsets into symbol table for each length for sorting */
9878 offs[1] = 0;
9879 for (len = 1; len < MAXBITS; len++) {
9880 offs[len + 1] = offs[len] + count[len];
9881 }
9882
9883 /* sort symbols by length, by symbol order within each length */
9884 for (sym = 0; sym < codes; sym++) {
9885 if (lens[lens_index + sym] !== 0) {
9886 work[offs[lens[lens_index + sym]]++] = sym;
9887 }
9888 }
9889
9890 /*
9891 Create and fill in decoding tables. In this loop, the table being
9892 filled is at next and has curr index bits. The code being used is huff
9893 with length len. That code is converted to an index by dropping drop
9894 bits off of the bottom. For codes where len is less than drop + curr,
9895 those top drop + curr - len bits are incremented through all values to
9896 fill the table with replicated entries.
9897
9898 root is the number of index bits for the root table. When len exceeds
9899 root, sub-tables are created pointed to by the root entry with an index
9900 of the low root bits of huff. This is saved in low to check for when a
9901 new sub-table should be started. drop is zero when the root table is
9902 being filled, and drop is root when sub-tables are being filled.
9903
9904 When a new sub-table is needed, it is necessary to look ahead in the
9905 code lengths to determine what size sub-table is needed. The length
9906 counts are used for this, and so count[] is decremented as codes are
9907 entered in the tables.
9908
9909 used keeps track of how many table entries have been allocated from the
9910 provided *table space. It is checked for LENS and DIST tables against
9911 the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
9912 the initial root table size constants. See the comments in inftrees.h
9913 for more information.
9914
9915 sym increments through all symbols, and the loop terminates when
9916 all codes of length max, i.e. all codes, have been processed. This
9917 routine permits incomplete codes, so another loop after this one fills
9918 in the rest of the decoding tables with invalid code markers.
9919 */
9920
9921 /* set up for code type */
9922 // poor man optimization - use if-else instead of switch,
9923 // to avoid deopts in old v8
9924 if (type === CODES) {
9925 base = extra = work; /* dummy value--not used */
9926 end = 19;
9927
9928 } else if (type === LENS) {
9929 base = lbase;
9930 base_index -= 257;
9931 extra = lext;
9932 extra_index -= 257;
9933 end = 256;
9934
9935 } else { /* DISTS */
9936 base = dbase;
9937 extra = dext;
9938 end = -1;
9939 }
9940
9941 /* initialize opts for loop */
9942 huff = 0; /* starting code */
9943 sym = 0; /* starting code symbol */
9944 len = min; /* starting code length */
9945 next = table_index; /* current table to fill in */
9946 curr = root; /* current table index bits */
9947 drop = 0; /* current bits to drop from code for index */
9948 low = -1; /* trigger new sub-table when len > root */
9949 used = 1 << root; /* use root table entries */
9950 mask = used - 1; /* mask for comparing low */
9951
9952 /* check available table space */
9953 if ((type === LENS && used > ENOUGH_LENS) ||
9954 (type === DISTS && used > ENOUGH_DISTS)) {
9955 return 1;
9956 }
9957
9958 /* process all codes and make table entries */
9959 for (;;) {
9960 /* create table entry */
9961 here_bits = len - drop;
9962 if (work[sym] < end) {
9963 here_op = 0;
9964 here_val = work[sym];
9965 }
9966 else if (work[sym] > end) {
9967 here_op = extra[extra_index + work[sym]];
9968 here_val = base[base_index + work[sym]];
9969 }
9970 else {
9971 here_op = 32 + 64; /* end of block */
9972 here_val = 0;
9973 }
9974
9975 /* replicate for those indices with low len bits equal to huff */
9976 incr = 1 << (len - drop);
9977 fill = 1 << curr;
9978 min = fill; /* save offset to next table */
9979 do {
9980 fill -= incr;
9981 table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0;
9982 } while (fill !== 0);
9983
9984 /* backwards increment the len-bit code huff */
9985 incr = 1 << (len - 1);
9986 while (huff & incr) {
9987 incr >>= 1;
9988 }
9989 if (incr !== 0) {
9990 huff &= incr - 1;
9991 huff += incr;
9992 } else {
9993 huff = 0;
9994 }
9995
9996 /* go to next symbol, update count, len */
9997 sym++;
9998 if (--count[len] === 0) {
9999 if (len === max) { break; }
10000 len = lens[lens_index + work[sym]];
10001 }
10002
10003 /* create new sub-table if needed */
10004 if (len > root && (huff & mask) !== low) {
10005 /* if first time, transition to sub-tables */
10006 if (drop === 0) {
10007 drop = root;
10008 }
10009
10010 /* increment past last table */
10011 next += min; /* here min is 1 << curr */
10012
10013 /* determine length of next table */
10014 curr = len - drop;
10015 left = 1 << curr;
10016 while (curr + drop < max) {
10017 left -= count[curr + drop];
10018 if (left <= 0) { break; }
10019 curr++;
10020 left <<= 1;
10021 }
10022
10023 /* check for enough space */
10024 used += 1 << curr;
10025 if ((type === LENS && used > ENOUGH_LENS) ||
10026 (type === DISTS && used > ENOUGH_DISTS)) {
10027 return 1;
10028 }
10029
10030 /* point entry in root table to sub-table */
10031 low = huff & mask;
10032 /*table.op[low] = curr;
10033 table.bits[low] = root;
10034 table.val[low] = next - opts.table_index;*/
10035 table[low] = (root << 24) | (curr << 16) | (next - table_index) |0;
10036 }
10037 }
10038
10039 /* fill in remaining table entry if code is incomplete (guaranteed to have
10040 at most one remaining entry, since if the code is incomplete, the
10041 maximum code length that was allowed to get this far is one bit) */
10042 if (huff !== 0) {
10043 //table.op[next + huff] = 64; /* invalid code marker */
10044 //table.bits[next + huff] = len - drop;
10045 //table.val[next + huff] = 0;
10046 table[next + huff] = ((len - drop) << 24) | (64 << 16) |0;
10047 }
10048
10049 /* set return parameters */
10050 //opts.table_index += used;
10051 opts.bits = root;
10052 return 0;
10053 };
10054
10055 },{"../utils/common":41}],51:[function(require,module,exports){
10056 'use strict';
10057
10058 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
10059 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
10060 //
10061 // This software is provided 'as-is', without any express or implied
10062 // warranty. In no event will the authors be held liable for any damages
10063 // arising from the use of this software.
10064 //
10065 // Permission is granted to anyone to use this software for any purpose,
10066 // including commercial applications, and to alter it and redistribute it
10067 // freely, subject to the following restrictions:
10068 //
10069 // 1. The origin of this software must not be misrepresented; you must not
10070 // claim that you wrote the original software. If you use this software
10071 // in a product, an acknowledgment in the product documentation would be
10072 // appreciated but is not required.
10073 // 2. Altered source versions must be plainly marked as such, and must not be
10074 // misrepresented as being the original software.
10075 // 3. This notice may not be removed or altered from any source distribution.
10076
10077 module.exports = {
10078 2: 'need dictionary', /* Z_NEED_DICT 2 */
10079 1: 'stream end', /* Z_STREAM_END 1 */
10080 0: '', /* Z_OK 0 */
10081 '-1': 'file error', /* Z_ERRNO (-1) */
10082 '-2': 'stream error', /* Z_STREAM_ERROR (-2) */
10083 '-3': 'data error', /* Z_DATA_ERROR (-3) */
10084 '-4': 'insufficient memory', /* Z_MEM_ERROR (-4) */
10085 '-5': 'buffer error', /* Z_BUF_ERROR (-5) */
10086 '-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */
10087 };
10088
10089 },{}],52:[function(require,module,exports){
10090 'use strict';
10091
10092 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
10093 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
10094 //
10095 // This software is provided 'as-is', without any express or implied
10096 // warranty. In no event will the authors be held liable for any damages
10097 // arising from the use of this software.
10098 //
10099 // Permission is granted to anyone to use this software for any purpose,
10100 // including commercial applications, and to alter it and redistribute it
10101 // freely, subject to the following restrictions:
10102 //
10103 // 1. The origin of this software must not be misrepresented; you must not
10104 // claim that you wrote the original software. If you use this software
10105 // in a product, an acknowledgment in the product documentation would be
10106 // appreciated but is not required.
10107 // 2. Altered source versions must be plainly marked as such, and must not be
10108 // misrepresented as being the original software.
10109 // 3. This notice may not be removed or altered from any source distribution.
10110
10111 var utils = require('../utils/common');
10112
10113 /* Public constants ==========================================================*/
10114 /* ===========================================================================*/
10115
10116
10117 //var Z_FILTERED = 1;
10118 //var Z_HUFFMAN_ONLY = 2;
10119 //var Z_RLE = 3;
10120 var Z_FIXED = 4;
10121 //var Z_DEFAULT_STRATEGY = 0;
10122
10123 /* Possible values of the data_type field (though see inflate()) */
10124 var Z_BINARY = 0;
10125 var Z_TEXT = 1;
10126 //var Z_ASCII = 1; // = Z_TEXT
10127 var Z_UNKNOWN = 2;
10128
10129 /*============================================================================*/
10130
10131
10132 function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }
10133
10134 // From zutil.h
10135
10136 var STORED_BLOCK = 0;
10137 var STATIC_TREES = 1;
10138 var DYN_TREES = 2;
10139 /* The three kinds of block type */
10140
10141 var MIN_MATCH = 3;
10142 var MAX_MATCH = 258;
10143 /* The minimum and maximum match lengths */
10144
10145 // From deflate.h
10146 /* ===========================================================================
10147 * Internal compression state.
10148 */
10149
10150 var LENGTH_CODES = 29;
10151 /* number of length codes, not counting the special END_BLOCK code */
10152
10153 var LITERALS = 256;
10154 /* number of literal bytes 0..255 */
10155
10156 var L_CODES = LITERALS + 1 + LENGTH_CODES;
10157 /* number of Literal or Length codes, including the END_BLOCK code */
10158
10159 var D_CODES = 30;
10160 /* number of distance codes */
10161
10162 var BL_CODES = 19;
10163 /* number of codes used to transfer the bit lengths */
10164
10165 var HEAP_SIZE = 2 * L_CODES + 1;
10166 /* maximum heap size */
10167
10168 var MAX_BITS = 15;
10169 /* All codes must not exceed MAX_BITS bits */
10170
10171 var Buf_size = 16;
10172 /* size of bit buffer in bi_buf */
10173
10174
10175 /* ===========================================================================
10176 * Constants
10177 */
10178
10179 var MAX_BL_BITS = 7;
10180 /* Bit length codes must not exceed MAX_BL_BITS bits */
10181
10182 var END_BLOCK = 256;
10183 /* end of block literal code */
10184
10185 var REP_3_6 = 16;
10186 /* repeat previous bit length 3-6 times (2 bits of repeat count) */
10187
10188 var REPZ_3_10 = 17;
10189 /* repeat a zero length 3-10 times (3 bits of repeat count) */
10190
10191 var REPZ_11_138 = 18;
10192 /* repeat a zero length 11-138 times (7 bits of repeat count) */
10193
10194 /* eslint-disable comma-spacing,array-bracket-spacing */
10195 var extra_lbits = /* extra bits for each length code */
10196 [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];
10197
10198 var extra_dbits = /* extra bits for each distance code */
10199 [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];
10200
10201 var extra_blbits = /* extra bits for each bit length code */
10202 [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7];
10203
10204 var bl_order =
10205 [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];
10206 /* eslint-enable comma-spacing,array-bracket-spacing */
10207
10208 /* The lengths of the bit length codes are sent in order of decreasing
10209 * probability, to avoid transmitting the lengths for unused bit length codes.
10210 */
10211
10212 /* ===========================================================================
10213 * Local data. These are initialized only once.
10214 */
10215
10216 // We pre-fill arrays with 0 to avoid uninitialized gaps
10217
10218 var DIST_CODE_LEN = 512; /* see definition of array dist_code below */
10219
10220 // !!!! Use flat array insdead of structure, Freq = i*2, Len = i*2+1
10221 var static_ltree = new Array((L_CODES + 2) * 2);
10222 zero(static_ltree);
10223 /* The static literal tree. Since the bit lengths are imposed, there is no
10224 * need for the L_CODES extra codes used during heap construction. However
10225 * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
10226 * below).
10227 */
10228
10229 var static_dtree = new Array(D_CODES * 2);
10230 zero(static_dtree);
10231 /* The static distance tree. (Actually a trivial tree since all codes use
10232 * 5 bits.)
10233 */
10234
10235 var _dist_code = new Array(DIST_CODE_LEN);
10236 zero(_dist_code);
10237 /* Distance codes. The first 256 values correspond to the distances
10238 * 3 .. 258, the last 256 values correspond to the top 8 bits of
10239 * the 15 bit distances.
10240 */
10241
10242 var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);
10243 zero(_length_code);
10244 /* length code for each normalized match length (0 == MIN_MATCH) */
10245
10246 var base_length = new Array(LENGTH_CODES);
10247 zero(base_length);
10248 /* First normalized length for each code (0 = MIN_MATCH) */
10249
10250 var base_dist = new Array(D_CODES);
10251 zero(base_dist);
10252 /* First normalized distance for each code (0 = distance of 1) */
10253
10254
10255 function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {
10256
10257 this.static_tree = static_tree; /* static tree or NULL */
10258 this.extra_bits = extra_bits; /* extra bits for each code or NULL */
10259 this.extra_base = extra_base; /* base index for extra_bits */
10260 this.elems = elems; /* max number of elements in the tree */
10261 this.max_length = max_length; /* max bit length for the codes */
10262
10263 // show if `static_tree` has data or dummy - needed for monomorphic objects
10264 this.has_stree = static_tree && static_tree.length;
10265 }
10266
10267
10268 var static_l_desc;
10269 var static_d_desc;
10270 var static_bl_desc;
10271
10272
10273 function TreeDesc(dyn_tree, stat_desc) {
10274 this.dyn_tree = dyn_tree; /* the dynamic tree */
10275 this.max_code = 0; /* largest code with non zero frequency */
10276 this.stat_desc = stat_desc; /* the corresponding static tree */
10277 }
10278
10279
10280
10281 function d_code(dist) {
10282 return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
10283 }
10284
10285
10286 /* ===========================================================================
10287 * Output a short LSB first on the stream.
10288 * IN assertion: there is enough room in pendingBuf.
10289 */
10290 function put_short(s, w) {
10291 // put_byte(s, (uch)((w) & 0xff));
10292 // put_byte(s, (uch)((ush)(w) >> 8));
10293 s.pending_buf[s.pending++] = (w) & 0xff;
10294 s.pending_buf[s.pending++] = (w >>> 8) & 0xff;
10295 }
10296
10297
10298 /* ===========================================================================
10299 * Send a value on a given number of bits.
10300 * IN assertion: length <= 16 and value fits in length bits.
10301 */
10302 function send_bits(s, value, length) {
10303 if (s.bi_valid > (Buf_size - length)) {
10304 s.bi_buf |= (value << s.bi_valid) & 0xffff;
10305 put_short(s, s.bi_buf);
10306 s.bi_buf = value >> (Buf_size - s.bi_valid);
10307 s.bi_valid += length - Buf_size;
10308 } else {
10309 s.bi_buf |= (value << s.bi_valid) & 0xffff;
10310 s.bi_valid += length;
10311 }
10312 }
10313
10314
10315 function send_code(s, c, tree) {
10316 send_bits(s, tree[c * 2]/*.Code*/, tree[c * 2 + 1]/*.Len*/);
10317 }
10318
10319
10320 /* ===========================================================================
10321 * Reverse the first len bits of a code, using straightforward code (a faster
10322 * method would use a table)
10323 * IN assertion: 1 <= len <= 15
10324 */
10325 function bi_reverse(code, len) {
10326 var res = 0;
10327 do {
10328 res |= code & 1;
10329 code >>>= 1;
10330 res <<= 1;
10331 } while (--len > 0);
10332 return res >>> 1;
10333 }
10334
10335
10336 /* ===========================================================================
10337 * Flush the bit buffer, keeping at most 7 bits in it.
10338 */
10339 function bi_flush(s) {
10340 if (s.bi_valid === 16) {
10341 put_short(s, s.bi_buf);
10342 s.bi_buf = 0;
10343 s.bi_valid = 0;
10344
10345 } else if (s.bi_valid >= 8) {
10346 s.pending_buf[s.pending++] = s.bi_buf & 0xff;
10347 s.bi_buf >>= 8;
10348 s.bi_valid -= 8;
10349 }
10350 }
10351
10352
10353 /* ===========================================================================
10354 * Compute the optimal bit lengths for a tree and update the total bit length
10355 * for the current block.
10356 * IN assertion: the fields freq and dad are set, heap[heap_max] and
10357 * above are the tree nodes sorted by increasing frequency.
10358 * OUT assertions: the field len is set to the optimal bit length, the
10359 * array bl_count contains the frequencies for each bit length.
10360 * The length opt_len is updated; static_len is also updated if stree is
10361 * not null.
10362 */
10363 function gen_bitlen(s, desc)
10364 // deflate_state *s;
10365 // tree_desc *desc; /* the tree descriptor */
10366 {
10367 var tree = desc.dyn_tree;
10368 var max_code = desc.max_code;
10369 var stree = desc.stat_desc.static_tree;
10370 var has_stree = desc.stat_desc.has_stree;
10371 var extra = desc.stat_desc.extra_bits;
10372 var base = desc.stat_desc.extra_base;
10373 var max_length = desc.stat_desc.max_length;
10374 var h; /* heap index */
10375 var n, m; /* iterate over the tree elements */
10376 var bits; /* bit length */
10377 var xbits; /* extra bits */
10378 var f; /* frequency */
10379 var overflow = 0; /* number of elements with bit length too large */
10380
10381 for (bits = 0; bits <= MAX_BITS; bits++) {
10382 s.bl_count[bits] = 0;
10383 }
10384
10385 /* In a first pass, compute the optimal bit lengths (which may
10386 * overflow in the case of the bit length tree).
10387 */
10388 tree[s.heap[s.heap_max] * 2 + 1]/*.Len*/ = 0; /* root of the heap */
10389
10390 for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
10391 n = s.heap[h];
10392 bits = tree[tree[n * 2 + 1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1;
10393 if (bits > max_length) {
10394 bits = max_length;
10395 overflow++;
10396 }
10397 tree[n * 2 + 1]/*.Len*/ = bits;
10398 /* We overwrite tree[n].Dad which is no longer needed */
10399
10400 if (n > max_code) { continue; } /* not a leaf node */
10401
10402 s.bl_count[bits]++;
10403 xbits = 0;
10404 if (n >= base) {
10405 xbits = extra[n - base];
10406 }
10407 f = tree[n * 2]/*.Freq*/;
10408 s.opt_len += f * (bits + xbits);
10409 if (has_stree) {
10410 s.static_len += f * (stree[n * 2 + 1]/*.Len*/ + xbits);
10411 }
10412 }
10413 if (overflow === 0) { return; }
10414
10415 // Trace((stderr,"\nbit length overflow\n"));
10416 /* This happens for example on obj2 and pic of the Calgary corpus */
10417
10418 /* Find the first bit length which could increase: */
10419 do {
10420 bits = max_length - 1;
10421 while (s.bl_count[bits] === 0) { bits--; }
10422 s.bl_count[bits]--; /* move one leaf down the tree */
10423 s.bl_count[bits + 1] += 2; /* move one overflow item as its brother */
10424 s.bl_count[max_length]--;
10425 /* The brother of the overflow item also moves one step up,
10426 * but this does not affect bl_count[max_length]
10427 */
10428 overflow -= 2;
10429 } while (overflow > 0);
10430
10431 /* Now recompute all bit lengths, scanning in increasing frequency.
10432 * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
10433 * lengths instead of fixing only the wrong ones. This idea is taken
10434 * from 'ar' written by Haruhiko Okumura.)
10435 */
10436 for (bits = max_length; bits !== 0; bits--) {
10437 n = s.bl_count[bits];
10438 while (n !== 0) {
10439 m = s.heap[--h];
10440 if (m > max_code) { continue; }
10441 if (tree[m * 2 + 1]/*.Len*/ !== bits) {
10442 // Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
10443 s.opt_len += (bits - tree[m * 2 + 1]/*.Len*/) * tree[m * 2]/*.Freq*/;
10444 tree[m * 2 + 1]/*.Len*/ = bits;
10445 }
10446 n--;
10447 }
10448 }
10449 }
10450
10451
10452 /* ===========================================================================
10453 * Generate the codes for a given tree and bit counts (which need not be
10454 * optimal).
10455 * IN assertion: the array bl_count contains the bit length statistics for
10456 * the given tree and the field len is set for all tree elements.
10457 * OUT assertion: the field code is set for all tree elements of non
10458 * zero code length.
10459 */
10460 function gen_codes(tree, max_code, bl_count)
10461 // ct_data *tree; /* the tree to decorate */
10462 // int max_code; /* largest code with non zero frequency */
10463 // ushf *bl_count; /* number of codes at each bit length */
10464 {
10465 var next_code = new Array(MAX_BITS + 1); /* next code value for each bit length */
10466 var code = 0; /* running code value */
10467 var bits; /* bit index */
10468 var n; /* code index */
10469
10470 /* The distribution counts are first used to generate the code values
10471 * without bit reversal.
10472 */
10473 for (bits = 1; bits <= MAX_BITS; bits++) {
10474 next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
10475 }
10476 /* Check that the bit counts in bl_count are consistent. The last code
10477 * must be all ones.
10478 */
10479 //Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
10480 // "inconsistent bit counts");
10481 //Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
10482
10483 for (n = 0; n <= max_code; n++) {
10484 var len = tree[n * 2 + 1]/*.Len*/;
10485 if (len === 0) { continue; }
10486 /* Now reverse the bits */
10487 tree[n * 2]/*.Code*/ = bi_reverse(next_code[len]++, len);
10488
10489 //Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
10490 // n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
10491 }
10492 }
10493
10494
10495 /* ===========================================================================
10496 * Initialize the various 'constant' tables.
10497 */
10498 function tr_static_init() {
10499 var n; /* iterates over tree elements */
10500 var bits; /* bit counter */
10501 var length; /* length value */
10502 var code; /* code value */
10503 var dist; /* distance index */
10504 var bl_count = new Array(MAX_BITS + 1);
10505 /* number of codes at each bit length for an optimal tree */
10506
10507 // do check in _tr_init()
10508 //if (static_init_done) return;
10509
10510 /* For some embedded targets, global variables are not initialized: */
10511 /*#ifdef NO_INIT_GLOBAL_POINTERS
10512 static_l_desc.static_tree = static_ltree;
10513 static_l_desc.extra_bits = extra_lbits;
10514 static_d_desc.static_tree = static_dtree;
10515 static_d_desc.extra_bits = extra_dbits;
10516 static_bl_desc.extra_bits = extra_blbits;
10517 #endif*/
10518
10519 /* Initialize the mapping length (0..255) -> length code (0..28) */
10520 length = 0;
10521 for (code = 0; code < LENGTH_CODES - 1; code++) {
10522 base_length[code] = length;
10523 for (n = 0; n < (1 << extra_lbits[code]); n++) {
10524 _length_code[length++] = code;
10525 }
10526 }
10527 //Assert (length == 256, "tr_static_init: length != 256");
10528 /* Note that the length 255 (match length 258) can be represented
10529 * in two different ways: code 284 + 5 bits or code 285, so we
10530 * overwrite length_code[255] to use the best encoding:
10531 */
10532 _length_code[length - 1] = code;
10533
10534 /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
10535 dist = 0;
10536 for (code = 0; code < 16; code++) {
10537 base_dist[code] = dist;
10538 for (n = 0; n < (1 << extra_dbits[code]); n++) {
10539 _dist_code[dist++] = code;
10540 }
10541 }
10542 //Assert (dist == 256, "tr_static_init: dist != 256");
10543 dist >>= 7; /* from now on, all distances are divided by 128 */
10544 for (; code < D_CODES; code++) {
10545 base_dist[code] = dist << 7;
10546 for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
10547 _dist_code[256 + dist++] = code;
10548 }
10549 }
10550 //Assert (dist == 256, "tr_static_init: 256+dist != 512");
10551
10552 /* Construct the codes of the static literal tree */
10553 for (bits = 0; bits <= MAX_BITS; bits++) {
10554 bl_count[bits] = 0;
10555 }
10556
10557 n = 0;
10558 while (n <= 143) {
10559 static_ltree[n * 2 + 1]/*.Len*/ = 8;
10560 n++;
10561 bl_count[8]++;
10562 }
10563 while (n <= 255) {
10564 static_ltree[n * 2 + 1]/*.Len*/ = 9;
10565 n++;
10566 bl_count[9]++;
10567 }
10568 while (n <= 279) {
10569 static_ltree[n * 2 + 1]/*.Len*/ = 7;
10570 n++;
10571 bl_count[7]++;
10572 }
10573 while (n <= 287) {
10574 static_ltree[n * 2 + 1]/*.Len*/ = 8;
10575 n++;
10576 bl_count[8]++;
10577 }
10578 /* Codes 286 and 287 do not exist, but we must include them in the
10579 * tree construction to get a canonical Huffman tree (longest code
10580 * all ones)
10581 */
10582 gen_codes(static_ltree, L_CODES + 1, bl_count);
10583
10584 /* The static distance tree is trivial: */
10585 for (n = 0; n < D_CODES; n++) {
10586 static_dtree[n * 2 + 1]/*.Len*/ = 5;
10587 static_dtree[n * 2]/*.Code*/ = bi_reverse(n, 5);
10588 }
10589
10590 // Now data ready and we can init static trees
10591 static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
10592 static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);
10593 static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);
10594
10595 //static_init_done = true;
10596 }
10597
10598
10599 /* ===========================================================================
10600 * Initialize a new block.
10601 */
10602 function init_block(s) {
10603 var n; /* iterates over tree elements */
10604
10605 /* Initialize the trees. */
10606 for (n = 0; n < L_CODES; n++) { s.dyn_ltree[n * 2]/*.Freq*/ = 0; }
10607 for (n = 0; n < D_CODES; n++) { s.dyn_dtree[n * 2]/*.Freq*/ = 0; }
10608 for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2]/*.Freq*/ = 0; }
10609
10610 s.dyn_ltree[END_BLOCK * 2]/*.Freq*/ = 1;
10611 s.opt_len = s.static_len = 0;
10612 s.last_lit = s.matches = 0;
10613 }
10614
10615
10616 /* ===========================================================================
10617 * Flush the bit buffer and align the output on a byte boundary
10618 */
10619 function bi_windup(s)
10620 {
10621 if (s.bi_valid > 8) {
10622 put_short(s, s.bi_buf);
10623 } else if (s.bi_valid > 0) {
10624 //put_byte(s, (Byte)s->bi_buf);
10625 s.pending_buf[s.pending++] = s.bi_buf;
10626 }
10627 s.bi_buf = 0;
10628 s.bi_valid = 0;
10629 }
10630
10631 /* ===========================================================================
10632 * Copy a stored block, storing first the length and its
10633 * one's complement if requested.
10634 */
10635 function copy_block(s, buf, len, header)
10636 //DeflateState *s;
10637 //charf *buf; /* the input data */
10638 //unsigned len; /* its length */
10639 //int header; /* true if block header must be written */
10640 {
10641 bi_windup(s); /* align on byte boundary */
10642
10643 if (header) {
10644 put_short(s, len);
10645 put_short(s, ~len);
10646 }
10647 // while (len--) {
10648 // put_byte(s, *buf++);
10649 // }
10650 utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);
10651 s.pending += len;
10652 }
10653
10654 /* ===========================================================================
10655 * Compares to subtrees, using the tree depth as tie breaker when
10656 * the subtrees have equal frequency. This minimizes the worst case length.
10657 */
10658 function smaller(tree, n, m, depth) {
10659 var _n2 = n * 2;
10660 var _m2 = m * 2;
10661 return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ ||
10662 (tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m]));
10663 }
10664
10665 /* ===========================================================================
10666 * Restore the heap property by moving down the tree starting at node k,
10667 * exchanging a node with the smallest of its two sons if necessary, stopping
10668 * when the heap property is re-established (each father smaller than its
10669 * two sons).
10670 */
10671 function pqdownheap(s, tree, k)
10672 // deflate_state *s;
10673 // ct_data *tree; /* the tree to restore */
10674 // int k; /* node to move down */
10675 {
10676 var v = s.heap[k];
10677 var j = k << 1; /* left son of k */
10678 while (j <= s.heap_len) {
10679 /* Set j to the smallest of the two sons: */
10680 if (j < s.heap_len &&
10681 smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
10682 j++;
10683 }
10684 /* Exit if v is smaller than both sons */
10685 if (smaller(tree, v, s.heap[j], s.depth)) { break; }
10686
10687 /* Exchange v with the smallest son */
10688 s.heap[k] = s.heap[j];
10689 k = j;
10690
10691 /* And continue down the tree, setting j to the left son of k */
10692 j <<= 1;
10693 }
10694 s.heap[k] = v;
10695 }
10696
10697
10698 // inlined manually
10699 // var SMALLEST = 1;
10700
10701 /* ===========================================================================
10702 * Send the block data compressed using the given Huffman trees
10703 */
10704 function compress_block(s, ltree, dtree)
10705 // deflate_state *s;
10706 // const ct_data *ltree; /* literal tree */
10707 // const ct_data *dtree; /* distance tree */
10708 {
10709 var dist; /* distance of matched string */
10710 var lc; /* match length or unmatched char (if dist == 0) */
10711 var lx = 0; /* running index in l_buf */
10712 var code; /* the code to send */
10713 var extra; /* number of extra bits to send */
10714
10715 if (s.last_lit !== 0) {
10716 do {
10717 dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]);
10718 lc = s.pending_buf[s.l_buf + lx];
10719 lx++;
10720
10721 if (dist === 0) {
10722 send_code(s, lc, ltree); /* send a literal byte */
10723 //Tracecv(isgraph(lc), (stderr," '%c' ", lc));
10724 } else {
10725 /* Here, lc is the match length - MIN_MATCH */
10726 code = _length_code[lc];
10727 send_code(s, code + LITERALS + 1, ltree); /* send the length code */
10728 extra = extra_lbits[code];
10729 if (extra !== 0) {
10730 lc -= base_length[code];
10731 send_bits(s, lc, extra); /* send the extra length bits */
10732 }
10733 dist--; /* dist is now the match distance - 1 */
10734 code = d_code(dist);
10735 //Assert (code < D_CODES, "bad d_code");
10736
10737 send_code(s, code, dtree); /* send the distance code */
10738 extra = extra_dbits[code];
10739 if (extra !== 0) {
10740 dist -= base_dist[code];
10741 send_bits(s, dist, extra); /* send the extra distance bits */
10742 }
10743 } /* literal or match pair ? */
10744
10745 /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
10746 //Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
10747 // "pendingBuf overflow");
10748
10749 } while (lx < s.last_lit);
10750 }
10751
10752 send_code(s, END_BLOCK, ltree);
10753 }
10754
10755
10756 /* ===========================================================================
10757 * Construct one Huffman tree and assigns the code bit strings and lengths.
10758 * Update the total bit length for the current block.
10759 * IN assertion: the field freq is set for all tree elements.
10760 * OUT assertions: the fields len and code are set to the optimal bit length
10761 * and corresponding code. The length opt_len is updated; static_len is
10762 * also updated if stree is not null. The field max_code is set.
10763 */
10764 function build_tree(s, desc)
10765 // deflate_state *s;
10766 // tree_desc *desc; /* the tree descriptor */
10767 {
10768 var tree = desc.dyn_tree;
10769 var stree = desc.stat_desc.static_tree;
10770 var has_stree = desc.stat_desc.has_stree;
10771 var elems = desc.stat_desc.elems;
10772 var n, m; /* iterate over heap elements */
10773 var max_code = -1; /* largest code with non zero frequency */
10774 var node; /* new node being created */
10775
10776 /* Construct the initial heap, with least frequent element in
10777 * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
10778 * heap[0] is not used.
10779 */
10780 s.heap_len = 0;
10781 s.heap_max = HEAP_SIZE;
10782
10783 for (n = 0; n < elems; n++) {
10784 if (tree[n * 2]/*.Freq*/ !== 0) {
10785 s.heap[++s.heap_len] = max_code = n;
10786 s.depth[n] = 0;
10787
10788 } else {
10789 tree[n * 2 + 1]/*.Len*/ = 0;
10790 }
10791 }
10792
10793 /* The pkzip format requires that at least one distance code exists,
10794 * and that at least one bit should be sent even if there is only one
10795 * possible code. So to avoid special checks later on we force at least
10796 * two codes of non zero frequency.
10797 */
10798 while (s.heap_len < 2) {
10799 node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);
10800 tree[node * 2]/*.Freq*/ = 1;
10801 s.depth[node] = 0;
10802 s.opt_len--;
10803
10804 if (has_stree) {
10805 s.static_len -= stree[node * 2 + 1]/*.Len*/;
10806 }
10807 /* node is 0 or 1 so it does not have extra bits */
10808 }
10809 desc.max_code = max_code;
10810
10811 /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
10812 * establish sub-heaps of increasing lengths:
10813 */
10814 for (n = (s.heap_len >> 1/*int /2*/); n >= 1; n--) { pqdownheap(s, tree, n); }
10815
10816 /* Construct the Huffman tree by repeatedly combining the least two
10817 * frequent nodes.
10818 */
10819 node = elems; /* next internal node of the tree */
10820 do {
10821 //pqremove(s, tree, n); /* n = node of least frequency */
10822 /*** pqremove ***/
10823 n = s.heap[1/*SMALLEST*/];
10824 s.heap[1/*SMALLEST*/] = s.heap[s.heap_len--];
10825 pqdownheap(s, tree, 1/*SMALLEST*/);
10826 /***/
10827
10828 m = s.heap[1/*SMALLEST*/]; /* m = node of next least frequency */
10829
10830 s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */
10831 s.heap[--s.heap_max] = m;
10832
10833 /* Create a new node father of n and m */
10834 tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/;
10835 s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
10836 tree[n * 2 + 1]/*.Dad*/ = tree[m * 2 + 1]/*.Dad*/ = node;
10837
10838 /* and insert the new node in the heap */
10839 s.heap[1/*SMALLEST*/] = node++;
10840 pqdownheap(s, tree, 1/*SMALLEST*/);
10841
10842 } while (s.heap_len >= 2);
10843
10844 s.heap[--s.heap_max] = s.heap[1/*SMALLEST*/];
10845
10846 /* At this point, the fields freq and dad are set. We can now
10847 * generate the bit lengths.
10848 */
10849 gen_bitlen(s, desc);
10850
10851 /* The field len is now set, we can generate the bit codes */
10852 gen_codes(tree, max_code, s.bl_count);
10853 }
10854
10855
10856 /* ===========================================================================
10857 * Scan a literal or distance tree to determine the frequencies of the codes
10858 * in the bit length tree.
10859 */
10860 function scan_tree(s, tree, max_code)
10861 // deflate_state *s;
10862 // ct_data *tree; /* the tree to be scanned */
10863 // int max_code; /* and its largest code of non zero frequency */
10864 {
10865 var n; /* iterates over all tree elements */
10866 var prevlen = -1; /* last emitted length */
10867 var curlen; /* length of current code */
10868
10869 var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */
10870
10871 var count = 0; /* repeat count of the current code */
10872 var max_count = 7; /* max repeat count */
10873 var min_count = 4; /* min repeat count */
10874
10875 if (nextlen === 0) {
10876 max_count = 138;
10877 min_count = 3;
10878 }
10879 tree[(max_code + 1) * 2 + 1]/*.Len*/ = 0xffff; /* guard */
10880
10881 for (n = 0; n <= max_code; n++) {
10882 curlen = nextlen;
10883 nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;
10884
10885 if (++count < max_count && curlen === nextlen) {
10886 continue;
10887
10888 } else if (count < min_count) {
10889 s.bl_tree[curlen * 2]/*.Freq*/ += count;
10890
10891 } else if (curlen !== 0) {
10892
10893 if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; }
10894 s.bl_tree[REP_3_6 * 2]/*.Freq*/++;
10895
10896 } else if (count <= 10) {
10897 s.bl_tree[REPZ_3_10 * 2]/*.Freq*/++;
10898
10899 } else {
10900 s.bl_tree[REPZ_11_138 * 2]/*.Freq*/++;
10901 }
10902
10903 count = 0;
10904 prevlen = curlen;
10905
10906 if (nextlen === 0) {
10907 max_count = 138;
10908 min_count = 3;
10909
10910 } else if (curlen === nextlen) {
10911 max_count = 6;
10912 min_count = 3;
10913
10914 } else {
10915 max_count = 7;
10916 min_count = 4;
10917 }
10918 }
10919 }
10920
10921
10922 /* ===========================================================================
10923 * Send a literal or distance tree in compressed form, using the codes in
10924 * bl_tree.
10925 */
10926 function send_tree(s, tree, max_code)
10927 // deflate_state *s;
10928 // ct_data *tree; /* the tree to be scanned */
10929 // int max_code; /* and its largest code of non zero frequency */
10930 {
10931 var n; /* iterates over all tree elements */
10932 var prevlen = -1; /* last emitted length */
10933 var curlen; /* length of current code */
10934
10935 var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */
10936
10937 var count = 0; /* repeat count of the current code */
10938 var max_count = 7; /* max repeat count */
10939 var min_count = 4; /* min repeat count */
10940
10941 /* tree[max_code+1].Len = -1; */ /* guard already set */
10942 if (nextlen === 0) {
10943 max_count = 138;
10944 min_count = 3;
10945 }
10946
10947 for (n = 0; n <= max_code; n++) {
10948 curlen = nextlen;
10949 nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;
10950
10951 if (++count < max_count && curlen === nextlen) {
10952 continue;
10953
10954 } else if (count < min_count) {
10955 do { send_code(s, curlen, s.bl_tree); } while (--count !== 0);
10956
10957 } else if (curlen !== 0) {
10958 if (curlen !== prevlen) {
10959 send_code(s, curlen, s.bl_tree);
10960 count--;
10961 }
10962 //Assert(count >= 3 && count <= 6, " 3_6?");
10963 send_code(s, REP_3_6, s.bl_tree);
10964 send_bits(s, count - 3, 2);
10965
10966 } else if (count <= 10) {
10967 send_code(s, REPZ_3_10, s.bl_tree);
10968 send_bits(s, count - 3, 3);
10969
10970 } else {
10971 send_code(s, REPZ_11_138, s.bl_tree);
10972 send_bits(s, count - 11, 7);
10973 }
10974
10975 count = 0;
10976 prevlen = curlen;
10977 if (nextlen === 0) {
10978 max_count = 138;
10979 min_count = 3;
10980
10981 } else if (curlen === nextlen) {
10982 max_count = 6;
10983 min_count = 3;
10984
10985 } else {
10986 max_count = 7;
10987 min_count = 4;
10988 }
10989 }
10990 }
10991
10992
10993 /* ===========================================================================
10994 * Construct the Huffman tree for the bit lengths and return the index in
10995 * bl_order of the last bit length code to send.
10996 */
10997 function build_bl_tree(s) {
10998 var max_blindex; /* index of last bit length code of non zero freq */
10999
11000 /* Determine the bit length frequencies for literal and distance trees */
11001 scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
11002 scan_tree(s, s.dyn_dtree, s.d_desc.max_code);
11003
11004 /* Build the bit length tree: */
11005 build_tree(s, s.bl_desc);
11006 /* opt_len now includes the length of the tree representations, except
11007 * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
11008 */
11009
11010 /* Determine the number of bit length codes to send. The pkzip format
11011 * requires that at least 4 bit length codes be sent. (appnote.txt says
11012 * 3 but the actual value used is 4.)
11013 */
11014 for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
11015 if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/*.Len*/ !== 0) {
11016 break;
11017 }
11018 }
11019 /* Update opt_len to include the bit length tree and counts */
11020 s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
11021 //Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
11022 // s->opt_len, s->static_len));
11023
11024 return max_blindex;
11025 }
11026
11027
11028 /* ===========================================================================
11029 * Send the header for a block using dynamic Huffman trees: the counts, the
11030 * lengths of the bit length codes, the literal tree and the distance tree.
11031 * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
11032 */
11033 function send_all_trees(s, lcodes, dcodes, blcodes)
11034 // deflate_state *s;
11035 // int lcodes, dcodes, blcodes; /* number of codes for each tree */
11036 {
11037 var rank; /* index in bl_order */
11038
11039 //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
11040 //Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
11041 // "too many codes");
11042 //Tracev((stderr, "\nbl counts: "));
11043 send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */
11044 send_bits(s, dcodes - 1, 5);
11045 send_bits(s, blcodes - 4, 4); /* not -3 as stated in appnote.txt */
11046 for (rank = 0; rank < blcodes; rank++) {
11047 //Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
11048 send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1]/*.Len*/, 3);
11049 }
11050 //Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
11051
11052 send_tree(s, s.dyn_ltree, lcodes - 1); /* literal tree */
11053 //Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
11054
11055 send_tree(s, s.dyn_dtree, dcodes - 1); /* distance tree */
11056 //Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
11057 }
11058
11059
11060 /* ===========================================================================
11061 * Check if the data type is TEXT or BINARY, using the following algorithm:
11062 * - TEXT if the two conditions below are satisfied:
11063 * a) There are no non-portable control characters belonging to the
11064 * "black list" (0..6, 14..25, 28..31).
11065 * b) There is at least one printable character belonging to the
11066 * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
11067 * - BINARY otherwise.
11068 * - The following partially-portable control characters form a
11069 * "gray list" that is ignored in this detection algorithm:
11070 * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
11071 * IN assertion: the fields Freq of dyn_ltree are set.
11072 */
11073 function detect_data_type(s) {
11074 /* black_mask is the bit mask of black-listed bytes
11075 * set bits 0..6, 14..25, and 28..31
11076 * 0xf3ffc07f = binary 11110011111111111100000001111111
11077 */
11078 var black_mask = 0xf3ffc07f;
11079 var n;
11080
11081 /* Check for non-textual ("black-listed") bytes. */
11082 for (n = 0; n <= 31; n++, black_mask >>>= 1) {
11083 if ((black_mask & 1) && (s.dyn_ltree[n * 2]/*.Freq*/ !== 0)) {
11084 return Z_BINARY;
11085 }
11086 }
11087
11088 /* Check for textual ("white-listed") bytes. */
11089 if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 ||
11090 s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) {
11091 return Z_TEXT;
11092 }
11093 for (n = 32; n < LITERALS; n++) {
11094 if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) {
11095 return Z_TEXT;
11096 }
11097 }
11098
11099 /* There are no "black-listed" or "white-listed" bytes:
11100 * this stream either is empty or has tolerated ("gray-listed") bytes only.
11101 */
11102 return Z_BINARY;
11103 }
11104
11105
11106 var static_init_done = false;
11107
11108 /* ===========================================================================
11109 * Initialize the tree data structures for a new zlib stream.
11110 */
11111 function _tr_init(s)
11112 {
11113
11114 if (!static_init_done) {
11115 tr_static_init();
11116 static_init_done = true;
11117 }
11118
11119 s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);
11120 s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);
11121 s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
11122
11123 s.bi_buf = 0;
11124 s.bi_valid = 0;
11125
11126 /* Initialize the first block of the first file: */
11127 init_block(s);
11128 }
11129
11130
11131 /* ===========================================================================
11132 * Send a stored block
11133 */
11134 function _tr_stored_block(s, buf, stored_len, last)
11135 //DeflateState *s;
11136 //charf *buf; /* input block */
11137 //ulg stored_len; /* length of input block */
11138 //int last; /* one if this is the last block for a file */
11139 {
11140 send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3); /* send block type */
11141 copy_block(s, buf, stored_len, true); /* with header */
11142 }
11143
11144
11145 /* ===========================================================================
11146 * Send one empty static block to give enough lookahead for inflate.
11147 * This takes 10 bits, of which 7 may remain in the bit buffer.
11148 */
11149 function _tr_align(s) {
11150 send_bits(s, STATIC_TREES << 1, 3);
11151 send_code(s, END_BLOCK, static_ltree);
11152 bi_flush(s);
11153 }
11154
11155
11156 /* ===========================================================================
11157 * Determine the best encoding for the current block: dynamic trees, static
11158 * trees or store, and output the encoded block to the zip file.
11159 */
11160 function _tr_flush_block(s, buf, stored_len, last)
11161 //DeflateState *s;
11162 //charf *buf; /* input block, or NULL if too old */
11163 //ulg stored_len; /* length of input block */
11164 //int last; /* one if this is the last block for a file */
11165 {
11166 var opt_lenb, static_lenb; /* opt_len and static_len in bytes */
11167 var max_blindex = 0; /* index of last bit length code of non zero freq */
11168
11169 /* Build the Huffman trees unless a stored block is forced */
11170 if (s.level > 0) {
11171
11172 /* Check if the file is binary or text */
11173 if (s.strm.data_type === Z_UNKNOWN) {
11174 s.strm.data_type = detect_data_type(s);
11175 }
11176
11177 /* Construct the literal and distance trees */
11178 build_tree(s, s.l_desc);
11179 // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
11180 // s->static_len));
11181
11182 build_tree(s, s.d_desc);
11183 // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
11184 // s->static_len));
11185 /* At this point, opt_len and static_len are the total bit lengths of
11186 * the compressed block data, excluding the tree representations.
11187 */
11188
11189 /* Build the bit length tree for the above two trees, and get the index
11190 * in bl_order of the last bit length code to send.
11191 */
11192 max_blindex = build_bl_tree(s);
11193
11194 /* Determine the best encoding. Compute the block lengths in bytes. */
11195 opt_lenb = (s.opt_len + 3 + 7) >>> 3;
11196 static_lenb = (s.static_len + 3 + 7) >>> 3;
11197
11198 // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
11199 // opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
11200 // s->last_lit));
11201
11202 if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; }
11203
11204 } else {
11205 // Assert(buf != (char*)0, "lost buf");
11206 opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
11207 }
11208
11209 if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) {
11210 /* 4: two words for the lengths */
11211
11212 /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
11213 * Otherwise we can't have processed more than WSIZE input bytes since
11214 * the last block flush, because compression would have been
11215 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
11216 * transform a block into a stored block.
11217 */
11218 _tr_stored_block(s, buf, stored_len, last);
11219
11220 } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
11221
11222 send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
11223 compress_block(s, static_ltree, static_dtree);
11224
11225 } else {
11226 send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);
11227 send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);
11228 compress_block(s, s.dyn_ltree, s.dyn_dtree);
11229 }
11230 // Assert (s->compressed_len == s->bits_sent, "bad compressed size");
11231 /* The above check is made mod 2^32, for files larger than 512 MB
11232 * and uLong implemented on 32 bits.
11233 */
11234 init_block(s);
11235
11236 if (last) {
11237 bi_windup(s);
11238 }
11239 // Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
11240 // s->compressed_len-7*last));
11241 }
11242
11243 /* ===========================================================================
11244 * Save the match info and tally the frequency counts. Return true if
11245 * the current block must be flushed.
11246 */
11247 function _tr_tally(s, dist, lc)
11248 // deflate_state *s;
11249 // unsigned dist; /* distance of matched string */
11250 // unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */
11251 {
11252 //var out_length, in_length, dcode;
11253
11254 s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff;
11255 s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;
11256
11257 s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;
11258 s.last_lit++;
11259
11260 if (dist === 0) {
11261 /* lc is the unmatched char */
11262 s.dyn_ltree[lc * 2]/*.Freq*/++;
11263 } else {
11264 s.matches++;
11265 /* Here, lc is the match length - MIN_MATCH */
11266 dist--; /* dist = match distance - 1 */
11267 //Assert((ush)dist < (ush)MAX_DIST(s) &&
11268 // (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
11269 // (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match");
11270
11271 s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]/*.Freq*/++;
11272 s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++;
11273 }
11274
11275 // (!) This block is disabled in zlib defailts,
11276 // don't enable it for binary compatibility
11277
11278 //#ifdef TRUNCATE_BLOCK
11279 // /* Try to guess if it is profitable to stop the current block here */
11280 // if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {
11281 // /* Compute an upper bound for the compressed length */
11282 // out_length = s.last_lit*8;
11283 // in_length = s.strstart - s.block_start;
11284 //
11285 // for (dcode = 0; dcode < D_CODES; dcode++) {
11286 // out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);
11287 // }
11288 // out_length >>>= 3;
11289 // //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
11290 // // s->last_lit, in_length, out_length,
11291 // // 100L - out_length*100L/in_length));
11292 // if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {
11293 // return true;
11294 // }
11295 // }
11296 //#endif
11297
11298 return (s.last_lit === s.lit_bufsize - 1);
11299 /* We avoid equality with lit_bufsize because of wraparound at 64K
11300 * on 16 bit machines and because stored blocks are restricted to
11301 * 64K-1 bytes.
11302 */
11303 }
11304
11305 exports._tr_init = _tr_init;
11306 exports._tr_stored_block = _tr_stored_block;
11307 exports._tr_flush_block = _tr_flush_block;
11308 exports._tr_tally = _tr_tally;
11309 exports._tr_align = _tr_align;
11310
11311 },{"../utils/common":41}],53:[function(require,module,exports){
11312 'use strict';
11313
11314 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
11315 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
11316 //
11317 // This software is provided 'as-is', without any express or implied
11318 // warranty. In no event will the authors be held liable for any damages
11319 // arising from the use of this software.
11320 //
11321 // Permission is granted to anyone to use this software for any purpose,
11322 // including commercial applications, and to alter it and redistribute it
11323 // freely, subject to the following restrictions:
11324 //
11325 // 1. The origin of this software must not be misrepresented; you must not
11326 // claim that you wrote the original software. If you use this software
11327 // in a product, an acknowledgment in the product documentation would be
11328 // appreciated but is not required.
11329 // 2. Altered source versions must be plainly marked as such, and must not be
11330 // misrepresented as being the original software.
11331 // 3. This notice may not be removed or altered from any source distribution.
11332
11333 function ZStream() {
11334 /* next input byte */
11335 this.input = null; // JS specific, because we have no pointers
11336 this.next_in = 0;
11337 /* number of bytes available at input */
11338 this.avail_in = 0;
11339 /* total number of input bytes read so far */
11340 this.total_in = 0;
11341 /* next output byte should be put there */
11342 this.output = null; // JS specific, because we have no pointers
11343 this.next_out = 0;
11344 /* remaining free space at output */
11345 this.avail_out = 0;
11346 /* total number of bytes output so far */
11347 this.total_out = 0;
11348 /* last error message, NULL if no error */
11349 this.msg = ''/*Z_NULL*/;
11350 /* not visible by applications */
11351 this.state = null;
11352 /* best guess about the data type: binary or text */
11353 this.data_type = 2/*Z_UNKNOWN*/;
11354 /* adler32 value of the uncompressed data */
11355 this.adler = 0;
11356 }
11357
11358 module.exports = ZStream;
11359
11360 },{}],54:[function(require,module,exports){
11361 'use strict';
11362 module.exports = typeof setImmediate === 'function' ? setImmediate :
11363 function setImmediate() {
11364 var args = [].slice.apply(arguments);
11365 args.splice(1, 0, 0);
11366 setTimeout.apply(null, args);
11367 };
11368
11369 },{}]},{},[10])(10)
11370 });